API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：异人君莫邪

xiaomianao666
Mar 13th, 2024
104
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 182.84 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥异人君莫邪@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"收藏页\",\"path\":\"alp\",\"rule\":\"js:\\nsetPageTitle('资源收藏')\\nvar d = [];    \\nvar  item=[];\\n//log(MY_URL)\\nvar s = MY_URL.split(\\\"link=\\\")[1]\\n s = decodeURIComponent(s);\\n//log(s)\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\nputMyVar('time',nowTime() );\\nif (getMyVar('item')==''){\\n   if (s.includes(\\\"资源库分享\\\")){\\n      s=JSON.parse(s.split(\\\"¥\\\")[1])\\n      item.push(s);\\n   } else {\\n      if (s.includes(\\\"m3u8\\\")) {\\n          s=s.replace(/(https?:\\\\/\\\\/\\\\S*.m3u8)/ig,'¥¥$1¥¥');\\n          log(s)\\n       } else {\\n          s=s.replace(/(https?:\\\\/\\\\/[a-zA-Z0-9\\\\.\\\\?=\\\\/]*)/ig,'¥¥$1¥¥');\\n       }\\n      var content=s.split('¥¥');\\n      content = content.filter(v => v);\\n      for ( var i = 0; i< content.length; i++ ) {\\n          if (content[i].includes(\\\"http\\\")){\\n              var title=content[i-1];\\n              if (title==''||title==undefined) { title='未获取到名称' };\\n                title=title.replace('\\\\n',\\\"\\\");\\n                item.push({           \\n                    name: title.replace(/^\\\\s*|\\\\s*$/g,\\\"\\\"),             \\n                    url:content[i],\\n                    time:getMyVar('time',''),\\n                    type:'未分类'\\n                });\\n           }\\n      }\\n   }\\n   putMyVar('item', JSON.stringify(item));\\n} \\naddListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"item\\\");refreshPage();\\n    }));\\nitem=JSON.parse(getMyVar('item'))\\n\\nitem.forEach((v,i) => {\\n     let el = {\\n          title:'📂 '+v.name,     \\n          col_type: \\\"text_1\\\",\\n      }   \\n      el.url= $(v.url).lazyRule(() => {\\nlog(input)\\n          if (input.includes(\\\"ali\\\")){\\n                    return 'hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=' +input ; \\n          } else if (input.includes(\\\"quark\\\")){\\n                    return  \\\"hiker://page/quarkList?realurl=\\\" + encodeURIComponent(input) + \\\"&rule=Quark.简&sharePwd=\\\";\\n          }\\n       });\\n      el.extra= { \\n          pageTitle:v.name,\\n          longClick:[{\\n                title:'编辑名称',\\n                js:$.toString((v,i)=>{ \\nreturn $(v.name, '【'+v.name+'】名称').input((i) =>{\\n                            if (input == \\\"\\\") {\\n                                return \\\"toast://不能为空\\\"\\n                             } else {\\n             let item=JSON.parse(getMyVar('item'));\\n                                   item[i].name=input;\\n              putMyVar('item', JSON.stringify(item)); \\n                                   refreshPage(false)\\n                                   return 'toast://重命名成功！'\\n                             } \\n                                 },i)\\n                           },v,i)\\n                         },{\\n                         title:'编辑分类',\\n                         js:$.toString((v,i)=>{ \\n                              showSelectOptions({\\n                   \\\"title\\\": \\\"更改【\\\"+v.type+\\\"】为\\\", \\n                \\\"options\\\" : [\\\"电影\\\", \\\"电视剧\\\",\\\"动漫\\\",\\\"综艺\\\",\\\"纪录片\\\",\\\"MV\\\",\\\"合集\\\",\\\"短视频\\\"], \\n                 col: 4, \\n                 js:$.toString((i)=>{                     \\n          let item=JSON.parse(getMyVar('item'));\\n                        item[i].type = input;\\n              putMyVar('item', JSON.stringify(item)); \\n                        refreshPage(false)\\n                        return toast('分类成功更改为【'+input+'】');\\n                 },i)\\n            });\\n                         },v,i)\\n                         },{\\n                         title:'添加收藏',\\n                         js:$.toString((v,i)=>{ \\n                             return \\\"confirm://确认收藏：\\\" + v.name + \\\".js:\\\" + $.toString((i) =>{              \\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                              config = getConfig();\\n             let item=JSON.parse(getMyVar('item'));\\n                              if (config.data.filter(v =>v.name==item[i].name)==''){     \\n                                        try {\\n                                             let s= item[i].name.replace(/\\\\s/,\\\"$\\\").split(\\\"$\\\")[0] ;                    \\n                                             let fetchUrl =  'https://m.douban.com/search/?query='+s+'&type=1002';\\n                                             let code = fetch(fetchUrl);\\n                                             let list  =\\npdfa(code,\\\"body&&.search_results_subjects&&ul&&li\\\")\\n                                             let pic = pdfh(list[0],\\\"li&&img&&src\\\");\\n                                             let id= pdfh(list[0],\\\"li&&a&&href\\\").split(\\\"/\\\")[3]\\n                                            let typehtml=\\nfetch(\\\"https://m.douban.com\\\"+pdfh(list[0],\\\"li&&a&&href\\\"));\\n                                           let dataType=\\npdfh(typehtml,\\\"body&&section,1&&data-type\\\")\\n//log(dataType)\\n                                             item[i].id=id;\\n                                             item[i].pic=pic; \\n                         item[i].dataType=dataType; \\n                                         } catch(e){item[i].id=''}                        \\nconfig.data.splice(config.data.filter(i => i.top).length, 0,item[i] )\\n                                        writeFile(getItem('file'), JSON.stringify(config));\\n                                        refreshPage(false);\\n                                        return \\\"toast://收藏成功！\\\";\\n                               } else {\\n                                  return \\\"toast://已经收藏过了！\\\"}\\n                              },i)\\n                         },v,i)\\n          }]\\n      }\\n      d.push(el)\\n})      \\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"加载数据\",\"path\":\"config\",\"rule\":\"function getConfig() {\\n    let  mode = getItem('mode', '本地');\\n    if (mode == \\\"本地\\\")  { setItem('file',  'hiker://files/rules/catzz/aliyunku/local.json');}    \\n     else { setItem('file', 'hiker://files/rules/catzz/aliyunku/panku.json'); }\\n     try {\\n        let config = fetch(getItem('file'));\\n        if (!config || config == \\\"\\\") {\\n            return {\\n                data: [],\\n                version: 0\\n            }\\n        } else {\\n            return JSON.parse(config)\\n        }\\n    } catch (e) {\\n        try {\\n            toast(\\\"数据文件格式出错！\\\")\\n        } catch (e) {}\\n        return {\\n            data: [],\\n            version: 0\\n        }\\n    }\\n}\\nfunction nowTime() {\\n        var date = new Date();\\n        var YY = date.getFullYear() + '-';\\n        var MM = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';\\n        var DD = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate());\\n        return YY + MM + DD ;\\n}\\nfunction sorts(list, method) {\\n        let toplist=list.filter(i => i.top)\\n        toplist.reverse()\\n        if (method.includes(\\\"名称\\\")) {         \\n            list.sort(function(a, b) {\\n                return              a.name.localeCompare(b.name)\\n            })            \\n        } else if (method.includes(\\\"时间\\\")) {\\n            list.sort(function(a, b) {\\n                return new Date(b.time) - new Date(a.time)\\n            })\\n        } \\n        if (method.includes(\\\"反\\\")) {\\n            list.reverse()\\n        }\\n         //log(toplist)\\n        list=list.filter(i =>! i.top) \\n        toplist.forEach(v => {list.splice(0, 0,v)})\\n        return  list\\n }\"},{\"col_type\":\"movie_3\",\"name\":\"设置页\",\"path\":\"setting\",\"rule\":\"function setting() {\\n    function getColoredText(text) {\\n        return '““””<span style=\\\"color: #19B89D\\\">' + text + '</span>';\\n    }\\n    const d = [];\\n    let interval = getItem('interval', '24');\\n    let pagenum = getItem('pagenum', '20');\\n    let  modeList=[\\\"本地模式\\\", \\\"远程模式\\\"];\\n    let  mode = getItem('mode', '本地');\\n    if (mode == \\\"本地\\\")  {\\n         modeList=[\\\"本地模式 ✅\\\", \\\"远程模式\\\"];\\n       } else {  \\n         modeList=[\\\"本地模式\\\", \\\"远程模式 ✅\\\"];\\n    }\\n      d.push({\\n        title: mode+'模式',\\n        col_type: \\\"icon_round_4\\\",\\n        pic_url: \\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/54.svg\\\",\\n        url: $(modeList, 1).select(() => {\\n           return $('确定切换？').confirm((mode) => {  \\n                  if (mode == \\\"本地模式\\\")  {\\n                         setItem('mode', '本地');\\n                         refreshPage();\\n                    } else if (mode == \\\"远程模式\\\"){\\n                         setItem('mode', '远程');\\n                         refreshPage();\\n                    } \\n              }, input)\\n           })   \\n    });    \\n    d.push({\\n        title: \\\"显示设置\\\",\\n        desc: \\\"\\\",\\n        pic_url: \\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/17.svg\\\",\\n        col_type: \\\"icon_round_4\\\",\\n        url:  $(pagenum, '输入单页列表数量').input(() => {\\n            if (parseInt(input) >= 10) {\\n                setItem('pagenum', input);\\n            } else { setItem('pagenum', '20')}\\n            refreshPage();\\n            return \\\"toast://设置成功，每页显示数量:\\\"+getItem('pagenum', '20')\\n        }),\\n    })\\n   d.push({\\n        title: \\\"文件编辑\\\",\\n        desc: \\\"\\\",\\n        col_type: \\\"icon_round_4\\\",\\n        pic_url: \\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/10.svg\\\",\\n        url:getItem('mode', '本地')=='本地'? \\\"editFile://hiker://files/rules/catzz/aliyunku/local.json\\\":\\\"editFile://hiker://files/rules/catzz/aliyunku/panku.json\\\"\\n    })\\nd.push({\\n        title: \\\"数据同步\\\",\\n        desc: \\\"\\\",\\n        col_type: \\\"icon_round_4\\\",\\n        pic_url: \\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/7.svg\\\",\\n        url: getItem('mode', '本地')=='本地'?\\\"toast://请切换到远程模式再同步！！！\\\": $('确认同步').confirm(() => {\\n                try { \\n                      let webdav = buildWebDav('http://morrainny.asuscomm.cn:5005/web/panku', 'hotcats', 'zhen992176'); \\nwebdav.upload('panku.json','hiker://files/rules/catzz/aliyunku/panku.json')\\n                      refreshPage()\\n                      return \\\"toast://同步成功！\\\"\\n                } catch(e) { toast(\\\"同步失败！\\\")}\\n        }),\\n    })\\n    d.push({\\n        title: \\\"\\\",\\n        desc: \\\"\\\",\\n        col_type: \\\"line\\\",\\n        url: \\\"'\\\",\\n    })\\n\\n    addListener(\\\"onRefresh\\\", $.toString(() => {\\n        clearMyVar(\\\"editMode\\\");}));    \\n\\n    let editMode = getMyVar('editMode', '批量分类');\\n    [ '批量分类','重新排序',  '批量删除'].forEach((v) => {\\n        d.push({\\n            title: v == editMode ? '““””' + v.bold().fontcolor('#19B89D') : v,\\n            url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n                putMyVar('editMode', v)\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, v),\\n            col_type: 'flex_button'\\n        })\\n    });\\n\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n config = getConfig();\\nlet flagSort = config.data.filter(i => i.checked);\\nlet flagDelete = config.data.filter(i => i.delete);\\n switch (editMode) {\\n     case \\\"批量分类\\\":\\n           flagSort.length?\\n            d.push({\\n                 title: \\\"““””选择分类\\\".bold(),\\n                 col_type: \\\"text_center_1\\\",\\n              url: $([ \\\"电影\\\",\\\"电视剧\\\",\\\"综艺\\\",\\\"动漫\\\",\\\"MV\\\",\\\"纪录片\\\",\\\"合集\\\",\\\"短视频\\\"],4).select((config) => {            \\n              for (var i=0;i<config.data.length;i++) {\\n                              if (config.data[i].checked){\\n                              config.data[i].type=input;\\n                              config.data[i].checked=false\\n                              };\\n                           }\\n                    \\nwriteFile(getItem('file'), JSON.stringify(config));\\n                    refreshPage(false);\\n                    return \\\"toast://所选资源分类更改成功！\\\";\\n                   },config)\\n          }) : \\\"\\\"\\n     break;\\n     case \\\"批量删除\\\":\\n           flagDelete.length?\\n            d.push({\\n                 title: \\\"““””删除确认\\\".bold(),\\n                 col_type: \\\"text_center_1\\\",\\n                 url: $('确认删除').confirm((config) => {\\n                    let rules = [];\\n                    config.data.forEach((x) => {\\n                        !x.delete ? rules.push(x) : null\\n                        });\\n                     config.data=rules;\\nwriteFile(getItem('file'),JSON.stringify(config));\\n                       refreshPage(false);\\n                       return 'hiker://empty'\\n                    },config)\\n          }) : \\\"\\\"\\n      break\\n  };\\n\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n    config = getConfig();\\n    config.data.forEach((v, i) => {\\n        let el = {\\n             title: v.top ? '🆙'+v.name : v.name,\\n             col_type: \\\"text_2\\\"\\n             }\\n        switch (editMode) {\\n            case '批量分类':\\n                if (v.type=='未分类'){\\n                    el.title='📌'+'[未分类]'+el.title\\n                 } else {\\n                      el.title='['+v.type+']'+el.title\\n                    }\\n                el.title = (v.checked ? '✅' : ' ') + el.title;\\n                el.url = $('#noLoading#').lazyRule((i) => {\\n                eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                       config = getConfig();\\n                       config.data[i].checked = !config.data[i].checked;                      writeFile(getItem('file'),JSON.stringify(config));\\n                       refreshPage(false);\\n                       return 'hiker://empty'\\n            }, i);\\n          break\\n          case '重新排序':\\n                let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n                el.title = (sortFlag == i ? '🔃  ' : '') + el.title\\n                if (sortFlag == -1)\\n                    el.url = $('#noLoading#').lazyRule((i) => {\\n                        putMyVar('sortFlag', i.toString())\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, i)\\n                else\\n                    el.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                        eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                        config = getConfig();\\n                        if (config.data[oldIndex].top&&newIndex<config.data.filter(i => i.top).length) {\\n                             config.data.splice(newIndex, 0, config.data.splice(oldIndex, 1)[0]);\\n                              writeFile(getItem('file'),         JSON.stringify(config));\\n                              putMyVar('sortFlag', '-1')\\n                              refreshPage(false)\\n                              return 'hiker://empty'\\n                        } else if (!config.data[oldIndex].top&&newIndex>config.data.filter(i => i.top).length-1) {\\n                             config.data.splice(newIndex, 0, config.data.splice(oldIndex, 1)[0]);\\n                              writeFile(getItem('file'),         JSON.stringify(config));\\n                              putMyVar('sortFlag', '-1')\\n                              refreshPage(false)\\n                              return 'hiker://empty'\\n                        } else {\\n                            return 'toast://移动的位置不正确！'\\n                         }\\n\\n                    }, sortFlag, i)\\n            break\\n            case '批量删除':\\n                el.title = (v.delete ? '❌' : '') + el.title;      \\n                el.url = $('#noLoading#').lazyRule((i) => {\\n                eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                config = getConfig();\\n                config.data[i].delete = !config.data[i].delete;                      writeFile(getItem('file'),JSON.stringify(config));\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }, i);          \\n           break\\n        }\\n        d.push(el)\\n    });\\n    return d;\\n}\\n\\n$.exports = {\\n    setting: setting\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"长按菜单\",\"path\":\"longClick\",\"rule\":\"var longClick=[\\n    {\\n       title: '青豆搜索', \\n          js:$.toString((v)=>{ \\n              return 'hiker://search?s=' +v.name.replace(/\\\\s/,\\\"$\\\").split(\\\"$\\\")[0] + '&rule=青豆'},v)  \\n     },{\\n       title: '编辑名称', \\n       js:$.toString((v)=>{ \\nreturn $(v.name, '【'+v.name+'】名称').input((name) => { eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n           config = getConfig();\\n           let renFlag=1;\\n           if (input) {\\n              for (var j=0;j<config.data.length;j++)  {\\n                   if (config.data[j].name.replace(/\\\\s/g,\\\"\\\")==input.replace(/\\\\s/g,\\\"\\\")) {                   \\n                       renFlag=0;\\n                       break;\\n                   }\\n              }\\n              if (renFlag) {\\n                  for (var i=0;i<config.data.length;i++) {\\n                      if (config.data[i].name==name){\\n                            config.data[i].name=input;\\n                            config.data[i].time = getMyVar('time','');\\n                            if (!config.data[i].top) {\\n                            config.data.splice(config.data.filter(i => i.top).length, 0, config.data.splice(i, 1)[0])\\n                             } else {\\n                            config.data.splice(0, 0, config.data.splice(i, 1)[0])\\n                             };\\n                           break;\\n                       } \\n                   }\\n                   writeFile(getItem('file'), JSON.stringify(config));\\n                   refreshPage(false);\\n                   toast('重命名成功！');\\n              } else {\\n                   toast('文件名已存在！')\\n              }\\n           } else {\\n                  toast('名称不能为空！')\\n           }\\n         },v.name)\\n       },v)  \\n    },{\\n       title: '★编辑海报', \\n       js:$.toString((v)=>{ \\nreturn $(v.img, '【'+v.name+'】海报').input((name) => {\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n    config = getConfig();\\n         if (input == \\\"\\\") {\\n             for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].img=input;\\n                       break;\\n                     }\\n               }\\n writeFile(getItem('file'), JSON.stringify(config));\\n            refreshPage(false);\\n            toast('海报置空成功！');\\n          } else if (input.match(/jpg|png|webp|gif|jpeg|bmp|svg/i)==null){ \\n             toast('只能为图片格式!')\\n          } else {\\n             for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].img=input;\\n                       break;\\n                     }\\n               }\\n writeFile(getItem('file'), JSON.stringify(config));\\n            refreshPage(false);\\n            toast('海报更改成功！');\\n          } \\n         },v.name)\\n       },v)  \\n    },{\\n       title: '★增加地址', \\n       js:$.toString((v)=>{ \\n          if (v.url2!=undefined) {\\n             return  \\\"toast://网址已达上限！\\\"\\n          } else {\\n           return $('','输入【'+v.name+'】新地址').input((name) => {\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n          config = getConfig();\\n         if (input.match(/http/)==null){ \\n              return \\\"toast://无效网址！\\\"\\n          } else {\\n       for (var i=0;i<config.data.length;i++) {\\n                if (config.data[i].name==name){\\n  (config.data[i].url1==undefined)?config.data[i].url1=input:config.data[i].url2=input;\\n                    break;\\n                }\\n        }   \\n               writeFile(getItem('file'), JSON.stringify(config));\\n               refreshPage(false)\\n               return 'toast://新增网址成功！'\\n           }\\n         },v.name)\\n       }\\n      },v)  \\n    },{\\n       title: '编辑地址', \\n       js:$.toString((v)=>{\\n           let urls=v.url+\\\"$\\\"+v.url1+\\\"$\\\"+v.url2;\\n           urls=urls.split(\\\"$\\\");\\n           urls=urls.filter(item => item!=\\\"undefined\\\");\\n           for (let i=0;i<urls.length;i++){\\n                 urls[i]=\\\"地址\\\"+(i==0?\\\"一\\\":i==1?\\\"二\\\":\\\"三\\\")\\n           }\\n           return $(urls).select((v) => {\\n              var editUrl=v.url;\\n              if (input==\\\"地址二\\\")editUrl=v.url1;\\n              if (input==\\\"地址三\\\")editUrl=v.url2;\\n              return $(editUrl, '【'+v.name+'】'+input).input((urlNo,name) => {\\n eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n          config = getConfig();\\n          if (input == \\\"\\\") {\\n              return \\\"toast://不能为空\\\"\\n          } else if (input.match(/http/)==null){ \\n              return \\\"toast://地址有误！\\\"\\n          } else {\\n              for (var i=0;i<config.data.length;i++) {\\n                  if (config.data[i].name==name){\\n                       if (urlNo==\\\"地址一\\\"){\\n                           config.data[i].url=input;\\n                        } else if (urlNo==\\\"地址二\\\"){\\n                           config.data[i].url1=input;\\n                        } else {\\n                            config.data[i].url2=input;\\n                        }\\n                        break;\\n                     }\\n               }   \\n               writeFile(getItem('file'), JSON.stringify(config));\\n               refreshPage(false)\\n               return 'toast://【'+urlNo+'】修改成功！'\\n             }\\n            },input,v.name)\\n         },v)\\n      },v)  \\n    },{\\n       title: '编辑封面', \\n       js:$.toString((v)=>{ \\nreturn $(v.pic, '【'+v.name+'】封面').input((name) => {\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n    config = getConfig();\\n         if (input == \\\"\\\") {\\n             for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].pic=input;\\n                       break;\\n                     }\\n               }\\n writeFile(getItem('file'), JSON.stringify(config));\\n            refreshPage(false);\\n            toast('封面图片置空成功！');\\n          } else if (input.match(/jpg|png|webp|gif|jpeg|bmp|svg/i)==null){ \\n             toast('只能为图片格式!')\\n          } else {\\n             for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].pic=input;\\n                       break;\\n                     }\\n               }\\n writeFile(getItem('file'), JSON.stringify(config));\\n            refreshPage(false);\\n            toast('封面图片更改成功！');\\n          } \\n         },v.name)\\n       },v)  \\n    },{\\n       title: '资源分类', \\n       js:$.toString((v)=>{ \\n           showSelectOptions({\\n              \\\"title\\\": \\\"更改\\\"+\\\"【\\\"+v.type+\\\"】为\\\", \\n                \\\"options\\\" : [\\\"电影\\\", \\\"电视剧\\\",\\\"动漫\\\",\\\"综艺\\\",\\\"纪录片\\\",\\\"MV\\\",\\\"合集\\\",\\\"短视频\\\"], \\n                 col: 4, \\n                 js:$.toString((v)=>{ \\n                      eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n         config = getConfig();\\n         for (var i=0;i<config.data.length;i++) {\\n               if (config.data[i].name==v.name){\\n                           config.data[i].type=input;\\n                           break;\\n               }\\n          }\\n          writeFile(getItem('file'),         JSON.stringify(config));\\n          refreshPage(false);\\n          toast('分类成功更改为【'+input+'】');\\n                 },v)\\n            });\\n        },v)\\n},{\\n       title: '豆瓣id', \\n       js:$.toString((v)=>{ \\nreturn $(v.id, '【'+v.name+'】豆瓣id').input((name) => {\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n    config = getConfig();\\n         if (input == \\\"\\\") {\\n             for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].id=input;\\n                       break;\\n                     }\\n               }\\n writeFile(getItem('file'), JSON.stringify(config));\\n            refreshPage(false);\\n            toast('id置空成功！');\\n          } else if (input.match(/^[0-9]*$/)==null){ \\n             toast('id只能为数字!')\\n          } else {\\n             for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].id=input;\\n                       break;\\n                     }\\n               }\\n writeFile(getItem('file'), JSON.stringify(config));\\n            refreshPage(false);\\n            toast('id更改成功！');\\n          } \\n         },v.name)\\n       },v)  \\n    },{\\n       title: '豆瓣分类', \\n       js:$.toString((v)=>{ \\n           showSelectOptions({\\n              \\\"title\\\": \\\"更改\\\"+\\\"【\\\"+v.dataType+\\\"】为\\\", \\n                \\\"options\\\" : [\\\"tv\\\", \\\"movie\\\"], \\n                 col: 1,\\n                 js:$.toString((name)=>{ \\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n         config = getConfig();\\n         for (var i=0;i<config.data.length;i++) {\\n                if (config.data[i].name==name){\\n                    config.data[i].dataType=input;\\n                     break;\\n                }\\n           }\\n           writeFile(getItem('file'),      JSON.stringify(config));\\n            refreshPage(false);\\n            toast('豆瓣分类更改成功！');\\n         },v.name)\\n        });\\n       },v)  \\n    },{\\n       title: '信息刮削', \\n       js:$.toString((v)=>{ \\n            if (!v.pic) {\\n                return $(v.name, '刮削【'+v.name+'】').input((name) =>{\\n                    try {\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);             \\n                           config = getConfig();  \\n                           let s= input.replace(/\\\\s/,\\\"$\\\").split(\\\"$\\\")[0] ;                    \\n                           let fetchUrl =  'https://m.douban.com/search/?query='+s+'&type=1002';\\n                           let code = fetch(fetchUrl);\\n//log(code)  \\n                           let list  =\\npdfa(code,\\\"body&&.search_results_subjects&&ul&&li\\\")\\n//log(list[0])\\n                           let pic = pdfh(list[0],\\\"li&&img&&src\\\");\\n//log(pic)\\n                           let id= pdfh(list[0],\\\"li&&a&&href\\\").split(\\\"/\\\")[3]\\n//log(id)\\n                           let typehtml=\\nfetch(\\\"https://m.douban.com\\\"+pdfh(list[0],\\\"li&&a&&href\\\"));\\n                          let dataType=\\npdfh(typehtml,\\\"body&&section,1&&data-type\\\")\\n//log(dataType)\\n                 for (var i=0;i<config.data.length;i++) {\\n                        if (config.data[i].name==name){\\n                                   config.data[i].id=id;\\n                                    config.data[i].pic=pic; \\n                                    config.data[i].dataType=dataType;\\n                                    break;\\n                        }\\n                }\\n                           writeFile(getItem('file'), JSON.stringify(config));\\n                           refreshPage(false);\\n                           toast(\\\"刮削成功!\\\"); \\n                  } catch(e){toast(\\\"刮削失败！\\\")}\\n               },v.name)\\n          } else { toast(\\\"已经刮削过!\\\"); }\\n      },v)\\n    },{\\n       title: '(取消)置顶', \\n       js:$.toString((v)=>{ \\n                                      if (!v.top) {\\n                                        return  $(\\\"置顶“\\\"+v.name+\\\"”？\\\").confirm((name)=>{\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);             \\n               config = getConfig();         \\n           for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].top=!config.data[i].top;\\n                       config.data.splice(0, 0, config.data.splice(i, 1)[0]); \\n                       break;\\n                     }\\n               }                       \\n                               writeFile(getItem('file'), JSON.stringify(config));\\n                               refreshPage(false);\\n                               toast(\\\"置顶成功!\\\"); \\n                           },v.name)\\n                                     } else {\\n                                         return  $(\\\"取消“\\\"+v.name+\\\"”置顶？\\\").confirm((name)=>{\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);             \\n                              config = getConfig();      \\n           for (var i=0;i<config.data.length;i++) {\\n                   if (config.data[i].name==name){\\n                       config.data[i].top=!config.data[i].top;                        config.data.splice(config.data.filter(i =>  i.top).length, 0, config.data.splice(i, 1)[0]); \\n                        break;\\n                     }\\n               }                                             \\n                               writeFile(getItem('file'), JSON.stringify(config));\\n                               refreshPage(false);\\n                               toast(\\\"取消置顶成功!\\\");                      \\n             },v.name)\\n          }\\n       },v)\\n    },{\\n        title: '分 享', \\n           js:$.toString((v)=>{ \\n              return  $('确定分享资源？').confirm((v) => {\\n                eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                  config = getConfig();\\n                  var data = '资源库分享¥'+JSON.stringify(v);\\n                  return \\\"copy://\\\" + data;\\n              }, v)\\n           },v)  \\n    },{\\n       title: '删  除', \\n       js:$.toString((v)=>{ \\n           return $(\\\"确认删除“\\\"+v.name+\\\"”？\\\").confirm((name)=>{\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);             \\n           config = getConfig();  \\nconfig.data = config.data.filter(i => i.name != name);\\nwriteFile(getItem('file'), JSON.stringify(config));\\n           refreshPage(false);\\n           toast(\\\"已经删除该资源!\\\"); \\n         },v.name)\\n      },v)  \\n    }\\n]\"},{\"col_type\":\"avatar\",\"name\":\"影视详情\",\"path\":\"Sdetail\",\"rule\":\"js:\\nputVar('qdb_file', 'hiker://files/rules/joker/qdb.js');\\neval(fetch(getVar(\\\"qdb_file\\\")));\\npre();\\nlet name = getParam('name', ''),\\n type = getParam('type', ''),\\n id = getParam('id', '');\\nlet urls=getMyVar(\\\"url\\\",'').split(\\\"$$$\\\");\\nurls=urls.filter(item => item!=\\\"undefined\\\");\\ntry {\\nlet i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id);\\n    setPageTitle(i.title);\\n    let info = \\\"\\\";\\n    if (i.is_tv) {\\n        info = [i.countries ? i.countries.join(\\\" \\\") : null, i.genres ? i.genres.join(\\\" \\\") : null, i.pubdate ? i.pubdate[0] + \\\"首播\\\" : null, i.episodes_count ? \\\"共\\\" + i.episodes_count + \\\"集\\\" : null, i.durations ? \\\"单集片长\\\" + i.durations : null].filter((e => null !== e)).join(\\\" / \\\");\\n    } else {\\n        info = [i.countries ? i.countries.join(\\\" \\\") : null, i.genres ? i.genres.join(\\\" \\\") : null, i.pubdate ? i.pubdate[0] + \\\"首播\\\" : null, i.durations ? \\\"片长\\\" + i.durations : null].filter((e => null !== e)).join(\\\" / \\\");\\n    }\\n    let infoItems = [{\\n        title: i.title + \\\"\\\\n\\\" + i.original_title + \\\"(\\\" + i.year + \\\")\\\",\\n        desc: info || i.card_subtitle,\\n        img: i.pic.normal + \\\"@Referer=\\\" + i.pic.normal,\\n        col_type: \\\"movie_1_vertical_pic_blur\\\",\\n        url: 'hiker://empty'\\n    }];\\n    let rating = \\\"\\\";\\n    if (i.rating) {\\n        rating = computeRating(i.rating.max, i.rating.value);\\n    }\\n    let ratingItems = [];\\n    let color = getConfig('starColor');\\n    let ratingTitle = ''\\n    if (rating) {\\n        ratingTitle = '豆瓣评分™'.bold() + '<br>' + rating.fontcolor(color) + '&nbsp;&nbsp;' + (i.rating.value.toFixed(1) + '分').bold();\\n    } else {\\n        ratingTitle = '暂无评分'.bold() + '<br>' + '点我查看影片信息'.fontcolor('grey');\\n    }\\n    ratingItems = [{\\n        title: '““””' + ratingTitle,\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            lineVisible: false\\n        },\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((type, id, ratingCount) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            rating(type, id, ratingCount);\\n        }, i.subtype, i.id, i.rating ? i.rating.count : 0)\\n    }];\\n\\n    let relatedItems = [{\\n        title: \\\"短评\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/短评.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            shortCommentList(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    }, {\\n        title: \\\"剧评\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧评.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            dramaReviewList(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    },{\\n        title: \\\"剧照\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧照.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            stillsList(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    }, {\\n        title: \\\"演职\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/演职.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            credits(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    }];\\n    let introItems = [];\\n    if (i.intro) {\\n        introItems = [ {\\ntitle: '““””<font color=\\\"#ff148e8e\\\"><b>剧情简介：</b>'+i.intro.replace(/\\\\n/g, \\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\").replace(/\\\\s/g, \\\" \\\").replace(/\\\\t/g, \\\" \\\").substr(0, 50)+'...</font><small><font color=\\\"red\\\">详情</font></small>',\\n          url: \\\"hiker://empty##\\\"+i.intro.replace(/\\\\n/g, \\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\").replace(/\\\\s/g, \\\" \\\").replace(/\\\\t/g, \\\" \\\")+`@rule=js:var res = {}; var d = [];d.push({title:'&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'+MY_URL.split('##')[1],col_type:'rich_text'});res.data = d;\\nsetHomeResult(res);`,\\n            col_type: \\\"text_1\\\"\\n        }]\\n    }\\n\\n  let videoRelatedItems = [];\\r\\n    if (i.trailer) {\\r\\n        videoRelatedItems.push({\\r\\n            title: i.title+\\\" - 预告片、花絮\\\",\\r\\n            img: \\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/more/356.png\\\",\\r\\n            url: \\n$('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n                eval(fetch(getVar(\\\"qdb_file\\\")));\\n                trailers(t[0], t[1]);\\n            }, [i.subtype, i.id]),\\r\\n            col_type: \\\"avatar\\\"\\r\\n        });\\r\\n    }\\n\\n    let linkItems = [];\\n    let title=i.title;\\n    urls.forEach((v, i) => { \\n       linkItems.push({\\n          title: v.includes(\\\"m3u8\\\")?(i+1)+' - '+title+'【视频资源】':v.includes(\\\"ali\\\")?(i+1)+' -'+title+' 【阿里资源】':(i+1)+' - '+title+'【夸克资源】',\\n         img:\\n\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/143.svg\\\",\\n        col_type: 'avatar',\\n        extra: {\\n                lineVisible: false,\\n                PageTitle:title,\\n                longClick:[{\\n                      title: '更改地址', \\n                      js:$.toString((url,name,i)=>{ \\n       return $(url, '【'+name+'】地址').input((name,urlNo) => {\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n          config = getConfig();\\n          if (input.match(/http/)==null){ \\n              return \\\"toast://地址有误！\\\"\\n          } else {\\n          for (let i=0;i<config.data.length;i++) {\\n             if (config.data[i].name==name){\\n                if(urlNo==0){\\n                    config.data[i].url=input\\n                } else if(urlNo==1){\\n                    config.data[i].url1=input\\n                } else {\\n                     config.data[i].url2=input\\n                }\\n             putMyVar(\\\"url\\\",config.data[i].url+\\\"$$$\\\"+config.data[i].url1+\\\"$$$\\\"+config.data[i].url2);\\n               break;\\n             }\\n          }   \\n   writeFile(getItem('file'), JSON.stringify(config));\\n               refreshPage(false)\\n               return 'toast://地址修改成功'\\n           }\\n         },name,i)\\n       },v,name,i)  \\n    },{\\n                      title: '删除地址', \\n                      js:$.toString((name,i)=>{ \\n       return $(\\\"确认删除“\\\"+name+\\\"”？\\\").confirm((name,urlNo)=>{\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n          config = getConfig();\\n          for (let i=0;i<config.data.length;i++) {\\n             if (config.data[i].name==name){\\n                if(urlNo==0){\\n                    delete config.data[i].url\\n                } else if(urlNo==1){\\n                    delete   config.data[i].url1\\n                } else {\\n                    delete config.data[i].url2\\n                }\\n             putMyVar(\\\"url\\\",config.data[i].url+\\\"$$$\\\"+config.data[i].url1+\\\"$$$\\\"+config.data[i].url2);\\n               break;\\n             }\\n          }   \\n   writeFile(getItem('file'), JSON.stringify(config));\\n               refreshPage(false)\\n               return 'toast://删除成功'\\n         },name,i)\\n       },name,i)  \\n    }]\\n        },\\n        url: $(\\\"#noLoading#\\\").lazyRule((url) => { \\n              if (url.includes(\\\"ali\\\")) { \\n                  return    \\\"hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=\\\"+url\\n               } else if (url.includes(\\\"quark\\\")) { \\n                 return \\\"hiker://page/quarkList?realurl=\\\" + encodeURIComponent(url) + \\\"&rule=Quark.简&sharePwd=\\\"\\n               } else {\\n                 return url\\n               }\\n         },v)           \\n    })\\n});\\n    let config = JSON.parse(fetch(getVar('qdb_config')));\\n\\n    let analysisConfigs = getConfig('analysisConfigs', config);\\n    let extraConfig = analysisConfigs[analysisConfigs.use].extra || '{}';\\n    let extra = {};\\n    try {\\n        if (extraConfig.startsWith('{')) eval('extra=' + extraConfig);\\n    } catch (e) {}\\n    let quickSearchConfigs = getConfig('quickSearchConfigs', config);\\n    let quickSearchItems = [];\\n    quickSearchConfigs.order.forEach(quickSearchItem => {\\n        if (quickSearchConfigs[quickSearchItem]) {\\n            quickSearchItems.push({\\n                title: quickSearchItem,\\n                img: quickSearchConfigs[quickSearchItem].pic,\\n                col_type: quickSearchConfigs.mode || 'icon_small_4',\\n                url: 'hiker://search?s=' + i.title + '&rule=' + quickSearchConfigs[quickSearchItem].name\\n            })\\n        }\\n    })\\n    setHomeResult({\\n        data: infoItems.concat(ratingItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n           .concat(introItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(relatedItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(quickSearchItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(videoRelatedItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(linkItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat({\\r\\n                col_type: 'text_1',\\r\\n                title: '““””<small><font color=#871f78>本规则及数据均收集自网络，仅限学习交流使用，请于导入后24小时内删除，不得以任何方式传播！</font></small>',\\r\\n                url: 'hiker://empty',\\r\\n                extra: {\\r\\n                    lineVisible: false\\r\\n                }\\r\\n            })\\n      })\\n} catch(e){toast(\\\"类型错误，资源获取出错！\\\");\\n }\"},{\"col_type\":\"movie_3\",\"name\":\"搜索页\",\"path\":\"sou\",\"rule\":\"js:\\nsetPageTitle(\\\"云盘库搜索\\\")\\nlet d = [];    \\nlet key = getParam('key', ''); \\nif (key ==\\\"\\\") {\\n key = MY_PARAMS.key\\n}\\n\\neval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\nconfig = getConfig();\\nconfig.data = config.data.filter(v => v.name.includes(key));\\nconfig.data.forEach((v, i) => {       \\neval(JSON.parse(fetch(\\\"hiker://page/longClick\\\")).rule);\\n    d.push ({\\n           title: v.name,\\n           url: $(\\\"#noLoading#\\\").lazyRule((v) => { \\n              if (v.id!=undefined&&v.id!=\\\"\\\") { \\n                  return    'hiker://page/Sdetail#noHistory##immersiveTheme#?type='+v.dataType+'&id=' + v.id+'&aliurl=' + v.url;\\n              } else {\\n                   return  'hiker://page/push?rule=云盘君(推送)&url=hiker://empty##'+v.url\\n              }\\n        },v)  ,\\n            extra: {\\n                pageTitle:v.name,\\n                longClick:longClick\\n            },\\n            img:v.pic==undefined?MY_RULE.icon:v.pic,\\n            col_type: \\\"avatar\\\",\\n     })\\n})\\nd.push ({\\n    title: \\\"🔜使用「聚云盘」搜索\\\",\\n    url: \\\"hiker://search?s=\\\"+key+\\\"&rule=聚云盘\\\",\\n    col_type: \\\"text_1\\\"\\n})\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"轮播\",\"path\":\"lunbo\",\"rule\":\"js:\\nfunction banner(title, start, arr, data, cfg) {\\n    let id = title + 'lunbo';\\n    var rnum = Math.floor(Math.random() * data.length);\\n    var item = data[rnum];\\n    let time = 5000;\\n    let col_type = 'pic_1_card';\\n    let color = \\\"white\\\";\\n    let desc = '';\\n    if (cfg != undefined) {\\n        time = cfg.time ? cfg.time : time;\\n        col_type = cfg.col_type ? cfg.col_type : col_type;\\n        desc = cfg.desc ? cfg.desc : desc;\\n    }\\n\\n    arr.push({\\n        col_type: col_type,\\n        img: item.img,\\n        desc: desc,\\n        title: item.name,\\n        url: $(\\\"#noLoading#\\\").lazyRule((v) => { \\n              if (v.id!=undefined&&v.id!=\\\"\\\") { \\n                  putMyVar(\\\"url\\\",v.url+\\\"$$$\\\"+v.url1+\\\"$$$\\\"+v.url2);\\n                  return    'hiker://page/Sdetail#noHistory##immersiveTheme#?name='+v.name+'&type='+v.dataType+'&id=' + v.id;\\n              } else {\\n                   if (v.url.includes(\\\"ali\\\")){\\n                    return 'hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=' + v.url; \\n                  } else if (v.url.includes(\\\"quark\\\")){\\n                    return  \\\"hiker://page/quarkList?realurl=\\\" + encodeURIComponent(v.url) + \\\"&rule=Quark.简&sharePwd=\\\";\\n                 }\\n               }\\n        },item)  ,\\n        extra: {\\n            id: id+'bar',\\n        }\\n    })\\n\\n    if (start == false || getMyVar('benstart', 'true') == 'false') {\\n        unRegisterTask(id)\\n        return\\n    }\\n    \\n\\n    let obj = {\\n        data: data,\\n    };\\n    registerTask(id, time, $.toString((obj,id) => {\\n        var data = obj.data;\\n        var i = Number(getMyVar('yingku'),'0');\\n        i = i + 1;\\n        if ( i > data.length-1) {\\n            i = 0\\n        }\\n        var item = data[i];\\n        try {\\n            updateItem(id+'bar', {\\n                title: item.name,\\n                img: item.img,\\n                url: $(\\\"#noLoading#\\\").lazyRule((v) => { \\n              if (v.id!=undefined&&v.id!=\\\"\\\") { \\n               putMyVar(\\\"url\\\",v.url+\\\"$$$\\\"+v.url1+\\\"$$$\\\"+v.url2);\\n                 return    'hiker://page/Sdetail#noHistory##immersiveTheme#?name='+v.name+'&type='+v.dataType+'&id=' + v.id;\\n              } else {\\n                   if (v.url.includes(\\\"ali\\\")){\\n                    return 'hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=' + v.url; \\n                  } else if (v.url.includes(\\\"quark\\\")){\\n                    return  \\\"hiker://page/quarkList?realurl=\\\" + encodeURIComponent(v.url) + \\\"&rule=Quark.简&sharePwd=\\\";\\n                 }\\n               }\\n        },item)  ,\\n                extra: {\\n                    title: item.name.replace(/<[^>]+>/g, ''),\\n                }\\n            })\\n        } catch (e) {\\n            log(e.message)\\n            unRegisterTask(id)\\n        }\\n        putMyVar('yingku', i);\\n    }, obj,id))\\n}\"}],\"params\":\"{\\\"longClick\\\":[{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    return \\\\\\\"hiker://search?s=\\\\\\\" + v.name.replace(/\\\\\\\\s/, \\\\\\\"$\\\\\\\").split(\\\\\\\"$\\\\\\\")[0] + \\\\\\\"&rule=\\\\\\\\u9752\\\\\\\\u8c46\\\\\\\";\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"青豆搜索\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    return $(v.name, \\\\\\\"\\\\\\\\u3010\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u3011\\\\\\\\u540d\\\\\\\\u79f0\\\\\\\").input((name) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        let renFlag = 1;\\\\n        if (input) {\\\\n            for (var j = 0; j < config.data.length; j++) {\\\\n                if (config.data[j].name.replace(/\\\\\\\\s/g, \\\\\\\"\\\\\\\") == input.replace(/\\\\\\\\s/g, \\\\\\\"\\\\\\\")) {\\\\n                    renFlag = 0;\\\\n                    break;\\\\n                }\\\\n            }\\\\n            if (renFlag) {\\\\n                for (var i = 0; i < config.data.length; i++) {\\\\n                    if (config.data[i].name == name) {\\\\n                        config.data[i].name = input;\\\\n                        config.data[i].time = getMyVar(\\\\\\\"time\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                        if (!config.data[i].top) {\\\\n                            config.data.splice(config.data.filter(i => i.top).length, 0, config.data.splice(i, 1)[0]);\\\\n                        } else {\\\\n                            config.data.splice(0, 0, config.data.splice(i, 1)[0]);\\\\n                        }\\\\n                        break;\\\\n                    }\\\\n                }\\\\n                writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                toast(\\\\\\\"\\\\\\\\u91cd\\\\\\\\u547d\\\\\\\\u540d\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n            } else {\\\\n                toast(\\\\\\\"\\\\\\\\u6587\\\\\\\\u4ef6\\\\\\\\u540d\\\\\\\\u5df2\\\\\\\\u5b58\\\\\\\\u5728\\\\\\\\uff01\\\\\\\");\\\\n            }\\\\n        } else {\\\\n            toast(\\\\\\\"\\\\\\\\u540d\\\\\\\\u79f0\\\\\\\\u4e0d\\\\\\\\u80fd\\\\\\\\u4e3a\\\\\\\\u7a7a\\\\\\\\uff01\\\\\\\");\\\\n        }\\\\n    }\\\\n    , v.name);\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"编辑名称\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    return $(v.img, \\\\\\\"\\\\\\\\u3010\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u3011\\\\\\\\u6d77\\\\\\\\u62a5\\\\\\\").input((name) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        if (input == \\\\\\\"\\\\\\\") {\\\\n            for (var i = 0; i < config.data.length; i++) {\\\\n                if (config.data[i].name == name) {\\\\n                    config.data[i].img = input;\\\\n                    break;\\\\n                }\\\\n            }\\\\n            writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast(\\\\\\\"\\\\\\\\u6d77\\\\\\\\u62a5\\\\\\\\u7f6e\\\\\\\\u7a7a\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n        } else {\\\\n            if (input.match(/jpg|png|webp|gif|jpeg|bmp|svg/i) == null) {\\\\n                toast(\\\\\\\"\\\\\\\\u53ea\\\\\\\\u80fd\\\\\\\\u4e3a\\\\\\\\u56fe\\\\\\\\u7247\\\\\\\\u683c\\\\\\\\u5f0f!\\\\\\\");\\\\n            } else {\\\\n                for (var i = 0; i < config.data.length; i++) {\\\\n                    if (config.data[i].name == name) {\\\\n                        config.data[i].img = input;\\\\n                        break;\\\\n                    }\\\\n                }\\\\n                writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                toast(\\\\\\\"\\\\\\\\u6d77\\\\\\\\u62a5\\\\\\\\u66f4\\\\\\\\u6539\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n            }\\\\n        }\\\\n    }\\\\n    , v.name);\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"★编辑海报\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    if (v.url2 != undefined) {\\\\n        return \\\\\\\"toast://\\\\\\\\u7f51\\\\\\\\u5740\\\\\\\\u5df2\\\\\\\\u8fbe\\\\\\\\u4e0a\\\\\\\\u9650\\\\\\\\uff01\\\\\\\";\\\\n    } else {\\\\n        return $(\\\\\\\"\\\\\\\", \\\\\\\"\\\\\\\\u8f93\\\\\\\\u5165\\\\\\\\u3010\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u3011\\\\\\\\u65b0\\\\\\\\u5730\\\\\\\\u5740\\\\\\\").input((name) => {\\\\n            eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n            config = getConfig();\\\\n            if (input.match(/http/) == null) {\\\\n                return \\\\\\\"toast://\\\\\\\\u65e0\\\\\\\\u6548\\\\\\\\u7f51\\\\\\\\u5740\\\\\\\\uff01\\\\\\\";\\\\n            } else {\\\\n                for (var i = 0; i < config.data.length; i++) {\\\\n                    if (config.data[i].name == name) {\\\\n                        (config.data[i].url1 == undefined) ? config.data[i].url1 = input : config.data[i].url2 = input;\\\\n                        break;\\\\n                    }\\\\n                }\\\\n                writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                return \\\\\\\"toast://\\\\\\\\u65b0\\\\\\\\u589e\\\\\\\\u7f51\\\\\\\\u5740\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\";\\\\n            }\\\\n        }\\\\n        , v.name);\\\\n    }\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"★增加地址\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    let urls = v.url + \\\\\\\"$\\\\\\\" + v.url1 + \\\\\\\"$\\\\\\\" + v.url2;\\\\n    urls = urls.split(\\\\\\\"$\\\\\\\");\\\\n    urls = urls.filter(item => item != \\\\\\\"undefined\\\\\\\");\\\\n    for (let i = 0; i < urls.length; i++) {\\\\n        urls[i] = \\\\\\\"\\\\\\\\u5730\\\\\\\\u5740\\\\\\\" + (i == 0 ? \\\\\\\"\\\\\\\\u4e00\\\\\\\" : i == 1 ? \\\\\\\"\\\\\\\\u4e8c\\\\\\\" : \\\\\\\"\\\\\\\\u4e09\\\\\\\");\\\\n    }\\\\n    return $(urls).select((v) => {\\\\n        var editUrl = v.url;\\\\n        if (input == \\\\\\\"\\\\\\\\u5730\\\\\\\\u5740\\\\\\\\u4e8c\\\\\\\") {\\\\n            editUrl = v.url1;\\\\n        }\\\\n        if (input == \\\\\\\"\\\\\\\\u5730\\\\\\\\u5740\\\\\\\\u4e09\\\\\\\") {\\\\n            editUrl = v.url2;\\\\n        }\\\\n        return $(editUrl, \\\\\\\"\\\\\\\\u3010\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u3011\\\\\\\" + input).input((urlNo, name) => {\\\\n            eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n            config = getConfig();\\\\n            if (input == \\\\\\\"\\\\\\\") {\\\\n                return \\\\\\\"toast://\\\\\\\\u4e0d\\\\\\\\u80fd\\\\\\\\u4e3a\\\\\\\\u7a7a\\\\\\\";\\\\n            } else {\\\\n                if (input.match(/http/) == null) {\\\\n                    return \\\\\\\"toast://\\\\\\\\u5730\\\\\\\\u5740\\\\\\\\u6709\\\\\\\\u8bef\\\\\\\\uff01\\\\\\\";\\\\n                } else {\\\\n                    for (var i = 0; i < config.data.length; i++) {\\\\n                        if (config.data[i].name == name) {\\\\n                            if (urlNo == \\\\\\\"\\\\\\\\u5730\\\\\\\\u5740\\\\\\\\u4e00\\\\\\\") {\\\\n                                config.data[i].url = input;\\\\n                            } else {\\\\n                                if (urlNo == \\\\\\\"\\\\\\\\u5730\\\\\\\\u5740\\\\\\\\u4e8c\\\\\\\") {\\\\n                                    config.data[i].url1 = input;\\\\n                                } else {\\\\n                                    config.data[i].url2 = input;\\\\n                                }\\\\n                            }\\\\n                            break;\\\\n                        }\\\\n                    }\\\\n                    writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n                    refreshPage(false);\\\\n                    return \\\\\\\"toast://\\\\\\\\u3010\\\\\\\" + urlNo + \\\\\\\"\\\\\\\\u3011\\\\\\\\u4fee\\\\\\\\u6539\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\";\\\\n                }\\\\n            }\\\\n        }\\\\n        , input, v.name);\\\\n    }\\\\n    , v);\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"编辑地址\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    return $(v.pic, \\\\\\\"\\\\\\\\u3010\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u3011\\\\\\\\u5c01\\\\\\\\u9762\\\\\\\").input((name) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        if (input == \\\\\\\"\\\\\\\") {\\\\n            for (var i = 0; i < config.data.length; i++) {\\\\n                if (config.data[i].name == name) {\\\\n                    config.data[i].pic = input;\\\\n                    break;\\\\n                }\\\\n            }\\\\n            writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast(\\\\\\\"\\\\\\\\u5c01\\\\\\\\u9762\\\\\\\\u56fe\\\\\\\\u7247\\\\\\\\u7f6e\\\\\\\\u7a7a\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n        } else {\\\\n            if (input.match(/jpg|png|webp|gif|jpeg|bmp|svg/i) == null) {\\\\n                toast(\\\\\\\"\\\\\\\\u53ea\\\\\\\\u80fd\\\\\\\\u4e3a\\\\\\\\u56fe\\\\\\\\u7247\\\\\\\\u683c\\\\\\\\u5f0f!\\\\\\\");\\\\n            } else {\\\\n                for (var i = 0; i < config.data.length; i++) {\\\\n                    if (config.data[i].name == name) {\\\\n                        config.data[i].pic = input;\\\\n                        break;\\\\n                    }\\\\n                }\\\\n                writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                toast(\\\\\\\"\\\\\\\\u5c01\\\\\\\\u9762\\\\\\\\u56fe\\\\\\\\u7247\\\\\\\\u66f4\\\\\\\\u6539\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n            }\\\\n        }\\\\n    }\\\\n    , v.name);\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"编辑封面\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    showSelectOptions({\\\\\\\"title\\\\\\\": \\\\\\\"\\\\\\\\u66f4\\\\\\\\u6539\\\\\\\" + \\\\\\\"\\\\\\\\u3010\\\\\\\" + v.type + \\\\\\\"\\\\\\\\u3011\\\\\\\\u4e3a\\\\\\\", \\\\\\\"options\\\\\\\": [\\\\\\\"\\\\\\\\u7535\\\\\\\\u5f71\\\\\\\", \\\\\\\"\\\\\\\\u7535\\\\\\\\u89c6\\\\\\\\u5267\\\\\\\", \\\\\\\"\\\\\\\\u52a8\\\\\\\\u6f2b\\\\\\\", \\\\\\\"\\\\\\\\u7efc\\\\\\\\u827a\\\\\\\", \\\\\\\"\\\\\\\\u7eaa\\\\\\\\u5f55\\\\\\\\u7247\\\\\\\", \\\\\\\"MV\\\\\\\", \\\\\\\"\\\\\\\\u5408\\\\\\\\u96c6\\\\\\\", \\\\\\\"\\\\\\\\u77ed\\\\\\\\u89c6\\\\\\\\u9891\\\\\\\"], col: 4, js: $.toString((v) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        for (var i = 0; i < config.data.length; i++) {\\\\n            if (config.data[i].name == v.name) {\\\\n                config.data[i].type = input;\\\\n                break;\\\\n            }\\\\n        }\\\\n        writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n        refreshPage(false);\\\\n        toast(\\\\\\\"\\\\\\\\u5206\\\\\\\\u7c7b\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\u66f4\\\\\\\\u6539\\\\\\\\u4e3a\\\\\\\\u3010\\\\\\\" + input + \\\\\\\"\\\\\\\\u3011\\\\\\\");\\\\n    }\\\\n    , v)});\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"资源分类\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    return $(v.id, \\\\\\\"\\\\\\\\u3010\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u3011\\\\\\\\u8c46\\\\\\\\u74e3id\\\\\\\").input((name) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        if (input == \\\\\\\"\\\\\\\") {\\\\n            for (var i = 0; i < config.data.length; i++) {\\\\n                if (config.data[i].name == name) {\\\\n                    config.data[i].id = input;\\\\n                    break;\\\\n                }\\\\n            }\\\\n            writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast(\\\\\\\"id\\\\\\\\u7f6e\\\\\\\\u7a7a\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n        } else {\\\\n            if (input.match(/^[0-9]*$/) == null) {\\\\n                toast(\\\\\\\"id\\\\\\\\u53ea\\\\\\\\u80fd\\\\\\\\u4e3a\\\\\\\\u6570\\\\\\\\u5b57!\\\\\\\");\\\\n            } else {\\\\n                for (var i = 0; i < config.data.length; i++) {\\\\n                    if (config.data[i].name == name) {\\\\n                        config.data[i].id = input;\\\\n                        break;\\\\n                    }\\\\n                }\\\\n                writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                toast(\\\\\\\"id\\\\\\\\u66f4\\\\\\\\u6539\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n            }\\\\n        }\\\\n    }\\\\n    , v.name);\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"豆瓣id\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    showSelectOptions({\\\\\\\"title\\\\\\\": \\\\\\\"\\\\\\\\u66f4\\\\\\\\u6539\\\\\\\" + \\\\\\\"\\\\\\\\u3010\\\\\\\" + v.dataType + \\\\\\\"\\\\\\\\u3011\\\\\\\\u4e3a\\\\\\\", \\\\\\\"options\\\\\\\": [\\\\\\\"tv\\\\\\\", \\\\\\\"movie\\\\\\\"], col: 1, js: $.toString((name) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        for (var i = 0; i < config.data.length; i++) {\\\\n            if (config.data[i].name == name) {\\\\n                config.data[i].dataType = input;\\\\n                break;\\\\n            }\\\\n        }\\\\n        writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n        refreshPage(false);\\\\n        toast(\\\\\\\"\\\\\\\\u8c46\\\\\\\\u74e3\\\\\\\\u5206\\\\\\\\u7c7b\\\\\\\\u66f4\\\\\\\\u6539\\\\\\\\u6210\\\\\\\\u529f\\\\\\\\uff01\\\\\\\");\\\\n    }\\\\n    , v.name)});\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"豆瓣分类\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    if (!v.pic) {\\\\n        return $(v.name, \\\\\\\"\\\\\\\\u522e\\\\\\\\u524a\\\\\\\\u3010\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u3011\\\\\\\").input((name) => {\\\\n            try {\\\\n                eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n                config = getConfig();\\\\n                let s = input.replace(/\\\\\\\\s/, \\\\\\\"$\\\\\\\").split(\\\\\\\"$\\\\\\\")[0];\\\\n                let fetchUrl = \\\\\\\"https://m.douban.com/search/?query=\\\\\\\" + s + \\\\\\\"&type=1002\\\\\\\";\\\\n                let code = fetch(fetchUrl);\\\\n                let list = pdfa(code, \\\\\\\"body&&.search_results_subjects&&ul&&li\\\\\\\");\\\\n                let pic = pdfh(list[0], \\\\\\\"li&&img&&src\\\\\\\");\\\\n                let id = pdfh(list[0], \\\\\\\"li&&a&&href\\\\\\\").split(\\\\\\\"/\\\\\\\")[3];\\\\n                let typehtml = fetch(\\\\\\\"https://m.douban.com\\\\\\\" + pdfh(list[0], \\\\\\\"li&&a&&href\\\\\\\"));\\\\n                let dataType = pdfh(typehtml, \\\\\\\"body&&section,1&&data-type\\\\\\\");\\\\n                for (var i = 0; i < config.data.length; i++) {\\\\n                    if (config.data[i].name == name) {\\\\n                        config.data[i].id = id;\\\\n                        config.data[i].pic = pic;\\\\n                        config.data[i].dataType = dataType;\\\\n                        break;\\\\n                    }\\\\n                }\\\\n                writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                toast(\\\\\\\"\\\\\\\\u522e\\\\\\\\u524a\\\\\\\\u6210\\\\\\\\u529f!\\\\\\\");\\\\n            }\\\\n            catch (e) {\\\\n                toast(\\\\\\\"\\\\\\\\u522e\\\\\\\\u524a\\\\\\\\u5931\\\\\\\\u8d25\\\\\\\\uff01\\\\\\\");\\\\n            }\\\\n        }\\\\n        , v.name);\\\\n    } else {\\\\n        toast(\\\\\\\"\\\\\\\\u5df2\\\\\\\\u7ecf\\\\\\\\u522e\\\\\\\\u524a\\\\\\\\u8fc7!\\\\\\\");\\\\n    }\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"信息刮削\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    if (!v.top) {\\\\n        return $(\\\\\\\"\\\\\\\\u7f6e\\\\\\\\u9876\\\\\\\\u201c\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u201d\\\\\\\\uff1f\\\\\\\").confirm((name) => {\\\\n            eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n            config = getConfig();\\\\n            for (var i = 0; i < config.data.length; i++) {\\\\n                if (config.data[i].name == name) {\\\\n                    config.data[i].top = !config.data[i].top;\\\\n                    config.data.splice(0, 0, config.data.splice(i, 1)[0]);\\\\n                    break;\\\\n                }\\\\n            }\\\\n            writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast(\\\\\\\"\\\\\\\\u7f6e\\\\\\\\u9876\\\\\\\\u6210\\\\\\\\u529f!\\\\\\\");\\\\n        }\\\\n        , v.name);\\\\n    } else {\\\\n        return $(\\\\\\\"\\\\\\\\u53d6\\\\\\\\u6d88\\\\\\\\u201c\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u201d\\\\\\\\u7f6e\\\\\\\\u9876\\\\\\\\uff1f\\\\\\\").confirm((name) => {\\\\n            eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n            config = getConfig();\\\\n            for (var i = 0; i < config.data.length; i++) {\\\\n                if (config.data[i].name == name) {\\\\n                    config.data[i].top = !config.data[i].top;\\\\n                    config.data.splice(config.data.filter(i => i.top).length, 0, config.data.splice(i, 1)[0]);\\\\n                    break;\\\\n                }\\\\n            }\\\\n            writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast(\\\\\\\"\\\\\\\\u53d6\\\\\\\\u6d88\\\\\\\\u7f6e\\\\\\\\u9876\\\\\\\\u6210\\\\\\\\u529f!\\\\\\\");\\\\n        }\\\\n        , v.name);\\\\n    }\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"(取消)置顶\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    return $(\\\\\\\"\\\\\\\\u786e\\\\\\\\u5b9a\\\\\\\\u5206\\\\\\\\u4eab\\\\\\\\u8d44\\\\\\\\u6e90\\\\\\\\uff1f\\\\\\\").confirm((v) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        var data = \\\\\\\"\\\\\\\\u8d44\\\\\\\\u6e90\\\\\\\\u5e93\\\\\\\\u5206\\\\\\\\u4eab\\\\\\\\xa5\\\\\\\" + JSON.stringify(v);\\\\n        return \\\\\\\"copy://\\\\\\\" + data;\\\\n    }\\\\n    , v);\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"分 享\\\"},{\\\"js\\\":\\\"(\\\\n(v) => {\\\\n    return $(\\\\\\\"\\\\\\\\u786e\\\\\\\\u8ba4\\\\\\\\u5220\\\\\\\\u9664\\\\\\\\u201c\\\\\\\" + v.name + \\\\\\\"\\\\\\\\u201d\\\\\\\\uff1f\\\\\\\").confirm((name) => {\\\\n        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n        config = getConfig();\\\\n        config.data = config.data.filter(i => i.name != name);\\\\n        writeFile(getItem(\\\\\\\"file\\\\\\\"), JSON.stringify(config));\\\\n        refreshPage(false);\\\\n        toast(\\\\\\\"\\\\\\\\u5df2\\\\\\\\u7ecf\\\\\\\\u5220\\\\\\\\u9664\\\\\\\\u8be5\\\\\\\\u8d44\\\\\\\\u6e90!\\\\\\\");\\\\n    }\\\\n    , v.name);\\\\n}\\\\n)({\\\\\\\"name\\\\\\\":\\\\\\\"异人君莫邪 (周三)更新9\\\\\\\",\\\\\\\"url\\\\\\\":\\\\\\\"https://www.aliyundrive.com/s/m2ZXSJyfrgJ/folder/65b08abc1f625bc6ab914a7eb4ab20b69efa2cc1\\\\\\\",\\\\\\\"time\\\\\\\":\\\\\\\"2024-03-13\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"动漫\\\\\\\",\\\\\\\"id\\\\\\\":\\\\\\\"36141015\\\\\\\",\\\\\\\"pic\\\\\\\":\\\\\\\"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg\\\\\\\",\\\\\\\"dataType\\\\\\\":\\\\\\\"tv\\\\\\\",\\\\\\\"img\\\\\\\":\\\\\\\"https://img3.doubanio.com/view/photo/s/public/p2902485707.webp@Referer=https://img3.doubanio.com/view/photo/s/public/p2902485707.webp\\\\\\\",\\\\\\\"top\\\\\\\":true})\\\",\\\"title\\\":\\\"删  除\\\"}],\\\"pageTitle\\\":\\\"异人君莫邪 (周三)更新9\\\"}\",\"saved\":false,\"title\":\"影视库\",\"version\":0,\"url\":\"hiker://page/Sdetail#autoCache##noHistory##immersiveTheme#?name=异人君莫邪 (周三)更新9&type=tv&id=36141015\",\"col_type\":\"avatar\",\"find_rule\":\"js:\\nputVar('qdb_file', 'hiker://files/rules/joker/qdb.js');\\neval(fetch(getVar(\\\"qdb_file\\\")));\\npre();\\nlet name = getParam('name', ''),\\n type = getParam('type', ''),\\n id = getParam('id', '');\\nlet urls=getMyVar(\\\"url\\\",'').split(\\\"$$$\\\");\\nurls=urls.filter(item => item!=\\\"undefined\\\");\\ntry {\\nlet i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id);\\n    setPageTitle(i.title);\\n    let info = \\\"\\\";\\n    if (i.is_tv) {\\n        info = [i.countries ? i.countries.join(\\\" \\\") : null, i.genres ? i.genres.join(\\\" \\\") : null, i.pubdate ? i.pubdate[0] + \\\"首播\\\" : null, i.episodes_count ? \\\"共\\\" + i.episodes_count + \\\"集\\\" : null, i.durations ? \\\"单集片长\\\" + i.durations : null].filter((e => null !== e)).join(\\\" / \\\");\\n    } else {\\n        info = [i.countries ? i.countries.join(\\\" \\\") : null, i.genres ? i.genres.join(\\\" \\\") : null, i.pubdate ? i.pubdate[0] + \\\"首播\\\" : null, i.durations ? \\\"片长\\\" + i.durations : null].filter((e => null !== e)).join(\\\" / \\\");\\n    }\\n    let infoItems = [{\\n        title: i.title + \\\"\\\\n\\\" + i.original_title + \\\"(\\\" + i.year + \\\")\\\",\\n        desc: info || i.card_subtitle,\\n        img: i.pic.normal + \\\"@Referer=\\\" + i.pic.normal,\\n        col_type: \\\"movie_1_vertical_pic_blur\\\",\\n        url: 'hiker://empty'\\n    }];\\n    let rating = \\\"\\\";\\n    if (i.rating) {\\n        rating = computeRating(i.rating.max, i.rating.value);\\n    }\\n    let ratingItems = [];\\n    let color = getConfig('starColor');\\n    let ratingTitle = ''\\n    if (rating) {\\n        ratingTitle = '豆瓣评分™'.bold() + '<br>' + rating.fontcolor(color) + '&nbsp;&nbsp;' + (i.rating.value.toFixed(1) + '分').bold();\\n    } else {\\n        ratingTitle = '暂无评分'.bold() + '<br>' + '点我查看影片信息'.fontcolor('grey');\\n    }\\n    ratingItems = [{\\n        title: '““””' + ratingTitle,\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            lineVisible: false\\n        },\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((type, id, ratingCount) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            rating(type, id, ratingCount);\\n        }, i.subtype, i.id, i.rating ? i.rating.count : 0)\\n    }];\\n\\n    let relatedItems = [{\\n        title: \\\"短评\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/短评.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            shortCommentList(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    }, {\\n        title: \\\"剧评\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧评.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            dramaReviewList(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    },{\\n        title: \\\"剧照\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧照.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            stillsList(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    }, {\\n        title: \\\"演职\\\",\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/演职.png\\\",\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n            eval(fetch(getVar(\\\"qdb_file\\\")));\\n            credits(t[0], t[1]);\\n        }, [i.subtype, i.id]),\\n        col_type: \\\"icon_round_small_4\\\"\\n    }];\\n    let introItems = [];\\n    if (i.intro) {\\n        introItems = [ {\\ntitle: '““””<font color=\\\"#ff148e8e\\\"><b>剧情简介：</b>'+i.intro.replace(/\\\\n/g, \\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\").replace(/\\\\s/g, \\\" \\\").replace(/\\\\t/g, \\\" \\\").substr(0, 50)+'...</font><small><font color=\\\"red\\\">详情</font></small>',\\n          url: \\\"hiker://empty##\\\"+i.intro.replace(/\\\\n/g, \\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\").replace(/\\\\s/g, \\\" \\\").replace(/\\\\t/g, \\\" \\\")+`@rule=js:var res = {}; var d = [];d.push({title:'&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'+MY_URL.split('##')[1],col_type:'rich_text'});res.data = d;\\nsetHomeResult(res);`,\\n            col_type: \\\"text_1\\\"\\n        }]\\n    }\\n\\n  let videoRelatedItems = [];\\r\\n    if (i.trailer) {\\r\\n        videoRelatedItems.push({\\r\\n            title: i.title+\\\" - 预告片、花絮\\\",\\r\\n            img: \\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/more/356.png\\\",\\r\\n            url: \\n$('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\n                eval(fetch(getVar(\\\"qdb_file\\\")));\\n                trailers(t[0], t[1]);\\n            }, [i.subtype, i.id]),\\r\\n            col_type: \\\"avatar\\\"\\r\\n        });\\r\\n    }\\n\\n    let linkItems = [];\\n    let title=i.title;\\n    urls.forEach((v, i) => { \\n       linkItems.push({\\n          title: v.includes(\\\"m3u8\\\")?(i+1)+' - '+title+'【视频资源】':v.includes(\\\"ali\\\")?(i+1)+' -'+title+' 【阿里资源】':(i+1)+' - '+title+'【夸克资源】',\\n         img:\\n\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/143.svg\\\",\\n        col_type: 'avatar',\\n        extra: {\\n                lineVisible: false,\\n                PageTitle:title,\\n                longClick:[{\\n                      title: '更改地址', \\n                      js:$.toString((url,name,i)=>{ \\n       return $(url, '【'+name+'】地址').input((name,urlNo) => {\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n          config = getConfig();\\n          if (input.match(/http/)==null){ \\n              return \\\"toast://地址有误！\\\"\\n          } else {\\n          for (let i=0;i<config.data.length;i++) {\\n             if (config.data[i].name==name){\\n                if(urlNo==0){\\n                    config.data[i].url=input\\n                } else if(urlNo==1){\\n                    config.data[i].url1=input\\n                } else {\\n                     config.data[i].url2=input\\n                }\\n             putMyVar(\\\"url\\\",config.data[i].url+\\\"$$$\\\"+config.data[i].url1+\\\"$$$\\\"+config.data[i].url2);\\n               break;\\n             }\\n          }   \\n   writeFile(getItem('file'), JSON.stringify(config));\\n               refreshPage(false)\\n               return 'toast://地址修改成功'\\n           }\\n         },name,i)\\n       },v,name,i)  \\n    },{\\n                      title: '删除地址', \\n                      js:$.toString((name,i)=>{ \\n       return $(\\\"确认删除“\\\"+name+\\\"”？\\\").confirm((name,urlNo)=>{\\n                         eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n          config = getConfig();\\n          for (let i=0;i<config.data.length;i++) {\\n             if (config.data[i].name==name){\\n                if(urlNo==0){\\n                    delete config.data[i].url\\n                } else if(urlNo==1){\\n                    delete   config.data[i].url1\\n                } else {\\n                    delete config.data[i].url2\\n                }\\n             putMyVar(\\\"url\\\",config.data[i].url+\\\"$$$\\\"+config.data[i].url1+\\\"$$$\\\"+config.data[i].url2);\\n               break;\\n             }\\n          }   \\n   writeFile(getItem('file'), JSON.stringify(config));\\n               refreshPage(false)\\n               return 'toast://删除成功'\\n         },name,i)\\n       },name,i)  \\n    }]\\n        },\\n        url: $(\\\"#noLoading#\\\").lazyRule((url) => { \\n              if (url.includes(\\\"ali\\\")) { \\n                  return    \\\"hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=\\\"+url\\n               } else if (url.includes(\\\"quark\\\")) { \\n                 return \\\"hiker://page/quarkList?realurl=\\\" + encodeURIComponent(url) + \\\"&rule=Quark.简&sharePwd=\\\"\\n               } else {\\n                 return url\\n               }\\n         },v)           \\n    })\\n});\\n    let config = JSON.parse(fetch(getVar('qdb_config')));\\n\\n    let analysisConfigs = getConfig('analysisConfigs', config);\\n    let extraConfig = analysisConfigs[analysisConfigs.use].extra || '{}';\\n    let extra = {};\\n    try {\\n        if (extraConfig.startsWith('{')) eval('extra=' + extraConfig);\\n    } catch (e) {}\\n    let quickSearchConfigs = getConfig('quickSearchConfigs', config);\\n    let quickSearchItems = [];\\n    quickSearchConfigs.order.forEach(quickSearchItem => {\\n        if (quickSearchConfigs[quickSearchItem]) {\\n            quickSearchItems.push({\\n                title: quickSearchItem,\\n                img: quickSearchConfigs[quickSearchItem].pic,\\n                col_type: quickSearchConfigs.mode || 'icon_small_4',\\n                url: 'hiker://search?s=' + i.title + '&rule=' + quickSearchConfigs[quickSearchItem].name\\n            })\\n        }\\n    })\\n    setHomeResult({\\n        data: infoItems.concat(ratingItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n           .concat(introItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(relatedItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(quickSearchItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(videoRelatedItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat(linkItems)\\n            .concat({\\n                col_type: 'line'\\n            })\\n            .concat({\\r\\n                col_type: 'text_1',\\r\\n                title: '““””<small><font color=#871f78>本规则及数据均收集自网络，仅限学习交流使用，请于导入后24小时内删除，不得以任何方式传播！</font></small>',\\r\\n                url: 'hiker://empty',\\r\\n                extra: {\\r\\n                    lineVisible: false\\r\\n                }\\r\\n            })\\n      })\\n} catch(e){toast(\\\"类型错误，资源获取出错！\\\");\\n }\",\"group\":\"①推荐\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"收藏页\\\",\\\"path\\\":\\\"alp\\\",\\\"rule\\\":\\\"js:\\\\nsetPageTitle('资源收藏')\\\\nvar d = [];    \\\\nvar  item=[];\\\\n//log(MY_URL)\\\\nvar s = MY_URL.split(\\\\\\\"link=\\\\\\\")[1]\\\\n s = decodeURIComponent(s);\\\\n//log(s)\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\nputMyVar('time',nowTime() );\\\\nif (getMyVar('item')==''){\\\\n   if (s.includes(\\\\\\\"资源库分享\\\\\\\")){\\\\n      s=JSON.parse(s.split(\\\\\\\"¥\\\\\\\")[1])\\\\n      item.push(s);\\\\n   } else {\\\\n      if (s.includes(\\\\\\\"m3u8\\\\\\\")) {\\\\n          s=s.replace(/(https?:\\\\\\\\/\\\\\\\\/\\\\\\\\S*.m3u8)/ig,'¥¥$1¥¥');\\\\n          log(s)\\\\n       } else {\\\\n          s=s.replace(/(https?:\\\\\\\\/\\\\\\\\/[a-zA-Z0-9\\\\\\\\.\\\\\\\\?=\\\\\\\\/]*)/ig,'¥¥$1¥¥');\\\\n       }\\\\n      var content=s.split('¥¥');\\\\n      content = content.filter(v => v);\\\\n      for ( var i = 0; i< content.length; i++ ) {\\\\n          if (content[i].includes(\\\\\\\"http\\\\\\\")){\\\\n              var title=content[i-1];\\\\n              if (title==''||title==undefined) { title='未获取到名称' };\\\\n                title=title.replace('\\\\\\\\n',\\\\\\\"\\\\\\\");\\\\n                item.push({           \\\\n                    name: title.replace(/^\\\\\\\\s*|\\\\\\\\s*$/g,\\\\\\\"\\\\\\\"),             \\\\n                    url:content[i],\\\\n                    time:getMyVar('time',''),\\\\n                    type:'未分类'\\\\n                });\\\\n           }\\\\n      }\\\\n   }\\\\n   putMyVar('item', JSON.stringify(item));\\\\n} \\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n        clearMyVar(\\\\\\\"item\\\\\\\");refreshPage();\\\\n    }));\\\\nitem=JSON.parse(getMyVar('item'))\\\\n\\\\nitem.forEach((v,i) => {\\\\n     let el = {\\\\n          title:'📂 '+v.name,     \\\\n          col_type: \\\\\\\"text_1\\\\\\\",\\\\n      }   \\\\n      el.url= $(v.url).lazyRule(() => {\\\\nlog(input)\\\\n          if (input.includes(\\\\\\\"ali\\\\\\\")){\\\\n                    return 'hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=' +input ; \\\\n          } else if (input.includes(\\\\\\\"quark\\\\\\\")){\\\\n                    return  \\\\\\\"hiker://page/quarkList?realurl=\\\\\\\" + encodeURIComponent(input) + \\\\\\\"&rule=Quark.简&sharePwd=\\\\\\\";\\\\n          }\\\\n       });\\\\n      el.extra= { \\\\n          pageTitle:v.name,\\\\n          longClick:[{\\\\n                title:'编辑名称',\\\\n                js:$.toString((v,i)=>{ \\\\nreturn $(v.name, '【'+v.name+'】名称').input((i) =>{\\\\n                            if (input == \\\\\\\"\\\\\\\") {\\\\n                                return \\\\\\\"toast://不能为空\\\\\\\"\\\\n                             } else {\\\\n             let item=JSON.parse(getMyVar('item'));\\\\n                                   item[i].name=input;\\\\n              putMyVar('item', JSON.stringify(item)); \\\\n                                   refreshPage(false)\\\\n                                   return 'toast://重命名成功！'\\\\n                             } \\\\n                                 },i)\\\\n                           },v,i)\\\\n                         },{\\\\n                         title:'编辑分类',\\\\n                         js:$.toString((v,i)=>{ \\\\n                              showSelectOptions({\\\\n                   \\\\\\\"title\\\\\\\": \\\\\\\"更改【\\\\\\\"+v.type+\\\\\\\"】为\\\\\\\", \\\\n                \\\\\\\"options\\\\\\\" : [\\\\\\\"电影\\\\\\\", \\\\\\\"电视剧\\\\\\\",\\\\\\\"动漫\\\\\\\",\\\\\\\"综艺\\\\\\\",\\\\\\\"纪录片\\\\\\\",\\\\\\\"MV\\\\\\\",\\\\\\\"合集\\\\\\\",\\\\\\\"短视频\\\\\\\"], \\\\n                 col: 4, \\\\n                 js:$.toString((i)=>{                     \\\\n          let item=JSON.parse(getMyVar('item'));\\\\n                        item[i].type = input;\\\\n              putMyVar('item', JSON.stringify(item)); \\\\n                        refreshPage(false)\\\\n                        return toast('分类成功更改为【'+input+'】');\\\\n                 },i)\\\\n            });\\\\n                         },v,i)\\\\n                         },{\\\\n                         title:'添加收藏',\\\\n                         js:$.toString((v,i)=>{ \\\\n                             return \\\\\\\"confirm://确认收藏：\\\\\\\" + v.name + \\\\\\\".js:\\\\\\\" + $.toString((i) =>{              \\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n                              config = getConfig();\\\\n             let item=JSON.parse(getMyVar('item'));\\\\n                              if (config.data.filter(v =>v.name==item[i].name)==''){     \\\\n                                        try {\\\\n                                             let s= item[i].name.replace(/\\\\\\\\s/,\\\\\\\"$\\\\\\\").split(\\\\\\\"$\\\\\\\")[0] ;                    \\\\n                                             let fetchUrl =  'https://m.douban.com/search/?query='+s+'&type=1002';\\\\n                                             let code = fetch(fetchUrl);\\\\n                                             let list  =\\\\npdfa(code,\\\\\\\"body&&.search_results_subjects&&ul&&li\\\\\\\")\\\\n                                             let pic = pdfh(list[0],\\\\\\\"li&&img&&src\\\\\\\");\\\\n                                             let id= pdfh(list[0],\\\\\\\"li&&a&&href\\\\\\\").split(\\\\\\\"/\\\\\\\")[3]\\\\n                                            let typehtml=\\\\nfetch(\\\\\\\"https://m.douban.com\\\\\\\"+pdfh(list[0],\\\\\\\"li&&a&&href\\\\\\\"));\\\\n                                           let dataType=\\\\npdfh(typehtml,\\\\\\\"body&&section,1&&data-type\\\\\\\")\\\\n//log(dataType)\\\\n                                             item[i].id=id;\\\\n                                             item[i].pic=pic; \\\\n                         item[i].dataType=dataType; \\\\n                                         } catch(e){item[i].id=''}                        \\\\nconfig.data.splice(config.data.filter(i => i.top).length, 0,item[i] )\\\\n                                        writeFile(getItem('file'), JSON.stringify(config));\\\\n                                        refreshPage(false);\\\\n                                        return \\\\\\\"toast://收藏成功！\\\\\\\";\\\\n                               } else {\\\\n                                  return \\\\\\\"toast://已经收藏过了！\\\\\\\"}\\\\n                              },i)\\\\n                         },v,i)\\\\n          }]\\\\n      }\\\\n      d.push(el)\\\\n})      \\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"加载数据\\\",\\\"path\\\":\\\"config\\\",\\\"rule\\\":\\\"function getConfig() {\\\\n    let  mode = getItem('mode', '本地');\\\\n    if (mode == \\\\\\\"本地\\\\\\\")  { setItem('file',  'hiker://files/rules/catzz/aliyunku/local.json');}    \\\\n     else { setItem('file', 'hiker://files/rules/catzz/aliyunku/panku.json'); }\\\\n     try {\\\\n        let config = fetch(getItem('file'));\\\\n        if (!config || config == \\\\\\\"\\\\\\\") {\\\\n            return {\\\\n                data: [],\\\\n                version: 0\\\\n            }\\\\n        } else {\\\\n            return JSON.parse(config)\\\\n        }\\\\n    } catch (e) {\\\\n        try {\\\\n            toast(\\\\\\\"数据文件格式出错！\\\\\\\")\\\\n        } catch (e) {}\\\\n        return {\\\\n            data: [],\\\\n            version: 0\\\\n        }\\\\n    }\\\\n}\\\\nfunction nowTime() {\\\\n        var date = new Date();\\\\n        var YY = date.getFullYear() + '-';\\\\n        var MM = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';\\\\n        var DD = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate());\\\\n        return YY + MM + DD ;\\\\n}\\\\nfunction sorts(list, method) {\\\\n        let toplist=list.filter(i => i.top)\\\\n        toplist.reverse()\\\\n        if (method.includes(\\\\\\\"名称\\\\\\\")) {         \\\\n            list.sort(function(a, b) {\\\\n                return              a.name.localeCompare(b.name)\\\\n            })            \\\\n        } else if (method.includes(\\\\\\\"时间\\\\\\\")) {\\\\n            list.sort(function(a, b) {\\\\n                return new Date(b.time) - new Date(a.time)\\\\n            })\\\\n        } \\\\n        if (method.includes(\\\\\\\"反\\\\\\\")) {\\\\n            list.reverse()\\\\n        }\\\\n         //log(toplist)\\\\n        list=list.filter(i =>! i.top) \\\\n        toplist.forEach(v => {list.splice(0, 0,v)})\\\\n        return  list\\\\n }\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"设置页\\\",\\\"path\\\":\\\"setting\\\",\\\"rule\\\":\\\"function setting() {\\\\n    function getColoredText(text) {\\\\n        return '““””<span style=\\\\\\\"color: #19B89D\\\\\\\">' + text + '</span>';\\\\n    }\\\\n    const d = [];\\\\n    let interval = getItem('interval', '24');\\\\n    let pagenum = getItem('pagenum', '20');\\\\n    let  modeList=[\\\\\\\"本地模式\\\\\\\", \\\\\\\"远程模式\\\\\\\"];\\\\n    let  mode = getItem('mode', '本地');\\\\n    if (mode == \\\\\\\"本地\\\\\\\")  {\\\\n         modeList=[\\\\\\\"本地模式 ✅\\\\\\\", \\\\\\\"远程模式\\\\\\\"];\\\\n       } else {  \\\\n         modeList=[\\\\\\\"本地模式\\\\\\\", \\\\\\\"远程模式 ✅\\\\\\\"];\\\\n    }\\\\n      d.push({\\\\n        title: mode+'模式',\\\\n        col_type: \\\\\\\"icon_round_4\\\\\\\",\\\\n        pic_url: \\\\\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/54.svg\\\\\\\",\\\\n        url: $(modeList, 1).select(() => {\\\\n           return $('确定切换？').confirm((mode) => {  \\\\n                  if (mode == \\\\\\\"本地模式\\\\\\\")  {\\\\n                         setItem('mode', '本地');\\\\n                         refreshPage();\\\\n                    } else if (mode == \\\\\\\"远程模式\\\\\\\"){\\\\n                         setItem('mode', '远程');\\\\n                         refreshPage();\\\\n                    } \\\\n              }, input)\\\\n           })   \\\\n    });    \\\\n    d.push({\\\\n        title: \\\\\\\"显示设置\\\\\\\",\\\\n        desc: \\\\\\\"\\\\\\\",\\\\n        pic_url: \\\\\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/17.svg\\\\\\\",\\\\n        col_type: \\\\\\\"icon_round_4\\\\\\\",\\\\n        url:  $(pagenum, '输入单页列表数量').input(() => {\\\\n            if (parseInt(input) >= 10) {\\\\n                setItem('pagenum', input);\\\\n            } else { setItem('pagenum', '20')}\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://设置成功，每页显示数量:\\\\\\\"+getItem('pagenum', '20')\\\\n        }),\\\\n    })\\\\n   d.push({\\\\n        title: \\\\\\\"文件编辑\\\\\\\",\\\\n        desc: \\\\\\\"\\\\\\\",\\\\n        col_type: \\\\\\\"icon_round_4\\\\\\\",\\\\n        pic_url: \\\\\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/10.svg\\\\\\\",\\\\n        url:getItem('mode', '本地')=='本地'? \\\\\\\"editFile://hiker://files/rules/catzz/aliyunku/local.json\\\\\\\":\\\\\\\"editFile://hiker://files/rules/catzz/aliyunku/panku.json\\\\\\\"\\\\n    })\\\\nd.push({\\\\n        title: \\\\\\\"数据同步\\\\\\\",\\\\n        desc: \\\\\\\"\\\\\\\",\\\\n        col_type: \\\\\\\"icon_round_4\\\\\\\",\\\\n        pic_url: \\\\\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/lmtubiao/main/messy/7.svg\\\\\\\",\\\\n        url: getItem('mode', '本地')=='本地'?\\\\\\\"toast://请切换到远程模式再同步！！！\\\\\\\": $('确认同步').confirm(() => {\\\\n                try { \\\\n                      let webdav = buildWebDav('http://morrainny.asuscomm.cn:5005/web/panku', 'hotcats', 'zhen992176'); \\\\nwebdav.upload('panku.json','hiker://files/rules/catzz/aliyunku/panku.json')\\\\n                      refreshPage()\\\\n                      return \\\\\\\"toast://同步成功！\\\\\\\"\\\\n                } catch(e) { toast(\\\\\\\"同步失败！\\\\\\\")}\\\\n        }),\\\\n    })\\\\n    d.push({\\\\n        title: \\\\\\\"\\\\\\\",\\\\n        desc: \\\\\\\"\\\\\\\",\\\\n        col_type: \\\\\\\"line\\\\\\\",\\\\n        url: \\\\\\\"'\\\\\\\",\\\\n    })\\\\n\\\\n    addListener(\\\\\\\"onRefresh\\\\\\\", $.toString(() => {\\\\n        clearMyVar(\\\\\\\"editMode\\\\\\\");}));    \\\\n\\\\n    let editMode = getMyVar('editMode', '批量分类');\\\\n    [ '批量分类','重新排序',  '批量删除'].forEach((v) => {\\\\n        d.push({\\\\n            title: v == editMode ? '““””' + v.bold().fontcolor('#19B89D') : v,\\\\n            url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\\\n                putMyVar('editMode', v)\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, v),\\\\n            col_type: 'flex_button'\\\\n        })\\\\n    });\\\\n\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n config = getConfig();\\\\nlet flagSort = config.data.filter(i => i.checked);\\\\nlet flagDelete = config.data.filter(i => i.delete);\\\\n switch (editMode) {\\\\n     case \\\\\\\"批量分类\\\\\\\":\\\\n           flagSort.length?\\\\n            d.push({\\\\n                 title: \\\\\\\"““””选择分类\\\\\\\".bold(),\\\\n                 col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n              url: $([ \\\\\\\"电影\\\\\\\",\\\\\\\"电视剧\\\\\\\",\\\\\\\"综艺\\\\\\\",\\\\\\\"动漫\\\\\\\",\\\\\\\"MV\\\\\\\",\\\\\\\"纪录片\\\\\\\",\\\\\\\"合集\\\\\\\",\\\\\\\"短视频\\\\\\\"],4).select((config) => {            \\\\n              for (var i=0;i<config.data.length;i++) {\\\\n                              if (config.data[i].checked){\\\\n                              config.data[i].type=input;\\\\n                              config.data[i].checked=false\\\\n                              };\\\\n                           }\\\\n                    \\\\nwriteFile(getItem('file'), JSON.stringify(config));\\\\n                    refreshPage(false);\\\\n                    return \\\\\\\"toast://所选资源分类更改成功！\\\\\\\";\\\\n                   },config)\\\\n          }) : \\\\\\\"\\\\\\\"\\\\n     break;\\\\n     case \\\\\\\"批量删除\\\\\\\":\\\\n           flagDelete.length?\\\\n            d.push({\\\\n                 title: \\\\\\\"““””删除确认\\\\\\\".bold(),\\\\n                 col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n                 url: $('确认删除').confirm((config) => {\\\\n                    let rules = [];\\\\n                    config.data.forEach((x) => {\\\\n                        !x.delete ? rules.push(x) : null\\\\n                        });\\\\n                     config.data=rules;\\\\nwriteFile(getItem('file'),JSON.stringify(config));\\\\n                       refreshPage(false);\\\\n                       return 'hiker://empty'\\\\n                    },config)\\\\n          }) : \\\\\\\"\\\\\\\"\\\\n      break\\\\n  };\\\\n\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n    config = getConfig();\\\\n    config.data.forEach((v, i) => {\\\\n        let el = {\\\\n             title: v.top ? '🆙'+v.name : v.name,\\\\n             col_type: \\\\\\\"text_2\\\\\\\"\\\\n             }\\\\n        switch (editMode) {\\\\n            case '批量分类':\\\\n                if (v.type=='未分类'){\\\\n                    el.title='📌'+'[未分类]'+el.title\\\\n                 } else {\\\\n                      el.title='['+v.type+']'+el.title\\\\n                    }\\\\n                el.title = (v.checked ? '✅' : ' ') + el.title;\\\\n                el.url = $('#noLoading#').lazyRule((i) => {\\\\n                eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n                       config = getConfig();\\\\n                       config.data[i].checked = !config.data[i].checked;                      writeFile(getItem('file'),JSON.stringify(config));\\\\n                       refreshPage(false);\\\\n                       return 'hiker://empty'\\\\n            }, i);\\\\n          break\\\\n          case '重新排序':\\\\n                let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\\\n                el.title = (sortFlag == i ? '🔃  ' : '') + el.title\\\\n                if (sortFlag == -1)\\\\n                    el.url = $('#noLoading#').lazyRule((i) => {\\\\n                        putMyVar('sortFlag', i.toString())\\\\n                        refreshPage(false)\\\\n                        return 'hiker://empty'\\\\n                    }, i)\\\\n                else\\\\n                    el.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\\\n                        eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n                        config = getConfig();\\\\n                        if (config.data[oldIndex].top&&newIndex<config.data.filter(i => i.top).length) {\\\\n                             config.data.splice(newIndex, 0, config.data.splice(oldIndex, 1)[0]);\\\\n                              writeFile(getItem('file'),         JSON.stringify(config));\\\\n                              putMyVar('sortFlag', '-1')\\\\n                              refreshPage(false)\\\\n                              return 'hiker://empty'\\\\n                        } else if (!config.data[oldIndex].top&&newIndex>config.data.filter(i => i.top).length-1) {\\\\n                             config.data.splice(newIndex, 0, config.data.splice(oldIndex, 1)[0]);\\\\n                              writeFile(getItem('file'),         JSON.stringify(config));\\\\n                              putMyVar('sortFlag', '-1')\\\\n                              refreshPage(false)\\\\n                              return 'hiker://empty'\\\\n                        } else {\\\\n                            return 'toast://移动的位置不正确！'\\\\n                         }\\\\n\\\\n                    }, sortFlag, i)\\\\n            break\\\\n            case '批量删除':\\\\n                el.title = (v.delete ? '❌' : '') + el.title;      \\\\n                el.url = $('#noLoading#').lazyRule((i) => {\\\\n                eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n                config = getConfig();\\\\n                config.data[i].delete = !config.data[i].delete;                      writeFile(getItem('file'),JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                return 'hiker://empty'\\\\n            }, i);          \\\\n           break\\\\n        }\\\\n        d.push(el)\\\\n    });\\\\n    return d;\\\\n}\\\\n\\\\n$.exports = {\\\\n    setting: setting\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"长按菜单\\\",\\\"path\\\":\\\"longClick\\\",\\\"rule\\\":\\\"var longClick=[\\\\n    {\\\\n       title: '青豆搜索', \\\\n          js:$.toString((v)=>{ \\\\n              return 'hiker://search?s=' +v.name.replace(/\\\\\\\\s/,\\\\\\\"$\\\\\\\").split(\\\\\\\"$\\\\\\\")[0] + '&rule=青豆'},v)  \\\\n     },{\\\\n       title: '编辑名称', \\\\n       js:$.toString((v)=>{ \\\\nreturn $(v.name, '【'+v.name+'】名称').input((name) => { eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n           config = getConfig();\\\\n           let renFlag=1;\\\\n           if (input) {\\\\n              for (var j=0;j<config.data.length;j++)  {\\\\n                   if (config.data[j].name.replace(/\\\\\\\\s/g,\\\\\\\"\\\\\\\")==input.replace(/\\\\\\\\s/g,\\\\\\\"\\\\\\\")) {                   \\\\n                       renFlag=0;\\\\n                       break;\\\\n                   }\\\\n              }\\\\n              if (renFlag) {\\\\n                  for (var i=0;i<config.data.length;i++) {\\\\n                      if (config.data[i].name==name){\\\\n                            config.data[i].name=input;\\\\n                            config.data[i].time = getMyVar('time','');\\\\n                            if (!config.data[i].top) {\\\\n                            config.data.splice(config.data.filter(i => i.top).length, 0, config.data.splice(i, 1)[0])\\\\n                             } else {\\\\n                            config.data.splice(0, 0, config.data.splice(i, 1)[0])\\\\n                             };\\\\n                           break;\\\\n                       } \\\\n                   }\\\\n                   writeFile(getItem('file'), JSON.stringify(config));\\\\n                   refreshPage(false);\\\\n                   toast('重命名成功！');\\\\n              } else {\\\\n                   toast('文件名已存在！')\\\\n              }\\\\n           } else {\\\\n                  toast('名称不能为空！')\\\\n           }\\\\n         },v.name)\\\\n       },v)  \\\\n    },{\\\\n       title: '★编辑海报', \\\\n       js:$.toString((v)=>{ \\\\nreturn $(v.img, '【'+v.name+'】海报').input((name) => {\\\\n                         eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n    config = getConfig();\\\\n         if (input == \\\\\\\"\\\\\\\") {\\\\n             for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].img=input;\\\\n                       break;\\\\n                     }\\\\n               }\\\\n writeFile(getItem('file'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast('海报置空成功！');\\\\n          } else if (input.match(/jpg|png|webp|gif|jpeg|bmp|svg/i)==null){ \\\\n             toast('只能为图片格式!')\\\\n          } else {\\\\n             for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].img=input;\\\\n                       break;\\\\n                     }\\\\n               }\\\\n writeFile(getItem('file'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast('海报更改成功！');\\\\n          } \\\\n         },v.name)\\\\n       },v)  \\\\n    },{\\\\n       title: '★增加地址', \\\\n       js:$.toString((v)=>{ \\\\n          if (v.url2!=undefined) {\\\\n             return  \\\\\\\"toast://网址已达上限！\\\\\\\"\\\\n          } else {\\\\n           return $('','输入【'+v.name+'】新地址').input((name) => {\\\\n                         eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n          config = getConfig();\\\\n         if (input.match(/http/)==null){ \\\\n              return \\\\\\\"toast://无效网址！\\\\\\\"\\\\n          } else {\\\\n       for (var i=0;i<config.data.length;i++) {\\\\n                if (config.data[i].name==name){\\\\n  (config.data[i].url1==undefined)?config.data[i].url1=input:config.data[i].url2=input;\\\\n                    break;\\\\n                }\\\\n        }   \\\\n               writeFile(getItem('file'), JSON.stringify(config));\\\\n               refreshPage(false)\\\\n               return 'toast://新增网址成功！'\\\\n           }\\\\n         },v.name)\\\\n       }\\\\n      },v)  \\\\n    },{\\\\n       title: '编辑地址', \\\\n       js:$.toString((v)=>{\\\\n           let urls=v.url+\\\\\\\"$\\\\\\\"+v.url1+\\\\\\\"$\\\\\\\"+v.url2;\\\\n           urls=urls.split(\\\\\\\"$\\\\\\\");\\\\n           urls=urls.filter(item => item!=\\\\\\\"undefined\\\\\\\");\\\\n           for (let i=0;i<urls.length;i++){\\\\n                 urls[i]=\\\\\\\"地址\\\\\\\"+(i==0?\\\\\\\"一\\\\\\\":i==1?\\\\\\\"二\\\\\\\":\\\\\\\"三\\\\\\\")\\\\n           }\\\\n           return $(urls).select((v) => {\\\\n              var editUrl=v.url;\\\\n              if (input==\\\\\\\"地址二\\\\\\\")editUrl=v.url1;\\\\n              if (input==\\\\\\\"地址三\\\\\\\")editUrl=v.url2;\\\\n              return $(editUrl, '【'+v.name+'】'+input).input((urlNo,name) => {\\\\n eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n          config = getConfig();\\\\n          if (input == \\\\\\\"\\\\\\\") {\\\\n              return \\\\\\\"toast://不能为空\\\\\\\"\\\\n          } else if (input.match(/http/)==null){ \\\\n              return \\\\\\\"toast://地址有误！\\\\\\\"\\\\n          } else {\\\\n              for (var i=0;i<config.data.length;i++) {\\\\n                  if (config.data[i].name==name){\\\\n                       if (urlNo==\\\\\\\"地址一\\\\\\\"){\\\\n                           config.data[i].url=input;\\\\n                        } else if (urlNo==\\\\\\\"地址二\\\\\\\"){\\\\n                           config.data[i].url1=input;\\\\n                        } else {\\\\n                            config.data[i].url2=input;\\\\n                        }\\\\n                        break;\\\\n                     }\\\\n               }   \\\\n               writeFile(getItem('file'), JSON.stringify(config));\\\\n               refreshPage(false)\\\\n               return 'toast://【'+urlNo+'】修改成功！'\\\\n             }\\\\n            },input,v.name)\\\\n         },v)\\\\n      },v)  \\\\n    },{\\\\n       title: '编辑封面', \\\\n       js:$.toString((v)=>{ \\\\nreturn $(v.pic, '【'+v.name+'】封面').input((name) => {\\\\n                         eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n    config = getConfig();\\\\n         if (input == \\\\\\\"\\\\\\\") {\\\\n             for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].pic=input;\\\\n                       break;\\\\n                     }\\\\n               }\\\\n writeFile(getItem('file'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast('封面图片置空成功！');\\\\n          } else if (input.match(/jpg|png|webp|gif|jpeg|bmp|svg/i)==null){ \\\\n             toast('只能为图片格式!')\\\\n          } else {\\\\n             for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].pic=input;\\\\n                       break;\\\\n                     }\\\\n               }\\\\n writeFile(getItem('file'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast('封面图片更改成功！');\\\\n          } \\\\n         },v.name)\\\\n       },v)  \\\\n    },{\\\\n       title: '资源分类', \\\\n       js:$.toString((v)=>{ \\\\n           showSelectOptions({\\\\n              \\\\\\\"title\\\\\\\": \\\\\\\"更改\\\\\\\"+\\\\\\\"【\\\\\\\"+v.type+\\\\\\\"】为\\\\\\\", \\\\n                \\\\\\\"options\\\\\\\" : [\\\\\\\"电影\\\\\\\", \\\\\\\"电视剧\\\\\\\",\\\\\\\"动漫\\\\\\\",\\\\\\\"综艺\\\\\\\",\\\\\\\"纪录片\\\\\\\",\\\\\\\"MV\\\\\\\",\\\\\\\"合集\\\\\\\",\\\\\\\"短视频\\\\\\\"], \\\\n                 col: 4, \\\\n                 js:$.toString((v)=>{ \\\\n                      eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n         config = getConfig();\\\\n         for (var i=0;i<config.data.length;i++) {\\\\n               if (config.data[i].name==v.name){\\\\n                           config.data[i].type=input;\\\\n                           break;\\\\n               }\\\\n          }\\\\n          writeFile(getItem('file'),         JSON.stringify(config));\\\\n          refreshPage(false);\\\\n          toast('分类成功更改为【'+input+'】');\\\\n                 },v)\\\\n            });\\\\n        },v)\\\\n},{\\\\n       title: '豆瓣id', \\\\n       js:$.toString((v)=>{ \\\\nreturn $(v.id, '【'+v.name+'】豆瓣id').input((name) => {\\\\n                         eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n    config = getConfig();\\\\n         if (input == \\\\\\\"\\\\\\\") {\\\\n             for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].id=input;\\\\n                       break;\\\\n                     }\\\\n               }\\\\n writeFile(getItem('file'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast('id置空成功！');\\\\n          } else if (input.match(/^[0-9]*$/)==null){ \\\\n             toast('id只能为数字!')\\\\n          } else {\\\\n             for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].id=input;\\\\n                       break;\\\\n                     }\\\\n               }\\\\n writeFile(getItem('file'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast('id更改成功！');\\\\n          } \\\\n         },v.name)\\\\n       },v)  \\\\n    },{\\\\n       title: '豆瓣分类', \\\\n       js:$.toString((v)=>{ \\\\n           showSelectOptions({\\\\n              \\\\\\\"title\\\\\\\": \\\\\\\"更改\\\\\\\"+\\\\\\\"【\\\\\\\"+v.dataType+\\\\\\\"】为\\\\\\\", \\\\n                \\\\\\\"options\\\\\\\" : [\\\\\\\"tv\\\\\\\", \\\\\\\"movie\\\\\\\"], \\\\n                 col: 1,\\\\n                 js:$.toString((name)=>{ \\\\n                         eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n         config = getConfig();\\\\n         for (var i=0;i<config.data.length;i++) {\\\\n                if (config.data[i].name==name){\\\\n                    config.data[i].dataType=input;\\\\n                     break;\\\\n                }\\\\n           }\\\\n           writeFile(getItem('file'),      JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            toast('豆瓣分类更改成功！');\\\\n         },v.name)\\\\n        });\\\\n       },v)  \\\\n    },{\\\\n       title: '信息刮削', \\\\n       js:$.toString((v)=>{ \\\\n            if (!v.pic) {\\\\n                return $(v.name, '刮削【'+v.name+'】').input((name) =>{\\\\n                    try {\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);             \\\\n                           config = getConfig();  \\\\n                           let s= input.replace(/\\\\\\\\s/,\\\\\\\"$\\\\\\\").split(\\\\\\\"$\\\\\\\")[0] ;                    \\\\n                           let fetchUrl =  'https://m.douban.com/search/?query='+s+'&type=1002';\\\\n                           let code = fetch(fetchUrl);\\\\n//log(code)  \\\\n                           let list  =\\\\npdfa(code,\\\\\\\"body&&.search_results_subjects&&ul&&li\\\\\\\")\\\\n//log(list[0])\\\\n                           let pic = pdfh(list[0],\\\\\\\"li&&img&&src\\\\\\\");\\\\n//log(pic)\\\\n                           let id= pdfh(list[0],\\\\\\\"li&&a&&href\\\\\\\").split(\\\\\\\"/\\\\\\\")[3]\\\\n//log(id)\\\\n                           let typehtml=\\\\nfetch(\\\\\\\"https://m.douban.com\\\\\\\"+pdfh(list[0],\\\\\\\"li&&a&&href\\\\\\\"));\\\\n                          let dataType=\\\\npdfh(typehtml,\\\\\\\"body&&section,1&&data-type\\\\\\\")\\\\n//log(dataType)\\\\n                 for (var i=0;i<config.data.length;i++) {\\\\n                        if (config.data[i].name==name){\\\\n                                   config.data[i].id=id;\\\\n                                    config.data[i].pic=pic; \\\\n                                    config.data[i].dataType=dataType;\\\\n                                    break;\\\\n                        }\\\\n                }\\\\n                           writeFile(getItem('file'), JSON.stringify(config));\\\\n                           refreshPage(false);\\\\n                           toast(\\\\\\\"刮削成功!\\\\\\\"); \\\\n                  } catch(e){toast(\\\\\\\"刮削失败！\\\\\\\")}\\\\n               },v.name)\\\\n          } else { toast(\\\\\\\"已经刮削过!\\\\\\\"); }\\\\n      },v)\\\\n    },{\\\\n       title: '(取消)置顶', \\\\n       js:$.toString((v)=>{ \\\\n                                      if (!v.top) {\\\\n                                        return  $(\\\\\\\"置顶“\\\\\\\"+v.name+\\\\\\\"”？\\\\\\\").confirm((name)=>{\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);             \\\\n               config = getConfig();         \\\\n           for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].top=!config.data[i].top;\\\\n                       config.data.splice(0, 0, config.data.splice(i, 1)[0]); \\\\n                       break;\\\\n                     }\\\\n               }                       \\\\n                               writeFile(getItem('file'), JSON.stringify(config));\\\\n                               refreshPage(false);\\\\n                               toast(\\\\\\\"置顶成功!\\\\\\\"); \\\\n                           },v.name)\\\\n                                     } else {\\\\n                                         return  $(\\\\\\\"取消“\\\\\\\"+v.name+\\\\\\\"”置顶？\\\\\\\").confirm((name)=>{\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);             \\\\n                              config = getConfig();      \\\\n           for (var i=0;i<config.data.length;i++) {\\\\n                   if (config.data[i].name==name){\\\\n                       config.data[i].top=!config.data[i].top;                        config.data.splice(config.data.filter(i =>  i.top).length, 0, config.data.splice(i, 1)[0]); \\\\n                        break;\\\\n                     }\\\\n               }                                             \\\\n                               writeFile(getItem('file'), JSON.stringify(config));\\\\n                               refreshPage(false);\\\\n                               toast(\\\\\\\"取消置顶成功!\\\\\\\");                      \\\\n             },v.name)\\\\n          }\\\\n       },v)\\\\n    },{\\\\n        title: '分 享', \\\\n           js:$.toString((v)=>{ \\\\n              return  $('确定分享资源？').confirm((v) => {\\\\n                eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n                  config = getConfig();\\\\n                  var data = '资源库分享¥'+JSON.stringify(v);\\\\n                  return \\\\\\\"copy://\\\\\\\" + data;\\\\n              }, v)\\\\n           },v)  \\\\n    },{\\\\n       title: '删  除', \\\\n       js:$.toString((v)=>{ \\\\n           return $(\\\\\\\"确认删除“\\\\\\\"+v.name+\\\\\\\"”？\\\\\\\").confirm((name)=>{\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);             \\\\n           config = getConfig();  \\\\nconfig.data = config.data.filter(i => i.name != name);\\\\nwriteFile(getItem('file'), JSON.stringify(config));\\\\n           refreshPage(false);\\\\n           toast(\\\\\\\"已经删除该资源!\\\\\\\"); \\\\n         },v.name)\\\\n      },v)  \\\\n    }\\\\n]\\\"},{\\\"col_type\\\":\\\"avatar\\\",\\\"name\\\":\\\"影视详情\\\",\\\"path\\\":\\\"Sdetail\\\",\\\"rule\\\":\\\"js:\\\\nputVar('qdb_file', 'hiker://files/rules/joker/qdb.js');\\\\neval(fetch(getVar(\\\\\\\"qdb_file\\\\\\\")));\\\\npre();\\\\nlet name = getParam('name', ''),\\\\n type = getParam('type', ''),\\\\n id = getParam('id', '');\\\\nlet urls=getMyVar(\\\\\\\"url\\\\\\\",'').split(\\\\\\\"$$$\\\\\\\");\\\\nurls=urls.filter(item => item!=\\\\\\\"undefined\\\\\\\");\\\\ntry {\\\\nlet i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id);\\\\n    setPageTitle(i.title);\\\\n    let info = \\\\\\\"\\\\\\\";\\\\n    if (i.is_tv) {\\\\n        info = [i.countries ? i.countries.join(\\\\\\\" \\\\\\\") : null, i.genres ? i.genres.join(\\\\\\\" \\\\\\\") : null, i.pubdate ? i.pubdate[0] + \\\\\\\"首播\\\\\\\" : null, i.episodes_count ? \\\\\\\"共\\\\\\\" + i.episodes_count + \\\\\\\"集\\\\\\\" : null, i.durations ? \\\\\\\"单集片长\\\\\\\" + i.durations : null].filter((e => null !== e)).join(\\\\\\\" / \\\\\\\");\\\\n    } else {\\\\n        info = [i.countries ? i.countries.join(\\\\\\\" \\\\\\\") : null, i.genres ? i.genres.join(\\\\\\\" \\\\\\\") : null, i.pubdate ? i.pubdate[0] + \\\\\\\"首播\\\\\\\" : null, i.durations ? \\\\\\\"片长\\\\\\\" + i.durations : null].filter((e => null !== e)).join(\\\\\\\" / \\\\\\\");\\\\n    }\\\\n    let infoItems = [{\\\\n        title: i.title + \\\\\\\"\\\\\\\\n\\\\\\\" + i.original_title + \\\\\\\"(\\\\\\\" + i.year + \\\\\\\")\\\\\\\",\\\\n        desc: info || i.card_subtitle,\\\\n        img: i.pic.normal + \\\\\\\"@Referer=\\\\\\\" + i.pic.normal,\\\\n        col_type: \\\\\\\"movie_1_vertical_pic_blur\\\\\\\",\\\\n        url: 'hiker://empty'\\\\n    }];\\\\n    let rating = \\\\\\\"\\\\\\\";\\\\n    if (i.rating) {\\\\n        rating = computeRating(i.rating.max, i.rating.value);\\\\n    }\\\\n    let ratingItems = [];\\\\n    let color = getConfig('starColor');\\\\n    let ratingTitle = ''\\\\n    if (rating) {\\\\n        ratingTitle = '豆瓣评分™'.bold() + '<br>' + rating.fontcolor(color) + '&nbsp;&nbsp;' + (i.rating.value.toFixed(1) + '分').bold();\\\\n    } else {\\\\n        ratingTitle = '暂无评分'.bold() + '<br>' + '点我查看影片信息'.fontcolor('grey');\\\\n    }\\\\n    ratingItems = [{\\\\n        title: '““””' + ratingTitle,\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            lineVisible: false\\\\n        },\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((type, id, ratingCount) => {\\\\n            eval(fetch(getVar(\\\\\\\"qdb_file\\\\\\\")));\\\\n            rating(type, id, ratingCount);\\\\n        }, i.subtype, i.id, i.rating ? i.rating.count : 0)\\\\n    }];\\\\n\\\\n    let relatedItems = [{\\\\n        title: \\\\\\\"短评\\\\\\\",\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/短评.png\\\\\\\",\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\n            eval(fetch(getVar(\\\\\\\"qdb_file\\\\\\\")));\\\\n            shortCommentList(t[0], t[1]);\\\\n        }, [i.subtype, i.id]),\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\n    }, {\\\\n        title: \\\\\\\"剧评\\\\\\\",\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧评.png\\\\\\\",\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\n            eval(fetch(getVar(\\\\\\\"qdb_file\\\\\\\")));\\\\n            dramaReviewList(t[0], t[1]);\\\\n        }, [i.subtype, i.id]),\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\n    },{\\\\n        title: \\\\\\\"剧照\\\\\\\",\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧照.png\\\\\\\",\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\n            eval(fetch(getVar(\\\\\\\"qdb_file\\\\\\\")));\\\\n            stillsList(t[0], t[1]);\\\\n        }, [i.subtype, i.id]),\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\n    }, {\\\\n        title: \\\\\\\"演职\\\\\\\",\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/演职.png\\\\\\\",\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\n            eval(fetch(getVar(\\\\\\\"qdb_file\\\\\\\")));\\\\n            credits(t[0], t[1]);\\\\n        }, [i.subtype, i.id]),\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\n    }];\\\\n    let introItems = [];\\\\n    if (i.intro) {\\\\n        introItems = [ {\\\\ntitle: '““””<font color=\\\\\\\"#ff148e8e\\\\\\\"><b>剧情简介：</b>'+i.intro.replace(/\\\\\\\\n/g, \\\\\\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\\\\\").replace(/\\\\\\\\s/g, \\\\\\\" \\\\\\\").replace(/\\\\\\\\t/g, \\\\\\\" \\\\\\\").substr(0, 50)+'...</font><small><font color=\\\\\\\"red\\\\\\\">详情</font></small>',\\\\n          url: \\\\\\\"hiker://empty##\\\\\\\"+i.intro.replace(/\\\\\\\\n/g, \\\\\\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\\\\\").replace(/\\\\\\\\s/g, \\\\\\\" \\\\\\\").replace(/\\\\\\\\t/g, \\\\\\\" \\\\\\\")+`@rule=js:var res = {}; var d = [];d.push({title:'&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'+MY_URL.split('##')[1],col_type:'rich_text'});res.data = d;\\\\nsetHomeResult(res);`,\\\\n            col_type: \\\\\\\"text_1\\\\\\\"\\\\n        }]\\\\n    }\\\\n\\\\n  let videoRelatedItems = [];\\\\r\\\\n    if (i.trailer) {\\\\r\\\\n        videoRelatedItems.push({\\\\r\\\\n            title: i.title+\\\\\\\" - 预告片、花絮\\\\\\\",\\\\r\\\\n            img: \\\\\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/more/356.png\\\\\\\",\\\\r\\\\n            url: \\\\n$('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\n                eval(fetch(getVar(\\\\\\\"qdb_file\\\\\\\")));\\\\n                trailers(t[0], t[1]);\\\\n            }, [i.subtype, i.id]),\\\\r\\\\n            col_type: \\\\\\\"avatar\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n    }\\\\n\\\\n    let linkItems = [];\\\\n    let title=i.title;\\\\n    urls.forEach((v, i) => { \\\\n       linkItems.push({\\\\n          title: v.includes(\\\\\\\"m3u8\\\\\\\")?(i+1)+' - '+title+'【视频资源】':v.includes(\\\\\\\"ali\\\\\\\")?(i+1)+' -'+title+' 【阿里资源】':(i+1)+' - '+title+'【夸克资源】',\\\\n         img:\\\\n\\\\\\\"https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/143.svg\\\\\\\",\\\\n        col_type: 'avatar',\\\\n        extra: {\\\\n                lineVisible: false,\\\\n                PageTitle:title,\\\\n                longClick:[{\\\\n                      title: '更改地址', \\\\n                      js:$.toString((url,name,i)=>{ \\\\n       return $(url, '【'+name+'】地址').input((name,urlNo) => {\\\\n                         eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n          config = getConfig();\\\\n          if (input.match(/http/)==null){ \\\\n              return \\\\\\\"toast://地址有误！\\\\\\\"\\\\n          } else {\\\\n          for (let i=0;i<config.data.length;i++) {\\\\n             if (config.data[i].name==name){\\\\n                if(urlNo==0){\\\\n                    config.data[i].url=input\\\\n                } else if(urlNo==1){\\\\n                    config.data[i].url1=input\\\\n                } else {\\\\n                     config.data[i].url2=input\\\\n                }\\\\n             putMyVar(\\\\\\\"url\\\\\\\",config.data[i].url+\\\\\\\"$$$\\\\\\\"+config.data[i].url1+\\\\\\\"$$$\\\\\\\"+config.data[i].url2);\\\\n               break;\\\\n             }\\\\n          }   \\\\n   writeFile(getItem('file'), JSON.stringify(config));\\\\n               refreshPage(false)\\\\n               return 'toast://地址修改成功'\\\\n           }\\\\n         },name,i)\\\\n       },v,name,i)  \\\\n    },{\\\\n                      title: '删除地址', \\\\n                      js:$.toString((name,i)=>{ \\\\n       return $(\\\\\\\"确认删除“\\\\\\\"+name+\\\\\\\"”？\\\\\\\").confirm((name,urlNo)=>{\\\\n                         eval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\n          config = getConfig();\\\\n          for (let i=0;i<config.data.length;i++) {\\\\n             if (config.data[i].name==name){\\\\n                if(urlNo==0){\\\\n                    delete config.data[i].url\\\\n                } else if(urlNo==1){\\\\n                    delete   config.data[i].url1\\\\n                } else {\\\\n                    delete config.data[i].url2\\\\n                }\\\\n             putMyVar(\\\\\\\"url\\\\\\\",config.data[i].url+\\\\\\\"$$$\\\\\\\"+config.data[i].url1+\\\\\\\"$$$\\\\\\\"+config.data[i].url2);\\\\n               break;\\\\n             }\\\\n          }   \\\\n   writeFile(getItem('file'), JSON.stringify(config));\\\\n               refreshPage(false)\\\\n               return 'toast://删除成功'\\\\n         },name,i)\\\\n       },name,i)  \\\\n    }]\\\\n        },\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((url) => { \\\\n              if (url.includes(\\\\\\\"ali\\\\\\\")) { \\\\n                  return    \\\\\\\"hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=\\\\\\\"+url\\\\n               } else if (url.includes(\\\\\\\"quark\\\\\\\")) { \\\\n                 return \\\\\\\"hiker://page/quarkList?realurl=\\\\\\\" + encodeURIComponent(url) + \\\\\\\"&rule=Quark.简&sharePwd=\\\\\\\"\\\\n               } else {\\\\n                 return url\\\\n               }\\\\n         },v)           \\\\n    })\\\\n});\\\\n    let config = JSON.parse(fetch(getVar('qdb_config')));\\\\n\\\\n    let analysisConfigs = getConfig('analysisConfigs', config);\\\\n    let extraConfig = analysisConfigs[analysisConfigs.use].extra || '{}';\\\\n    let extra = {};\\\\n    try {\\\\n        if (extraConfig.startsWith('{')) eval('extra=' + extraConfig);\\\\n    } catch (e) {}\\\\n    let quickSearchConfigs = getConfig('quickSearchConfigs', config);\\\\n    let quickSearchItems = [];\\\\n    quickSearchConfigs.order.forEach(quickSearchItem => {\\\\n        if (quickSearchConfigs[quickSearchItem]) {\\\\n            quickSearchItems.push({\\\\n                title: quickSearchItem,\\\\n                img: quickSearchConfigs[quickSearchItem].pic,\\\\n                col_type: quickSearchConfigs.mode || 'icon_small_4',\\\\n                url: 'hiker://search?s=' + i.title + '&rule=' + quickSearchConfigs[quickSearchItem].name\\\\n            })\\\\n        }\\\\n    })\\\\n    setHomeResult({\\\\n        data: infoItems.concat(ratingItems)\\\\n            .concat({\\\\n                col_type: 'line'\\\\n            })\\\\n           .concat(introItems)\\\\n            .concat({\\\\n                col_type: 'line'\\\\n            })\\\\n            .concat(relatedItems)\\\\n            .concat({\\\\n                col_type: 'line'\\\\n            })\\\\n            .concat(quickSearchItems)\\\\n            .concat({\\\\n                col_type: 'line'\\\\n            })\\\\n            .concat(videoRelatedItems)\\\\n            .concat({\\\\n                col_type: 'line'\\\\n            })\\\\n            .concat(linkItems)\\\\n            .concat({\\\\n                col_type: 'line'\\\\n            })\\\\n            .concat({\\\\r\\\\n                col_type: 'text_1',\\\\r\\\\n                title: '““””<small><font color=#871f78>本规则及数据均收集自网络，仅限学习交流使用，请于导入后24小时内删除，不得以任何方式传播！</font></small>',\\\\r\\\\n                url: 'hiker://empty',\\\\r\\\\n                extra: {\\\\r\\\\n                    lineVisible: false\\\\r\\\\n                }\\\\r\\\\n            })\\\\n      })\\\\n} catch(e){toast(\\\\\\\"类型错误，资源获取出错！\\\\\\\");\\\\n }\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索页\\\",\\\"path\\\":\\\"sou\\\",\\\"rule\\\":\\\"js:\\\\nsetPageTitle(\\\\\\\"云盘库搜索\\\\\\\")\\\\nlet d = [];    \\\\nlet key = getParam('key', ''); \\\\nif (key ==\\\\\\\"\\\\\\\") {\\\\n key = MY_PARAMS.key\\\\n}\\\\n\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/config\\\\\\\")).rule);\\\\nconfig = getConfig();\\\\nconfig.data = config.data.filter(v => v.name.includes(key));\\\\nconfig.data.forEach((v, i) => {       \\\\neval(JSON.parse(fetch(\\\\\\\"hiker://page/longClick\\\\\\\")).rule);\\\\n    d.push ({\\\\n           title: v.name,\\\\n           url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((v) => { \\\\n              if (v.id!=undefined&&v.id!=\\\\\\\"\\\\\\\") { \\\\n                  return    'hiker://page/Sdetail#noHistory##immersiveTheme#?type='+v.dataType+'&id=' + v.id+'&aliurl=' + v.url;\\\\n              } else {\\\\n                   return  'hiker://page/push?rule=云盘君(推送)&url=hiker://empty##'+v.url\\\\n              }\\\\n        },v)  ,\\\\n            extra: {\\\\n                pageTitle:v.name,\\\\n                longClick:longClick\\\\n            },\\\\n            img:v.pic==undefined?MY_RULE.icon:v.pic,\\\\n            col_type: \\\\\\\"avatar\\\\\\\",\\\\n     })\\\\n})\\\\nd.push ({\\\\n    title: \\\\\\\"🔜使用「聚云盘」搜索\\\\\\\",\\\\n    url: \\\\\\\"hiker://search?s=\\\\\\\"+key+\\\\\\\"&rule=聚云盘\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n})\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"轮播\\\",\\\"path\\\":\\\"lunbo\\\",\\\"rule\\\":\\\"js:\\\\nfunction banner(title, start, arr, data, cfg) {\\\\n    let id = title + 'lunbo';\\\\n    var rnum = Math.floor(Math.random() * data.length);\\\\n    var item = data[rnum];\\\\n    let time = 5000;\\\\n    let col_type = 'pic_1_card';\\\\n    let color = \\\\\\\"white\\\\\\\";\\\\n    let desc = '';\\\\n    if (cfg != undefined) {\\\\n        time = cfg.time ? cfg.time : time;\\\\n        col_type = cfg.col_type ? cfg.col_type : col_type;\\\\n        desc = cfg.desc ? cfg.desc : desc;\\\\n    }\\\\n\\\\n    arr.push({\\\\n        col_type: col_type,\\\\n        img: item.img,\\\\n        desc: desc,\\\\n        title: item.name,\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((v) => { \\\\n              if (v.id!=undefined&&v.id!=\\\\\\\"\\\\\\\") { \\\\n                  putMyVar(\\\\\\\"url\\\\\\\",v.url+\\\\\\\"$$$\\\\\\\"+v.url1+\\\\\\\"$$$\\\\\\\"+v.url2);\\\\n                  return    'hiker://page/Sdetail#noHistory##immersiveTheme#?name='+v.name+'&type='+v.dataType+'&id=' + v.id;\\\\n              } else {\\\\n                   if (v.url.includes(\\\\\\\"ali\\\\\\\")){\\\\n                    return 'hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=' + v.url; \\\\n                  } else if (v.url.includes(\\\\\\\"quark\\\\\\\")){\\\\n                    return  \\\\\\\"hiker://page/quarkList?realurl=\\\\\\\" + encodeURIComponent(v.url) + \\\\\\\"&rule=Quark.简&sharePwd=\\\\\\\";\\\\n                 }\\\\n               }\\\\n        },item)  ,\\\\n        extra: {\\\\n            id: id+'bar',\\\\n        }\\\\n    })\\\\n\\\\n    if (start == false || getMyVar('benstart', 'true') == 'false') {\\\\n        unRegisterTask(id)\\\\n        return\\\\n    }\\\\n    \\\\n\\\\n    let obj = {\\\\n        data: data,\\\\n    };\\\\n    registerTask(id, time, $.toString((obj,id) => {\\\\n        var data = obj.data;\\\\n        var i = Number(getMyVar('yingku'),'0');\\\\n        i = i + 1;\\\\n        if ( i > data.length-1) {\\\\n            i = 0\\\\n        }\\\\n        var item = data[i];\\\\n        try {\\\\n            updateItem(id+'bar', {\\\\n                title: item.name,\\\\n                img: item.img,\\\\n                url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((v) => { \\\\n              if (v.id!=undefined&&v.id!=\\\\\\\"\\\\\\\") { \\\\n               putMyVar(\\\\\\\"url\\\\\\\",v.url+\\\\\\\"$$$\\\\\\\"+v.url1+\\\\\\\"$$$\\\\\\\"+v.url2);\\\\n                 return    'hiker://page/Sdetail#noHistory##immersiveTheme#?name='+v.name+'&type='+v.dataType+'&id=' + v.id;\\\\n              } else {\\\\n                   if (v.url.includes(\\\\\\\"ali\\\\\\\")){\\\\n                    return 'hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=' + v.url; \\\\n                  } else if (v.url.includes(\\\\\\\"quark\\\\\\\")){\\\\n                    return  \\\\\\\"hiker://page/quarkList?realurl=\\\\\\\" + encodeURIComponent(v.url) + \\\\\\\"&rule=Quark.简&sharePwd=\\\\\\\";\\\\n                 }\\\\n               }\\\\n        },item)  ,\\\\n                extra: {\\\\n                    title: item.name.replace(/<[^>]+>/g, ''),\\\\n                }\\\\n            })\\\\n        } catch (e) {\\\\n            log(e.message)\\\\n            unRegisterTask(id)\\\\n        }\\\\n        putMyVar('yingku', i);\\\\n    }, obj,id))\\\\n}\\\"}]\",\"proxy\":\"\"}","picUrl":"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg@Referer=https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2902485705.jpg","title":"异人君莫邪"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!