API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：玩偶哥哥-庆余年第二季

xiaomianao666
May 16th, 2024
70
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 137.43 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥玩偶哥哥-庆余年第二季@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"二级内容\",\"path\":\"er\",\"rule\":\"js:\\n/*ver 20230930 2.0\\n */\\nconst customs = {};\\n\\n//预设\\nfunction customData(custom) {\\n  Object.keys(custom).forEach((k) => {\\n    customs[k] = custom[k];\\n  })\\n}\\n\\n\\nlet Erji = {\\n  通免: $('').lazyRule(() => {\\n    try {\\n      var html = JSON.parse(request(input).match(/r player_.*?=(.*?)</)[1])\\n      var url = html.url\\n      if (html.encrypt == '1') {\\n        url = unescape(url);\\n      } else if (html.encrypt == '2') {\\n        url = unescape(base64Decode(url));\\n      }\\n      if (/m3u8|mp4/.test(url)) {\\n        return url\\n      } else {\\n        return \\\"video://\\\" + input\\n      }\\n    } catch (e) {\\n      return \\\"video://\\\" + input\\n    }\\n  }),\\n  evalJSRule: function (item, jsRule) {\\n    let rule = jsRule.replace(\\\"@js:\\\", \\\"\\\");\\n    rule = rule.trim();\\n    //log($.stringify(rule))\\n    let input = item;\\n    if (rule.startsWith(\\\"(\\\")) {\\n      eval(\\\"result = \\\" + rule);\\n    } else {\\n      /**\\n      * 还原成 $.toString(...) 的最终结果，达到最终处理方式跟上面的 if 一致的目的\\n      */\\n      eval(\\\"result = \\\" + \\\"(() => {\\\" + rule + \\\"})()\\\");\\n    }\\n    return result || \\\"\\\";\\n  },\\n  updataRule: function (rule, headers) {\\n    headers = headers != undefined ? headers : {};\\n    setLastChapterRule('js:' + $.toString((url, rule, headers) => {\\n      var html = fetch(url, headers);\\n      setResult(eval(rule))\\n    }, MY_URL, rule, headers))\\n  },\\n  updataFun: function (method, params) {\\n    var methodArgs = this.getArgs(method);\\n    var args = methodArgs.map(function(arg) {\\n      return params[arg];\\n    });\\n    //method.apply(null, args);\\n    setLastChapterRule('js:' + $.toString((method,args) => {\\n      method.apply(null, args);\\n    }, method,args))\\n  },\\n  updata:function(args1,args2){\\n      if(args1.constructor==Function){\\n        return this.updataFun(args1,args2);\\n      }else{\\n        return this.updataRule(args1,args2);\\n      }\\n  },\\n  getArgs:function(func){\\n    var args = func.toString().match(/function\\\\s.*?\\\\(([^)]*)\\\\)/)[1];\\n    return args.split(\\\",\\\").map(function (arg) {\\n      return arg.replace(/\\\\/\\\\*.*\\\\*\\\\//, \\\"\\\").trim();\\n    }).filter(function (args) {\\n      return args;\\n    });\\n  },\\n  maxList: (arr) => { \\n    return arr.reduce((acc, curr) => (curr.length > acc.length ? curr : acc), []) \\n  },\\n  close: function (list, sorts) {\\n    addListener('onClose', $.toString((list, sorts) => {\\n      list.map(x => {\\n        clearMyVar('er_' + x + 'fold');\\n        clearMyVar('er_' + x);\\n      })\\n      for (let i = 0; i < sorts; i++) {\\n        clearMyVar('playlist_' + i);\\n      }\\n      clearMyVar('er_playlists');\\n    }, list, sorts))\\n  },\\n  dataConvert: function (data) {\\n    var newclslist = data.map(function (obj) {\\n      var newObj = Object.assign({}, obj);\\n      if (newObj.hasOwnProperty('type')) {\\n        newObj.col_type = newObj.type;\\n      }\\n      return newObj;\\n    });\\n    return newclslist;\\n  },\\n  preLoad: function (func) {\\n    let myfunc = null\\n    if (func != undefined && func.constructor == Function) {\\n      myfunc = func\\n    }\\n    $.extend({\\n      dataConvert: this.dataConvert,\\n      msm: Methods.MultiSelectMode,\\n      func: myfunc,\\n    })\\n  },\\n  small: function (str, color,h) {\\n    h=h==undefined?true:h;\\n    return (h?'““””':'')+'<small><font color=\\\"' + (color || '') + '\\\">' + str + '</font></small>';\\n  },\\n  声明: function () {\\n    d.push({\\n      title: this.small('以上数据来源于网络，如您喜欢，请支持官方！', '#871F78'),\\n      desc: this.small('此规则仅限学习交流使用，请于导入后24小时内删除，任何组织或个人不得以任何方式方法传播此规则的整体或部分！', '#F20C00'),\\n      url: 'hiker://empty',\\n      col_type: 'text_center_1'\\n    });\\n  },\\n  substr: function (str, maxLength) {\\n    let len = 0;\\n    for (let i = 0; i < str.length; i++) {\\n      if (str.charCodeAt(i) > 255) {\\n        len += 2;\\n      } else {\\n        len++;\\n      }\\n      if (len > maxLength) {\\n        return str.slice(0, i) + '...';\\n      }\\n    }\\n    return str;\\n  },\\n  setDesc: function (desc, num) {\\n    var custom = this.getPreset();\\n    desc = desc.constructor == Array ? desc.join('<br>') : desc;\\n    if (desc.replace(/(<br>|\\\\s+)/g, '').length == 0) {\\n      return\\n    }\\n    var info = storage0.getMyVar('er_info', '{}')\\n    if (info['desc'] != undefined) {\\n      info['desc'] = info['desc'] + ' 简介:' + desc;\\n      storage0.putMyVar('er_info', info);\\n    }\\n\\n    const mark = 'desc';\\n    num = typeof (num) == 'undefined' ? 100 : num\\n    desc = desc.startsWith('　　') ? desc : '　　' + desc;\\n    desc = desc.replace(/'/g, \\\"&#39;\\\");\\n    desc = desc.replace(/\\\\r\\\\n/g, \\\"<br>\\\");\\n\\n\\n    let sdesc = this.substr(desc, num);\\n\\n    var colors = {\\n      show: custom.简介展开,\\n      hide: custom.简介收起\\n    }\\n\\n    var lazy = $(`#noLoading#`).lazyRule((dc, sdc, m, cs) => {\\n      var show = storage0.getItem(m, '0');\\n      var title = findItem('desc').title;\\n      var re = /(<\\\\/small><br>.*?>).+/g;\\n      var exp = '展开:';\\n      var ret = '收起:';\\n      if (show == '1') {\\n        updateItem('desc', {\\n          title: title\\n            .replace(ret, exp)\\n            .replace(re, '$1' + sdc + '</small>')\\n            .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.hide + '$2')\\n\\n        })\\n        storage0.setItem(m, '0');\\n      } else {\\n        updateItem('desc', {\\n          title: title\\n            .replace(exp, ret)\\n            .replace(re, '$1' + dc + '</small>')\\n            .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.show + '$2')\\n        })\\n        storage0.setItem(m, '1');\\n      }\\n      return `hiker://empty`\\n    }, desc, sdesc, mark, colors)\\n    var sc = storage0.getItem(mark, '0') == '0' ? '展开:' : '收起:';\\n    var dc = storage0.getItem(mark, '0') == '0' ? sdesc : desc;\\n    var cs = storage0.getItem(mark, '0') == '0' ? colors.hide : colors.show;\\n    d.push({\\n      title: '' + '<b><font color=\\\"#098AC1\\\">∷剧情简介\\t</font></b>' + \\\"<small><a style='text-decoration: none;' href='\\\" + lazy + \\\"'>\\\" + sc + '</a></small><br><font color=\\\"' + cs + '\\\">' + `${dc}` + '</small>',\\n      col_type: 'rich_text',\\n      extra: {\\n        id: 'desc',\\n        lineSpacing: 6,\\n        textSize: 15,\\n        lineVisible: true,\\n      }\\n    })\\n  },\\n  setDesc2: function (desc, num) {\\n    var custom = this.getPreset();\\n    desc = desc.constructor == Array ? desc.join('<br>') : desc;\\n    if (desc.replace(/(<br>|\\\\s+)/g, '').length == 0) {\\n      return\\n    }\\n    var info = storage0.getMyVar('er_info', '{}')\\n    if (info['desc'] != undefined) {\\n      info['desc'] = info['desc'] + ' 简介:' + desc;\\n      storage0.putMyVar('er_info', info);\\n    }\\n\\n    const mark = 'desc';\\n    num = typeof (num) == 'undefined' ? 100 : num\\n    desc = desc.startsWith('　　') ? desc : '　　' + desc;\\n    desc = desc.replace(/'/g, \\\"&#39;\\\");\\n    desc = desc.replace(/\\\\r\\\\n/g, \\\"<br>\\\");\\n\\n    let sdesc = this.substr(desc, num);\\n\\n    var colors = {\\n      show: custom.简介展开,\\n      hide: custom.简介收起\\n    }\\n    d.push({\\n      title: '剧情简介<span style=\\\"color:#ff0000;\\\"><b><small>' + (storage0.getItem(mark, '0')=='0'?'展开':'收起') + '</small></b></span>:',\\n      col_type: 'avatar',\\n      img: 'https://hikerfans.com/tubiao/system/75.png',\\n      url: $('#noLoading#').lazyRule((mark,dc, sdc,cs) => {\\n        var ds = storage0.getItem(mark, '0');\\n        var title = findItem('dshow').title;\\n        var dtitle = findItem('dcontent').title;\\n        if (ds == '0') {\\n          storage0.setItem(mark, '1')\\n          updateItem('dcontent', {\\n            title: dtitle.replace(/\\\\>.*?\\\\</,'>'+dc+'<')\\n            .replace(/(color=\\\").*?(\\\")/,'$1'+cs.show+'$2')\\n          });\\n          updateItem('dshow', {\\n            title: title.replace('展开', '收起')                        \\n          });\\n\\n\\n        } else {\\n          storage0.setItem(mark, '0')\\n          updateItem('dcontent', {\\n            title: dtitle.replace(/\\\\>.*?\\\\</,'>'+sdc+'<')\\n            .replace(/(color=\\\").*?(\\\")/,'$1'+cs.hide+'$2')\\n          });\\n          updateItem('dshow', {\\n            title: title.replace('收起', '展开')                        \\n          });\\n        }\\n        return 'hiker://empty'\\n      },mark, desc, sdesc,colors),\\n      extra: {\\n        id: 'dshow',\\n      }\\n    })\\n    var sc=storage0.getItem(mark, '0') == '0' ? sdesc.fontcolor(colors.hide) : desc.fontcolor(colors.show);\\n    d.push({\\n      title:sc,\\n      col_type: 'rich_text',\\n      extra: {\\n        id: 'dcontent',\\n        lineSpacing: 6,\\n        textSize: 15,\\n        lineVisible: true,\\n      }\\n    })\\n  },\\n  strConvert:function(arr, sp) {\\n      sp = sp != undefined ? sp : '/';\\n      var reg = new RegExp(sp);\\n\\n      return arr.map(x => {\\n        str = x;\\n        if (reg.test(str)) {\\n          str = str.split(sp).map((val, index) => (index === 0 ? '' : '') + val).slice(0, 5).join(' ').replace(/ $/, '');\\n        }\\n        return str\\n      })\\n  },\\n  setContent: function (obj) {\\n    //log(obj)\\n    var custom = this.getPreset();\\n    var num = obj.num != undefined ? obj.num : 100;\\n    var contents = obj.main;\\n    if (contents.constructor == String) {\\n      contents = contents.split('\\\\n');\\n    }\\n    var sortOrder = obj.sort ? obj.sort : [];\\n    var filterlist = obj.filist ? obj.filist : [];\\n    var img = obj.img;\\n    var texts = contents.map(x => {\\n      if (x.includes('href')) {\\n        var list = pdfa(x, 'body&&a').map(k => pdfh(k, 'Text')).slice(0, 5).join(' ');\\n        if (list == '') {\\n          return pdfh(x, 'Text');\\n        } else {\\n          return pdfh(x, ':matchText&&Text') + list;\\n        }\\n      }\\n      return pdfh(x, 'Text');\\n    });\\n    var array = texts.sort((a, b) => {\\n      const indexA = sortOrder.indexOf(a.substr(0, 2));\\n      const indexB = sortOrder.indexOf(b.substr(0, 2));\\n      return indexA - indexB;\\n    })\\n    var regex = new RegExp('(' + sortOrder.join('|') + ')');\\n    array = array.filter(function (item) {\\n      return regex.test(item);\\n    });\\n\\n    var fireg = new RegExp('(' + filterlist.join('|') + ')');\\n    if (filterlist.length > 0) {\\n      array = array.filter(function (item) {\\n        return !fireg.test(item);\\n      });\\n    }\\n    //log(array)\\n\\n    //array = sortOrder.length==0?array:this.strConvert(array);\\n    array = this.strConvert(array, obj.sp);\\n\\n    if (array.length > 6) {\\n      array = array.slice(0, 6);\\n    }\\n\\n    var titles = [];\\n    var descs = [];\\n\\n    switch (array.length) {\\n      case 2:\\n        titles = array[0];\\n        descs = array[1];\\n        break;\\n      case 3:\\n        titles = array.slice(0, 1);\\n        descs = array.slice(1);\\n        break;\\n      case 4:\\n      case 5:\\n        titles = array.slice(0, 2);\\n        descs = array.slice(2);\\n        break;\\n      case 6:\\n      default:\\n        titles = array.slice(0, 3);\\n        descs = array.slice(3);\\n        break;\\n    }\\n    storage0.putMyVar('er_info', {\\n      desc: descs.join('\\\\n'),\\n      img: img,\\n    })\\n    d.push({\\n      title: '<b>'+titles[0].fontcolor(custom.标题颜色)+'</b>'+this.small( '\\\\n' + titles.slice(1, 3).join('\\\\n'), custom.描述上),\\n      desc: this.small(descs.join('\\\\n'), custom.描述下),\\n      pic_url: img + '@Referer=',\\n      url: MY_URL,\\n      col_type: 'movie_1_vertical_pic_blur',\\n      extra: {\\n        id: \\\"detailid\\\",\\n        gradient: obj.渐变 ? obj.渐变 : false,\\n      }\\n    })\\n    if (obj.desc != undefined) {\\n      this.setDesc(obj.desc, num);\\n    }\\n  },\\n  setCustom: function (obj, img,colors) {\\n    var array = [];\\n    if (obj.constructor == Array) {\\n      array = obj;\\n    }\\n    var titles = [];\\n    var descs = [];\\n    if('titles' in obj){\\n      titles=obj.titles;\\n    }\\n    if('descs' in obj){\\n      descs=obj.descs;\\n    }\\n    \\n    if(titles.length==0&&descs.length==0){\\n    array = this.strConvert(array);\\n    switch (array.length) {\\n      case 2:\\n        titles = array[0];\\n        descs = array[1];\\n        break;\\n      case 3:\\n        titles = array.slice(0, 1);\\n        descs = array.slice(1);\\n        break;\\n      case 4:\\n      case 5:\\n        titles = array.slice(0, 2);\\n        descs = array.slice(2);\\n        break;\\n      case 6:\\n        titles = array.slice(0, 3);\\n        descs = array.slice(3);\\n        break;\\n      }\\n    }\\n    \\n    \\n    storage0.putMyVar('er_info', {\\n      desc: descs.join('\\\\n'),\\n      img: img,\\n    })\\n    if (colors != undefined) {\\n      var color_list=[];\\n\\n      for (var key in colors) {\\n      var range = key.split('-');\\n      var start = parseInt(range[0]);\\n      var end = range[1] ? parseInt(range[1]) : start;\\n      for (var i = start; i <= end; i++) {\\n        color_list[i-1] = colors[key];\\n        }\\n      }\\n\\n      \\n      if(color_list!=titles.length+descs.length){\\n        const fillCount = (titles.length+descs.length) - color_list.length; // 需要补齐的个数\\n        const filledArr = Array(fillCount).fill({}); // 生成填充数组\\n        color_list=color_list.concat(filledArr);\\n      }\\n  \\n      var midIndex = Math.floor(color_list.length / 2); \\n      var firstHalf = color_list.slice(0, midIndex);\\n      var secondHalf = color_list.slice(midIndex);\\n           \\n      function textArray(style,textArray) {\\n        var list=[];\\n        style.forEach((x, i) => {\\n        var left = [];\\n        var right = [];\\n        var str = textArray[i];\\n        Object.keys(x).forEach(k => {\\n            switch (k) {\\n                case 'color':\\n                    left.push('<font color=\\\"' + x[k] + '\\\">');\\n                    right.push('</font>');\\n                    break;\\n                default:\\n                    left.push(`<${k}>`);\\n                    right.push(`</${k}>`);\\n                break;\\n                }\\n              });\\n             list[i] = left.join('') + str + right.join('');\\n          });\\n        return list;\\n      }\\n      titles=textArray(firstHalf,titles);\\n      descs=textArray(secondHalf,descs);\\n      \\n      d.push({\\n        title:'““””'+titles[0]+'\\\\n'+titles.slice(1,3).join('\\\\n'),\\n        desc:'““””'+descs.join('\\\\n'),\\n        img:img+'@Referer='+img,\\n        url:MY_URL,\\n        col_type:'movie_1_vertical_pic_blur',\\n        extra:{\\n          id:\\\"detailid\\\",\\n        }\\n      })\\n      \\n    } else {\\n      d.push({\\n        title: titles[0] + '\\\\n' + this.small(titles.slice(1, 3).join('\\\\n')),\\n        desc: this.small(descs.join('\\\\n')),\\n        pic_url: img + '@Referer=',\\n        url: MY_URL,\\n        col_type: 'movie_1_vertical_pic_blur',\\n        extra:{\\n          id: \\\"detailid\\\",\\n        }\\n      })\\n  }\\n  },\\n  isColor: function (text) {\\n    const regex = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$|^([a-z]+)$/i;\\n    return regex.test(text);\\n  },\\n  getPreset: function (custom) {\\n    if (typeof customs == 'object' && !custom) {\\n      custom = customs;\\n    } else {\\n      custom = custom ? custom : {}\\n    }\\n    custom.正序颜色 = (custom.正序颜色 && this.isColor(custom.正序颜色)) ? custom.正序颜色 : '#1AAD19';\\n    custom.逆序颜色 = (custom.逆序颜色 && this.isColor(custom.逆序颜色)) ? custom.逆序颜色 : '#FF0000';\\n    custom.图标 = custom.图标 ? custom.图标 : 'https://i2.100024.xyz/2023/06/10/h4z627.webp';\\n    custom.线路选中 = custom.线路选中 ? custom.线路选中 : '#008B8B';\\n    custom.线路样式 = custom.线路样式 ? custom.线路样式 : 'scroll_button';\\n    custom.分割样式 = custom.分割样式 ? custom.分割样式 : 'blank_block';\\n    custom.简介展开 = custom.简介展开 ? custom.简介展开 : 'black';\\n    custom.简介收起 = custom.简介收起 ? custom.简介收起 : 'grey';\\n    Object.assign({}, customs, custom);\\n    //log(custom)\\n    return custom;\\n  },\\n  createPList: function (tabs, vari, shsort, custom, parse) {\\n    vari = \\\"er_\\\" + vari;\\n    let stabs = tabs;\\n    tabs = tabs.map(x => x.title!=undefined?x.title:x);\\n    var info = { parse: parse, mark: shsort };\\n    if (stabs.some(x => x.hasOwnProperty('url'))) {\\n      info['urls'] = stabs.map(x => x.url);\\n    }\\n\\n    for (var i = 0; i < tabs.length; i++) {\\n      var url = $('#noLoading#').lazyRule((vari, shsort, i, linec, info) => {\\n\\n        var lists = storage0.getMyVar(shsort + '_list', '[]');\\n\\n        if (getMyVar(vari + 'fold', '1') == '0') {\\n          var btn = findItem(shsort + '_button');\\n          var folds = ['<font color=\\\"#D3D3D3\\\">☷', '<font color=\\\"#FFA500\\\">☰'];\\n          var plist = storage0.getMyVar('er_playlists', '{}');\\n\\n          var col = plist[shsort].col_type;\\n          var cls = plist[shsort].cls;\\n          var pic = plist[shsort].pic;\\n          var extra = plist[shsort].extra;\\n          //log(extra)\\n          updateItem(btn.extra.id, {\\n            title: btn.title.replace(folds[0], folds[1]),\\n          })\\n\\n          putMyVar(vari + 'fold', '1');\\n          //return 'toast://展开才能操作';\\n        } else {\\n          var plist = storage0.getMyVar('er_playlists', '{}');\\n\\n          var col = plist[shsort].col_type;\\n          var cls = plist[shsort].cls;\\n          var pic = plist[shsort].pic;\\n          var extra = plist[shsort].extra;\\n          //log(extra)\\n        }\\n        putMyVar(vari, i);\\n\\n        var xlist = lists[i];\\n        if ($.func != undefined && $.func.constructor == Function) {\\n          deleteItemByCls(shsort);\\n          addItemAfter(shsort + '_line', {\\n            col_type: 'pic_1',\\n            img: 'https://img.nickyam.com/file/fe41a7a1744a3a8194df2.gif',\\n            url: 'toast://loading',\\n            extra: {\\n              cls: shsort\\n            }\\n          })\\n          xlist = $.func(i, info);\\n          storage0.putMyVar(shsort + '_list', xlist);\\n        }\\n        var plays = xlist.map(x => {\\n          return {\\n            title: x.title,\\n            url: x.url,\\n            col_type: col,\\n            pic: pic,\\n            extra: Object.assign({}, extra, {\\n              id: x.url.replace(/@lazyRule[\\\\s\\\\S]+/g, ''),\\n              cls: cls,\\n            })\\n          }\\n        })\\n        if (getMyVar(shsort + '_sort') == '1') {\\n          plays.reverse();\\n        }\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\n        if (pcfg['单推']) {\\n          updateItem(shsort + '_push', {\\n            title: pcfg['obj']['单推'][0]\\n          })\\n          pcfg['单推'] = false;\\n        }\\n        if (pcfg['选推']) {\\n          updateItem(shsort + '_pushs', {\\n            title: pcfg['obj']['选推'][0]\\n          })\\n          pcfg['选推'] = false;\\n        }\\n        storage0.putMyVar(shsort + '_pushcfg', pcfg);\\n        deleteItemByCls(shsort);\\n        addItemAfter(shsort + '_line', plays);\\n\\n        var tabx = findItemsByCls(shsort + '_tab');\\n        tabx.forEach((x, ii) => {\\n          var title = x.title;\\n          if (i == ii) {\\n            updateItem(x.extra.id, {\\n              title: title.replace(/#(\\\\w+)?/g, linec),\\n            })\\n          } else {\\n            updateItem(x.extra.id, {\\n              title: title.replace(/#(\\\\w+)?/g, '#'),\\n            })\\n          }\\n        })\\n        return 'toast://切换成功！';\\n      }, vari, shsort, i, custom.线路选中, info)\\n      d.push({\\n        title: '““””' + (getMyVar(vari, '0') == i ? tabs[i].fontcolor(custom.线路选中) : tabs[i].fontcolor('#')),\\n        url: url,\\n        col_type: custom.线路样式,\\n        extra: {\\n          cls: shsort + '_tab',\\n          id: shsort + '_tab_' + i,\\n        }\\n      })\\n    }\\n    d.push({\\n      col_type: custom.分割样式,\\n      extra: {\\n        id: shsort + '_line',\\n      }\\n    })\\n  },\\n  pushTab: function (vari, shsort) {\\n    addListener('onRefresh', $.toString((shsort) => {\\n      clearMyVar(shsort + '_pushcfg');\\n      clearMyVar(shsort + '_duoselect');\\n    }, shsort))\\n    var pobj = {\\n      '单推': ['⦿单推', '<b>⦿单推</b>'.fontcolor('#00FA9A')],\\n      '选推': ['☑选推', '<b>☑选推</b>'.fontcolor('#4682B4')],\\n    }\\n\\n    d.push({\\n      title: '⌘',\\n      col_type: 'scroll_button',\\n      url: 'hiker://empty',\\n      extra: {\\n        cls: shsort + '_pushtab',\\n      }\\n    }, {\\n      title: pobj['单推'][0],\\n      col_type: 'scroll_button',\\n      url: $('#noLoading#').lazyRule((shsort, pobj, vari) => {\\n        if (getMyVar(vari + 'fold', '1') == '0') {\\n          return 'toast://展开才能操作';\\n        }\\n\\n        var titles = pobj['单推'];\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\n        pcfg['obj'] = pobj;\\n        var 单推 = pcfg['单推'] ? pcfg['单推'] : false;\\n\\n        if (单推) {\\n          updateItem(shsort + '_push', {\\n            title: titles[0],\\n          })\\n          pcfg['单推'] = false;\\n          pcfg['playlist'].map((x) => {\\n            updateItem(x.extra.id, {\\n              url: x.url,\\n            })\\n          })\\n        } else {\\n          updateItem(shsort + '_push', {\\n            title: '““””' + titles[1],\\n          })\\n          updateItem(shsort + '_pushs', {\\n            title: pobj['选推'][0],\\n          })\\n          pcfg['单推'] = true;\\n          pcfg['选推'] = false;\\n          var playlist = findItemsByCls(shsort);\\n          pcfg['playlist'] = playlist;\\n          findItemsByCls(shsort).map(x => {\\n            var dpush = {\\n              name: getPageTitle(),\\n              url: x.title + '$' + x.extra.id\\n            }\\n            updateItem(x.extra.id, {\\n              url: $('').lazyRule((dpush) => {\\n                return 'hiker://page/push?rule=XYQ推送&pushurl=' + encodeURIComponent(JSON.stringify(dpush));\\n              }, dpush)\\n            })\\n          })\\n        }\\n        storage0.putMyVar(shsort + '_pushcfg', pcfg);\\n        return 'toast://' + (!单推 ? '单推开启' : '单推关闭');\\n      }, shsort, pobj, vari),\\n      extra: {\\n        id: shsort + '_push',\\n        cls: shsort + '_pushtab',\\n      }\\n    }, {\\n      title: pobj['选推'][0],\\n      col_type: 'scroll_button',\\n      url: $('#noLoading#').lazyRule((shsort, pobj, vari) => {\\n        if (getMyVar(vari + 'fold', '1') == '0') {\\n          return 'toast://展开才能操作';\\n        }\\n        var titles = pobj['选推'];\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\n        pcfg['obj'] = pobj;\\n        var 选推 = pcfg['选推'] ? pcfg['选推'] : false;\\n        if (选推) {\\n          updateItem(shsort + '_pushs', {\\n            title: titles[0],\\n          })\\n          pcfg['选推'] = false;\\n          pcfg['playlist'].map((x) => {\\n            updateItem(x.extra.id, {\\n              title: x.title,\\n              url: x.url,\\n            })\\n          })\\n          updateItem(shsort + '_pushto', {\\n            title: '推送本页=>TVBox',\\n          });\\n          clearMyVar(shsort + '_duoselect');\\n        } else {\\n          updateItem(shsort + '_pushs', {\\n            title: '““””' + titles[1],\\n          })\\n          pcfg['选推'] = true;\\n          pcfg['单推'] = false;\\n          var playlist = findItemsByCls(shsort);\\n          pcfg['playlist'] = playlist;\\n          let Ids = playlist.map(it => it.extra.id);\\n          Ids.forEach(x => {\\n            var title = findItem(x).title;\\n            updateItem(x, {\\n              url: $.msm(title, x, shsort),\\n            });\\n          });\\n          updateItem(shsort + '_push', {\\n            title: pobj['单推'][0],\\n          })\\n          updateItem(shsort + '_pushto', {\\n            title: '推送选中=>TVBox',\\n          });\\n        }\\n        storage0.putMyVar(shsort + '_pushcfg', pcfg);\\n        return 'toast://' + (!选推 ? '选推开启' : '选推关闭');\\n      }, shsort, pobj, vari),\\n      extra: {\\n        id: shsort + '_pushs',\\n        cls: shsort + '_pushtab'\\n      }\\n    }, {\\n      title: \\\"推送本页=>TVBox\\\",\\n      col_type: 'scroll_button',\\n      url: $('#noLoading#').lazyRule((shsort, vari) => {\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\n        var 单推 = pcfg['单推'] ? pcfg['单推'] : false;\\n        var 选推 = pcfg['选推'] ? pcfg['选推'] : false;\\n        if (!单推 && !选推) {\\n          var tabs = storage0.getMyVar(shsort + '_tabs', '[]');\\n          try {\\n            var pls = storage0.getMyVar(shsort + '_list', '[]').map(li => {\\n              return li.map(item => item.title + '$' + item.url.replace(/@lazyRule[\\\\s\\\\S]+/g, '')).join('#')\\n            }).join('$$$');\\n          } catch (e) {\\n            var pls = storage0.getMyVar(shsort + \\\"_list\\\", '[]').map(x => x.title + \\\"$\\\" + x.url.replace(/@lazyRule[\\\\s\\\\S]+/g, '')).join(\\\"#\\\");\\n            var tabs = [tabs[getMyVar(vari, '0')]];\\n          }\\n          //log(pls)\\n          //log(tabs)\\n        }\\n        if (选推) {\\n          var pls = storage0.getMyVar(shsort + \\\"_duoselect\\\", '[]').map(x => x.title + \\\"$\\\" + x.url).join(\\\"#\\\");\\n          if (pls.length == 0) {\\n            return 'toast://选择为空';\\n          }\\n          var tabs = ['播放列表'];\\n        }\\n\\n        var info = storage0.getMyVar('er_info', '{}');\\n        var desc = info['desc'];\\n        var 推送 = {\\n          \\\"name\\\": getPageTitle(),\\n          \\\"content\\\": desc || '',\\n          \\\"pic\\\": info['img'] || '',\\n          \\\"from\\\": tabs.join('$$$'),\\n          \\\"url\\\": pls,\\n        }\\n        //log(推送)\\n        return \\\"hiker://page/push?rule=XYQ推送&pushurl=\\\" + encodeURIComponent(JSON.stringify(推送))\\n      }, shsort, vari),\\n      extra: {\\n        id: shsort + '_pushto',\\n        cls: shsort + '_pushtab'\\n      }\\n    }, {\\n      col_type: 'blank_block',\\n      extra: {\\n        cls: shsort + '_pushtab',\\n      }\\n    })\\n  },\\n  setLongclick: function (shsort, custom) {\\n    return [{\\n      title: '样式🎨',\\n      js: $.toString((shsort) => {\\n        let all_cols = [''].concat(getColTypes());\\n        all_cols = all_cols.filter(x =>\\n          /(text_|flex).*/.test(x) && x != 'text_icon');\\n        //log(all_cols)\\n        let cls = storage0.getMyVar('er_playlists', '{}') ||\\n          '';\\n        if (cls[shsort] != '') {\\n          col = cls[shsort].col_type;\\n        }\\n        let 按钮样式 = all_cols.map((it) => {\\n          return it === col ? '➡️' + it : it;\\n        });\\n        let tips = '请选择选集按钮样式';\\n        return $(按钮样式, 2, tips).select((shsort, cls) => {\\n          input = input.replace(/➡️/g, '');\\n          /*storage0.setItem('按钮样式', input);*/\\n          let oldIds = (findItemsByCls(shsort) || []).map(it => it.extra.id); //老元素ids\\n          oldIds.forEach(x => {\\n            updateItem(x, {\\n              col_type: input\\n            });\\n          });\\n          return 'toast://已切换选集按钮样式为:' + input;\\n        }, shsort, cls);\\n      }, shsort, custom)\\n    }]\\n  },\\n  setTabs: function (tabs, vari, shsort, parse) {\\n    let custom = parse.自定义;\\n    let stabs = tabs;\\n    tabs = tabs.map(x => x.title!=undefined?x.title:x);\\n\\n    custom = this.getPreset(custom);\\n\\n    shsort = shsort ? shsort : 'shsort';\\n    var title = (getMyVar(shsort + '_sort', '0') == '1') ? '<b><span style=\\\"color: ' + custom.逆序颜色 + '\\\">逆序</span></b>' : '<b><span style=\\\"color: ' + custom.正序颜色 + '\\\">正序</span></b>'\\n    \\n    d.push({\\n      title: vari + ':' + title,\\n      desc: '共' + String(tabs.length).fontcolor('#4682B4') + '条线路',\\n      url: $('#noLoading#').lazyRule((shsort, vari, custom) => {\\n        let conf = getMyVar(shsort + '_sort', '0');\\n        if (getMyVar('er_' + vari + 'fold', '1') == '0') {\\n          return 'toast://展开才能操作';\\n        }\\n        var clslists = findItemsByCls(shsort);\\n        var newclslist = $.dataConvert(clslists);\\n\\n        var titles = [`${custom.正序颜色}\\\">正序`, `${custom.逆序颜色}\\\">逆序`];\\n\\n        deleteItemByCls(shsort);\\n        newclslist.reverse();\\n        addItemAfter(shsort + '_line', newclslist);\\n\\n        var obj = findItem(shsort + '_avatar')\\n\\n        if (conf == '1') {\\n          updateItem(shsort + '_avatar', {\\n            title: obj.title.replace(titles[1], titles[0]),\\n          })\\n          putMyVar(shsort + '_sort', '0');\\n        } else {\\n          updateItem(shsort + '_avatar', {\\n            title: obj.title.replace(titles[0], titles[1]),\\n          })\\n          putMyVar(shsort + '_sort', '1');\\n        }\\n        return 'toast://切换排序成功';\\n      }, shsort, vari, custom),\\n      col_type: 'avatar',\\n      img: custom.图标,\\n      extra: {\\n        id: shsort + '_avatar',\\n        longClick: this.setLongclick(shsort),\\n      }\\n    })\\n    var 折叠 = '““””<b>' + '☷'.fontcolor(\\\"#D3D3D3\\\");\\n    var 展开 = '““””<b>' + '☰'.fontcolor(\\\"#FFA500\\\");\\n    var foldname = 'er_' + vari + 'fold';\\n    var fold = getMyVar(foldname, '1');\\n    if (typeof (parse['推送']) != 'undefined' && parse['推送'])\\n      this.pushTab('er_' + vari, shsort);\\n\\n    d.push({\\n      title: fold === '0' ? 折叠 : 展开,\\n      col_type: custom.线路样式,\\n      url: $('#noLoading#').lazyRule((foldname, shsort) => {\\n        var fold = getMyVar(foldname, '1');\\n        var obj = findItem(shsort + '_line');\\n        var btn = findItem(shsort + '_button');\\n        var folds = ['<font color=\\\"#D3D3D3\\\">☷', '<font color=\\\"#FFA500\\\">☰'];\\n\\n        if (fold == '0') {\\n          putMyVar(foldname, '1');\\n          var cs = storage0.getMyVar(shsort + '_cls');\\n          addItemAfter(obj.extra.id, cs);\\n          updateItem(btn.extra.id, {\\n            title: btn.title.replace(folds[0], folds[1]),\\n          })\\n        }\\n        if (fold == '1') {\\n          putMyVar(foldname, '0');\\n          var pcls = findItemsByCls(shsort);\\n          var cx = $.dataConvert(pcls);\\n          storage0.putMyVar(shsort + '_cls', cx);\\n          deleteItemByCls(shsort);\\n          updateItem(btn.extra.id, {\\n            title: btn.title.replace(folds[1], folds[0]),\\n          })\\n        }\\n\\n        return 'toast://' + (fold === '1' ? '收起' : '展开');\\n      }, foldname, shsort),\\n      extra: {\\n        id: shsort + '_button',\\n      }\\n    })\\n    this.createPList(stabs, vari, shsort, custom, parse);\\n  },\\n  setTabs2: function (tabs, vari, shsort, parse, exp) {\\n    let custom = parse.自定义;\\n    let stabs = tabs;\\n    tabs = tabs.map(x => x.title!=undefined?x.title:x);\\n    custom = this.getPreset(custom);\\n    shsort = shsort ? shsort : 'shsort';\\n    var title = (getMyVar(shsort + '_sort', '0') == '1') ? '<b><span style=\\\"color:' + custom.逆序颜色 + '\\\">逆序</span></b>' : '<b><span style=\\\"color:' + custom.正序颜色 + '\\\">正序</span></b>'\\n\\n    var 折叠 = '<b>折叠' + '☷'.fontcolor(\\\"#D3D3D3\\\");\\n    var 展开 = '<b>展开' + '☰'.fontcolor(\\\"#FFA500\\\");\\n    var foldname = 'er_' + vari + 'fold';\\n    var fold = getMyVar(foldname, '1');\\n\\n    var url = $('#noLoading#').lazyRule((foldname, shsort, push) => {\\n      var pl = storage0.getMyVar('er_playlists', '{}');\\n      if (Object.keys(pl).length == 1) {\\n        return 'hiker://empty'\\n      }\\n\\n      var fold = getMyVar(foldname, '1');\\n      var obj = findItem(shsort + '_avatar')\\n      if (fold == '1') {\\n        var bcls = findItem(shsort + '_button');\\n        var tcls = findItemsByCls(shsort + '_tab');\\n        var lcls = findItem(shsort + '_line');\\n\\n        var pcls = findItemsByCls(shsort);\\n        var cs = [bcls].concat(tcls, [lcls], pcls);\\n\\n        if (push) {\\n          var pcls = findItemsByCls(shsort + '_pushtab');\\n          cs = pcls.concat(cs);\\n        }\\n\\n        var cx = $.dataConvert(cs);\\n        storage0.putMyVar(shsort + '_cls', cx);\\n        if (push) {\\n          deleteItemByCls(shsort + '_pushtab');\\n        }\\n        deleteItem(bcls.extra.id);\\n        deleteItemByCls(shsort + '_tab');\\n        deleteItem(shsort + '_line');\\n        deleteItemByCls(shsort);\\n\\n        updateItem(obj.extra.id, {\\n          desc: obj.desc.replace('展开<font color=\\\"#FFA500\\\">☰', '折叠<font color=\\\"#D3D3D3\\\">☷'),\\n        })\\n      }\\n      if (fold == '0') {\\n        var cs = storage0.getMyVar(shsort + '_cls');\\n        addItemAfter(shsort + '_avatar', cs);\\n        updateItem(obj.extra.id, {\\n          desc: obj.desc.replace('折叠<font color=\\\"#D3D3D3\\\">☷', '展开<font color=\\\"#FFA500\\\">☰'),\\n        })\\n      }\\n      putMyVar(foldname, fold === '1' ? '0' : '1');\\n      return 'toast://' + (fold === '1' ? '收起' : '展开');\\n    }, foldname, shsort, (parse['推送'] ? true : false));\\n    var desc = (fold === '0' ? 折叠 : 展开) + '\\\\t';\\n\\n    if (exp.length == 1) {\\n      url = 'hiker://empty';\\n      desc = '';\\n    }\\n    d.push({\\n      title: vari + ':\\\\t\\\\t' + '共' + String(tabs.length).fontcolor('#4682B4') + '条线路',\\n      desc: desc,\\n      col_type: 'avatar',\\n      img: custom.图标,\\n      url: url,\\n      extra: {\\n        id: shsort + '_avatar',\\n        longClick: this.setLongclick(shsort),\\n      }\\n    })\\n    if (typeof (parse['推送']) != 'undefined' && parse['推送'])\\n      this.pushTab('er_' + vari, shsort);\\n\\n    if (fold == '0') {\\n      return\\n    }\\n\\n    d.push({\\n      title: '““””' + title,\\n      url: $('#noLoading#').lazyRule((vari, shsort, custom) => {\\n        let conf = getMyVar(shsort + '_sort', '0');\\n        var clslists = findItemsByCls(shsort);\\n        var newclslist = $.dataConvert(clslists);\\n        deleteItemByCls(shsort);\\n        newclslist.reverse();\\n        addItemAfter(shsort + '_line', newclslist);\\n\\n        var obj = findItem(shsort + '_button')\\n        var titles = [`${custom.正序颜色}\\\">正序`, `${custom.逆序颜色}\\\">逆序`];\\n\\n        if (conf == '1') {\\n          updateItem(shsort + '_button', {\\n            title: obj.title.replace(titles[1], titles[0]),\\n          })\\n          putMyVar(shsort + '_sort', '0');\\n        } else {\\n          updateItem(shsort + '_button', {\\n            title: obj.title.replace(titles[0], titles[1]),\\n          })\\n          putMyVar(shsort + '_sort', '1');\\n        }\\n        //refreshPage()\\n        return 'toast://切换排序成功'\\n      }, vari, shsort, custom),\\n      col_type: custom.线路样式,\\n      extra: {\\n        id: shsort + '_button',\\n      }\\n    })\\n    this.createPList(stabs, vari, shsort, custom, parse);\\n  },\\n  setLists: function (lists, index, shsort, parse) {\\n    //log(lists)\\n    shsort = shsort ? shsort : 'shsort';\\n    storage0.putMyVar(shsort + '_list', lists);\\n\\n    parse = parse ? parse : {};\\n    var 样式 = parse.样式 ? parse.样式 : '';\\n    var 图标 = parse.图标 ? parse.图标 : 'https://hikerfans.com/tubiao/movie/13.svg';\\n    var ajax = parse.动态数据 ? parse.动态数据 : false;\\n\\n    if (ajax) {\\n      var list = lists;\\n      if (getMyVar(shsort + '_sort') == '1' && lists.length > 0) {\\n        list = lists.reverse();\\n      }\\n    } else {\\n      var list = lists[index];\\n      if (getMyVar(shsort + '_sort') == '1' && lists.length > 0) {\\n        list = lists[index].reverse();\\n      }\\n    }\\n\\n\\n\\n    if (样式 == '') {\\n      样式 = list.length > 3 ? 'text_4' : 'text_2'\\n    }\\n\\n    var extra = '';\\n\\n    if (parse.extra != undefined) {\\n      extra = parse.extra\\n    }\\n\\n    if (list.length > 0) {\\n      var plist = storage0.getMyVar('er_playlists', '{}');\\n      if (!plist.hasOwnProperty(shsort)) {\\n        plist[shsort] = {};\\n      }\\n      plist[shsort]['cls'] = shsort;\\n      plist[shsort]['col_type'] = 样式;\\n      plist[shsort]['pic'] = 图标;\\n      plist[shsort]['extra'] = extra;\\n      storage0.putMyVar('er_playlists', plist);\\n    }\\n\\n\\n\\n    for (var j in list) {\\n\\n      let lt = {\\n        title: list[j].title,\\n        url: list[j].url,\\n        col_type: 样式,\\n        pic: 图标,\\n        extra: {\\n          id: list[j].url.replace(/@lazyRule[\\\\s\\\\S]+/g, ''),\\n          cls: shsort,\\n        }\\n      };\\n      lt['extra'] = Object.assign({}, lt['extra'], extra);\\n      d.push(lt);\\n    }\\n  },\\n  evalRe: function (input, 函数) {\\n    let result = input;\\n    result = eval('input' + 函数);\\n    return result;\\n  },\\n  getTabs: function (parse) {\\n    var tabs = [];\\n    var arts = [];\\n    if (typeof parse.线路 == 'object') {\\n      arts = parse.线路;\\n    }\\n    if (arts.length == 0) {\\n      arts = pdfa(html, parse.线路);\\n    }\\n    var 线路名 = parse.线路名称;\\n    var 线路链接 = parse.线路链接 ? parse.线路链接 : '';\\n    var 替换函数 = '';\\n    if (parse.线路名称.includes('@@')) {\\n      线路名 = parse.线路名称.split('@@')[0];\\n      替换函数 = parse.线路名称.split('@@')[1];\\n    }\\n    for (var i in arts) {\\n      let linename = '';\\n      if (线路名 == '') {\\n        linename = arts[i];\\n      } else {\\n        linename = pdfh(arts[i], 线路名);\\n      }\\n      if (替换函数 != '') {\\n        linename = this.evalRe(linename, 替换函数);\\n      }\\n      tabs.push({ title: linename });\\n      if (线路链接 != '') {\\n        tabs[i]['url'] = pd(arts[i], 线路链接);\\n      }\\n    }\\n    //log(tabs);\\n    return tabs;\\n  },\\n  getLists: function (parse, shsort, h) {\\n    html = h || html;\\n    shsort = shsort ? shsort : 'shsort';\\n    var lists = [];\\n    var conts = [];\\n    if (typeof parse.选集 == 'object') {\\n      conts = parse.选集;\\n    }\\n    if (conts.length == 0) {\\n      try {\\n        conts = pdfa(html, parse.选集);\\n      } catch {\\n        toast('选集定位有误')\\n      }\\n    }\\n\\n    let 替换函数 = '';\\n    var 选集名称 = parse.选集名称 ? parse.选集名称 : 'a&&Text';\\n    if (选集名称.includes('@@')) {\\n      选集名称 = parse.选集名称.split('@@')[0];\\n      替换函数 = parse.选集名称.split('@@')[1];\\n    }\\n\\n    var 选集链接 = parse.选集链接 ? parse.选集链接 : 'a&&href';\\n    var 解析 = parse.解析 ? parse.解析 : '';\\n    var temp = [];\\n\\n    for (var i in conts) {\\n      if (parse.选集列表 != undefined) {\\n        if (parse.选集列表 == 'object') {\\n          lists.push(conts[i].map(x => {\\n            return {\\n              title: x.title,\\n              url: x.url + 解析,\\n            }\\n          }))\\n        } else {\\n          lists.push(pdfa(conts[i], parse.选集列表).map(x => {\\n            return {\\n              title: pdfh(x, 选集名称),\\n              url: pd(x, 选集链接) + 解析,\\n            }\\n          }))\\n        }\\n      } else {\\n        var url = pd(conts[i], 选集链接);\\n        if (!选集链接.includes('href')) {\\n          url = pdfh(conts[i], 选集链接);\\n        }\\n        let title = pdfh(conts[i], 选集名称);\\n        title = 替换函数 != '' ? this.evalRe(title, 替换函数) : title;\\n        temp.push({\\n          title: title,\\n          url: 'hiker://page/aliyun?rule=云盘君.简&page=fypage&realurl='+url + 解析,\\n        })\\n      }\\n    }\\n    let 倒序 = parse.倒序 ? parse.倒序 : false;\\n    var results = lists.length ? lists : [temp];\\n    if (倒序) {\\n      results = results.map(x => x.reverse());\\n    }\\n    var plist = storage0.getMyVar('er_playlists', '{}');\\n    if (results.some(x => x.length > 0)) {\\n      if (!plist.hasOwnProperty(shsort)) {\\n        plist[shsort] = {};\\n      }\\n      plist[shsort]['length'] = results.length;\\n    };\\n    storage0.putMyVar('er_playlists', plist);\\n    return results;\\n  },\\n  getPlayers: function (parse, mode, func) {\\n    //log(mode)\\n    var play = 'er_playlist_';\\n    this.preLoad(func);\\n    this.close(parse.map(x => x.类型), parse.length);\\n    mode = mode ? mode : 1;\\n\\n    let pe = [1];\\n    try {\\n      pe = parse.map(x => pdfa(html, x.线路).length).filter(y => y > 0);\\n    } catch { }\\n\\n\\n    parse.forEach((item, i) => {\\n      var tabs = [{ title: '主线' }];\\n      if (item.线路 != undefined) {\\n        tabs = this.getTabs(item);\\n      }\\n      putMyVar(play + i + '_tabs', tabs.map(x => x.title));\\n\\n      if (item.动态数据) {\\n        if (mode == 1) {\\n          this.setTabs(tabs, item.类型, play + i, item);\\n        } else {\\n          this.setTabs2(tabs, item.类型, play + i, item, pe);\\n        }\\n        putMyVar('er_html', html);\\n        putMyVar('er_url', MY_URL);\\n        var info = { parse: item, mark: play + i, url: MY_URL };\\n        if (tabs.some(x => x.url)) {\\n          info['urls'] = tabs.map(x => x.url);\\n        }\\n\\n        var lists = func(getMyVar('er_' + item.类型, '0'), info);\\n      } else {\\n        var lists = this.getLists(item, play + i);\\n\\n        if (lists.some(x => x.length > 0)) {\\n          if (mode == 1) {\\n            this.setTabs(tabs, item.类型, play + i, item);\\n          } else {\\n            this.setTabs2(tabs, item.类型, play + i, item, pe);\\n          }\\n        }\\n      }\\n      if (getMyVar('er_' + item.类型 + 'fold', '1') == '1') {\\n        this.setLists(lists, getMyVar('er_' + item.类型, '0'), play + i, item);\\n      }\\n      d.push({\\n        col_type: 'blank_block'\\n      })\\n    })\\n  }\\n}\\n\\n\\nlet Methods = {\\n  //多选模块\\n  MultiSelectMode: function (name, id, shsort) {\\n    return $('#noLoading#').lazyRule((datatitle, dataurl, shsort) => {\\n      function unique(arr) {\\n        const res = new Map()\\n        return arr.filter((a) => !res.has(a.url) && res.set(a.url, 1))\\n      }\\n      let duoselect = storage0.getMyVar(shsort + \\\"_duoselect\\\") ? storage0.getMyVar(shsort + \\\"_duoselect\\\") : [];\\n      if (duoselect.findIndex(x => x.url === dataurl) == -1) {\\n        duoselect.push({\\n          title: datatitle,\\n          url: dataurl\\n        })\\n        duoselect = unique(duoselect)\\n        updateItem(dataurl, {\\n          title: `““””<span style=\\\"color:#FF5733\\\">` + datatitle,\\n        });\\n      } else {\\n        function removeByValue(arr, val) {\\n          for (var i = 0; i < arr.length; i++) {\\n            if (arr[i]['url'] == val) {\\n              arr.splice(i, 1);\\n              break;\\n            }\\n          }\\n        }\\n        removeByValue(duoselect, dataurl)\\n        updateItem(dataurl, {\\n          title: datatitle\\n        });\\n      }\\n      storage0.putMyVar(shsort + \\\"_duoselect\\\", duoselect);\\n      return \\\"hiker://empty\\\"\\n    }, name, id, shsort)\\n  },\\n}\\n\\n\\n$.exports = {\\n  Erji: Erji,\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级\",\"path\":\"ej\",\"rule\":\"js: \\nvar d = [];\\nMY_URL=MY_URL.replace('hiker://empty##','');\\nvar html = fetch(MY_URL);\\nrc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\nvar contents = pdfa(html, 'body&&.video-info-items')\\nvar content = contents.map(x => pdfh(x, 'div&&Text'));\\n\\nd.push({\\n    img:  pd(html, \\\".lazyload&&data-src\\\"),\\n    title: small(pdfh(html, '.page-title&&Text')+'\\\\n'+pdfh(html, '.video-info-aux&&Text')+'\\\\n'+content[3],'f4c7ba'),\\n    desc: small(content.slice(0,3).join('\\\\n'),'4d4030'),\\n    url: MY_URL,\\n    col_type: 'movie_1_vertical_pic_blur',\\nextra: {\\n            gradient: true\\n        }\\n\\n})\\n\\neval(JSON.parse(request('hiker://page/er',{})).rule);\\n\\nvar playlist = [{\\n    类型: '阿里云盘',\\n    //线路: '',\\n    选集: 'body&&.module-row-one',\\n    //线路名称: 'Text@@.replace(\\\"β\\\",\\\"\\\")',\\n    //选集列表: 'ul&&li',\\n    选集名称: 'h4&&Text',\\n    选集链接: 'p&&Text',\\n    样式: 'avatar',\\n    图标: 'https://cdn-icons-png.flaticon.com/128/892/892300.png'\\n}]\\n\\n\\nErji.setDesc(pdfh(html, '.sqjj_a&&Text').replace('[收起部分]',''));\\nErji.getPlayers(playlist);\\nErji.声明();\\n\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"category\",\"rule\":\"js:\\nvar d = [];\\nvar MY_URL='https://wogg.link/index.php/vodshow/1--------1---.html;';\\nconst page = MY_PAGE;\\neval(JSON.parse(request('hiker://page/yi?rule=α')).rule)\\n\\nif (page == 1) {\\n    \\n}\\n\\nvar 定位信息 = [{\\n    大类定位: '.library-list',\\n    小类: 'body&&a',\\n}, {\\n    一级定位: 'body&&.library-box,1:',\\n    小类: 'body&&a',\\n}];\\nlet true_url = getMyVar(MY_RULE.url, MY_URL)\\nif (page > 1 && !/-(\\\\d+)\\\\.html/.test(true_url)) {\\n    true_url = true_url.replace('---.html', page + '---.html');\\n}\\n//log(true_url)\\nMY_URL = true_url;\\nvar html = fetch(MY_URL);\\n\\nconst dc = dynamicClass({\\n    分类颜色: getRangeColors()\\n});\\ndc.开启折叠()\\ndc.开启搜索(false).创建动态分类(定位信息)\\n\\nvar list = pdfa(html, 'body&&.module-item');\\nlist.forEach(item => {  \\n    d.push({\\n        title: pdfh(item, 'img&&alt'),\\n          desc: pdfh(item, '.module-item-text&&Text'),\\n        img: pd(item, '.lazy&&data-src'),\\n        url: pd(item, 'a&&href')+'#immersiveTheme##autoCache#@rule=js:$.require(\\\"hiker://page/ej\\\")',\\n        col_type: 'movie_3_marquee',\\n    })\\n})\\n\\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    putMyVar('rnum', 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.title,\\n        url: item.url,\\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    //log(data)\\n\\n    let obj = {\\n        data: data,\\n    };\\n\\n    registerTask(id, time, $.toString((obj,id) => {\\n        var data = obj.data;\\n        var rum = getMyVar('rnum');\\n\\n        var i = Number(getMyVar('banneri', '0'));\\n        if (rum != '') {\\n            i = Number(rum) + 1\\n            clearMyVar('rnum')\\n        } else {\\n            i = i + 1;\\n        }\\n        //log(i)\\n        //log(data.length)\\n\\n        if (i > data.length - 1) {\\n            i = 0\\n        }\\n        var item = data[i];\\n        //log(item)\\n        try {\\n            updateItem(id+'bar', {\\n                title: item.title,\\n                img: item.img,\\n                url: item.url,\\n                extra: {\\n                    //name: item.title.replace(/<[^>]+>/g, ''),\\n                    //sname: item.extra.sname,\\n                    //stype: item.extra.stype,\\n                    //surl: item.url,\\n                    //img:item.img,\\n                    title: item.title.replace(/<[^>]+>/g, ''),\\n                }\\n            })\\n        } catch (e) {\\n            log(e.message)\\n            unRegisterTask(id)\\n        }\\n        putMyVar('banneri', i);\\n\\n    }, obj,id))\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"一级\",\"path\":\"yi\",\"rule\":\"var Icon_prefix = 'https://hikerfans.com/tubiao/circle/';\\n//轮播\\nvar lundata = pdfa(html, 轮播列表).map((x) => {\\n    //log(x)\\n        var urll = pd(x, 轮播链接) + '#immersiveTheme#';\\n    return {\\n        title: pdfh(x, 轮播标题),\\n        img: pdfh(x,轮播图片) + '@Referer=',\\n        url: 'hiker://page/ej?url='+urll+'#noHistory#',\\n    }\\n});\\neval(JSON.parse(fetch(\\\"hiker://page/lunbo\\\", {})).rule);\\nbanner(MY_RULE.title, true, d, lundata, {\\n        time: 5000,\\n        col_type: 'card_pic_1',\\n        desc: '0'\\n    })\"}],\"saved\":false,\"title\":\"玩偶哥哥\",\"version\":0,\"url\":\"https://wogg.link/index.php/voddetail/84217.html#immersiveTheme##autoCache#;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\",\"col_type\":\"movie_3\",\"find_rule\":\"js:$.require(\\\"hiker://page/ej\\\")\",\"group\":\"②网盘\",\"ua\":\"mobile\",\"preRule\":\"if (request('hiker://home@α') == 'null') {\\n    confirm({\\n        title: '依赖检测',\\n        content: '检测到缺少小程序,请导入!',\\n        confirm: () => {\\n            return \\\"海阔视界首页频道规则【α】￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=6417\\\"\\n        }\\n    })\\n}\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级内容\\\",\\\"path\\\":\\\"er\\\",\\\"rule\\\":\\\"js:\\\\n/*ver 20230930 2.0\\\\n */\\\\nconst customs = {};\\\\n\\\\n//预设\\\\nfunction customData(custom) {\\\\n  Object.keys(custom).forEach((k) => {\\\\n    customs[k] = custom[k];\\\\n  })\\\\n}\\\\n\\\\n\\\\nlet Erji = {\\\\n  通免: $('').lazyRule(() => {\\\\n    try {\\\\n      var html = JSON.parse(request(input).match(/r player_.*?=(.*?)</)[1])\\\\n      var url = html.url\\\\n      if (html.encrypt == '1') {\\\\n        url = unescape(url);\\\\n      } else if (html.encrypt == '2') {\\\\n        url = unescape(base64Decode(url));\\\\n      }\\\\n      if (/m3u8|mp4/.test(url)) {\\\\n        return url\\\\n      } else {\\\\n        return \\\\\\\"video://\\\\\\\" + input\\\\n      }\\\\n    } catch (e) {\\\\n      return \\\\\\\"video://\\\\\\\" + input\\\\n    }\\\\n  }),\\\\n  evalJSRule: function (item, jsRule) {\\\\n    let rule = jsRule.replace(\\\\\\\"@js:\\\\\\\", \\\\\\\"\\\\\\\");\\\\n    rule = rule.trim();\\\\n    //log($.stringify(rule))\\\\n    let input = item;\\\\n    if (rule.startsWith(\\\\\\\"(\\\\\\\")) {\\\\n      eval(\\\\\\\"result = \\\\\\\" + rule);\\\\n    } else {\\\\n      /**\\\\n      * 还原成 $.toString(...) 的最终结果，达到最终处理方式跟上面的 if 一致的目的\\\\n      */\\\\n      eval(\\\\\\\"result = \\\\\\\" + \\\\\\\"(() => {\\\\\\\" + rule + \\\\\\\"})()\\\\\\\");\\\\n    }\\\\n    return result || \\\\\\\"\\\\\\\";\\\\n  },\\\\n  updataRule: function (rule, headers) {\\\\n    headers = headers != undefined ? headers : {};\\\\n    setLastChapterRule('js:' + $.toString((url, rule, headers) => {\\\\n      var html = fetch(url, headers);\\\\n      setResult(eval(rule))\\\\n    }, MY_URL, rule, headers))\\\\n  },\\\\n  updataFun: function (method, params) {\\\\n    var methodArgs = this.getArgs(method);\\\\n    var args = methodArgs.map(function(arg) {\\\\n      return params[arg];\\\\n    });\\\\n    //method.apply(null, args);\\\\n    setLastChapterRule('js:' + $.toString((method,args) => {\\\\n      method.apply(null, args);\\\\n    }, method,args))\\\\n  },\\\\n  updata:function(args1,args2){\\\\n      if(args1.constructor==Function){\\\\n        return this.updataFun(args1,args2);\\\\n      }else{\\\\n        return this.updataRule(args1,args2);\\\\n      }\\\\n  },\\\\n  getArgs:function(func){\\\\n    var args = func.toString().match(/function\\\\\\\\s.*?\\\\\\\\(([^)]*)\\\\\\\\)/)[1];\\\\n    return args.split(\\\\\\\",\\\\\\\").map(function (arg) {\\\\n      return arg.replace(/\\\\\\\\/\\\\\\\\*.*\\\\\\\\*\\\\\\\\//, \\\\\\\"\\\\\\\").trim();\\\\n    }).filter(function (args) {\\\\n      return args;\\\\n    });\\\\n  },\\\\n  maxList: (arr) => { \\\\n    return arr.reduce((acc, curr) => (curr.length > acc.length ? curr : acc), []) \\\\n  },\\\\n  close: function (list, sorts) {\\\\n    addListener('onClose', $.toString((list, sorts) => {\\\\n      list.map(x => {\\\\n        clearMyVar('er_' + x + 'fold');\\\\n        clearMyVar('er_' + x);\\\\n      })\\\\n      for (let i = 0; i < sorts; i++) {\\\\n        clearMyVar('playlist_' + i);\\\\n      }\\\\n      clearMyVar('er_playlists');\\\\n    }, list, sorts))\\\\n  },\\\\n  dataConvert: function (data) {\\\\n    var newclslist = data.map(function (obj) {\\\\n      var newObj = Object.assign({}, obj);\\\\n      if (newObj.hasOwnProperty('type')) {\\\\n        newObj.col_type = newObj.type;\\\\n      }\\\\n      return newObj;\\\\n    });\\\\n    return newclslist;\\\\n  },\\\\n  preLoad: function (func) {\\\\n    let myfunc = null\\\\n    if (func != undefined && func.constructor == Function) {\\\\n      myfunc = func\\\\n    }\\\\n    $.extend({\\\\n      dataConvert: this.dataConvert,\\\\n      msm: Methods.MultiSelectMode,\\\\n      func: myfunc,\\\\n    })\\\\n  },\\\\n  small: function (str, color,h) {\\\\n    h=h==undefined?true:h;\\\\n    return (h?'““””':'')+'<small><font color=\\\\\\\"' + (color || '') + '\\\\\\\">' + str + '</font></small>';\\\\n  },\\\\n  声明: function () {\\\\n    d.push({\\\\n      title: this.small('以上数据来源于网络，如您喜欢，请支持官方！', '#871F78'),\\\\n      desc: this.small('此规则仅限学习交流使用，请于导入后24小时内删除，任何组织或个人不得以任何方式方法传播此规则的整体或部分！', '#F20C00'),\\\\n      url: 'hiker://empty',\\\\n      col_type: 'text_center_1'\\\\n    });\\\\n  },\\\\n  substr: function (str, maxLength) {\\\\n    let len = 0;\\\\n    for (let i = 0; i < str.length; i++) {\\\\n      if (str.charCodeAt(i) > 255) {\\\\n        len += 2;\\\\n      } else {\\\\n        len++;\\\\n      }\\\\n      if (len > maxLength) {\\\\n        return str.slice(0, i) + '...';\\\\n      }\\\\n    }\\\\n    return str;\\\\n  },\\\\n  setDesc: function (desc, num) {\\\\n    var custom = this.getPreset();\\\\n    desc = desc.constructor == Array ? desc.join('<br>') : desc;\\\\n    if (desc.replace(/(<br>|\\\\\\\\s+)/g, '').length == 0) {\\\\n      return\\\\n    }\\\\n    var info = storage0.getMyVar('er_info', '{}')\\\\n    if (info['desc'] != undefined) {\\\\n      info['desc'] = info['desc'] + ' 简介:' + desc;\\\\n      storage0.putMyVar('er_info', info);\\\\n    }\\\\n\\\\n    const mark = 'desc';\\\\n    num = typeof (num) == 'undefined' ? 100 : num\\\\n    desc = desc.startsWith('　　') ? desc : '　　' + desc;\\\\n    desc = desc.replace(/'/g, \\\\\\\"&#39;\\\\\\\");\\\\n    desc = desc.replace(/\\\\\\\\r\\\\\\\\n/g, \\\\\\\"<br>\\\\\\\");\\\\n\\\\n\\\\n    let sdesc = this.substr(desc, num);\\\\n\\\\n    var colors = {\\\\n      show: custom.简介展开,\\\\n      hide: custom.简介收起\\\\n    }\\\\n\\\\n    var lazy = $(`#noLoading#`).lazyRule((dc, sdc, m, cs) => {\\\\n      var show = storage0.getItem(m, '0');\\\\n      var title = findItem('desc').title;\\\\n      var re = /(<\\\\\\\\/small><br>.*?>).+/g;\\\\n      var exp = '展开:';\\\\n      var ret = '收起:';\\\\n      if (show == '1') {\\\\n        updateItem('desc', {\\\\n          title: title\\\\n            .replace(ret, exp)\\\\n            .replace(re, '$1' + sdc + '</small>')\\\\n            .replace(/(<\\\\\\\\/small><br>\\\\\\\\<font color=\\\\\\\").*?(\\\\\\\">)/, '$1' + cs.hide + '$2')\\\\n\\\\n        })\\\\n        storage0.setItem(m, '0');\\\\n      } else {\\\\n        updateItem('desc', {\\\\n          title: title\\\\n            .replace(exp, ret)\\\\n            .replace(re, '$1' + dc + '</small>')\\\\n            .replace(/(<\\\\\\\\/small><br>\\\\\\\\<font color=\\\\\\\").*?(\\\\\\\">)/, '$1' + cs.show + '$2')\\\\n        })\\\\n        storage0.setItem(m, '1');\\\\n      }\\\\n      return `hiker://empty`\\\\n    }, desc, sdesc, mark, colors)\\\\n    var sc = storage0.getItem(mark, '0') == '0' ? '展开:' : '收起:';\\\\n    var dc = storage0.getItem(mark, '0') == '0' ? sdesc : desc;\\\\n    var cs = storage0.getItem(mark, '0') == '0' ? colors.hide : colors.show;\\\\n    d.push({\\\\n      title: '' + '<b><font color=\\\\\\\"#098AC1\\\\\\\">∷剧情简介\\\\t</font></b>' + \\\\\\\"<small><a style='text-decoration: none;' href='\\\\\\\" + lazy + \\\\\\\"'>\\\\\\\" + sc + '</a></small><br><font color=\\\\\\\"' + cs + '\\\\\\\">' + `${dc}` + '</small>',\\\\n      col_type: 'rich_text',\\\\n      extra: {\\\\n        id: 'desc',\\\\n        lineSpacing: 6,\\\\n        textSize: 15,\\\\n        lineVisible: true,\\\\n      }\\\\n    })\\\\n  },\\\\n  setDesc2: function (desc, num) {\\\\n    var custom = this.getPreset();\\\\n    desc = desc.constructor == Array ? desc.join('<br>') : desc;\\\\n    if (desc.replace(/(<br>|\\\\\\\\s+)/g, '').length == 0) {\\\\n      return\\\\n    }\\\\n    var info = storage0.getMyVar('er_info', '{}')\\\\n    if (info['desc'] != undefined) {\\\\n      info['desc'] = info['desc'] + ' 简介:' + desc;\\\\n      storage0.putMyVar('er_info', info);\\\\n    }\\\\n\\\\n    const mark = 'desc';\\\\n    num = typeof (num) == 'undefined' ? 100 : num\\\\n    desc = desc.startsWith('　　') ? desc : '　　' + desc;\\\\n    desc = desc.replace(/'/g, \\\\\\\"&#39;\\\\\\\");\\\\n    desc = desc.replace(/\\\\\\\\r\\\\\\\\n/g, \\\\\\\"<br>\\\\\\\");\\\\n\\\\n    let sdesc = this.substr(desc, num);\\\\n\\\\n    var colors = {\\\\n      show: custom.简介展开,\\\\n      hide: custom.简介收起\\\\n    }\\\\n    d.push({\\\\n      title: '剧情简介<span style=\\\\\\\"color:#ff0000;\\\\\\\"><b><small>' + (storage0.getItem(mark, '0')=='0'?'展开':'收起') + '</small></b></span>:',\\\\n      col_type: 'avatar',\\\\n      img: 'https://hikerfans.com/tubiao/system/75.png',\\\\n      url: $('#noLoading#').lazyRule((mark,dc, sdc,cs) => {\\\\n        var ds = storage0.getItem(mark, '0');\\\\n        var title = findItem('dshow').title;\\\\n        var dtitle = findItem('dcontent').title;\\\\n        if (ds == '0') {\\\\n          storage0.setItem(mark, '1')\\\\n          updateItem('dcontent', {\\\\n            title: dtitle.replace(/\\\\\\\\>.*?\\\\\\\\</,'>'+dc+'<')\\\\n            .replace(/(color=\\\\\\\").*?(\\\\\\\")/,'$1'+cs.show+'$2')\\\\n          });\\\\n          updateItem('dshow', {\\\\n            title: title.replace('展开', '收起')                        \\\\n          });\\\\n\\\\n\\\\n        } else {\\\\n          storage0.setItem(mark, '0')\\\\n          updateItem('dcontent', {\\\\n            title: dtitle.replace(/\\\\\\\\>.*?\\\\\\\\</,'>'+sdc+'<')\\\\n            .replace(/(color=\\\\\\\").*?(\\\\\\\")/,'$1'+cs.hide+'$2')\\\\n          });\\\\n          updateItem('dshow', {\\\\n            title: title.replace('收起', '展开')                        \\\\n          });\\\\n        }\\\\n        return 'hiker://empty'\\\\n      },mark, desc, sdesc,colors),\\\\n      extra: {\\\\n        id: 'dshow',\\\\n      }\\\\n    })\\\\n    var sc=storage0.getItem(mark, '0') == '0' ? sdesc.fontcolor(colors.hide) : desc.fontcolor(colors.show);\\\\n    d.push({\\\\n      title:sc,\\\\n      col_type: 'rich_text',\\\\n      extra: {\\\\n        id: 'dcontent',\\\\n        lineSpacing: 6,\\\\n        textSize: 15,\\\\n        lineVisible: true,\\\\n      }\\\\n    })\\\\n  },\\\\n  strConvert:function(arr, sp) {\\\\n      sp = sp != undefined ? sp : '/';\\\\n      var reg = new RegExp(sp);\\\\n\\\\n      return arr.map(x => {\\\\n        str = x;\\\\n        if (reg.test(str)) {\\\\n          str = str.split(sp).map((val, index) => (index === 0 ? '' : '') + val).slice(0, 5).join(' ').replace(/ $/, '');\\\\n        }\\\\n        return str\\\\n      })\\\\n  },\\\\n  setContent: function (obj) {\\\\n    //log(obj)\\\\n    var custom = this.getPreset();\\\\n    var num = obj.num != undefined ? obj.num : 100;\\\\n    var contents = obj.main;\\\\n    if (contents.constructor == String) {\\\\n      contents = contents.split('\\\\\\\\n');\\\\n    }\\\\n    var sortOrder = obj.sort ? obj.sort : [];\\\\n    var filterlist = obj.filist ? obj.filist : [];\\\\n    var img = obj.img;\\\\n    var texts = contents.map(x => {\\\\n      if (x.includes('href')) {\\\\n        var list = pdfa(x, 'body&&a').map(k => pdfh(k, 'Text')).slice(0, 5).join(' ');\\\\n        if (list == '') {\\\\n          return pdfh(x, 'Text');\\\\n        } else {\\\\n          return pdfh(x, ':matchText&&Text') + list;\\\\n        }\\\\n      }\\\\n      return pdfh(x, 'Text');\\\\n    });\\\\n    var array = texts.sort((a, b) => {\\\\n      const indexA = sortOrder.indexOf(a.substr(0, 2));\\\\n      const indexB = sortOrder.indexOf(b.substr(0, 2));\\\\n      return indexA - indexB;\\\\n    })\\\\n    var regex = new RegExp('(' + sortOrder.join('|') + ')');\\\\n    array = array.filter(function (item) {\\\\n      return regex.test(item);\\\\n    });\\\\n\\\\n    var fireg = new RegExp('(' + filterlist.join('|') + ')');\\\\n    if (filterlist.length > 0) {\\\\n      array = array.filter(function (item) {\\\\n        return !fireg.test(item);\\\\n      });\\\\n    }\\\\n    //log(array)\\\\n\\\\n    //array = sortOrder.length==0?array:this.strConvert(array);\\\\n    array = this.strConvert(array, obj.sp);\\\\n\\\\n    if (array.length > 6) {\\\\n      array = array.slice(0, 6);\\\\n    }\\\\n\\\\n    var titles = [];\\\\n    var descs = [];\\\\n\\\\n    switch (array.length) {\\\\n      case 2:\\\\n        titles = array[0];\\\\n        descs = array[1];\\\\n        break;\\\\n      case 3:\\\\n        titles = array.slice(0, 1);\\\\n        descs = array.slice(1);\\\\n        break;\\\\n      case 4:\\\\n      case 5:\\\\n        titles = array.slice(0, 2);\\\\n        descs = array.slice(2);\\\\n        break;\\\\n      case 6:\\\\n      default:\\\\n        titles = array.slice(0, 3);\\\\n        descs = array.slice(3);\\\\n        break;\\\\n    }\\\\n    storage0.putMyVar('er_info', {\\\\n      desc: descs.join('\\\\\\\\n'),\\\\n      img: img,\\\\n    })\\\\n    d.push({\\\\n      title: '<b>'+titles[0].fontcolor(custom.标题颜色)+'</b>'+this.small( '\\\\\\\\n' + titles.slice(1, 3).join('\\\\\\\\n'), custom.描述上),\\\\n      desc: this.small(descs.join('\\\\\\\\n'), custom.描述下),\\\\n      pic_url: img + '@Referer=',\\\\n      url: MY_URL,\\\\n      col_type: 'movie_1_vertical_pic_blur',\\\\n      extra: {\\\\n        id: \\\\\\\"detailid\\\\\\\",\\\\n        gradient: obj.渐变 ? obj.渐变 : false,\\\\n      }\\\\n    })\\\\n    if (obj.desc != undefined) {\\\\n      this.setDesc(obj.desc, num);\\\\n    }\\\\n  },\\\\n  setCustom: function (obj, img,colors) {\\\\n    var array = [];\\\\n    if (obj.constructor == Array) {\\\\n      array = obj;\\\\n    }\\\\n    var titles = [];\\\\n    var descs = [];\\\\n    if('titles' in obj){\\\\n      titles=obj.titles;\\\\n    }\\\\n    if('descs' in obj){\\\\n      descs=obj.descs;\\\\n    }\\\\n    \\\\n    if(titles.length==0&&descs.length==0){\\\\n    array = this.strConvert(array);\\\\n    switch (array.length) {\\\\n      case 2:\\\\n        titles = array[0];\\\\n        descs = array[1];\\\\n        break;\\\\n      case 3:\\\\n        titles = array.slice(0, 1);\\\\n        descs = array.slice(1);\\\\n        break;\\\\n      case 4:\\\\n      case 5:\\\\n        titles = array.slice(0, 2);\\\\n        descs = array.slice(2);\\\\n        break;\\\\n      case 6:\\\\n        titles = array.slice(0, 3);\\\\n        descs = array.slice(3);\\\\n        break;\\\\n      }\\\\n    }\\\\n    \\\\n    \\\\n    storage0.putMyVar('er_info', {\\\\n      desc: descs.join('\\\\\\\\n'),\\\\n      img: img,\\\\n    })\\\\n    if (colors != undefined) {\\\\n      var color_list=[];\\\\n\\\\n      for (var key in colors) {\\\\n      var range = key.split('-');\\\\n      var start = parseInt(range[0]);\\\\n      var end = range[1] ? parseInt(range[1]) : start;\\\\n      for (var i = start; i <= end; i++) {\\\\n        color_list[i-1] = colors[key];\\\\n        }\\\\n      }\\\\n\\\\n      \\\\n      if(color_list!=titles.length+descs.length){\\\\n        const fillCount = (titles.length+descs.length) - color_list.length; // 需要补齐的个数\\\\n        const filledArr = Array(fillCount).fill({}); // 生成填充数组\\\\n        color_list=color_list.concat(filledArr);\\\\n      }\\\\n  \\\\n      var midIndex = Math.floor(color_list.length / 2); \\\\n      var firstHalf = color_list.slice(0, midIndex);\\\\n      var secondHalf = color_list.slice(midIndex);\\\\n           \\\\n      function textArray(style,textArray) {\\\\n        var list=[];\\\\n        style.forEach((x, i) => {\\\\n        var left = [];\\\\n        var right = [];\\\\n        var str = textArray[i];\\\\n        Object.keys(x).forEach(k => {\\\\n            switch (k) {\\\\n                case 'color':\\\\n                    left.push('<font color=\\\\\\\"' + x[k] + '\\\\\\\">');\\\\n                    right.push('</font>');\\\\n                    break;\\\\n                default:\\\\n                    left.push(`<${k}>`);\\\\n                    right.push(`</${k}>`);\\\\n                break;\\\\n                }\\\\n              });\\\\n             list[i] = left.join('') + str + right.join('');\\\\n          });\\\\n        return list;\\\\n      }\\\\n      titles=textArray(firstHalf,titles);\\\\n      descs=textArray(secondHalf,descs);\\\\n      \\\\n      d.push({\\\\n        title:'““””'+titles[0]+'\\\\\\\\n'+titles.slice(1,3).join('\\\\\\\\n'),\\\\n        desc:'““””'+descs.join('\\\\\\\\n'),\\\\n        img:img+'@Referer='+img,\\\\n        url:MY_URL,\\\\n        col_type:'movie_1_vertical_pic_blur',\\\\n        extra:{\\\\n          id:\\\\\\\"detailid\\\\\\\",\\\\n        }\\\\n      })\\\\n      \\\\n    } else {\\\\n      d.push({\\\\n        title: titles[0] + '\\\\\\\\n' + this.small(titles.slice(1, 3).join('\\\\\\\\n')),\\\\n        desc: this.small(descs.join('\\\\\\\\n')),\\\\n        pic_url: img + '@Referer=',\\\\n        url: MY_URL,\\\\n        col_type: 'movie_1_vertical_pic_blur',\\\\n        extra:{\\\\n          id: \\\\\\\"detailid\\\\\\\",\\\\n        }\\\\n      })\\\\n  }\\\\n  },\\\\n  isColor: function (text) {\\\\n    const regex = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$|^([a-z]+)$/i;\\\\n    return regex.test(text);\\\\n  },\\\\n  getPreset: function (custom) {\\\\n    if (typeof customs == 'object' && !custom) {\\\\n      custom = customs;\\\\n    } else {\\\\n      custom = custom ? custom : {}\\\\n    }\\\\n    custom.正序颜色 = (custom.正序颜色 && this.isColor(custom.正序颜色)) ? custom.正序颜色 : '#1AAD19';\\\\n    custom.逆序颜色 = (custom.逆序颜色 && this.isColor(custom.逆序颜色)) ? custom.逆序颜色 : '#FF0000';\\\\n    custom.图标 = custom.图标 ? custom.图标 : 'https://i2.100024.xyz/2023/06/10/h4z627.webp';\\\\n    custom.线路选中 = custom.线路选中 ? custom.线路选中 : '#008B8B';\\\\n    custom.线路样式 = custom.线路样式 ? custom.线路样式 : 'scroll_button';\\\\n    custom.分割样式 = custom.分割样式 ? custom.分割样式 : 'blank_block';\\\\n    custom.简介展开 = custom.简介展开 ? custom.简介展开 : 'black';\\\\n    custom.简介收起 = custom.简介收起 ? custom.简介收起 : 'grey';\\\\n    Object.assign({}, customs, custom);\\\\n    //log(custom)\\\\n    return custom;\\\\n  },\\\\n  createPList: function (tabs, vari, shsort, custom, parse) {\\\\n    vari = \\\\\\\"er_\\\\\\\" + vari;\\\\n    let stabs = tabs;\\\\n    tabs = tabs.map(x => x.title!=undefined?x.title:x);\\\\n    var info = { parse: parse, mark: shsort };\\\\n    if (stabs.some(x => x.hasOwnProperty('url'))) {\\\\n      info['urls'] = stabs.map(x => x.url);\\\\n    }\\\\n\\\\n    for (var i = 0; i < tabs.length; i++) {\\\\n      var url = $('#noLoading#').lazyRule((vari, shsort, i, linec, info) => {\\\\n\\\\n        var lists = storage0.getMyVar(shsort + '_list', '[]');\\\\n\\\\n        if (getMyVar(vari + 'fold', '1') == '0') {\\\\n          var btn = findItem(shsort + '_button');\\\\n          var folds = ['<font color=\\\\\\\"#D3D3D3\\\\\\\">☷', '<font color=\\\\\\\"#FFA500\\\\\\\">☰'];\\\\n          var plist = storage0.getMyVar('er_playlists', '{}');\\\\n\\\\n          var col = plist[shsort].col_type;\\\\n          var cls = plist[shsort].cls;\\\\n          var pic = plist[shsort].pic;\\\\n          var extra = plist[shsort].extra;\\\\n          //log(extra)\\\\n          updateItem(btn.extra.id, {\\\\n            title: btn.title.replace(folds[0], folds[1]),\\\\n          })\\\\n\\\\n          putMyVar(vari + 'fold', '1');\\\\n          //return 'toast://展开才能操作';\\\\n        } else {\\\\n          var plist = storage0.getMyVar('er_playlists', '{}');\\\\n\\\\n          var col = plist[shsort].col_type;\\\\n          var cls = plist[shsort].cls;\\\\n          var pic = plist[shsort].pic;\\\\n          var extra = plist[shsort].extra;\\\\n          //log(extra)\\\\n        }\\\\n        putMyVar(vari, i);\\\\n\\\\n        var xlist = lists[i];\\\\n        if ($.func != undefined && $.func.constructor == Function) {\\\\n          deleteItemByCls(shsort);\\\\n          addItemAfter(shsort + '_line', {\\\\n            col_type: 'pic_1',\\\\n            img: 'https://img.nickyam.com/file/fe41a7a1744a3a8194df2.gif',\\\\n            url: 'toast://loading',\\\\n            extra: {\\\\n              cls: shsort\\\\n            }\\\\n          })\\\\n          xlist = $.func(i, info);\\\\n          storage0.putMyVar(shsort + '_list', xlist);\\\\n        }\\\\n        var plays = xlist.map(x => {\\\\n          return {\\\\n            title: x.title,\\\\n            url: x.url,\\\\n            col_type: col,\\\\n            pic: pic,\\\\n            extra: Object.assign({}, extra, {\\\\n              id: x.url.replace(/@lazyRule[\\\\\\\\s\\\\\\\\S]+/g, ''),\\\\n              cls: cls,\\\\n            })\\\\n          }\\\\n        })\\\\n        if (getMyVar(shsort + '_sort') == '1') {\\\\n          plays.reverse();\\\\n        }\\\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\\\n        if (pcfg['单推']) {\\\\n          updateItem(shsort + '_push', {\\\\n            title: pcfg['obj']['单推'][0]\\\\n          })\\\\n          pcfg['单推'] = false;\\\\n        }\\\\n        if (pcfg['选推']) {\\\\n          updateItem(shsort + '_pushs', {\\\\n            title: pcfg['obj']['选推'][0]\\\\n          })\\\\n          pcfg['选推'] = false;\\\\n        }\\\\n        storage0.putMyVar(shsort + '_pushcfg', pcfg);\\\\n        deleteItemByCls(shsort);\\\\n        addItemAfter(shsort + '_line', plays);\\\\n\\\\n        var tabx = findItemsByCls(shsort + '_tab');\\\\n        tabx.forEach((x, ii) => {\\\\n          var title = x.title;\\\\n          if (i == ii) {\\\\n            updateItem(x.extra.id, {\\\\n              title: title.replace(/#(\\\\\\\\w+)?/g, linec),\\\\n            })\\\\n          } else {\\\\n            updateItem(x.extra.id, {\\\\n              title: title.replace(/#(\\\\\\\\w+)?/g, '#'),\\\\n            })\\\\n          }\\\\n        })\\\\n        return 'toast://切换成功！';\\\\n      }, vari, shsort, i, custom.线路选中, info)\\\\n      d.push({\\\\n        title: '““””' + (getMyVar(vari, '0') == i ? tabs[i].fontcolor(custom.线路选中) : tabs[i].fontcolor('#')),\\\\n        url: url,\\\\n        col_type: custom.线路样式,\\\\n        extra: {\\\\n          cls: shsort + '_tab',\\\\n          id: shsort + '_tab_' + i,\\\\n        }\\\\n      })\\\\n    }\\\\n    d.push({\\\\n      col_type: custom.分割样式,\\\\n      extra: {\\\\n        id: shsort + '_line',\\\\n      }\\\\n    })\\\\n  },\\\\n  pushTab: function (vari, shsort) {\\\\n    addListener('onRefresh', $.toString((shsort) => {\\\\n      clearMyVar(shsort + '_pushcfg');\\\\n      clearMyVar(shsort + '_duoselect');\\\\n    }, shsort))\\\\n    var pobj = {\\\\n      '单推': ['⦿单推', '<b>⦿单推</b>'.fontcolor('#00FA9A')],\\\\n      '选推': ['☑选推', '<b>☑选推</b>'.fontcolor('#4682B4')],\\\\n    }\\\\n\\\\n    d.push({\\\\n      title: '⌘',\\\\n      col_type: 'scroll_button',\\\\n      url: 'hiker://empty',\\\\n      extra: {\\\\n        cls: shsort + '_pushtab',\\\\n      }\\\\n    }, {\\\\n      title: pobj['单推'][0],\\\\n      col_type: 'scroll_button',\\\\n      url: $('#noLoading#').lazyRule((shsort, pobj, vari) => {\\\\n        if (getMyVar(vari + 'fold', '1') == '0') {\\\\n          return 'toast://展开才能操作';\\\\n        }\\\\n\\\\n        var titles = pobj['单推'];\\\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\\\n        pcfg['obj'] = pobj;\\\\n        var 单推 = pcfg['单推'] ? pcfg['单推'] : false;\\\\n\\\\n        if (单推) {\\\\n          updateItem(shsort + '_push', {\\\\n            title: titles[0],\\\\n          })\\\\n          pcfg['单推'] = false;\\\\n          pcfg['playlist'].map((x) => {\\\\n            updateItem(x.extra.id, {\\\\n              url: x.url,\\\\n            })\\\\n          })\\\\n        } else {\\\\n          updateItem(shsort + '_push', {\\\\n            title: '““””' + titles[1],\\\\n          })\\\\n          updateItem(shsort + '_pushs', {\\\\n            title: pobj['选推'][0],\\\\n          })\\\\n          pcfg['单推'] = true;\\\\n          pcfg['选推'] = false;\\\\n          var playlist = findItemsByCls(shsort);\\\\n          pcfg['playlist'] = playlist;\\\\n          findItemsByCls(shsort).map(x => {\\\\n            var dpush = {\\\\n              name: getPageTitle(),\\\\n              url: x.title + '$' + x.extra.id\\\\n            }\\\\n            updateItem(x.extra.id, {\\\\n              url: $('').lazyRule((dpush) => {\\\\n                return 'hiker://page/push?rule=XYQ推送&pushurl=' + encodeURIComponent(JSON.stringify(dpush));\\\\n              }, dpush)\\\\n            })\\\\n          })\\\\n        }\\\\n        storage0.putMyVar(shsort + '_pushcfg', pcfg);\\\\n        return 'toast://' + (!单推 ? '单推开启' : '单推关闭');\\\\n      }, shsort, pobj, vari),\\\\n      extra: {\\\\n        id: shsort + '_push',\\\\n        cls: shsort + '_pushtab',\\\\n      }\\\\n    }, {\\\\n      title: pobj['选推'][0],\\\\n      col_type: 'scroll_button',\\\\n      url: $('#noLoading#').lazyRule((shsort, pobj, vari) => {\\\\n        if (getMyVar(vari + 'fold', '1') == '0') {\\\\n          return 'toast://展开才能操作';\\\\n        }\\\\n        var titles = pobj['选推'];\\\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\\\n        pcfg['obj'] = pobj;\\\\n        var 选推 = pcfg['选推'] ? pcfg['选推'] : false;\\\\n        if (选推) {\\\\n          updateItem(shsort + '_pushs', {\\\\n            title: titles[0],\\\\n          })\\\\n          pcfg['选推'] = false;\\\\n          pcfg['playlist'].map((x) => {\\\\n            updateItem(x.extra.id, {\\\\n              title: x.title,\\\\n              url: x.url,\\\\n            })\\\\n          })\\\\n          updateItem(shsort + '_pushto', {\\\\n            title: '推送本页=>TVBox',\\\\n          });\\\\n          clearMyVar(shsort + '_duoselect');\\\\n        } else {\\\\n          updateItem(shsort + '_pushs', {\\\\n            title: '““””' + titles[1],\\\\n          })\\\\n          pcfg['选推'] = true;\\\\n          pcfg['单推'] = false;\\\\n          var playlist = findItemsByCls(shsort);\\\\n          pcfg['playlist'] = playlist;\\\\n          let Ids = playlist.map(it => it.extra.id);\\\\n          Ids.forEach(x => {\\\\n            var title = findItem(x).title;\\\\n            updateItem(x, {\\\\n              url: $.msm(title, x, shsort),\\\\n            });\\\\n          });\\\\n          updateItem(shsort + '_push', {\\\\n            title: pobj['单推'][0],\\\\n          })\\\\n          updateItem(shsort + '_pushto', {\\\\n            title: '推送选中=>TVBox',\\\\n          });\\\\n        }\\\\n        storage0.putMyVar(shsort + '_pushcfg', pcfg);\\\\n        return 'toast://' + (!选推 ? '选推开启' : '选推关闭');\\\\n      }, shsort, pobj, vari),\\\\n      extra: {\\\\n        id: shsort + '_pushs',\\\\n        cls: shsort + '_pushtab'\\\\n      }\\\\n    }, {\\\\n      title: \\\\\\\"推送本页=>TVBox\\\\\\\",\\\\n      col_type: 'scroll_button',\\\\n      url: $('#noLoading#').lazyRule((shsort, vari) => {\\\\n        var pcfg = storage0.getMyVar(shsort + '_pushcfg', '{}');\\\\n        var 单推 = pcfg['单推'] ? pcfg['单推'] : false;\\\\n        var 选推 = pcfg['选推'] ? pcfg['选推'] : false;\\\\n        if (!单推 && !选推) {\\\\n          var tabs = storage0.getMyVar(shsort + '_tabs', '[]');\\\\n          try {\\\\n            var pls = storage0.getMyVar(shsort + '_list', '[]').map(li => {\\\\n              return li.map(item => item.title + '$' + item.url.replace(/@lazyRule[\\\\\\\\s\\\\\\\\S]+/g, '')).join('#')\\\\n            }).join('$$$');\\\\n          } catch (e) {\\\\n            var pls = storage0.getMyVar(shsort + \\\\\\\"_list\\\\\\\", '[]').map(x => x.title + \\\\\\\"$\\\\\\\" + x.url.replace(/@lazyRule[\\\\\\\\s\\\\\\\\S]+/g, '')).join(\\\\\\\"#\\\\\\\");\\\\n            var tabs = [tabs[getMyVar(vari, '0')]];\\\\n          }\\\\n          //log(pls)\\\\n          //log(tabs)\\\\n        }\\\\n        if (选推) {\\\\n          var pls = storage0.getMyVar(shsort + \\\\\\\"_duoselect\\\\\\\", '[]').map(x => x.title + \\\\\\\"$\\\\\\\" + x.url).join(\\\\\\\"#\\\\\\\");\\\\n          if (pls.length == 0) {\\\\n            return 'toast://选择为空';\\\\n          }\\\\n          var tabs = ['播放列表'];\\\\n        }\\\\n\\\\n        var info = storage0.getMyVar('er_info', '{}');\\\\n        var desc = info['desc'];\\\\n        var 推送 = {\\\\n          \\\\\\\"name\\\\\\\": getPageTitle(),\\\\n          \\\\\\\"content\\\\\\\": desc || '',\\\\n          \\\\\\\"pic\\\\\\\": info['img'] || '',\\\\n          \\\\\\\"from\\\\\\\": tabs.join('$$$'),\\\\n          \\\\\\\"url\\\\\\\": pls,\\\\n        }\\\\n        //log(推送)\\\\n        return \\\\\\\"hiker://page/push?rule=XYQ推送&pushurl=\\\\\\\" + encodeURIComponent(JSON.stringify(推送))\\\\n      }, shsort, vari),\\\\n      extra: {\\\\n        id: shsort + '_pushto',\\\\n        cls: shsort + '_pushtab'\\\\n      }\\\\n    }, {\\\\n      col_type: 'blank_block',\\\\n      extra: {\\\\n        cls: shsort + '_pushtab',\\\\n      }\\\\n    })\\\\n  },\\\\n  setLongclick: function (shsort, custom) {\\\\n    return [{\\\\n      title: '样式🎨',\\\\n      js: $.toString((shsort) => {\\\\n        let all_cols = [''].concat(getColTypes());\\\\n        all_cols = all_cols.filter(x =>\\\\n          /(text_|flex).*/.test(x) && x != 'text_icon');\\\\n        //log(all_cols)\\\\n        let cls = storage0.getMyVar('er_playlists', '{}') ||\\\\n          '';\\\\n        if (cls[shsort] != '') {\\\\n          col = cls[shsort].col_type;\\\\n        }\\\\n        let 按钮样式 = all_cols.map((it) => {\\\\n          return it === col ? '➡️' + it : it;\\\\n        });\\\\n        let tips = '请选择选集按钮样式';\\\\n        return $(按钮样式, 2, tips).select((shsort, cls) => {\\\\n          input = input.replace(/➡️/g, '');\\\\n          /*storage0.setItem('按钮样式', input);*/\\\\n          let oldIds = (findItemsByCls(shsort) || []).map(it => it.extra.id); //老元素ids\\\\n          oldIds.forEach(x => {\\\\n            updateItem(x, {\\\\n              col_type: input\\\\n            });\\\\n          });\\\\n          return 'toast://已切换选集按钮样式为:' + input;\\\\n        }, shsort, cls);\\\\n      }, shsort, custom)\\\\n    }]\\\\n  },\\\\n  setTabs: function (tabs, vari, shsort, parse) {\\\\n    let custom = parse.自定义;\\\\n    let stabs = tabs;\\\\n    tabs = tabs.map(x => x.title!=undefined?x.title:x);\\\\n\\\\n    custom = this.getPreset(custom);\\\\n\\\\n    shsort = shsort ? shsort : 'shsort';\\\\n    var title = (getMyVar(shsort + '_sort', '0') == '1') ? '<b><span style=\\\\\\\"color: ' + custom.逆序颜色 + '\\\\\\\">逆序</span></b>' : '<b><span style=\\\\\\\"color: ' + custom.正序颜色 + '\\\\\\\">正序</span></b>'\\\\n    \\\\n    d.push({\\\\n      title: vari + ':' + title,\\\\n      desc: '共' + String(tabs.length).fontcolor('#4682B4') + '条线路',\\\\n      url: $('#noLoading#').lazyRule((shsort, vari, custom) => {\\\\n        let conf = getMyVar(shsort + '_sort', '0');\\\\n        if (getMyVar('er_' + vari + 'fold', '1') == '0') {\\\\n          return 'toast://展开才能操作';\\\\n        }\\\\n        var clslists = findItemsByCls(shsort);\\\\n        var newclslist = $.dataConvert(clslists);\\\\n\\\\n        var titles = [`${custom.正序颜色}\\\\\\\">正序`, `${custom.逆序颜色}\\\\\\\">逆序`];\\\\n\\\\n        deleteItemByCls(shsort);\\\\n        newclslist.reverse();\\\\n        addItemAfter(shsort + '_line', newclslist);\\\\n\\\\n        var obj = findItem(shsort + '_avatar')\\\\n\\\\n        if (conf == '1') {\\\\n          updateItem(shsort + '_avatar', {\\\\n            title: obj.title.replace(titles[1], titles[0]),\\\\n          })\\\\n          putMyVar(shsort + '_sort', '0');\\\\n        } else {\\\\n          updateItem(shsort + '_avatar', {\\\\n            title: obj.title.replace(titles[0], titles[1]),\\\\n          })\\\\n          putMyVar(shsort + '_sort', '1');\\\\n        }\\\\n        return 'toast://切换排序成功';\\\\n      }, shsort, vari, custom),\\\\n      col_type: 'avatar',\\\\n      img: custom.图标,\\\\n      extra: {\\\\n        id: shsort + '_avatar',\\\\n        longClick: this.setLongclick(shsort),\\\\n      }\\\\n    })\\\\n    var 折叠 = '““””<b>' + '☷'.fontcolor(\\\\\\\"#D3D3D3\\\\\\\");\\\\n    var 展开 = '““””<b>' + '☰'.fontcolor(\\\\\\\"#FFA500\\\\\\\");\\\\n    var foldname = 'er_' + vari + 'fold';\\\\n    var fold = getMyVar(foldname, '1');\\\\n    if (typeof (parse['推送']) != 'undefined' && parse['推送'])\\\\n      this.pushTab('er_' + vari, shsort);\\\\n\\\\n    d.push({\\\\n      title: fold === '0' ? 折叠 : 展开,\\\\n      col_type: custom.线路样式,\\\\n      url: $('#noLoading#').lazyRule((foldname, shsort) => {\\\\n        var fold = getMyVar(foldname, '1');\\\\n        var obj = findItem(shsort + '_line');\\\\n        var btn = findItem(shsort + '_button');\\\\n        var folds = ['<font color=\\\\\\\"#D3D3D3\\\\\\\">☷', '<font color=\\\\\\\"#FFA500\\\\\\\">☰'];\\\\n\\\\n        if (fold == '0') {\\\\n          putMyVar(foldname, '1');\\\\n          var cs = storage0.getMyVar(shsort + '_cls');\\\\n          addItemAfter(obj.extra.id, cs);\\\\n          updateItem(btn.extra.id, {\\\\n            title: btn.title.replace(folds[0], folds[1]),\\\\n          })\\\\n        }\\\\n        if (fold == '1') {\\\\n          putMyVar(foldname, '0');\\\\n          var pcls = findItemsByCls(shsort);\\\\n          var cx = $.dataConvert(pcls);\\\\n          storage0.putMyVar(shsort + '_cls', cx);\\\\n          deleteItemByCls(shsort);\\\\n          updateItem(btn.extra.id, {\\\\n            title: btn.title.replace(folds[1], folds[0]),\\\\n          })\\\\n        }\\\\n\\\\n        return 'toast://' + (fold === '1' ? '收起' : '展开');\\\\n      }, foldname, shsort),\\\\n      extra: {\\\\n        id: shsort + '_button',\\\\n      }\\\\n    })\\\\n    this.createPList(stabs, vari, shsort, custom, parse);\\\\n  },\\\\n  setTabs2: function (tabs, vari, shsort, parse, exp) {\\\\n    let custom = parse.自定义;\\\\n    let stabs = tabs;\\\\n    tabs = tabs.map(x => x.title!=undefined?x.title:x);\\\\n    custom = this.getPreset(custom);\\\\n    shsort = shsort ? shsort : 'shsort';\\\\n    var title = (getMyVar(shsort + '_sort', '0') == '1') ? '<b><span style=\\\\\\\"color:' + custom.逆序颜色 + '\\\\\\\">逆序</span></b>' : '<b><span style=\\\\\\\"color:' + custom.正序颜色 + '\\\\\\\">正序</span></b>'\\\\n\\\\n    var 折叠 = '<b>折叠' + '☷'.fontcolor(\\\\\\\"#D3D3D3\\\\\\\");\\\\n    var 展开 = '<b>展开' + '☰'.fontcolor(\\\\\\\"#FFA500\\\\\\\");\\\\n    var foldname = 'er_' + vari + 'fold';\\\\n    var fold = getMyVar(foldname, '1');\\\\n\\\\n    var url = $('#noLoading#').lazyRule((foldname, shsort, push) => {\\\\n      var pl = storage0.getMyVar('er_playlists', '{}');\\\\n      if (Object.keys(pl).length == 1) {\\\\n        return 'hiker://empty'\\\\n      }\\\\n\\\\n      var fold = getMyVar(foldname, '1');\\\\n      var obj = findItem(shsort + '_avatar')\\\\n      if (fold == '1') {\\\\n        var bcls = findItem(shsort + '_button');\\\\n        var tcls = findItemsByCls(shsort + '_tab');\\\\n        var lcls = findItem(shsort + '_line');\\\\n\\\\n        var pcls = findItemsByCls(shsort);\\\\n        var cs = [bcls].concat(tcls, [lcls], pcls);\\\\n\\\\n        if (push) {\\\\n          var pcls = findItemsByCls(shsort + '_pushtab');\\\\n          cs = pcls.concat(cs);\\\\n        }\\\\n\\\\n        var cx = $.dataConvert(cs);\\\\n        storage0.putMyVar(shsort + '_cls', cx);\\\\n        if (push) {\\\\n          deleteItemByCls(shsort + '_pushtab');\\\\n        }\\\\n        deleteItem(bcls.extra.id);\\\\n        deleteItemByCls(shsort + '_tab');\\\\n        deleteItem(shsort + '_line');\\\\n        deleteItemByCls(shsort);\\\\n\\\\n        updateItem(obj.extra.id, {\\\\n          desc: obj.desc.replace('展开<font color=\\\\\\\"#FFA500\\\\\\\">☰', '折叠<font color=\\\\\\\"#D3D3D3\\\\\\\">☷'),\\\\n        })\\\\n      }\\\\n      if (fold == '0') {\\\\n        var cs = storage0.getMyVar(shsort + '_cls');\\\\n        addItemAfter(shsort + '_avatar', cs);\\\\n        updateItem(obj.extra.id, {\\\\n          desc: obj.desc.replace('折叠<font color=\\\\\\\"#D3D3D3\\\\\\\">☷', '展开<font color=\\\\\\\"#FFA500\\\\\\\">☰'),\\\\n        })\\\\n      }\\\\n      putMyVar(foldname, fold === '1' ? '0' : '1');\\\\n      return 'toast://' + (fold === '1' ? '收起' : '展开');\\\\n    }, foldname, shsort, (parse['推送'] ? true : false));\\\\n    var desc = (fold === '0' ? 折叠 : 展开) + '\\\\\\\\t';\\\\n\\\\n    if (exp.length == 1) {\\\\n      url = 'hiker://empty';\\\\n      desc = '';\\\\n    }\\\\n    d.push({\\\\n      title: vari + ':\\\\\\\\t\\\\\\\\t' + '共' + String(tabs.length).fontcolor('#4682B4') + '条线路',\\\\n      desc: desc,\\\\n      col_type: 'avatar',\\\\n      img: custom.图标,\\\\n      url: url,\\\\n      extra: {\\\\n        id: shsort + '_avatar',\\\\n        longClick: this.setLongclick(shsort),\\\\n      }\\\\n    })\\\\n    if (typeof (parse['推送']) != 'undefined' && parse['推送'])\\\\n      this.pushTab('er_' + vari, shsort);\\\\n\\\\n    if (fold == '0') {\\\\n      return\\\\n    }\\\\n\\\\n    d.push({\\\\n      title: '““””' + title,\\\\n      url: $('#noLoading#').lazyRule((vari, shsort, custom) => {\\\\n        let conf = getMyVar(shsort + '_sort', '0');\\\\n        var clslists = findItemsByCls(shsort);\\\\n        var newclslist = $.dataConvert(clslists);\\\\n        deleteItemByCls(shsort);\\\\n        newclslist.reverse();\\\\n        addItemAfter(shsort + '_line', newclslist);\\\\n\\\\n        var obj = findItem(shsort + '_button')\\\\n        var titles = [`${custom.正序颜色}\\\\\\\">正序`, `${custom.逆序颜色}\\\\\\\">逆序`];\\\\n\\\\n        if (conf == '1') {\\\\n          updateItem(shsort + '_button', {\\\\n            title: obj.title.replace(titles[1], titles[0]),\\\\n          })\\\\n          putMyVar(shsort + '_sort', '0');\\\\n        } else {\\\\n          updateItem(shsort + '_button', {\\\\n            title: obj.title.replace(titles[0], titles[1]),\\\\n          })\\\\n          putMyVar(shsort + '_sort', '1');\\\\n        }\\\\n        //refreshPage()\\\\n        return 'toast://切换排序成功'\\\\n      }, vari, shsort, custom),\\\\n      col_type: custom.线路样式,\\\\n      extra: {\\\\n        id: shsort + '_button',\\\\n      }\\\\n    })\\\\n    this.createPList(stabs, vari, shsort, custom, parse);\\\\n  },\\\\n  setLists: function (lists, index, shsort, parse) {\\\\n    //log(lists)\\\\n    shsort = shsort ? shsort : 'shsort';\\\\n    storage0.putMyVar(shsort + '_list', lists);\\\\n\\\\n    parse = parse ? parse : {};\\\\n    var 样式 = parse.样式 ? parse.样式 : '';\\\\n    var 图标 = parse.图标 ? parse.图标 : 'https://hikerfans.com/tubiao/movie/13.svg';\\\\n    var ajax = parse.动态数据 ? parse.动态数据 : false;\\\\n\\\\n    if (ajax) {\\\\n      var list = lists;\\\\n      if (getMyVar(shsort + '_sort') == '1' && lists.length > 0) {\\\\n        list = lists.reverse();\\\\n      }\\\\n    } else {\\\\n      var list = lists[index];\\\\n      if (getMyVar(shsort + '_sort') == '1' && lists.length > 0) {\\\\n        list = lists[index].reverse();\\\\n      }\\\\n    }\\\\n\\\\n\\\\n\\\\n    if (样式 == '') {\\\\n      样式 = list.length > 3 ? 'text_4' : 'text_2'\\\\n    }\\\\n\\\\n    var extra = '';\\\\n\\\\n    if (parse.extra != undefined) {\\\\n      extra = parse.extra\\\\n    }\\\\n\\\\n    if (list.length > 0) {\\\\n      var plist = storage0.getMyVar('er_playlists', '{}');\\\\n      if (!plist.hasOwnProperty(shsort)) {\\\\n        plist[shsort] = {};\\\\n      }\\\\n      plist[shsort]['cls'] = shsort;\\\\n      plist[shsort]['col_type'] = 样式;\\\\n      plist[shsort]['pic'] = 图标;\\\\n      plist[shsort]['extra'] = extra;\\\\n      storage0.putMyVar('er_playlists', plist);\\\\n    }\\\\n\\\\n\\\\n\\\\n    for (var j in list) {\\\\n\\\\n      let lt = {\\\\n        title: list[j].title,\\\\n        url: list[j].url,\\\\n        col_type: 样式,\\\\n        pic: 图标,\\\\n        extra: {\\\\n          id: list[j].url.replace(/@lazyRule[\\\\\\\\s\\\\\\\\S]+/g, ''),\\\\n          cls: shsort,\\\\n        }\\\\n      };\\\\n      lt['extra'] = Object.assign({}, lt['extra'], extra);\\\\n      d.push(lt);\\\\n    }\\\\n  },\\\\n  evalRe: function (input, 函数) {\\\\n    let result = input;\\\\n    result = eval('input' + 函数);\\\\n    return result;\\\\n  },\\\\n  getTabs: function (parse) {\\\\n    var tabs = [];\\\\n    var arts = [];\\\\n    if (typeof parse.线路 == 'object') {\\\\n      arts = parse.线路;\\\\n    }\\\\n    if (arts.length == 0) {\\\\n      arts = pdfa(html, parse.线路);\\\\n    }\\\\n    var 线路名 = parse.线路名称;\\\\n    var 线路链接 = parse.线路链接 ? parse.线路链接 : '';\\\\n    var 替换函数 = '';\\\\n    if (parse.线路名称.includes('@@')) {\\\\n      线路名 = parse.线路名称.split('@@')[0];\\\\n      替换函数 = parse.线路名称.split('@@')[1];\\\\n    }\\\\n    for (var i in arts) {\\\\n      let linename = '';\\\\n      if (线路名 == '') {\\\\n        linename = arts[i];\\\\n      } else {\\\\n        linename = pdfh(arts[i], 线路名);\\\\n      }\\\\n      if (替换函数 != '') {\\\\n        linename = this.evalRe(linename, 替换函数);\\\\n      }\\\\n      tabs.push({ title: linename });\\\\n      if (线路链接 != '') {\\\\n        tabs[i]['url'] = pd(arts[i], 线路链接);\\\\n      }\\\\n    }\\\\n    //log(tabs);\\\\n    return tabs;\\\\n  },\\\\n  getLists: function (parse, shsort, h) {\\\\n    html = h || html;\\\\n    shsort = shsort ? shsort : 'shsort';\\\\n    var lists = [];\\\\n    var conts = [];\\\\n    if (typeof parse.选集 == 'object') {\\\\n      conts = parse.选集;\\\\n    }\\\\n    if (conts.length == 0) {\\\\n      try {\\\\n        conts = pdfa(html, parse.选集);\\\\n      } catch {\\\\n        toast('选集定位有误')\\\\n      }\\\\n    }\\\\n\\\\n    let 替换函数 = '';\\\\n    var 选集名称 = parse.选集名称 ? parse.选集名称 : 'a&&Text';\\\\n    if (选集名称.includes('@@')) {\\\\n      选集名称 = parse.选集名称.split('@@')[0];\\\\n      替换函数 = parse.选集名称.split('@@')[1];\\\\n    }\\\\n\\\\n    var 选集链接 = parse.选集链接 ? parse.选集链接 : 'a&&href';\\\\n    var 解析 = parse.解析 ? parse.解析 : '';\\\\n    var temp = [];\\\\n\\\\n    for (var i in conts) {\\\\n      if (parse.选集列表 != undefined) {\\\\n        if (parse.选集列表 == 'object') {\\\\n          lists.push(conts[i].map(x => {\\\\n            return {\\\\n              title: x.title,\\\\n              url: x.url + 解析,\\\\n            }\\\\n          }))\\\\n        } else {\\\\n          lists.push(pdfa(conts[i], parse.选集列表).map(x => {\\\\n            return {\\\\n              title: pdfh(x, 选集名称),\\\\n              url: pd(x, 选集链接) + 解析,\\\\n            }\\\\n          }))\\\\n        }\\\\n      } else {\\\\n        var url = pd(conts[i], 选集链接);\\\\n        if (!选集链接.includes('href')) {\\\\n          url = pdfh(conts[i], 选集链接);\\\\n        }\\\\n        let title = pdfh(conts[i], 选集名称);\\\\n        title = 替换函数 != '' ? this.evalRe(title, 替换函数) : title;\\\\n        temp.push({\\\\n          title: title,\\\\n          url: 'hiker://page/aliyun?rule=云盘君.简&page=fypage&realurl='+url + 解析,\\\\n        })\\\\n      }\\\\n    }\\\\n    let 倒序 = parse.倒序 ? parse.倒序 : false;\\\\n    var results = lists.length ? lists : [temp];\\\\n    if (倒序) {\\\\n      results = results.map(x => x.reverse());\\\\n    }\\\\n    var plist = storage0.getMyVar('er_playlists', '{}');\\\\n    if (results.some(x => x.length > 0)) {\\\\n      if (!plist.hasOwnProperty(shsort)) {\\\\n        plist[shsort] = {};\\\\n      }\\\\n      plist[shsort]['length'] = results.length;\\\\n    };\\\\n    storage0.putMyVar('er_playlists', plist);\\\\n    return results;\\\\n  },\\\\n  getPlayers: function (parse, mode, func) {\\\\n    //log(mode)\\\\n    var play = 'er_playlist_';\\\\n    this.preLoad(func);\\\\n    this.close(parse.map(x => x.类型), parse.length);\\\\n    mode = mode ? mode : 1;\\\\n\\\\n    let pe = [1];\\\\n    try {\\\\n      pe = parse.map(x => pdfa(html, x.线路).length).filter(y => y > 0);\\\\n    } catch { }\\\\n\\\\n\\\\n    parse.forEach((item, i) => {\\\\n      var tabs = [{ title: '主线' }];\\\\n      if (item.线路 != undefined) {\\\\n        tabs = this.getTabs(item);\\\\n      }\\\\n      putMyVar(play + i + '_tabs', tabs.map(x => x.title));\\\\n\\\\n      if (item.动态数据) {\\\\n        if (mode == 1) {\\\\n          this.setTabs(tabs, item.类型, play + i, item);\\\\n        } else {\\\\n          this.setTabs2(tabs, item.类型, play + i, item, pe);\\\\n        }\\\\n        putMyVar('er_html', html);\\\\n        putMyVar('er_url', MY_URL);\\\\n        var info = { parse: item, mark: play + i, url: MY_URL };\\\\n        if (tabs.some(x => x.url)) {\\\\n          info['urls'] = tabs.map(x => x.url);\\\\n        }\\\\n\\\\n        var lists = func(getMyVar('er_' + item.类型, '0'), info);\\\\n      } else {\\\\n        var lists = this.getLists(item, play + i);\\\\n\\\\n        if (lists.some(x => x.length > 0)) {\\\\n          if (mode == 1) {\\\\n            this.setTabs(tabs, item.类型, play + i, item);\\\\n          } else {\\\\n            this.setTabs2(tabs, item.类型, play + i, item, pe);\\\\n          }\\\\n        }\\\\n      }\\\\n      if (getMyVar('er_' + item.类型 + 'fold', '1') == '1') {\\\\n        this.setLists(lists, getMyVar('er_' + item.类型, '0'), play + i, item);\\\\n      }\\\\n      d.push({\\\\n        col_type: 'blank_block'\\\\n      })\\\\n    })\\\\n  }\\\\n}\\\\n\\\\n\\\\nlet Methods = {\\\\n  //多选模块\\\\n  MultiSelectMode: function (name, id, shsort) {\\\\n    return $('#noLoading#').lazyRule((datatitle, dataurl, shsort) => {\\\\n      function unique(arr) {\\\\n        const res = new Map()\\\\n        return arr.filter((a) => !res.has(a.url) && res.set(a.url, 1))\\\\n      }\\\\n      let duoselect = storage0.getMyVar(shsort + \\\\\\\"_duoselect\\\\\\\") ? storage0.getMyVar(shsort + \\\\\\\"_duoselect\\\\\\\") : [];\\\\n      if (duoselect.findIndex(x => x.url === dataurl) == -1) {\\\\n        duoselect.push({\\\\n          title: datatitle,\\\\n          url: dataurl\\\\n        })\\\\n        duoselect = unique(duoselect)\\\\n        updateItem(dataurl, {\\\\n          title: `““””<span style=\\\\\\\"color:#FF5733\\\\\\\">` + datatitle,\\\\n        });\\\\n      } else {\\\\n        function removeByValue(arr, val) {\\\\n          for (var i = 0; i < arr.length; i++) {\\\\n            if (arr[i]['url'] == val) {\\\\n              arr.splice(i, 1);\\\\n              break;\\\\n            }\\\\n          }\\\\n        }\\\\n        removeByValue(duoselect, dataurl)\\\\n        updateItem(dataurl, {\\\\n          title: datatitle\\\\n        });\\\\n      }\\\\n      storage0.putMyVar(shsort + \\\\\\\"_duoselect\\\\\\\", duoselect);\\\\n      return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, name, id, shsort)\\\\n  },\\\\n}\\\\n\\\\n\\\\n$.exports = {\\\\n  Erji: Erji,\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级\\\",\\\"path\\\":\\\"ej\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\nMY_URL=MY_URL.replace('hiker://empty##','');\\\\nvar html = fetch(MY_URL);\\\\nrc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\\\nvar contents = pdfa(html, 'body&&.video-info-items')\\\\nvar content = contents.map(x => pdfh(x, 'div&&Text'));\\\\n\\\\nd.push({\\\\n    img:  pd(html, \\\\\\\".lazyload&&data-src\\\\\\\"),\\\\n    title: small(pdfh(html, '.page-title&&Text')+'\\\\\\\\n'+pdfh(html, '.video-info-aux&&Text')+'\\\\\\\\n'+content[3],'f4c7ba'),\\\\n    desc: small(content.slice(0,3).join('\\\\\\\\n'),'4d4030'),\\\\n    url: MY_URL,\\\\n    col_type: 'movie_1_vertical_pic_blur',\\\\nextra: {\\\\n            gradient: true\\\\n        }\\\\n\\\\n})\\\\n\\\\neval(JSON.parse(request('hiker://page/er',{})).rule);\\\\n\\\\nvar playlist = [{\\\\n    类型: '阿里云盘',\\\\n    //线路: '',\\\\n    选集: 'body&&.module-row-one',\\\\n    //线路名称: 'Text@@.replace(\\\\\\\"β\\\\\\\",\\\\\\\"\\\\\\\")',\\\\n    //选集列表: 'ul&&li',\\\\n    选集名称: 'h4&&Text',\\\\n    选集链接: 'p&&Text',\\\\n    样式: 'avatar',\\\\n    图标: 'https://cdn-icons-png.flaticon.com/128/892/892300.png'\\\\n}]\\\\n\\\\n\\\\nErji.setDesc(pdfh(html, '.sqjj_a&&Text').replace('[收起部分]',''));\\\\nErji.getPlayers(playlist);\\\\nErji.声明();\\\\n\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"分类\\\",\\\"path\\\":\\\"category\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar MY_URL='https://wogg.link/index.php/vodshow/1--------1---.html;';\\\\nconst page = MY_PAGE;\\\\neval(JSON.parse(request('hiker://page/yi?rule=α')).rule)\\\\n\\\\nif (page == 1) {\\\\n    \\\\n}\\\\n\\\\nvar 定位信息 = [{\\\\n    大类定位: '.library-list',\\\\n    小类: 'body&&a',\\\\n}, {\\\\n    一级定位: 'body&&.library-box,1:',\\\\n    小类: 'body&&a',\\\\n}];\\\\nlet true_url = getMyVar(MY_RULE.url, MY_URL)\\\\nif (page > 1 && !/-(\\\\\\\\d+)\\\\\\\\.html/.test(true_url)) {\\\\n    true_url = true_url.replace('---.html', page + '---.html');\\\\n}\\\\n//log(true_url)\\\\nMY_URL = true_url;\\\\nvar html = fetch(MY_URL);\\\\n\\\\nconst dc = dynamicClass({\\\\n    分类颜色: getRangeColors()\\\\n});\\\\ndc.开启折叠()\\\\ndc.开启搜索(false).创建动态分类(定位信息)\\\\n\\\\nvar list = pdfa(html, 'body&&.module-item');\\\\nlist.forEach(item => {  \\\\n    d.push({\\\\n        title: pdfh(item, 'img&&alt'),\\\\n          desc: pdfh(item, '.module-item-text&&Text'),\\\\n        img: pd(item, '.lazy&&data-src'),\\\\n        url: pd(item, 'a&&href')+'#immersiveTheme##autoCache#@rule=js:$.require(\\\\\\\"hiker://page/ej\\\\\\\")',\\\\n        col_type: 'movie_3_marquee',\\\\n    })\\\\n})\\\\n\\\\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    putMyVar('rnum', 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.title,\\\\n        url: item.url,\\\\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    //log(data)\\\\n\\\\n    let obj = {\\\\n        data: data,\\\\n    };\\\\n\\\\n    registerTask(id, time, $.toString((obj,id) => {\\\\n        var data = obj.data;\\\\n        var rum = getMyVar('rnum');\\\\n\\\\n        var i = Number(getMyVar('banneri', '0'));\\\\n        if (rum != '') {\\\\n            i = Number(rum) + 1\\\\n            clearMyVar('rnum')\\\\n        } else {\\\\n            i = i + 1;\\\\n        }\\\\n        //log(i)\\\\n        //log(data.length)\\\\n\\\\n        if (i > data.length - 1) {\\\\n            i = 0\\\\n        }\\\\n        var item = data[i];\\\\n        //log(item)\\\\n        try {\\\\n            updateItem(id+'bar', {\\\\n                title: item.title,\\\\n                img: item.img,\\\\n                url: item.url,\\\\n                extra: {\\\\n                    //name: item.title.replace(/<[^>]+>/g, ''),\\\\n                    //sname: item.extra.sname,\\\\n                    //stype: item.extra.stype,\\\\n                    //surl: item.url,\\\\n                    //img:item.img,\\\\n                    title: item.title.replace(/<[^>]+>/g, ''),\\\\n                }\\\\n            })\\\\n        } catch (e) {\\\\n            log(e.message)\\\\n            unRegisterTask(id)\\\\n        }\\\\n        putMyVar('banneri', i);\\\\n\\\\n    }, obj,id))\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"一级\\\",\\\"path\\\":\\\"yi\\\",\\\"rule\\\":\\\"var Icon_prefix = 'https://hikerfans.com/tubiao/circle/';\\\\n//轮播\\\\nvar lundata = pdfa(html, 轮播列表).map((x) => {\\\\n    //log(x)\\\\n        var urll = pd(x, 轮播链接) + '#immersiveTheme#';\\\\n    return {\\\\n        title: pdfh(x, 轮播标题),\\\\n        img: pdfh(x,轮播图片) + '@Referer=',\\\\n        url: 'hiker://page/ej?url='+urll+'#noHistory#',\\\\n    }\\\\n});\\\\neval(JSON.parse(fetch(\\\\\\\"hiker://page/lunbo\\\\\\\", {})).rule);\\\\nbanner(MY_RULE.title, true, d, lundata, {\\\\n        time: 5000,\\\\n        col_type: 'card_pic_1',\\\\n        desc: '0'\\\\n    })\\\"}]\"}","picUrl":"https://pic1.imgyzzy.com/upload/vod/2024-05-12/17155189301.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!