API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：番·仓________风吹花海轻舞，醉卧番仓梦乡。

xiaomianao666
May 17th, 2024
198
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 163.09 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\":\"js:\\nvar chp = [];\\ntry {\\n    var html = getResCode();\\n    var conts = parseDomForArray(html, 'body&&.sort-item');\\n    for (var i = 0; i < conts.length; i++) {\\n        var list = pdfa(conts[i], 'body&&a');\\n        chp.push(list.length);\\n    }     \\n} catch (e) {}\\nsetResult('更新至:' + (Math.max.apply(null, chp)));\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"一级分类列表\",\"path\":\"yi\",\"rule\":\"js:\\n/*\\n一级封装 \\n动态分类 列表创建 自动下一页\\nver 20230710 1.0\\n*/\\n\\n//eval(JSON.parse(fetch('hiker://page/lazy', {})).rule);\\n\\nfunction dynamicClass(options) {\\n  const obj = {\\n    //默认值\\n    layout: \\\"undefined\\\",\\n    html: \\\"empty\\\",\\n    page: 0,\\n    分类颜色: \\\"#FA7298\\\",\\n    折叠: \\\"““””<b>\\\" + \\\"∨\\\".fontcolor(\\\"#1aad19\\\") + \\\"</b>\\\",\\n    展开: \\\"““””<b>\\\" + \\\"∧\\\".fontcolor(\\\"#FF0000\\\") + \\\"</b>\\\",\\n    open: true,\\n    state: MY_RULE.url,\\n    search: false,\\n    clears: [],\\n    clearall: [\\\"yi_firstpage\\\"],\\n    debug: false,\\n\\n    预设(param) {\\n      if(param==undefined){\\n        param=[];\\n      }\\n      Object.keys(param).forEach((property) => {\\n        // 对每个属性名执行操作\\n        const value = param[property]; // 获取属性值\\n        // 在这里执行您的操作\\n        this[property] = value;\\n        if (this.debug) {\\n          console.log(property + \\\":\\\" + value);\\n        }\\n      });\\n    },\\n    evalJSRule(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    getTitle(src, category) {\\n      let title = \\\"\\\";\\n      let titleRule = category || \\\"a&&Text\\\";\\n      if (titleRule.startsWith(\\\"@js:\\\")) {\\n        title = this.evalJSRule(src, titleRule);\\n      } else {\\n        title = parseDomForHtml(src, titleRule);\\n      }\\n      return title || \\\"\\\";\\n    },\\n    getUrl(src, category) {\\n      let url = \\\"\\\";\\n      let urlRule = category.链接 || \\\"a&&href\\\";\\n      if (urlRule.startsWith(\\\"@js:\\\")) {\\n        url = this.evalJSRule(src, urlRule);\\n      } else {\\n        url = pd(src, urlRule);\\n      }\\n      if (typeof category.链接处理 == \\\"function\\\") {\\n        url = category.链接处理(url);\\n      }\\n      return url || \\\"\\\";\\n    },\\n    isNull(param) {\\n      if (param == null) {\\n        return this;\\n      }\\n      return false;\\n    },\\n    isBoolean(variable) {\\n      if (typeof variable !== \\\"boolean\\\") {\\n        throw new Error(\\\"开启折叠请传入布尔值\\\");\\n      }\\n    },\\n    清除(list) {\\n      if (this.isNull(list)) {\\n        return this;\\n      }\\n      if (list.constructor == String) {\\n        throw new Error(\\\"清除报错:请传列表\\\");\\n      }\\n      this.clears = list;\\n      return this;\\n    },\\n    全清(list) {\\n      if (this.isNull(list)) {\\n        return this;\\n      }\\n      var c = this.clearall;\\n      list = c.concat(list);\\n      this.clearall = list;\\n      return this;\\n    },\\n    源码(input) {\\n      this.html = input;\\n      return this;\\n    },\\n    界面(input) {\\n      this.layout = input;\\n      return this;\\n    },\\n    页码(input) {\\n      this.page = input;\\n      return this;\\n    },\\n    状态(input) {\\n      this.state = input;\\n      return this;\\n    },\\n    开启搜索() {\\n      this.search = true;\\n      return this;\\n    },\\n    开启折叠(input) {\\n      if (input == undefined) {\\n        input = true;\\n      }\\n      this.isBoolean(input);\\n      this.open = input;\\n      return this;\\n    },\\n    setTitle(k, i, t) {\\n      return k == i ? \\\"““””\\\" + t.fontcolor(this.分类颜色) : t;\\n    },\\n    action(obj) {\\n      return [\\n        {\\n          title: \\\"清除状态\\\",\\n          js: $.toString((obj) => {\\n            log(obj);\\n            clearMyVar(obj.state);\\n            clearMyVar(\\\"head.cate\\\");\\n            obj.all.forEach((item) => {\\n              clearMyVar(item);\\n            });\\n            obj.cl.forEach((item) => {\\n              clearMyVar(item);\\n            });\\n            refreshPage();\\n          }, obj),\\n        },\\n      ];\\n    },\\n    checkParam() {\\n      var obj = {};\\n      if (this.page == 0 && typeof page == \\\"undefined\\\") {\\n        throw new Error(\\\"请传入页码\\\");\\n      } else {\\n        if (typeof page == \\\"undefined\\\") {\\n          obj[\\\"页码\\\"] = this.page;\\n        } else {\\n          obj[\\\"页码\\\"] = page;\\n        }\\n      }\\n      if (this.html == \\\"empty\\\" && typeof html == \\\"undefined\\\") {\\n        throw new Error(\\\"请传入源码\\\");\\n      } else {\\n        if (typeof html == \\\"undefined\\\") {\\n          obj[\\\"源码\\\"] = this.html;\\n        } else {\\n          obj[\\\"源码\\\"] = html;\\n        }\\n      }\\n      if (this.layout == \\\"undefined\\\" && typeof d == \\\"undefined\\\") {\\n        throw new Error(\\\"请传入界面\\\");\\n      } else {\\n        if (typeof d == \\\"undefined\\\") {\\n          obj[\\\"界面\\\"] = this.layout;\\n        } else {\\n          obj[\\\"界面\\\"] = d;\\n        }\\n      }\\n      return obj;\\n    },\\n    创建动态分类(ruleObj) {\\n      if (ruleObj == undefined) {\\n        ruleObj = [];\\n      }\\n      //初始化变量开始\\n      const param = this.checkParam();\\n      const page = param.页码;\\n      const html = param.源码;\\n      const d = param.界面;\\n      const 状态 = this.state;\\n      const search = this.search;\\n      const empty = \\\"hiker://empty\\\";\\n      const 折叠状态 = this.open;\\n      var 展开 = this.展开;\\n      var 折叠 = this.折叠;\\n      var 全清 = this.clearall;\\n      var 清除 = this.clears;\\n      //初始化变量结束\\n      let init_cate = new Array(20).fill(\\\"0\\\");\\n      const fold = getMyVar(MY_RULE.group, \\\"0\\\");\\n      const cate_temp = JSON.parse(\\n        getMyVar(\\\"head.cate\\\", JSON.stringify(init_cate))\\n      );\\n      if (search && page == 1) {\\n        d.push({\\n          title: \\\"\\\",\\n          url: \\\"'hiker://search?rule=\\\" + MY_RULE.title + \\\"&s='+input\\\",\\n          desc: \\\"搜索关键词\\\",\\n          col_type: \\\"input\\\",\\n          extra: {\\n            defaultValue: getMyVar(\\\"keyword\\\", \\\"\\\"),\\n            onChange: $.toString(() => {\\n              putMyVar(\\\"keyword\\\", input);\\n            }),\\n          },\\n        });\\n      }\\n      const categories = [];\\n      ruleObj.forEach((x) => {\\n        var list = [];\\n        if(x.一级定位){\\n          if (x.一级定位.startsWith(\\\"@js:\\\")) {\\n          list = this.evalJSRule(html, x.一级定位);\\n         } else {\\n          list = pdfa(html, x.一级定位);\\n          }\\n        }\\n        if(x.大类定位){\\n          if (x.大类定位.startsWith(\\\"@js:\\\")) {\\n          list = this.evalJSRule(html, x.大类定位);\\n         } else {\\n          list = [pdfa(html, x.大类定位).join('\\\\n')];\\n         }\\n        }\\n        var 一级 = list.map((s) => {\\n          var slist = [];\\n          if (!(\\\"小类\\\" in x)) {\\n            x.小类 = \\\"body&&a:not(:matches(首页)):not(a:not([href]))\\\";\\n          }\\n          if (x.小类.startsWith(\\\"@js:\\\")) {\\n            slist = this.evalJSRule(s, x.小类);\\n          } else {\\n            slist = pdfa(s, x.小类);\\n          }\\n          var 定位 = slist.map((item) => {\\n            var title = this.getTitle(item, x.标题);\\n            var url = this.getUrl(item, x);\\n            var obj = { title: title, url: url };\\n            return JSON.stringify(obj);\\n          });\\n          return 定位;\\n        });\\n        //log(一级)\\n        //log(一级.length)\\n        if (一级.length == 1) {\\n          categories.push(一级.join(\\\"\\\\n\\\"));\\n        } else {\\n          一级.forEach((item) => {\\n            categories.push(item.join(\\\",\\\"));\\n          });\\n        }\\n        //log(categories)\\n      });\\n      if (折叠状态) {\\n        if (page == 1) {\\n          d.push({\\n            title: fold === \\\"1\\\" ? 折叠 : 展开,\\n            url: $(\\\"#noLoading#\\\").lazyRule(\\n              (fold, u, all) => {\\n                putMyVar(MY_RULE.group, fold === \\\"1\\\" ? \\\"0\\\" : \\\"1\\\");\\n                /*all.forEach((item) => {\\n                  clearMyVar(item);\\n                });*/\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\";\\n              },\\n              fold,\\n              状态,\\n              全清\\n            ),\\n            col_type: \\\"scroll_button\\\",\\n            extra: {\\n              longClick: this.action({\\n                state: 状态,\\n                all: 全清,\\n                cl: 清除,\\n              }),\\n            },\\n          });\\n        }\\n      }\\n      if (page == 1) {\\n      categories.forEach((category, index) => {\\n        //log(categories)\\n        let sub_categories = [];\\n        /*if (小类定位.includes(\\\";\\\")) {\\n          sub_categories = pdfa(category, 小类定位.split(\\\";\\\")[0]);\\n          if (sub_categories.length == 0) {\\n            sub_categories = pdfa(category, 小类定位.split(\\\";\\\")[1]);\\n          }\\n        } else {*/\\n        //log(index)\\n        sub_categories = JSON.parse(`[${category}]`);\\n        // sub_categories = pdfa(category, 小类定位);\\n        //}\\n        if (index === 0) {\\n          sub_categories.forEach((item, key) => {\\n\\n            //let title = pdfh(item, _大类标题);\\n            let title = item.title;\\n            if (typeof 排除 != \\\"undefined\\\" && 排除 != \\\"\\\") {\\n              title = title.replace(newRegExp(排除, \\\"g\\\"), \\\"\\\");\\n            }\\n            let json=''\\n            json = item.url;\\n            \\n            let params = {\\n              cate_temp: cate_temp,\\n              key: key,\\n              page: page,\\n              clears: 清除,\\n              json: json,\\n              state: 状态,\\n              allclears: 全清,\\n            };\\n\\n            //let url = pd(item, _大类链接);\\n            let url = item.url;\\n            /*if (大类处理) {\\n              url = 一级分类处理(url);\\n            }*/\\n            //log(url)\\n            d.push({\\n              title: this.setTitle(key.toString(), cate_temp[index], title),\\n              col_type: \\\"scroll_button\\\",\\n              url: $(\\\"hiker://empty#noLoading#\\\").lazyRule((params) => {\\n                let new_cate = [];\\n                params.clears.forEach((item) => {\\n                  clearMyVar(item);\\n                });\\n                params.allclears.forEach((item) => {\\n                  clearMyVar(item);\\n                });\\n\\n                params.cate_temp.forEach((cate, index) => {\\n                  new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\");\\n                });\\n                putMyVar(\\\"head.cate\\\", JSON.stringify(new_cate));\\n                if (params.json.constructor === Object) {\\n                  putMyVar(\\\"dt_\\\" + params.json.type, params.json.value);\\n                } else {\\n                  putMyVar(params.state, params.json);\\n                }\\n                refreshPage(true);\\n                return \\\"hiker://empty\\\";\\n              }, params),\\n            });\\n          });\\n          d.push({\\n            col_type: \\\"blank_block\\\",\\n          });\\n        } else if (fold === \\\"1\\\" || 折叠状态 == false) {\\n          sub_categories.forEach((item, key) => {\\n            var extrapos = false;\\n            /*if (item.includes('type=\\\"@extra\\\"')) {\\n              extrapos = true;\\n              //log('附加定位')\\n            }*/\\n\\n            if (extrapos) {\\n              var title = pdfh(item, \\\"a&&Text\\\");\\n              if (typeof 排除 != \\\"undefined\\\" && 排除 != \\\"\\\") {\\n                title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n              }\\n              var json = {\\n                type: pdfh(item, \\\"a&&state\\\"),\\n                value: pdfh(item, \\\"a&&value\\\"),\\n              };\\n            } else {\\n              //var title = pdfh(item, 分类标题);\\n              var title = item.title;\\n              if (typeof 排除 != \\\"undefined\\\" && 排除 != \\\"\\\") {\\n                title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n              }\\n\\n              var json = \\\"\\\";\\n              /*switch (true) {\\n                case 分类链接.includes(\\\"@@@\\\"):\\n                  json = {\\n                    type: pdfh(item, 分类链接.split(\\\"@@@\\\")[0]),\\n                    value: pdfh(item, 分类链接.split(\\\"@@@\\\")[1]),\\n                  };\\n                  break;\\n                case 分类链接.includes(\\\"@@\\\"):\\n                  json = {\\n                    type: 分类链接.split(\\\"@@\\\")[0],\\n                    value: pdfh(item, 分类链接.split(\\\"@@\\\")[1]),\\n                  };\\n                  break;\\n                default:\\n                  json = item.url;\\n                  // json = pd(item, 分类链接);\\n                  break;\\n              }*/\\n              json = item.url;\\n              /*var json=分类链接.includes('@@@')?{\\n                    type:pdfh(item,分类链接.split('@@@')[0]),\\n                    value:pdfh(item,分类链接.split('@@@')[1]),\\n                }:pd(item,分类链接);\\n                \\n                json=分类链接.includes('@@')?{\\n                    type:分类链接.split('@@')[0],\\n                    value:pdfh(item,分类链接.split('@@')[1]),\\n                }:pd(item,分类链接);*/\\n            }\\n\\n            let params = {\\n              cate_temp: cate_temp,\\n              index: index,\\n              key: key,\\n              page: page,\\n              json: json,\\n              state: 状态,\\n              allclears: 全清,\\n            };\\n            d.push({\\n              title: this.setTitle(key.toString(), cate_temp[index], title),\\n              url: $(\\\"hiker://empty\\\" + \\\"#noLoading#\\\").lazyRule((params) => {\\n                params.allclears.forEach((item) => {\\n                  clearMyVar(item);\\n                });\\n                params.cate_temp[params.index] = params.key.toString();\\n                putMyVar(\\\"head.cate\\\", JSON.stringify(params.cate_temp));\\n                if (params.json.constructor === Object) {\\n                  putMyVar(\\\"dt_\\\" + params.json.type, params.json.value);\\n                } else {\\n                  putMyVar(params.state, params.json);\\n                }\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n              }, params),\\n              col_type: \\\"scroll_button\\\",\\n            });\\n          });\\n          d.push({\\n            col_type: \\\"blank_block\\\",\\n          });\\n        }\\n      });\\n    }\\n    },\\n  };\\n  obj.预设(options);\\n  return obj;\\n}\\n\\n  //.状态(\\\"url\\\")\\n  //.界面(d)\\n  //.源码(xhtml)\\n  //.全清([\\\"1\\\", \\\"2\\\"])\\n  //.清除()\\n  //.开启折叠()\\n  //.页码(page)\\n  //.创建动态分类(定位列表);\\n\\nfunction getObjfuc(obj) {\\n  const methods = Object.getOwnPropertyNames(obj).filter(\\n    (name) => typeof obj[name] === \\\"function\\\"\\n  );\\n  if (methods.length == 0) {\\n    console.log(obj.toString());\\n    return;\\n  }\\n  const formattedString = methods\\n    .map((name) => {\\n      const fn = obj[name];\\n      const fnString = `${name}: ${fn.toString()}`;\\n      const restoredFnString = fnString.replace(\\n        /\\\\\\\\u([\\\\d\\\\w]{4})/gi,\\n        function (match, grp) {\\n          return String.fromCharCode(parseInt(grp, 16));\\n        }\\n      );\\n      return restoredFnString;\\n    })\\n    .join(\\\"\\\\n\\\");\\n  console.log(formattedString);\\n}\\n\\n/*\\nver 2023-06-16  1.0\\n*/\\nvar 状态 =\\n  typeof 状态标记 != \\\"undefined\\\" && 状态标记 != \\\"\\\" ? 状态标记 : MY_RULE.url;\\n\\nlet dt_debug=false;  \\n  \\naddListener(\\n  \\\"onClose\\\",\\n  $.toString(() => {})\\n);\\n\\nvar Create = {\\n  spage: {\\n    get: function () {\\n      return storage0.getMyVar(\\\"spage\\\", \\\"\\\");\\n    },\\n    set: function (url) {\\n      storage0.putMyVar(\\\"spage\\\", url);\\n    },\\n  },\\n  nextPage: function () {\\n    var result = false;\\n    try {\\n      var next = eval(下一页);\\n      //log('n:'+next)\\n      if(next ==\\\"\\\"){\\n        throw new Error('下一页链接为空')\\n      }\\n      result=true;\\n      if(true_url==next){\\n         result=false;\\n      }\\n    } catch (e) {\\n      //log(\\\"可能不存在下一页或者下一页定位有问题\\\");\\n      log(\\\"错误信息:\\\" + e.message);\\n    }\\n    if ((next == \\\"\\\" || next == undefined) && page == 1) {\\n      next = true_url;\\n    } else {\\n      //result=false;\\n      next = getMyVar(状态);\\n    }\\n    //log('l'+true_url)\\n    //log('n'+next)\\n    if(page!=1){\\n    if (true_url == next&&!result) {\\n      result = false;\\n    } else {\\n      result = true;\\n     }\\n    }\\n    return result;\\n    //putMyVar(状态, next);\\n  },\\n  getBackImage: function (imgurl) {\\n    var result = imgurl;\\n    try {\\n      result = /url(?:\\\\s+)?\\\\((.*?)\\\\)/g\\n        .exec(imgurl)[1]\\n        .replace(/('|\\\"|&quot;)/gm, \\\"\\\");\\n    } catch {}\\n    return result;\\n  },\\n  httpHandle: function (input) {\\n    if (input.startsWith(\\\"http\\\")) {\\n      return input;\\n    } else if (input.startsWith(\\\"//\\\")) {\\n      return \\\"https:\\\" + input;\\n    } else if (input.startsWith(\\\"/\\\")) {\\n      return MY_HOME + input;\\n    }\\n  },\\n  imgHandle: function (item, rule) {\\n    var img = \\\"\\\";\\n    if (rule.img.startsWith(\\\"pd\\\")) {\\n      img = eval(rule.img);\\n    } else if (rule.backimg) {\\n      img = pdfh(item, rule.img);\\n      img = this.getBackImage(img);\\n      img = this.httpHandle(img);\\n    } else {\\n      img = pdfh(item, rule.img);\\n      if (!img.startsWith(\\\"http\\\")) {\\n        img = pd(item, rule.img);\\n        img = this.httpHandle(img);\\n      }\\n    }\\n    return img + rule.ref;\\n  },\\n  urlHandle: function (item, rule) {\\n    var href = \\\"\\\";\\n    if (rule.url.startsWith(\\\"pd\\\")) {\\n      href = eval(rule.url);\\n    } else {\\n      href = pd(item, rule.url);\\n    }\\n    href = rule.imt ? href + \\\"#immersiveTheme#\\\" : href;\\n    return href;\\n  },\\n  setContent: function (item, input) {\\n    let output = \\\"\\\";\\n    if (input == undefined) {\\n      return output;\\n    }\\n    if (input.startsWith(\\\"pd\\\")) {\\n      output = eval(input);\\n    } else {\\n      output = pdfh(item, input);\\n    }\\n    return output;\\n  },\\n  refresh: function () {\\n    addListener(\\n      \\\"onRefresh\\\",\\n      $.toString((u) => {\\n        clearMyVar(\\\"yilist\\\");\\n        //var p = storage0.getMyVar('spage', '');\\n        //putMyVar(u, p);\\n      }, 状态)\\n    );\\n  },\\n  jsonList: function (arr, json, rule) {\\n    if (json.constructor != Object) {\\n      try {\\n        json = JSON.parse(json);\\n      } catch {}\\n    }\\n    json[rule.list].forEach((item) => {\\n      var img = eval(rule.img) + rule.ref;\\n      var href = eval(rule.url);\\n      href = rule.imt ? href + \\\"#immersiveTheme#\\\" : href;\\n      var lazy = rule.lazy ? rule.lazy : \\\"\\\";\\n      var dd = {\\n        title: eval(rule.title),\\n        desc: eval(rule.desc),\\n        content: eval(rule.content),\\n        pic_url: img,\\n        url: \\\"hiker://empty##\\\" + href,\\n        col_type: rule.col_type,\\n        extra: {\\n          img: img,\\n        },\\n      };\\n      if (lazy != \\\"\\\") {\\n        dd[\\\"url\\\"] = href + lazy;\\n      }\\n      arr.push(dd);\\n    });\\n  },\\n  ruleList: function (arr, html, rule) {\\n    var list = pdfa(html, rule.list);\\n    list.forEach((item, i) => {\\n      var title = this.setContent(item, rule.title);\\n      var desc = this.setContent(item, rule.desc);\\n      var img = this.imgHandle(item, rule);\\n      var url = this.urlHandle(item, rule);\\n      var content = this.setContent(item, rule.content);\\n      var lazy = rule.lazy ? rule.lazy : \\\"\\\";\\n      var dd = {\\n        title: title,\\n        desc: desc,\\n        pic_url: img,\\n        url: url,\\n        content: content,\\n        col_type: rule.col_type,\\n        extra: {\\n          img: img,\\n        },\\n      };\\n      if (lazy != \\\"\\\") {\\n        dd[\\\"url\\\"] = url + lazy;\\n      }\\n      arr.push(dd);\\n    });\\n  },\\n  List: function (arr, html, rule, param) {\\n    param = param ? param : {};\\n    var auto = param.auto ? param.auto : false;\\n    var show = param.show ? param.show : false;\\n    if (page == 1) {\\n      //this.spage.set(true_url);\\n    }\\n    this.refresh();\\n    var list = pdfa(html, rule.list);\\n    //log(this.nextPage())\\n    if ((storage0.getMyVar('yi_isnext','t')=='t'&&list.length > 0) || page == 1) {\\n      list.forEach((item, i) => {\\n        deleteItem(\\\"pagenum\\\");\\n        deleteItem(\\\"pageline\\\");\\n        var id = \\\"\\\";\\n        var cls = \\\"\\\";\\n        var title = this.setContent(item, rule.title);\\n        var desc = this.setContent(item, rule.desc);\\n        var img = this.imgHandle(item, rule);\\n        var url = this.urlHandle(item, rule);\\n        var content = this.setContent(item, rule.content);\\n        if (i == list.length - 1) {\\n          id = \\\"lastid_\\\" + page;\\n          cls = \\\"lastmark\\\";\\n        }\\n        d.push({\\n          title: title,\\n          desc: desc,\\n          pic_url: img,\\n          url: \\\"hiker://page/er?url=\\\" + url,\\n          content: content,\\n          col_type: rule.col_type,\\n          extra: {\\n            title: title,\\n            img: img,\\n            id: id,\\n            cls: cls,\\n          },\\n        });\\n        if (i == list.length - 1 && show) {\\n          d.push({\\n            col_type: \\\"line\\\",\\n            extra: {\\n              id: \\\"pageline\\\",\\n            },\\n          });\\n\\n          d.push({\\n            title: \\\"““””<small>加载中...</small>\\\",\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n              id: \\\"pagenum\\\",\\n            },\\n          });\\n        }\\n      });\\n    } else {\\n      updateItem(\\\"pagenum\\\", {\\n        title: '““””<font color=\\\"grey\\\"><small>到底了</small></font>',\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n          id: \\\"last\\\",\\n        },\\n      });\\n    }\\n    if (list.length == 0 && page == 1) {\\n      d.push({\\n        col_type: \\\"line\\\",\\n      });\\n      d.push({\\n        title: '““””<font color=\\\"grey\\\"><small>无内容</small></font>',\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {},\\n      });\\n    }\\n    if(this.nextPage()){\\n      //log('t');\\n        storage0.putMyVar('yi_isnext','t');\\n    }else{\\n      //log('f');\\n        storage0.putMyVar('yi_isnext','f');\\n    }\\n    if (auto) {\\n      //createNextPage();\\n      autoPage();\\n    }\\n  },\\n};\\n\\nvar extMethod = {\\n  ToParams: function () {\\n    var json = arguments[0];\\n    return Object.keys(json)\\n      .map((key) => key + \\\"=\\\" + json[key])\\n      .join(\\\"&\\\");\\n  },\\n  urlParse: function (u) {\\n    var dict = {};\\n    dict.Source = u;\\n    let params = (url) => {\\n      let queryParams = {};\\n      let reg = /([^?=&]+)=([^?=&]+)/g;\\n      url.replace(reg, function () {\\n        queryParams[arguments[1]] = arguments[2];\\n      });\\n      return queryParams;\\n    };\\n    var javaUrl = JavaImporter(java.net.URL);\\n    with (javaUrl) {\\n      var url = new URL(u);\\n      dict.Protocol = url.getProtocol();\\n      dict.Host = url.getHost();\\n      dict.Port = url.getPort();\\n      dict.File = url.getFile();\\n      dict.Path = url.getPath();\\n      dict.Ref = url.getRef();\\n      dict.Hosts = `${dict.Protocol}://${url.getHost()}`;\\n    }\\n    dict.Params = params(u);\\n    return dict;\\n  },\\n  isEqual: function (x, y) {\\n    const ok = Object.keys,\\n      tx = typeof x,\\n      ty = typeof y;\\n    return x && y && tx === \\\"object\\\" && tx === ty\\n      ? ok(x).length === ok(y).length &&\\n          ok(x).every((key) => this.isEqual(x[key], y[key]))\\n      : x === y;\\n  },\\n  findDifferentIndex: function (str1, str2) {\\n    const diffChars = [];\\n    for (let i = 0; i < str2.length; i++) {\\n      if (str1[i] !== str2[i]) {\\n        diffChars.push({\\n          index: i,\\n          s1: str1[i],\\n          s2: str2[i],\\n        });\\n      }\\n    }\\n    return diffChars;\\n  },\\n  replaceCharAt: function (str, index, replacement) {\\n    if (index < 0 || index >= str.length) {\\n      return str;\\n    }\\n    //log(index)\\n    const arr = str.split(\\\"\\\");\\n    arr[index] = replacement;\\n    return arr.join(\\\"\\\");\\n  },\\n  getObjectKeysDiff:function(obj1, obj2) {\\n  const differentKeys = [];\\n  for (let key in obj1) {\\n    if (!obj2.hasOwnProperty(key) || obj1[key] !== obj2[key]) {\\n      differentKeys.push(key);\\n    }\\n  }\\n  for (let key in obj2) {\\n    if (!obj1.hasOwnProperty(key)) {\\n      differentKeys.push(key);\\n    }\\n  }\\n  return differentKeys;\\n  },\\n  getNextUrl: function (source, target, params) {\\n    var u1 = this.urlParse(source);\\n    var u2 = this.urlParse(target);\\n    var pa = undefined;\\n    if (typeof params == \\\"object\\\") {\\n      pa = params.hasOwnProperty(\\\"特征\\\") ? params.特征 : undefined;\\n    }\\n    var nexturl = source;\\n    var ca = Object.keys(u2.Params).length == 0 ? \\\"\\\" : \\\"?\\\";\\n    if (pa != undefined) {\\n      var rs = String(u2.Path).replace(new RegExp(pa), \\\"$1fypage\\\");\\n      nexturl = u2.Hosts + rs + ca + this.ToParams(u2.Params);\\n    } else {\\n      if (this.isEqual(u1.Params, u2.Params)) {\\n        if(dt_debug){\\n        log(u1.Path);\\n        log(u2.Path);\\n        }\\n        var df = this.findDifferentIndex(String(u1.Path), String(u2.Path));\\n        if(dt_debug){\\n        log(df);\\n        }\\n        if (df.length == 1) {\\n          var re = df[0].index;\\n        } else {\\n          var f = df.filter((x) => /\\\\d+/.test(x.s2));\\n          var re = f[0].index;\\n        }\\n        var eq = this.replaceCharAt(String(u2.Path), re, \\\"fypage\\\");\\n        nexturl = u2.Hosts + eq + ca + this.ToParams(u2.Params);\\n      } else {\\n        var ep=this.getObjectKeysDiff(u1.Params,u2.Params)\\n        if(ep.length==1){\\n          u1.Params[ep[0]]='fypage'\\n        }else{\\n          log(ep);\\n        }\\n        var eq = String(u1.Path).replace(/\\\\d+/, \\\"fypage\\\");\\n        nexturl = u1.Hosts + eq + ca + this.ToParams(u1.Params);\\n      }\\n    }\\n    //log('next:'+nexturl)\\n    return nexturl;\\n  },\\n};\\n\\nfunction getTruelink(mark, url, page) {\\n  var p = getMyVar(mark, url).replace(\\\"fypage\\\", page);\\n  if (page == 1) {\\n    return getMyVar(\\\"yi_firstpage\\\", p);\\n  } else if (p != \\\"\\\") {\\n    return p;\\n  } else {\\n    return url;\\n  }\\n}\\n//构建\\nfunction createNextPage() {\\n  let startnum = 1;\\n  var obj = arguments[0];\\n  if (true_url != getMyVar(\\\"yi_pageurl\\\", \\\"\\\")) {\\n    clearMyVar(\\\"yi_pageurl\\\");\\n  }\\n  if (page == startnum && getMyVar(\\\"yi_pageurl\\\") == \\\"\\\") {\\n    putMyVar(\\\"yi_firstpage\\\", true_url);\\n    try {\\n      var next = eval(下一页);\\n      //log(\\\"next\\\");\\n      //log(next);\\n    } catch {\\n      log(\\\"可能不存在下一页或者下一页定位有问题\\\");\\n      next = \\\"\\\";\\n    }\\n    if (next != \\\"\\\") {\\n      var nxurl = extMethod.getNextUrl(true_url, next, obj);\\n      //log(\\\"nxurl:\\\" + nxurl);\\n      putMyVar(状态, nxurl);\\n      putMyVar(\\\"yi_pageurl\\\", nxurl);\\n    }\\n  }\\n}\\n\\nfunction autoPage() {\\n  if(page==1){\\n    putMyVar(\\\"yi_firstpage\\\", true_url);\\n    }\\n    try {\\n      var next = eval(下一页);\\n      //log(\\\"next\\\");\\n      //log('next:'+next);\\n    } catch {\\n      log(\\\"可能不存在下一页或者下一页定位有问题\\\");\\n      next = \\\"\\\";\\n    }\\n    if (next != \\\"\\\") {\\n      putMyVar(状态, next);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"解析\",\"path\":\"lazy\",\"rule\":\"var lazy = $('').lazyRule((MY_HOME) => {\\n    var inp = fetch(input,{});\\n    var html = pdfh(inp, 'source&&src');\\n    var pic = pdfh(inp, '.message&&img,-1&&data-lazy-src')\\n    if(html){\\n     url = html.match(/http?[^\\\\s]+/)[0]\\n     return url\\n         } if(pic) {\\n        return \\\"pics://\\\"+pdfa(inp, '.message&&img').map(img =>pd(img, 'img&&data-lazy-src')+\\\"@Referer=\\\",).join(\\\"&&\\\")\\n     }else{\\n     return 'toast://洗洗睡吧'\\n        }\\n},MY_HOME)\"},{\"col_type\":\"movie_3\",\"name\":\"二级页面内容\",\"path\":\"er\",\"rule\":\"js:\\nvar d = []\\neval(JSON.parse(request('hiker://page/repair')).rule);\\nMY_URL=MY_URL.replace('hiker://empty##','');\\nvar temp = guard(MY_URL);\\n    if(temp.includes(\\\"检测中\\\")){\\n         MY_URL = MY_HOME + temp.match(/href =\\\"(.*?)\\\"/)[1]\\n          }\\nvar html = guard(MY_URL);\\nlog(MY_URL)\\neval(JSON.parse(fetch('hiker://page/lazy', {})).rule);\\n\\nvar title = pdfh(html,'h4&&Text');\\nvar desc = pdfh(html,'.media-body&&.date&&Text')+\\\"\\\\t\\\\t\\\\t点击尝试播放\\\";\\n   if(title !==null){\\n    d.push({\\n        title: '““””<middle><font color=#FFA500>'+title+'</font></middle>',\\n        desc: desc,\\n        url: MY_URL,\\n        col_type: 'text_1',\\n        extra: {lineVisible: false}\\n    })\\n}\\n\\nvar 识别码;\\ntry{\\n  识别码 = parseDomForHtml(html, 'body&&.fan-info&&a,-1&&Text').replace('识别码: ','');\\n           }catch(err){}\\n\\nvar img = pd(html,'.message&&img&&src||data-lazy-src');\\n    if(img !==null){\\n        d.push({\\n             img: img,\\n             url: MY_URL + lazy,\\n             col_type: 'pic_1_full',\\n                  });\\n         }\\n\\ntry{\\nvar k = pdfh(html,'.pg&&a,-2&&Text').replace(/\\\\./g,'');\\nlog(typeof(k))\\nfor (var j = 1; j <= k ; j++){\\n    d.push({\\n        title: '第' + j +'页',\\n        url: MY_URL + '?tpage=' + j + lazy,\\n        col_type: 'text_5',\\n})\\n}}catch(err){\\n    //console.log('只有一页,凑合看吧', err);\\n}\\n\\n\\n\\n var fh = pdfh(html,'.fan-info&&Text');\\n    if(fh){\\nd.push({\\n    title: '““””<middle><font color=cyan>'+fh+'</font></middle>',\\n    url: 'hiker://search?rule=' + MY_RULE.title + '&s='+pdfh(html, '.fan-info&&a&&Text'),\\n    col_type: 'text_1',\\n       extra: {lineVisible: false}\\n});\\n}\\n\\nif(识别码){\\neval(JSON.parse(fetch('hiker://page/tool', {})).rule);\\n}\\n//预览图\\ntry{\\n    var list = pdfa(html,\\\".yulantu&&img,0:9\\\")\\nif(list.length>0){\\n   d.push({\\n        title: '““””<middle><font color=#ff6877>样品图像</font></middle>',\\n        url: MY_URL + $('').lazyRule(() => {\\n                    var html = request(input)\\n                    var pics = pdfa(html,\\\".yulantu&&img\\\").map(item=>pd(item,\\\"img&&src\\\"))\\n                    return \\\"pics://\\\"+pics.join(\\\"&&\\\")\\n                }),\\n        col_type: 'text_1',\\n        extra: {lineVisible: false}\\n    })\\n}\\nlist.forEach(item=>{\\n     d.push({\\n         img: pd(item,\\\"img&&src\\\"),\\n         url: pd(item,\\\"img&&src\\\"),\\n         col_type: \\\"pic_3_square\\\"\\n        })\\n       })\\n     }catch{}\\n\\n//磁力\\nvar cili = pdfa(html, '.cililian&&blockquote');\\nvar cl = pdfa(html, '.cililian&&script:not([data-cfasync])');\\nif(cl.length>0){\\nfor (var i = 0; i < Math.min(cili.length, cl.length); i++) {\\n var title = '““””<middle><font color=yellow>'+pdfh(cili[i],'blockquote--a&&Text')+'</font></middle>'+'““””<middle><font color=#0099FF>'+pdfh(cili[i],'a&&Text').replace(\\\"[email protected]\\\",\\\"\\\")+'</font></middle>';\\n var cl0 = pdfh(cl[i],'script&&Html').split(\\\"reurl('\\\")[1].split(\\\"')\\\")[0];\\nd.push({\\n    title: title,\\n    url: 'magnet:?xt=urn:btih:'+reurl(cl0),\\n    col_type: 'text_center_1',\\n       extra: {lineVisible: false}\\n});\\n}}else{\\nfor (var j in cili) {\\n var title = pdfh(cili[j],'blockquote&&Text');\\nd.push({\\n    title: '““””<middle><font color=yellow>'+title+'</font></middle>',\\n    url: pdfh(cili[j],'a&&Text'),\\n    col_type: 'text_center_1',\\n       extra: {lineVisible: false}\\n});\\n}\\n}\\n\\n\\n\\n/*\\nvar xiaoshuo = JSON.parse(pdfh(html,'.message&&script&&Html').match(/\\\\[.*?\\\\]/g)[1]);\\nxiaoshuo.forEach(x =>{\\n    d.push({\\n       title: x.name,\\n       desc: x.artist,\\n       img: MY_HOME + x.cover,\\n       url: MY_HOME + x.url,\\n       col_type: 'avatar'\\n       })\\n   })*/\\n\\ntry{\\nvar urls = html.match(/\\\\/mp3\\\\/.*?\\\\.mp3/g);\\nurls = urls.map(function(url) {\\n  return MY_HOME + url;\\n});\\nvar names = html.match(/第.*?集/g);   \\n       for (var i = 0; i < Math.min(urls.length, names.length); i++) {\\n  d.push({\\n    url: urls[i],\\n    title: names[i],\\n    desc: '有声小说',\\n    img: MY_HOME + '/img/play1.png',\\n    col_type: 'avatar'\\n  });\\n}}catch (err) {\\n  //console.log('此页面没有有声小说', err);\\n};\\n\\n\\nvar content = parseDomForHtml(html, \\\".message&&.htxt&&Html\\\");\\nif(content){\\nd.push({\\n    title: content,\\n    desc: '',\\n    pic_url: '',\\n    url: '',\\n    col_type: 'rich_text'\\n});\\n}\\n   d.push({\\n        title: '““””<middle><font color=#A020F0>相关资源推荐</font></middle>',\\n        url: \\\"copy://\\\" + 识别码,\\n        col_type: 'text_1',\\n         extra: {lineVisible: false}\\n    });\\n\\nlet tj = pdfa(html, 'body&&.plugin_list');\\ntj.forEach(x => {   \\n d.push({\\n    title: pdfh(x, 'a&&title'),\\n    desc: pdfh(x,'.date&&Text'),\\n    img: pd(x,'img&&src'),\\n    url: \\\"hiker://page/er?url=\\\"+pd(x, 'a&&href'),\\n    col_type: 'movie_2',\\n      extra:{\\n         pageTitle: pdfh(x, 'a&&title'),\\n         }\\n\\n  });\\n})\\n\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"二级外部搜索\",\"path\":\"tool\",\"rule\":\"//var title = parseDomForHtml(html, 搜索标签);\\n//var title = MY_PARAMS.title;\\n//log(title)\\n\\n//ThissAV\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#FF0000\\\"> ThisAV</font></middle>',\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/logos-and-brands/512/232_Nintendo_Switch_logo-128.png',\\n    url: $('').lazyRule((识别码) => {\\n                 var av = \\\"https://thisav.com/cn/\\\" + 识别码; \\n//log(av)\\n              try{\\n                 var html = fetch(av, {\\n                    headers: {\\n                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0)'\\n                           },timeout:5000\\n                           });\\n                 eval(html.match(/eval.*?\\\\n/)[0])\\n                    // 获取画质列表，并去最高画质\\n                    let group_quality = fetch(source,{headers:{\\\"origin\\\":\\\"https://thisav.com\\\"}})\\n                    hghest_quality = group_quality.match(/^(.*)\\\\.m3u8$/gm)\\n                    return source.replace(\\\"playlist.m3u8\\\", hghest_quality[hghest_quality.length-1]) + ';{Origin@https://thisav.com}'         \\n                 }catch{return \\\"toast://挂梯或没有此影片\\\"}\\n                  },识别码),\\n    col_type: 'icon_5',\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\"https://thisav.com/cn/\\\" + 识别码;},识别码)}] }\\n});\\n\\n//MISSAV\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#00FF00\\\"> MISSAV</font></middle>',\\n    pic_url: 'https://cdn1.iconfinder.com/data/icons/fruits-n-vegetables-colored-gradient/128/cauliflower-128.png',\\n    url: $('').lazyRule((识别码) => {\\n       try{\\n             var av = \\\"https://missav.to/search/movie/\\\" + 识别码;  \\n             var urls = [];    \\n             var list = pdfa(fetch(av,{timeout:5000}),\\\".videos-list&&article\\\");\\n            for(var j in list){\\n              urls.push({\\n                       url: pdfh(list[j],\\\"a&&href\\\")\\n                        })\\n            }\\n            var plays = bf(urls).map(h=>h.match(/src=\\\"(.*?)\\\"/)[1].split(\\\"&\\\")[0].replace(\\\"?id=\\\",\\\"hls/\\\") + \\\".m3u8\\\")   \\n             return {urls:plays}\\n       }catch{\\n         try{\\n             var av = \\\"https://missav.to/search/movie/\\\" + 识别码.replace(/\\\\-|\\\\_/,\\\"%20\\\");  \\n             var urls = [];    \\n             var list = pdfa(fetch(av,{timeout:5000}),\\\".videos-list&&article\\\");\\n            for(var j in list){\\n              urls.push({\\n                       url: pdfh(list[j],\\\"a&&href\\\")\\n                        })\\n            }\\n            var plays = bf(urls).map(h=>h.match(/src=\\\"(.*?)\\\"/)[1].split(\\\"&\\\")[0].replace(\\\"?id=\\\",\\\"hls/\\\") + \\\".m3u8\\\")   \\n             return {urls:plays}\\n          }catch{return \\\"toast://没有此影片\\\"}\\n       }   \\n                  },识别码),\\n    col_type: 'icon_5',\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\"https://missav.to/search/movie/\\\" + 识别码},识别码)}] }\\n});\\n\\n//njav\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#1E90FF\\\"> nJav.tv</font></middle>',\\n    pic_url: 'https://cdn2.iconfinder.com/data/icons/social-icons-33/128/Facebook_Messenger-128.png',\\n    url: $('').lazyRule((识别码) => {\\n                 var av = \\\"https://njav.tv/zh/v/\\\" + 识别码; \\n//log(av)\\n                 var html = fetch(av,{timeout:5000})\\n                 if(!html || html.includes(\\\"请检查地址栏中的网址\\\")){         \\n                 return \\\"toast://挂梯或没有此影片\\\"\\n                   }else{\\n                 return \\\"video://\\\" + av;\\n                    }\\n               },识别码),\\n    col_type: 'icon_5',\\n    extra: {\\n                videoExcludeRules: ['240'],\\n                blockRules: ['*.doppiocdn.*'],\\n                blockRules: ['dmm.co.jp'],\\n                //videoRules: ['*m3u8*'],\\n                cacheM3u8: true,\\n               longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\"https://njav.tv/zh/v/\\\" + 识别码;},识别码)}]\\n                        }\\n});\\n\\n//av01\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#75127A\\\"> AV01</font></middle>',\\n    pic_url: 'https://cdn2.iconfinder.com/data/icons/owl-10/500/nim532_11_purple_owl_kid_birthday_face_eye-128.png',\\n    url: $('').lazyRule((识别码) => {\\n                 var av = \\\"https://www.av01.tv/\\\" + 识别码; \\n//log(av)\\n                 var html = fetch(av,{timeout:5000})\\n                 var code = pdfh(html,'#plyr_video&&poster')\\nlog(code)\\n                 if(!code){         \\n                 return \\\"toast://挂梯或没有此影片\\\"\\n                   }else{\\n                 return \\\"video://\\\" + av;\\n                    }\\n               },识别码),\\n    col_type: 'icon_5',\\n    extra: {\\n                videoExcludeRules: ['doppiocdn'],\\n                videoExcludeRules: ['240'],\\n                videoExcludeRules: ['480'],\\n                blockRules: ['.doppiocdn.'],\\n                blockRules: ['dmm.co.jp'],\\n                //videoRules: ['*m3u8*'],\\n                cacheM3u8: true,\\n               longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\"https://www.av01.tv/\\\" + 识别码;},识别码)}]\\n                        }\\n});\\n\\n//Jable\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#FF8C00\\\"> Jable</font></middle>',\\n    pic_url: 'https://cdn3.iconfinder.com/data/icons/cat-power-premium/120/cat_foodlove-128.png',\\n    url: $('').lazyRule((识别码) => {\\n                 var av = \\\"https://jable.tv/videos/\\\" + 识别码 + \\\"/\\\"; \\n//log(av)\\n                // request(\\\"https://jable.tv/\\\")\\n              try{\\n                 var html = fetch(av,{timeout:5000})\\n                 var url = html.match(/https?:\\\\/\\\\/\\\\S+?\\\\.m3u8/)[0]\\n                 return url\\n                 }catch{return \\\"toast://没有挂梯子或没有此影片\\\"}\\n                  },识别码),\\n    col_type: 'icon_5',\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\"https://jable.tv/videos/\\\" + 识别码 + \\\"/\\\";},识别码)}] }\\n});\\n\\n//ThissAV破解\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#FEFE00\\\">無碼破解</font></middle>',\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/social-media-flat-7/64/Social-media_Snapchat-128.png',\\n    url: $('').lazyRule((识别码) => {\\n                 var av = \\\"https://thisav.com/cn/\\\" + 识别码 + \\\"-uncensored-leak\\\"; \\n//log(av)\\n              try{\\n                 var html = fetch(av, {\\n                    headers: {\\n                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0)'\\n                           },timeout:5000\\n                           });\\n                 eval(html.match(/eval.*?\\\\n/)[0])\\n                    // 获取画质列表，并去最高画质\\n                    let group_quality = fetch(source,{headers:{\\\"origin\\\":\\\"https://thisav.com\\\"}})\\n                    hghest_quality = group_quality.match(/^(.*)\\\\.m3u8$/gm)\\n                    return source.replace(\\\"playlist.m3u8\\\", hghest_quality[hghest_quality.length-1]) + ';{Origin@https://thisav.com}'         \\n                 }catch{return \\\"toast://挂梯或没有此影片\\\"}\\n                  },识别码),\\n    col_type: 'icon_5',\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\"https://thisav.com/cn/\\\" + 识别码 + \\\"-uncensored-leak\\\";},识别码)}] }\\n});\\n\\n//njav破解\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#1E90FF\\\"> nJav破解</font></middle>',\\n    pic_url: 'https://cdn0.iconfinder.com/data/icons/CuteMonstersPNG/128/blue_monster.png',\\n    url: $('').lazyRule((识别码) => {\\n                 var av = \\\"https://njav.tv/zh/v/\\\" + 识别码 + \\\"-uncensored-leaked\\\"; \\n//log(av)\\n                 var html = fetch(av,{timeout:5000})\\n                 if(!html || html.includes(\\\"请检查地址栏中的网址\\\")){         \\n                 return \\\"toast://挂梯或没有此影片\\\"\\n                   }else{\\n                 return \\\"video://\\\" + av;\\n                    }\\n               },识别码),\\n    col_type: 'icon_5',\\n    extra: {\\n                videoExcludeRules: ['240'],\\n                blockRules: ['*.doppiocdn.*'],\\n                blockRules: ['dmm.co.jp'],\\n                //videoRules: ['*m3u8*'],\\n                cacheM3u8: true,\\n               longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\"https://njav.tv/zh/v/\\\" + 识别码 + \\\"-uncensored-leaked\\\";},识别码)}]\\n                        }\\n});\\n\\n//Supjav\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#A32986\\\">Supjav</font></middle>',\\n    pic_url: 'https://cdn3.iconfinder.com/data/icons/logos-brands-3/24/logo_brand_brands_logos_skrill-128.png',\\n    url: \\\"x5://https://supjav.com/zh/?s=\\\" + 识别码,\\n    col_type: 'icon_5',\\n    extra:{\\n                lineVisible:false,\\n                longClick: [{title: '召唤雨见', js: $.toString((识别码)=>{ \\n/*\\nopenAppIntent('com.yujian.ResideMenuDemo', 'cn.yujian.MainActivity', {intentData: 'https://supjav.com/zh/?s=' + 识别码})\\n*/\\n            return \\\"yjbrowser://search?q=https://supjav.com/zh/?s=\\\" + 识别码\\n                       },识别码)},{title: '查看网址', js: $.toString((识别码)=>{ \\n        return \\\"https://supjav.com/zh/?s=\\\" + 识别码\\n                       },识别码)}]\\n             }\\n                  });\\n\\n//聚搜\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#67E0FA\\\">聚搜 • R</font></middle>',\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/essentials-72/24/002_-_Search-128.png',\\n    url: \\\"hiker://search?s=\\\" + 识别码 + \\\"&rule=好看视频&simple=false\\\",\\n    col_type: 'icon_5',\\n    extra: {               \\n               longClick: [{title: 'Jav.Guru', js: $.toString((识别码)=>{ return \\\"https://jav.guru/?s=\\\" + 识别码;},识别码)},{title: 'JavBangers', js: $.toString((识别码)=>{ return \\\"https://www.javbangers.com/search/\\\" + 识别码 +'/';},识别码)},{title: '复制识别码', js: $.toString((识别码)=>{ return \\\"copy://\\\" + 识别码;},识别码)}]\\n                        }\\n});\\n\\n\\n//磁力君.简\\nd.push({\\n    title: '‘‘’’<b><middle><font color=\\\"#EF4823\\\">磁力君.简</font></middle>',\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/shopping-doodle/512/Shopping-31-128.png',\\n    url: \\\"hiker://page/sou?rule=磁力君.简&p=fypage&searchTerms=\\\" + 识别码,\\n    col_type: 'icon_5',\\n    extra: {               \\n               longClick: [{title: '谷歌搜索', js: $.toString((识别码)=>{ return \\\"https://www.google.com/search?q=\\\" + 识别码;},识别码)},{title: 'Yandex搜索', js: $.toString((识别码)=>{ return \\\"https://yandex.com/search/touch/?text=\\\" + 识别码;},识别码)},{title: '复制识别码', js: $.toString((识别码)=>{ return \\\"copy://\\\" + 识别码;},识别码)}]\\n                        }\\n});\\n\"},{\"col_type\":\"movie_3\",\"name\":\"0级首页页面\",\"path\":\"shou\",\"rule\":\"js:\\nvar d = [];\\nMY_URL = MY_URL.replace('hiker://empty##', '');\\neval(JSON.parse(request('hiker://page/repair')).rule);\\nvar temp = guard(MY_URL);\\n    if(temp.includes(\\\"检测中\\\")){\\n         MY_URL = MY_HOME + temp.match(/href =\\\"(.*?)\\\"/)[1]\\n          }\\nvar html = guard(MY_URL);\\nlog(MY_URL)\\n\\nvar lis = pdfa(html, '.resouci&&a:not(:matches(美图|更多))');\\nlis.forEach(x => {   \\n    d.push({\\n       title: pdfh(x, 'a&&Text'),\\n       url: pd(x, 'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'scroll_button',\\n  });\\n})\\n/*\\nd.push({\\n     col_type: 'blank_block',\\n})*/\\n\\nvar conts = pdfa(html, '.sou-tagyun&&.sou-tag');\\nfor (var i = 0; i < conts.length; i++) {\\n      var list = pdfa(conts[i], 'body&&a'); \\nd.push({\\n     col_type: 'blank_block',\\n});\\n        for (var j = 0; j < list.length; j++) {       \\n            d.push({\\n                title: pdfh(list[j], 'a&&Text'),\\n                url: pd(list[j], 'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n                col_type: 'scroll_button',            \\n            });\\n        }\\n    }\\n\\nvar lis = pdfa(html, 'body&&.pic-home&&li');\\nlis.forEach(x => {   \\n    d.push({\\n       title: pdfh(x, 'a&&Text'),\\n       img: pd(x, 'img&&src'),\\n       url: pd(x, 'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'movie_2',\\n  });\\n})\\n\\nd.push({\\n    title: '<span style=\\\"color:#ff6600\\\"><b>🔥识别码视频\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t热门分类</b></span>',\\n    url: \\\"hiker://empty\\\",\\n    col_type: 'rich_text'\\n});\\n\\nvar title = pdfa(html, '.aui-layout-tuijian&&.aui-layout-text');\\nvar img = pdfa(html, '.aui-layout-tuijian&&img');\\nvar url = pdfa(html, '.aui-layout-tuijian&&a');\\nfor (var i = 0; i < Math.min(title.length, img.length,url.length); i++) {\\n   d.push({\\n       title: pdfh(title[i],'Text'),\\n       img: pd(img[i],'img&&src'),\\n       url: pd(url[i],'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'icon_4_card',\\n})\\n}\\n\\nd.push({\\n    title: '<span style=\\\"color:#ff6600\\\"><b>🔥国产视频\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t热门分类</b></span>',\\n    url: \\\"hiker://empty\\\",\\n    col_type: 'rich_text'\\n});\\n\\nvar title = pdfa(html, '.aui-layout-tuijian,1&&.aui-layout-text');\\nvar img = pdfa(html, '.aui-layout-tuijian,1&&img');\\nvar url = pdfa(html, '.aui-layout-tuijian,1&&a');\\nfor (var i = 0; i < Math.min(title.length, img.length,url.length); i++) {\\n   d.push({\\n       title: pdfh(title[i],'Text'),\\n       img: pd(img[i],'img&&src'),\\n       url: pd(url[i],'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'icon_4_card',\\n})\\n}\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"一级搜索页面\",\"path\":\"ss\",\"rule\":\"js:\\nvar d = [];\\n/*\\naddListener(\\\"onClose\\\", () => {\\n    for (let it of listMyVarKeys()) {\\n        clearMyVar(it);\\n    }\\n});*/\\naddListener(\\\"onRefresh\\\", () => {\\n    clearMyVar(\\\"nextPage\\\");\\n});\\nvar whost = config.host;\\nMY_URL = MY_URL.replace('hiker://empty##', '');\\nlet true_url = getVar(MY_RULE.url, MY_URL);\\n\\nconst page = MY_PAGE;\\n//获取上次缓存的下页链接\\nlet nextPage = getMyVar(\\\"nextPage\\\", \\\"\\\");\\n//如果有下一页且不是第一页就使用下一页链接\\nif (nextPage && MY_PAGE > 1) {\\n    true_url = nextPage;\\n}\\nvar temp = fetch(true_url);\\n    if(temp.includes(\\\"检测中\\\")){\\n         true_url = whost + temp.match(/href =\\\"(.*?)\\\"/)[1]\\n        // request(whost)\\n          }\\nvar html = fetch(true_url);\\nlog(true_url)\\ntry {\\n    //缓存下一页\\n    let nextUrl = pd(html, \\\"a:contains(下一页)&&href\\\");\\n    putMyVar(\\\"nextPage\\\", nextUrl || \\\"\\\");\\n    //log(\\\"下一页：\\\" + nextUrl)\\n} catch (e) {\\n    clearMyVar(\\\"nextPage\\\");\\n    toast(\\\"好像没有下一页了！\\\");\\n}\\n\\ntry{\\nvar k = pdfh(html,'body&&.pagination&&a,-2&&Text').replace(/\\\\./g,'');\\nlet now = getItem('now', '首页');\\n\\nvar arr = ['随机','跳页','尾页'+k]; \\nfor (var i = 1; i < (k < 101 ? k : 101) ; i += (i == 1) ? 4 : 5){\\n  arr.push(i); \\n}\\nif(k>200){\\nfor (var i = 200; i < (k < 1001 ? k : 1001) ; i += 100){\\n  arr.push(i); \\n}}\\nvar names = []\\nnames = arr.map(function(item) {\\n  if (typeof item === 'number') {\\n    return item + \\\"页\\\";\\n  } else {\\n    return item;\\n  }\\n});\\n\\nfor (var j = 0; j < Math.min(arr.length, names.length); j++) {\\nif(arr[j]=='跳页'){\\n             d.push({\\r\\n            title:now ==names[j]? '““””' + names[j].fontcolor('red') : names[j],\\r\\n            col_type: \\\"scroll_button\\\",\\r\\n            url: $(23, '请输入要跳转到的页数').input((true_url,k,names,j) => {\\r\\n                if (isNaN(parseInt(input))) {\\r\\n                    return 'toast://输入有误,请输入一个1~' + k + '的数字'\\r\\n                }\\r\\n                let toPage = parseInt(input);\\r\\n                if (toPage < 1 || toPage > k) {\\r\\n                    return 'toast://输入有误,请输入一个1~' + k + '的数字'\\r\\n                }\\n          if(/forum\\\\-\\\\d+\\\\-\\\\d+/.test(true_url)){\\nvar url = true_url.replace(/\\\\d+\\\\.htm/, toPage + '.htm');\\n              }else{\\nvar url = true_url.replace(/\\\\.htm/, '-' + toPage + '.htm');\\n              }\\r\\n                setItem(\\\"now\\\", names[j]);\\n                putVar(MY_RULE.url, url);\\n                //putMyVar('yi_firstpage', url);\\n                refreshPage(true);\\r\\n                return 'toast://跳越到了第' + toPage + '页'\\r\\n            },true_url, k,names,j),\\r\\n        });\\n\\n}else{\\n\\nif(arr[j]=='随机'){\\n              arr[j] = Math.floor(Math.random() * k) +1   \\n}else if(arr[j]=='尾页'+k){\\n              arr[j] = k\\n}else if(arr[j]==1){\\n              names[j] = \\\"首页\\\"\\n}else if(arr[j]=='跳页'){\\n             arr[j] = 223\\n}\\n\\n          if(/forum\\\\-\\\\d+\\\\-\\\\d+/.test(true_url)){\\nvar url = true_url.replace(/\\\\d+\\\\.htm/, arr[j] + '.htm');\\n              }else{\\nvar url = true_url.replace(/\\\\.htm/, '-' + arr[j] + '.htm');\\n              }\\n\\n    d.push({\\n        title:now ==names[j]? '““””' + names[j].fontcolor('red') : names[j],\\n        url: url + $('#noLoading#').lazyRule((arr,names,j) => {\\n            setItem(\\\"now\\\",names[j]);\\n            putVar(MY_RULE.url, input);\\n            //putMyVar('yi_firstpage', input);\\n            refreshPage(true);\\n            return 'toast://穿越到了第' + arr[j] + \\\"页\\\";\\n                    },arr,names,j),\\n        col_type: 'scroll_button',\\n               })\\n}\\n}}catch(err){\\n    toast(\\\"好像没有下一页了！\\\");\\n};\\n\\n\\nvar list = pdfa(html, 'body&&.plugin_list');\\nlist.forEach(x => {   \\n    d.push({\\n       title: pdfh(x, 'a&&Text').replace(\\\"【磁力】\\\",\\\"\\\"),\\n       desc: pdfh(x,'.date&&Text'),\\n       img: pd(x,'img||a&&src||data-original'),\\n       url: \\\"hiker://page/er?url=\\\"+pd(x, 'a&&href'),\\n       col_type: 'movie_2',\\n       extra:{\\n          pageTitle:pdfh(x, 'a&&Text'),\\n                  }\\n  });\\n})\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"环境\",\"path\":\"repair\",\"rule\":\"js:\\nvar document = {};\\nvar window = {\\n    location: {\\n        reload: function() {\\n            return;\\n        }\\n    }\\n};\\n\\n// 定义一个对象用于存储 cookie 名称和值的键值对\\nvar cookies = {};\\nObject.defineProperty(document, 'cookie', {\\n    enumerable: true,\\n    configurable: true,\\n    get: function() {\\n        return Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join('; ');\\n    },\\n    set: function(value) {\\n        var list = [];\\n        if (value.includes(';')) {\\n            list = value.split(';');\\n        } else {\\n            list = [value];\\n        }\\n        list.forEach(x => {\\n            var index = x.indexOf(\\\"=\\\");\\n            var key = x.substring(0, index).trim();\\n            var value = x.substring(index + 1);\\n            cookies[key] = value;\\n        })\\n    }\\n});\\n\\nfunction guard(url, headobj) {\\n    var head = headobj ? headobj:{\\n        headers: {\\n            Cookie: getCookie(url),\\n        }\\n    }\\n    var html = fetch(url, head);\\n    if (html.includes('_guard/auto.js')) {\\n        document[\\\"cookie\\\"] = getCookie(url);\\n        eval(fetch(getHome(url) + '/_guard/auto.js'))\\n        html = fetch(url, {\\n            headers: {\\n                Cookie: document[\\\"cookie\\\"],\\n            }\\n        });\\n    }\\n    //log(document[\\\"cookie\\\"])\\n    return html\\n}\\n\\nfunction csplit(a, b, c) {\\n    b = parseInt(b, 10) || 76;\\n    c = c || '\\\\r\\\\n';\\n    if (b < 1) {\\n        return false\\n    }\\n    return a.match(new RegExp(\\\".{0,\\\" + b + \\\"}\\\",\\\"g\\\")).join(c)\\n}\\n\\nfunction reurl(a) {\\n    var b = '';\\n    var c = csplit(a, 8).split('\\\\r\\\\n');\\n    for (var i = 0; i < (c.length - 1); i++) {\\n        b = b + String.fromCharCode((parseInt(c[i], 2) - 10).toString(10))\\n    }\\n    return b\\n}\"}],\"saved\":false,\"title\":\"番·仓\",\"version\":0,\"url\":\"https://www.fdns1.xyz\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar d = [];\\nMY_URL = MY_URL.replace('hiker://empty##', '');\\neval(JSON.parse(request('hiker://page/repair')).rule);\\nvar temp = guard(MY_URL);\\n    if(temp.includes(\\\"检测中\\\")){\\n         MY_URL = MY_HOME + temp.match(/href =\\\"(.*?)\\\"/)[1]\\n          }\\nvar html = guard(MY_URL);\\nlog(MY_URL)\\n\\nvar lis = pdfa(html, '.resouci&&a:not(:matches(美图|更多))');\\nlis.forEach(x => {   \\n    d.push({\\n       title: pdfh(x, 'a&&Text'),\\n       url: pd(x, 'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'scroll_button',\\n  });\\n})\\n/*\\nd.push({\\n     col_type: 'blank_block',\\n})*/\\n\\nvar conts = pdfa(html, '.sou-tagyun&&.sou-tag');\\nfor (var i = 0; i < conts.length; i++) {\\n      var list = pdfa(conts[i], 'body&&a'); \\nd.push({\\n     col_type: 'blank_block',\\n});\\n        for (var j = 0; j < list.length; j++) {       \\n            d.push({\\n                title: pdfh(list[j], 'a&&Text'),\\n                url: pd(list[j], 'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n                col_type: 'scroll_button',            \\n            });\\n        }\\n    }\\n\\nvar lis = pdfa(html, 'body&&.pic-home&&li');\\nlis.forEach(x => {   \\n    d.push({\\n       title: pdfh(x, 'a&&Text'),\\n       img: pd(x, 'img&&src'),\\n       url: pd(x, 'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'movie_2',\\n  });\\n})\\n\\nd.push({\\n    title: '<span style=\\\"color:#ff6600\\\"><b>🔥识别码视频\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t热门分类</b></span>',\\n    url: \\\"hiker://empty\\\",\\n    col_type: 'rich_text'\\n});\\n\\nvar title = pdfa(html, '.aui-layout-tuijian&&.aui-layout-text');\\nvar img = pdfa(html, '.aui-layout-tuijian&&img');\\nvar url = pdfa(html, '.aui-layout-tuijian&&a');\\nfor (var i = 0; i < Math.min(title.length, img.length,url.length); i++) {\\n   d.push({\\n       title: pdfh(title[i],'Text'),\\n       img: pd(img[i],'img&&src'),\\n       url: pd(url[i],'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'icon_4_card',\\n})\\n}\\n\\nd.push({\\n    title: '<span style=\\\"color:#ff6600\\\"><b>🔥国产视频\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t热门分类</b></span>',\\n    url: \\\"hiker://empty\\\",\\n    col_type: 'rich_text'\\n});\\n\\nvar title = pdfa(html, '.aui-layout-tuijian,1&&.aui-layout-text');\\nvar img = pdfa(html, '.aui-layout-tuijian,1&&img');\\nvar url = pdfa(html, '.aui-layout-tuijian,1&&a');\\nfor (var i = 0; i < Math.min(title.length, img.length,url.length); i++) {\\n   d.push({\\n       title: pdfh(title[i],'Text'),\\n       img: pd(img[i],'img&&src'),\\n       url: pd(url[i],'a&&href')+'##fypage@rule=js:$.require(\\\"hiker://page/ss\\\")',\\n       col_type: 'icon_4_card',\\n})\\n}\\n\\nsetResult(d)\",\"group\":\"我的小程序\",\"ua\":\"pc\",\"preRule\":\"//发布地址    https://www.fcfabu.com/\\n\\nvar 更新间隔 = 23\\nlet time = new Date().getTime().toString()\\nlet 时间间隔 = time-getItem('time', new Date().getTime().toString())\\n//log(\\\"当前时间戳\\\"+time)\\n//log(\\\"间隔时间戳\\\"+时间间隔)\\nlet 间隔天数 = Math.floor(时间间隔 / (24 * 60 * 60 * 1000));\\nlet 间隔时数 = Math.floor(时间间隔 / (60 * 60 * 1000));\\nlet 间隔分数 = Math.floor(时间间隔 / ( 60 * 1000));\\nlet 间隔秒数 = Math.floor(时间间隔 / 1000);\\n    //log(\\\"间隔时间====\\\"+间隔秒数+\\\"秒\\\")\\nsetItem('time', time);\\n/*\\nvar url;\\ntry{\\n  url = JSON.parse(fetch(getItem('link', ''), {\\n        onlyHeaders: true\\n    })).url\\n}catch{}\\nlog(url)\\n(getItem('link', '')+'/') != url)\\n*/\\nif (间隔天数>=更新间隔 || !getItem('link', '').startsWith('http') || fetch(getItem('link')).includes(\\\"hao123\\\")) {\\n    let fabu = 'https://www.fcfabu.com';\\n    let temp = fetch(fabu);\\n    if(temp.includes(\\\"检测中\\\")){\\n         url = fabu + temp.match(/href =\\\"(.*?)\\\"/)[1]\\n         temp = fetch(url)\\n          }\\n    let link = parseDomForHtml(temp, '.enter-link&&a&&href');\\n    setItem('link', link);\\n    //toast('更新域名');\\n    log('更新域名：'+link);\\n     confirm({\\n        title:'番·仓', \\n        content:'已更新网址为\\\\n'+link, \\n        confirm:$.toString(()=>{}), \\n        cancel:$.toString(()=>{})\\n    })\\n}\\ninitConfig({\\n    host: getItem('link', 'https://www.fanad.xyz/')\\n});\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"一级分类列表\\\",\\\"path\\\":\\\"yi\\\",\\\"rule\\\":\\\"js:\\\\n/*\\\\n一级封装 \\\\n动态分类 列表创建 自动下一页\\\\nver 20230710 1.0\\\\n*/\\\\n\\\\n//eval(JSON.parse(fetch('hiker://page/lazy', {})).rule);\\\\n\\\\nfunction dynamicClass(options) {\\\\n  const obj = {\\\\n    //默认值\\\\n    layout: \\\\\\\"undefined\\\\\\\",\\\\n    html: \\\\\\\"empty\\\\\\\",\\\\n    page: 0,\\\\n    分类颜色: \\\\\\\"#FA7298\\\\\\\",\\\\n    折叠: \\\\\\\"““””<b>\\\\\\\" + \\\\\\\"∨\\\\\\\".fontcolor(\\\\\\\"#1aad19\\\\\\\") + \\\\\\\"</b>\\\\\\\",\\\\n    展开: \\\\\\\"““””<b>\\\\\\\" + \\\\\\\"∧\\\\\\\".fontcolor(\\\\\\\"#FF0000\\\\\\\") + \\\\\\\"</b>\\\\\\\",\\\\n    open: true,\\\\n    state: MY_RULE.url,\\\\n    search: false,\\\\n    clears: [],\\\\n    clearall: [\\\\\\\"yi_firstpage\\\\\\\"],\\\\n    debug: false,\\\\n\\\\n    预设(param) {\\\\n      if(param==undefined){\\\\n        param=[];\\\\n      }\\\\n      Object.keys(param).forEach((property) => {\\\\n        // 对每个属性名执行操作\\\\n        const value = param[property]; // 获取属性值\\\\n        // 在这里执行您的操作\\\\n        this[property] = value;\\\\n        if (this.debug) {\\\\n          console.log(property + \\\\\\\":\\\\\\\" + value);\\\\n        }\\\\n      });\\\\n    },\\\\n    evalJSRule(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    getTitle(src, category) {\\\\n      let title = \\\\\\\"\\\\\\\";\\\\n      let titleRule = category || \\\\\\\"a&&Text\\\\\\\";\\\\n      if (titleRule.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n        title = this.evalJSRule(src, titleRule);\\\\n      } else {\\\\n        title = parseDomForHtml(src, titleRule);\\\\n      }\\\\n      return title || \\\\\\\"\\\\\\\";\\\\n    },\\\\n    getUrl(src, category) {\\\\n      let url = \\\\\\\"\\\\\\\";\\\\n      let urlRule = category.链接 || \\\\\\\"a&&href\\\\\\\";\\\\n      if (urlRule.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n        url = this.evalJSRule(src, urlRule);\\\\n      } else {\\\\n        url = pd(src, urlRule);\\\\n      }\\\\n      if (typeof category.链接处理 == \\\\\\\"function\\\\\\\") {\\\\n        url = category.链接处理(url);\\\\n      }\\\\n      return url || \\\\\\\"\\\\\\\";\\\\n    },\\\\n    isNull(param) {\\\\n      if (param == null) {\\\\n        return this;\\\\n      }\\\\n      return false;\\\\n    },\\\\n    isBoolean(variable) {\\\\n      if (typeof variable !== \\\\\\\"boolean\\\\\\\") {\\\\n        throw new Error(\\\\\\\"开启折叠请传入布尔值\\\\\\\");\\\\n      }\\\\n    },\\\\n    清除(list) {\\\\n      if (this.isNull(list)) {\\\\n        return this;\\\\n      }\\\\n      if (list.constructor == String) {\\\\n        throw new Error(\\\\\\\"清除报错:请传列表\\\\\\\");\\\\n      }\\\\n      this.clears = list;\\\\n      return this;\\\\n    },\\\\n    全清(list) {\\\\n      if (this.isNull(list)) {\\\\n        return this;\\\\n      }\\\\n      var c = this.clearall;\\\\n      list = c.concat(list);\\\\n      this.clearall = list;\\\\n      return this;\\\\n    },\\\\n    源码(input) {\\\\n      this.html = input;\\\\n      return this;\\\\n    },\\\\n    界面(input) {\\\\n      this.layout = input;\\\\n      return this;\\\\n    },\\\\n    页码(input) {\\\\n      this.page = input;\\\\n      return this;\\\\n    },\\\\n    状态(input) {\\\\n      this.state = input;\\\\n      return this;\\\\n    },\\\\n    开启搜索() {\\\\n      this.search = true;\\\\n      return this;\\\\n    },\\\\n    开启折叠(input) {\\\\n      if (input == undefined) {\\\\n        input = true;\\\\n      }\\\\n      this.isBoolean(input);\\\\n      this.open = input;\\\\n      return this;\\\\n    },\\\\n    setTitle(k, i, t) {\\\\n      return k == i ? \\\\\\\"““””\\\\\\\" + t.fontcolor(this.分类颜色) : t;\\\\n    },\\\\n    action(obj) {\\\\n      return [\\\\n        {\\\\n          title: \\\\\\\"清除状态\\\\\\\",\\\\n          js: $.toString((obj) => {\\\\n            log(obj);\\\\n            clearMyVar(obj.state);\\\\n            clearMyVar(\\\\\\\"head.cate\\\\\\\");\\\\n            obj.all.forEach((item) => {\\\\n              clearMyVar(item);\\\\n            });\\\\n            obj.cl.forEach((item) => {\\\\n              clearMyVar(item);\\\\n            });\\\\n            refreshPage();\\\\n          }, obj),\\\\n        },\\\\n      ];\\\\n    },\\\\n    checkParam() {\\\\n      var obj = {};\\\\n      if (this.page == 0 && typeof page == \\\\\\\"undefined\\\\\\\") {\\\\n        throw new Error(\\\\\\\"请传入页码\\\\\\\");\\\\n      } else {\\\\n        if (typeof page == \\\\\\\"undefined\\\\\\\") {\\\\n          obj[\\\\\\\"页码\\\\\\\"] = this.page;\\\\n        } else {\\\\n          obj[\\\\\\\"页码\\\\\\\"] = page;\\\\n        }\\\\n      }\\\\n      if (this.html == \\\\\\\"empty\\\\\\\" && typeof html == \\\\\\\"undefined\\\\\\\") {\\\\n        throw new Error(\\\\\\\"请传入源码\\\\\\\");\\\\n      } else {\\\\n        if (typeof html == \\\\\\\"undefined\\\\\\\") {\\\\n          obj[\\\\\\\"源码\\\\\\\"] = this.html;\\\\n        } else {\\\\n          obj[\\\\\\\"源码\\\\\\\"] = html;\\\\n        }\\\\n      }\\\\n      if (this.layout == \\\\\\\"undefined\\\\\\\" && typeof d == \\\\\\\"undefined\\\\\\\") {\\\\n        throw new Error(\\\\\\\"请传入界面\\\\\\\");\\\\n      } else {\\\\n        if (typeof d == \\\\\\\"undefined\\\\\\\") {\\\\n          obj[\\\\\\\"界面\\\\\\\"] = this.layout;\\\\n        } else {\\\\n          obj[\\\\\\\"界面\\\\\\\"] = d;\\\\n        }\\\\n      }\\\\n      return obj;\\\\n    },\\\\n    创建动态分类(ruleObj) {\\\\n      if (ruleObj == undefined) {\\\\n        ruleObj = [];\\\\n      }\\\\n      //初始化变量开始\\\\n      const param = this.checkParam();\\\\n      const page = param.页码;\\\\n      const html = param.源码;\\\\n      const d = param.界面;\\\\n      const 状态 = this.state;\\\\n      const search = this.search;\\\\n      const empty = \\\\\\\"hiker://empty\\\\\\\";\\\\n      const 折叠状态 = this.open;\\\\n      var 展开 = this.展开;\\\\n      var 折叠 = this.折叠;\\\\n      var 全清 = this.clearall;\\\\n      var 清除 = this.clears;\\\\n      //初始化变量结束\\\\n      let init_cate = new Array(20).fill(\\\\\\\"0\\\\\\\");\\\\n      const fold = getMyVar(MY_RULE.group, \\\\\\\"0\\\\\\\");\\\\n      const cate_temp = JSON.parse(\\\\n        getMyVar(\\\\\\\"head.cate\\\\\\\", JSON.stringify(init_cate))\\\\n      );\\\\n      if (search && page == 1) {\\\\n        d.push({\\\\n          title: \\\\\\\"\\\\\\\",\\\\n          url: \\\\\\\"'hiker://search?rule=\\\\\\\" + MY_RULE.title + \\\\\\\"&s='+input\\\\\\\",\\\\n          desc: \\\\\\\"搜索关键词\\\\\\\",\\\\n          col_type: \\\\\\\"input\\\\\\\",\\\\n          extra: {\\\\n            defaultValue: getMyVar(\\\\\\\"keyword\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n            onChange: $.toString(() => {\\\\n              putMyVar(\\\\\\\"keyword\\\\\\\", input);\\\\n            }),\\\\n          },\\\\n        });\\\\n      }\\\\n      const categories = [];\\\\n      ruleObj.forEach((x) => {\\\\n        var list = [];\\\\n        if(x.一级定位){\\\\n          if (x.一级定位.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n          list = this.evalJSRule(html, x.一级定位);\\\\n         } else {\\\\n          list = pdfa(html, x.一级定位);\\\\n          }\\\\n        }\\\\n        if(x.大类定位){\\\\n          if (x.大类定位.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n          list = this.evalJSRule(html, x.大类定位);\\\\n         } else {\\\\n          list = [pdfa(html, x.大类定位).join('\\\\\\\\n')];\\\\n         }\\\\n        }\\\\n        var 一级 = list.map((s) => {\\\\n          var slist = [];\\\\n          if (!(\\\\\\\"小类\\\\\\\" in x)) {\\\\n            x.小类 = \\\\\\\"body&&a:not(:matches(首页)):not(a:not([href]))\\\\\\\";\\\\n          }\\\\n          if (x.小类.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n            slist = this.evalJSRule(s, x.小类);\\\\n          } else {\\\\n            slist = pdfa(s, x.小类);\\\\n          }\\\\n          var 定位 = slist.map((item) => {\\\\n            var title = this.getTitle(item, x.标题);\\\\n            var url = this.getUrl(item, x);\\\\n            var obj = { title: title, url: url };\\\\n            return JSON.stringify(obj);\\\\n          });\\\\n          return 定位;\\\\n        });\\\\n        //log(一级)\\\\n        //log(一级.length)\\\\n        if (一级.length == 1) {\\\\n          categories.push(一级.join(\\\\\\\"\\\\\\\\n\\\\\\\"));\\\\n        } else {\\\\n          一级.forEach((item) => {\\\\n            categories.push(item.join(\\\\\\\",\\\\\\\"));\\\\n          });\\\\n        }\\\\n        //log(categories)\\\\n      });\\\\n      if (折叠状态) {\\\\n        if (page == 1) {\\\\n          d.push({\\\\n            title: fold === \\\\\\\"1\\\\\\\" ? 折叠 : 展开,\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(\\\\n              (fold, u, all) => {\\\\n                putMyVar(MY_RULE.group, fold === \\\\\\\"1\\\\\\\" ? \\\\\\\"0\\\\\\\" : \\\\\\\"1\\\\\\\");\\\\n                /*all.forEach((item) => {\\\\n                  clearMyVar(item);\\\\n                });*/\\\\n                refreshPage(false);\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n              },\\\\n              fold,\\\\n              状态,\\\\n              全清\\\\n            ),\\\\n            col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n            extra: {\\\\n              longClick: this.action({\\\\n                state: 状态,\\\\n                all: 全清,\\\\n                cl: 清除,\\\\n              }),\\\\n            },\\\\n          });\\\\n        }\\\\n      }\\\\n      if (page == 1) {\\\\n      categories.forEach((category, index) => {\\\\n        //log(categories)\\\\n        let sub_categories = [];\\\\n        /*if (小类定位.includes(\\\\\\\";\\\\\\\")) {\\\\n          sub_categories = pdfa(category, 小类定位.split(\\\\\\\";\\\\\\\")[0]);\\\\n          if (sub_categories.length == 0) {\\\\n            sub_categories = pdfa(category, 小类定位.split(\\\\\\\";\\\\\\\")[1]);\\\\n          }\\\\n        } else {*/\\\\n        //log(index)\\\\n        sub_categories = JSON.parse(`[${category}]`);\\\\n        // sub_categories = pdfa(category, 小类定位);\\\\n        //}\\\\n        if (index === 0) {\\\\n          sub_categories.forEach((item, key) => {\\\\n\\\\n            //let title = pdfh(item, _大类标题);\\\\n            let title = item.title;\\\\n            if (typeof 排除 != \\\\\\\"undefined\\\\\\\" && 排除 != \\\\\\\"\\\\\\\") {\\\\n              title = title.replace(newRegExp(排除, \\\\\\\"g\\\\\\\"), \\\\\\\"\\\\\\\");\\\\n            }\\\\n            let json=''\\\\n            json = item.url;\\\\n            \\\\n            let params = {\\\\n              cate_temp: cate_temp,\\\\n              key: key,\\\\n              page: page,\\\\n              clears: 清除,\\\\n              json: json,\\\\n              state: 状态,\\\\n              allclears: 全清,\\\\n            };\\\\n\\\\n            //let url = pd(item, _大类链接);\\\\n            let url = item.url;\\\\n            /*if (大类处理) {\\\\n              url = 一级分类处理(url);\\\\n            }*/\\\\n            //log(url)\\\\n            d.push({\\\\n              title: this.setTitle(key.toString(), cate_temp[index], title),\\\\n              col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n              url: $(\\\\\\\"hiker://empty#noLoading#\\\\\\\").lazyRule((params) => {\\\\n                let new_cate = [];\\\\n                params.clears.forEach((item) => {\\\\n                  clearMyVar(item);\\\\n                });\\\\n                params.allclears.forEach((item) => {\\\\n                  clearMyVar(item);\\\\n                });\\\\n\\\\n                params.cate_temp.forEach((cate, index) => {\\\\n                  new_cate.push(index === 0 ? params.key.toString() : \\\\\\\"0\\\\\\\");\\\\n                });\\\\n                putMyVar(\\\\\\\"head.cate\\\\\\\", JSON.stringify(new_cate));\\\\n                if (params.json.constructor === Object) {\\\\n                  putMyVar(\\\\\\\"dt_\\\\\\\" + params.json.type, params.json.value);\\\\n                } else {\\\\n                  putMyVar(params.state, params.json);\\\\n                }\\\\n                refreshPage(true);\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n              }, params),\\\\n            });\\\\n          });\\\\n          d.push({\\\\n            col_type: \\\\\\\"blank_block\\\\\\\",\\\\n          });\\\\n        } else if (fold === \\\\\\\"1\\\\\\\" || 折叠状态 == false) {\\\\n          sub_categories.forEach((item, key) => {\\\\n            var extrapos = false;\\\\n            /*if (item.includes('type=\\\\\\\"@extra\\\\\\\"')) {\\\\n              extrapos = true;\\\\n              //log('附加定位')\\\\n            }*/\\\\n\\\\n            if (extrapos) {\\\\n              var title = pdfh(item, \\\\\\\"a&&Text\\\\\\\");\\\\n              if (typeof 排除 != \\\\\\\"undefined\\\\\\\" && 排除 != \\\\\\\"\\\\\\\") {\\\\n                title = title.replace(new RegExp(排除, \\\\\\\"g\\\\\\\"), \\\\\\\"\\\\\\\");\\\\n              }\\\\n              var json = {\\\\n                type: pdfh(item, \\\\\\\"a&&state\\\\\\\"),\\\\n                value: pdfh(item, \\\\\\\"a&&value\\\\\\\"),\\\\n              };\\\\n            } else {\\\\n              //var title = pdfh(item, 分类标题);\\\\n              var title = item.title;\\\\n              if (typeof 排除 != \\\\\\\"undefined\\\\\\\" && 排除 != \\\\\\\"\\\\\\\") {\\\\n                title = title.replace(new RegExp(排除, \\\\\\\"g\\\\\\\"), \\\\\\\"\\\\\\\");\\\\n              }\\\\n\\\\n              var json = \\\\\\\"\\\\\\\";\\\\n              /*switch (true) {\\\\n                case 分类链接.includes(\\\\\\\"@@@\\\\\\\"):\\\\n                  json = {\\\\n                    type: pdfh(item, 分类链接.split(\\\\\\\"@@@\\\\\\\")[0]),\\\\n                    value: pdfh(item, 分类链接.split(\\\\\\\"@@@\\\\\\\")[1]),\\\\n                  };\\\\n                  break;\\\\n                case 分类链接.includes(\\\\\\\"@@\\\\\\\"):\\\\n                  json = {\\\\n                    type: 分类链接.split(\\\\\\\"@@\\\\\\\")[0],\\\\n                    value: pdfh(item, 分类链接.split(\\\\\\\"@@\\\\\\\")[1]),\\\\n                  };\\\\n                  break;\\\\n                default:\\\\n                  json = item.url;\\\\n                  // json = pd(item, 分类链接);\\\\n                  break;\\\\n              }*/\\\\n              json = item.url;\\\\n              /*var json=分类链接.includes('@@@')?{\\\\n                    type:pdfh(item,分类链接.split('@@@')[0]),\\\\n                    value:pdfh(item,分类链接.split('@@@')[1]),\\\\n                }:pd(item,分类链接);\\\\n                \\\\n                json=分类链接.includes('@@')?{\\\\n                    type:分类链接.split('@@')[0],\\\\n                    value:pdfh(item,分类链接.split('@@')[1]),\\\\n                }:pd(item,分类链接);*/\\\\n            }\\\\n\\\\n            let params = {\\\\n              cate_temp: cate_temp,\\\\n              index: index,\\\\n              key: key,\\\\n              page: page,\\\\n              json: json,\\\\n              state: 状态,\\\\n              allclears: 全清,\\\\n            };\\\\n            d.push({\\\\n              title: this.setTitle(key.toString(), cate_temp[index], title),\\\\n              url: $(\\\\\\\"hiker://empty\\\\\\\" + \\\\\\\"#noLoading#\\\\\\\").lazyRule((params) => {\\\\n                params.allclears.forEach((item) => {\\\\n                  clearMyVar(item);\\\\n                });\\\\n                params.cate_temp[params.index] = params.key.toString();\\\\n                putMyVar(\\\\\\\"head.cate\\\\\\\", JSON.stringify(params.cate_temp));\\\\n                if (params.json.constructor === Object) {\\\\n                  putMyVar(\\\\\\\"dt_\\\\\\\" + params.json.type, params.json.value);\\\\n                } else {\\\\n                  putMyVar(params.state, params.json);\\\\n                }\\\\n                refreshPage();\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n              }, params),\\\\n              col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n            });\\\\n          });\\\\n          d.push({\\\\n            col_type: \\\\\\\"blank_block\\\\\\\",\\\\n          });\\\\n        }\\\\n      });\\\\n    }\\\\n    },\\\\n  };\\\\n  obj.预设(options);\\\\n  return obj;\\\\n}\\\\n\\\\n  //.状态(\\\\\\\"url\\\\\\\")\\\\n  //.界面(d)\\\\n  //.源码(xhtml)\\\\n  //.全清([\\\\\\\"1\\\\\\\", \\\\\\\"2\\\\\\\"])\\\\n  //.清除()\\\\n  //.开启折叠()\\\\n  //.页码(page)\\\\n  //.创建动态分类(定位列表);\\\\n\\\\nfunction getObjfuc(obj) {\\\\n  const methods = Object.getOwnPropertyNames(obj).filter(\\\\n    (name) => typeof obj[name] === \\\\\\\"function\\\\\\\"\\\\n  );\\\\n  if (methods.length == 0) {\\\\n    console.log(obj.toString());\\\\n    return;\\\\n  }\\\\n  const formattedString = methods\\\\n    .map((name) => {\\\\n      const fn = obj[name];\\\\n      const fnString = `${name}: ${fn.toString()}`;\\\\n      const restoredFnString = fnString.replace(\\\\n        /\\\\\\\\\\\\\\\\u([\\\\\\\\d\\\\\\\\w]{4})/gi,\\\\n        function (match, grp) {\\\\n          return String.fromCharCode(parseInt(grp, 16));\\\\n        }\\\\n      );\\\\n      return restoredFnString;\\\\n    })\\\\n    .join(\\\\\\\"\\\\\\\\n\\\\\\\");\\\\n  console.log(formattedString);\\\\n}\\\\n\\\\n/*\\\\nver 2023-06-16  1.0\\\\n*/\\\\nvar 状态 =\\\\n  typeof 状态标记 != \\\\\\\"undefined\\\\\\\" && 状态标记 != \\\\\\\"\\\\\\\" ? 状态标记 : MY_RULE.url;\\\\n\\\\nlet dt_debug=false;  \\\\n  \\\\naddListener(\\\\n  \\\\\\\"onClose\\\\\\\",\\\\n  $.toString(() => {})\\\\n);\\\\n\\\\nvar Create = {\\\\n  spage: {\\\\n    get: function () {\\\\n      return storage0.getMyVar(\\\\\\\"spage\\\\\\\", \\\\\\\"\\\\\\\");\\\\n    },\\\\n    set: function (url) {\\\\n      storage0.putMyVar(\\\\\\\"spage\\\\\\\", url);\\\\n    },\\\\n  },\\\\n  nextPage: function () {\\\\n    var result = false;\\\\n    try {\\\\n      var next = eval(下一页);\\\\n      //log('n:'+next)\\\\n      if(next ==\\\\\\\"\\\\\\\"){\\\\n        throw new Error('下一页链接为空')\\\\n      }\\\\n      result=true;\\\\n      if(true_url==next){\\\\n         result=false;\\\\n      }\\\\n    } catch (e) {\\\\n      //log(\\\\\\\"可能不存在下一页或者下一页定位有问题\\\\\\\");\\\\n      log(\\\\\\\"错误信息:\\\\\\\" + e.message);\\\\n    }\\\\n    if ((next == \\\\\\\"\\\\\\\" || next == undefined) && page == 1) {\\\\n      next = true_url;\\\\n    } else {\\\\n      //result=false;\\\\n      next = getMyVar(状态);\\\\n    }\\\\n    //log('l'+true_url)\\\\n    //log('n'+next)\\\\n    if(page!=1){\\\\n    if (true_url == next&&!result) {\\\\n      result = false;\\\\n    } else {\\\\n      result = true;\\\\n     }\\\\n    }\\\\n    return result;\\\\n    //putMyVar(状态, next);\\\\n  },\\\\n  getBackImage: function (imgurl) {\\\\n    var result = imgurl;\\\\n    try {\\\\n      result = /url(?:\\\\\\\\s+)?\\\\\\\\((.*?)\\\\\\\\)/g\\\\n        .exec(imgurl)[1]\\\\n        .replace(/('|\\\\\\\"|&quot;)/gm, \\\\\\\"\\\\\\\");\\\\n    } catch {}\\\\n    return result;\\\\n  },\\\\n  httpHandle: function (input) {\\\\n    if (input.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n      return input;\\\\n    } else if (input.startsWith(\\\\\\\"//\\\\\\\")) {\\\\n      return \\\\\\\"https:\\\\\\\" + input;\\\\n    } else if (input.startsWith(\\\\\\\"/\\\\\\\")) {\\\\n      return MY_HOME + input;\\\\n    }\\\\n  },\\\\n  imgHandle: function (item, rule) {\\\\n    var img = \\\\\\\"\\\\\\\";\\\\n    if (rule.img.startsWith(\\\\\\\"pd\\\\\\\")) {\\\\n      img = eval(rule.img);\\\\n    } else if (rule.backimg) {\\\\n      img = pdfh(item, rule.img);\\\\n      img = this.getBackImage(img);\\\\n      img = this.httpHandle(img);\\\\n    } else {\\\\n      img = pdfh(item, rule.img);\\\\n      if (!img.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n        img = pd(item, rule.img);\\\\n        img = this.httpHandle(img);\\\\n      }\\\\n    }\\\\n    return img + rule.ref;\\\\n  },\\\\n  urlHandle: function (item, rule) {\\\\n    var href = \\\\\\\"\\\\\\\";\\\\n    if (rule.url.startsWith(\\\\\\\"pd\\\\\\\")) {\\\\n      href = eval(rule.url);\\\\n    } else {\\\\n      href = pd(item, rule.url);\\\\n    }\\\\n    href = rule.imt ? href + \\\\\\\"#immersiveTheme#\\\\\\\" : href;\\\\n    return href;\\\\n  },\\\\n  setContent: function (item, input) {\\\\n    let output = \\\\\\\"\\\\\\\";\\\\n    if (input == undefined) {\\\\n      return output;\\\\n    }\\\\n    if (input.startsWith(\\\\\\\"pd\\\\\\\")) {\\\\n      output = eval(input);\\\\n    } else {\\\\n      output = pdfh(item, input);\\\\n    }\\\\n    return output;\\\\n  },\\\\n  refresh: function () {\\\\n    addListener(\\\\n      \\\\\\\"onRefresh\\\\\\\",\\\\n      $.toString((u) => {\\\\n        clearMyVar(\\\\\\\"yilist\\\\\\\");\\\\n        //var p = storage0.getMyVar('spage', '');\\\\n        //putMyVar(u, p);\\\\n      }, 状态)\\\\n    );\\\\n  },\\\\n  jsonList: function (arr, json, rule) {\\\\n    if (json.constructor != Object) {\\\\n      try {\\\\n        json = JSON.parse(json);\\\\n      } catch {}\\\\n    }\\\\n    json[rule.list].forEach((item) => {\\\\n      var img = eval(rule.img) + rule.ref;\\\\n      var href = eval(rule.url);\\\\n      href = rule.imt ? href + \\\\\\\"#immersiveTheme#\\\\\\\" : href;\\\\n      var lazy = rule.lazy ? rule.lazy : \\\\\\\"\\\\\\\";\\\\n      var dd = {\\\\n        title: eval(rule.title),\\\\n        desc: eval(rule.desc),\\\\n        content: eval(rule.content),\\\\n        pic_url: img,\\\\n        url: \\\\\\\"hiker://empty##\\\\\\\" + href,\\\\n        col_type: rule.col_type,\\\\n        extra: {\\\\n          img: img,\\\\n        },\\\\n      };\\\\n      if (lazy != \\\\\\\"\\\\\\\") {\\\\n        dd[\\\\\\\"url\\\\\\\"] = href + lazy;\\\\n      }\\\\n      arr.push(dd);\\\\n    });\\\\n  },\\\\n  ruleList: function (arr, html, rule) {\\\\n    var list = pdfa(html, rule.list);\\\\n    list.forEach((item, i) => {\\\\n      var title = this.setContent(item, rule.title);\\\\n      var desc = this.setContent(item, rule.desc);\\\\n      var img = this.imgHandle(item, rule);\\\\n      var url = this.urlHandle(item, rule);\\\\n      var content = this.setContent(item, rule.content);\\\\n      var lazy = rule.lazy ? rule.lazy : \\\\\\\"\\\\\\\";\\\\n      var dd = {\\\\n        title: title,\\\\n        desc: desc,\\\\n        pic_url: img,\\\\n        url: url,\\\\n        content: content,\\\\n        col_type: rule.col_type,\\\\n        extra: {\\\\n          img: img,\\\\n        },\\\\n      };\\\\n      if (lazy != \\\\\\\"\\\\\\\") {\\\\n        dd[\\\\\\\"url\\\\\\\"] = url + lazy;\\\\n      }\\\\n      arr.push(dd);\\\\n    });\\\\n  },\\\\n  List: function (arr, html, rule, param) {\\\\n    param = param ? param : {};\\\\n    var auto = param.auto ? param.auto : false;\\\\n    var show = param.show ? param.show : false;\\\\n    if (page == 1) {\\\\n      //this.spage.set(true_url);\\\\n    }\\\\n    this.refresh();\\\\n    var list = pdfa(html, rule.list);\\\\n    //log(this.nextPage())\\\\n    if ((storage0.getMyVar('yi_isnext','t')=='t'&&list.length > 0) || page == 1) {\\\\n      list.forEach((item, i) => {\\\\n        deleteItem(\\\\\\\"pagenum\\\\\\\");\\\\n        deleteItem(\\\\\\\"pageline\\\\\\\");\\\\n        var id = \\\\\\\"\\\\\\\";\\\\n        var cls = \\\\\\\"\\\\\\\";\\\\n        var title = this.setContent(item, rule.title);\\\\n        var desc = this.setContent(item, rule.desc);\\\\n        var img = this.imgHandle(item, rule);\\\\n        var url = this.urlHandle(item, rule);\\\\n        var content = this.setContent(item, rule.content);\\\\n        if (i == list.length - 1) {\\\\n          id = \\\\\\\"lastid_\\\\\\\" + page;\\\\n          cls = \\\\\\\"lastmark\\\\\\\";\\\\n        }\\\\n        d.push({\\\\n          title: title,\\\\n          desc: desc,\\\\n          pic_url: img,\\\\n          url: \\\\\\\"hiker://page/er?url=\\\\\\\" + url,\\\\n          content: content,\\\\n          col_type: rule.col_type,\\\\n          extra: {\\\\n            title: title,\\\\n            img: img,\\\\n            id: id,\\\\n            cls: cls,\\\\n          },\\\\n        });\\\\n        if (i == list.length - 1 && show) {\\\\n          d.push({\\\\n            col_type: \\\\\\\"line\\\\\\\",\\\\n            extra: {\\\\n              id: \\\\\\\"pageline\\\\\\\",\\\\n            },\\\\n          });\\\\n\\\\n          d.push({\\\\n            title: \\\\\\\"““””<small>加载中...</small>\\\\\\\",\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            extra: {\\\\n              id: \\\\\\\"pagenum\\\\\\\",\\\\n            },\\\\n          });\\\\n        }\\\\n      });\\\\n    } else {\\\\n      updateItem(\\\\\\\"pagenum\\\\\\\", {\\\\n        title: '““””<font color=\\\\\\\"grey\\\\\\\"><small>到底了</small></font>',\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n          id: \\\\\\\"last\\\\\\\",\\\\n        },\\\\n      });\\\\n    }\\\\n    if (list.length == 0 && page == 1) {\\\\n      d.push({\\\\n        col_type: \\\\\\\"line\\\\\\\",\\\\n      });\\\\n      d.push({\\\\n        title: '““””<font color=\\\\\\\"grey\\\\\\\"><small>无内容</small></font>',\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {},\\\\n      });\\\\n    }\\\\n    if(this.nextPage()){\\\\n      //log('t');\\\\n        storage0.putMyVar('yi_isnext','t');\\\\n    }else{\\\\n      //log('f');\\\\n        storage0.putMyVar('yi_isnext','f');\\\\n    }\\\\n    if (auto) {\\\\n      //createNextPage();\\\\n      autoPage();\\\\n    }\\\\n  },\\\\n};\\\\n\\\\nvar extMethod = {\\\\n  ToParams: function () {\\\\n    var json = arguments[0];\\\\n    return Object.keys(json)\\\\n      .map((key) => key + \\\\\\\"=\\\\\\\" + json[key])\\\\n      .join(\\\\\\\"&\\\\\\\");\\\\n  },\\\\n  urlParse: function (u) {\\\\n    var dict = {};\\\\n    dict.Source = u;\\\\n    let params = (url) => {\\\\n      let queryParams = {};\\\\n      let reg = /([^?=&]+)=([^?=&]+)/g;\\\\n      url.replace(reg, function () {\\\\n        queryParams[arguments[1]] = arguments[2];\\\\n      });\\\\n      return queryParams;\\\\n    };\\\\n    var javaUrl = JavaImporter(java.net.URL);\\\\n    with (javaUrl) {\\\\n      var url = new URL(u);\\\\n      dict.Protocol = url.getProtocol();\\\\n      dict.Host = url.getHost();\\\\n      dict.Port = url.getPort();\\\\n      dict.File = url.getFile();\\\\n      dict.Path = url.getPath();\\\\n      dict.Ref = url.getRef();\\\\n      dict.Hosts = `${dict.Protocol}://${url.getHost()}`;\\\\n    }\\\\n    dict.Params = params(u);\\\\n    return dict;\\\\n  },\\\\n  isEqual: function (x, y) {\\\\n    const ok = Object.keys,\\\\n      tx = typeof x,\\\\n      ty = typeof y;\\\\n    return x && y && tx === \\\\\\\"object\\\\\\\" && tx === ty\\\\n      ? ok(x).length === ok(y).length &&\\\\n          ok(x).every((key) => this.isEqual(x[key], y[key]))\\\\n      : x === y;\\\\n  },\\\\n  findDifferentIndex: function (str1, str2) {\\\\n    const diffChars = [];\\\\n    for (let i = 0; i < str2.length; i++) {\\\\n      if (str1[i] !== str2[i]) {\\\\n        diffChars.push({\\\\n          index: i,\\\\n          s1: str1[i],\\\\n          s2: str2[i],\\\\n        });\\\\n      }\\\\n    }\\\\n    return diffChars;\\\\n  },\\\\n  replaceCharAt: function (str, index, replacement) {\\\\n    if (index < 0 || index >= str.length) {\\\\n      return str;\\\\n    }\\\\n    //log(index)\\\\n    const arr = str.split(\\\\\\\"\\\\\\\");\\\\n    arr[index] = replacement;\\\\n    return arr.join(\\\\\\\"\\\\\\\");\\\\n  },\\\\n  getObjectKeysDiff:function(obj1, obj2) {\\\\n  const differentKeys = [];\\\\n  for (let key in obj1) {\\\\n    if (!obj2.hasOwnProperty(key) || obj1[key] !== obj2[key]) {\\\\n      differentKeys.push(key);\\\\n    }\\\\n  }\\\\n  for (let key in obj2) {\\\\n    if (!obj1.hasOwnProperty(key)) {\\\\n      differentKeys.push(key);\\\\n    }\\\\n  }\\\\n  return differentKeys;\\\\n  },\\\\n  getNextUrl: function (source, target, params) {\\\\n    var u1 = this.urlParse(source);\\\\n    var u2 = this.urlParse(target);\\\\n    var pa = undefined;\\\\n    if (typeof params == \\\\\\\"object\\\\\\\") {\\\\n      pa = params.hasOwnProperty(\\\\\\\"特征\\\\\\\") ? params.特征 : undefined;\\\\n    }\\\\n    var nexturl = source;\\\\n    var ca = Object.keys(u2.Params).length == 0 ? \\\\\\\"\\\\\\\" : \\\\\\\"?\\\\\\\";\\\\n    if (pa != undefined) {\\\\n      var rs = String(u2.Path).replace(new RegExp(pa), \\\\\\\"$1fypage\\\\\\\");\\\\n      nexturl = u2.Hosts + rs + ca + this.ToParams(u2.Params);\\\\n    } else {\\\\n      if (this.isEqual(u1.Params, u2.Params)) {\\\\n        if(dt_debug){\\\\n        log(u1.Path);\\\\n        log(u2.Path);\\\\n        }\\\\n        var df = this.findDifferentIndex(String(u1.Path), String(u2.Path));\\\\n        if(dt_debug){\\\\n        log(df);\\\\n        }\\\\n        if (df.length == 1) {\\\\n          var re = df[0].index;\\\\n        } else {\\\\n          var f = df.filter((x) => /\\\\\\\\d+/.test(x.s2));\\\\n          var re = f[0].index;\\\\n        }\\\\n        var eq = this.replaceCharAt(String(u2.Path), re, \\\\\\\"fypage\\\\\\\");\\\\n        nexturl = u2.Hosts + eq + ca + this.ToParams(u2.Params);\\\\n      } else {\\\\n        var ep=this.getObjectKeysDiff(u1.Params,u2.Params)\\\\n        if(ep.length==1){\\\\n          u1.Params[ep[0]]='fypage'\\\\n        }else{\\\\n          log(ep);\\\\n        }\\\\n        var eq = String(u1.Path).replace(/\\\\\\\\d+/, \\\\\\\"fypage\\\\\\\");\\\\n        nexturl = u1.Hosts + eq + ca + this.ToParams(u1.Params);\\\\n      }\\\\n    }\\\\n    //log('next:'+nexturl)\\\\n    return nexturl;\\\\n  },\\\\n};\\\\n\\\\nfunction getTruelink(mark, url, page) {\\\\n  var p = getMyVar(mark, url).replace(\\\\\\\"fypage\\\\\\\", page);\\\\n  if (page == 1) {\\\\n    return getMyVar(\\\\\\\"yi_firstpage\\\\\\\", p);\\\\n  } else if (p != \\\\\\\"\\\\\\\") {\\\\n    return p;\\\\n  } else {\\\\n    return url;\\\\n  }\\\\n}\\\\n//构建\\\\nfunction createNextPage() {\\\\n  let startnum = 1;\\\\n  var obj = arguments[0];\\\\n  if (true_url != getMyVar(\\\\\\\"yi_pageurl\\\\\\\", \\\\\\\"\\\\\\\")) {\\\\n    clearMyVar(\\\\\\\"yi_pageurl\\\\\\\");\\\\n  }\\\\n  if (page == startnum && getMyVar(\\\\\\\"yi_pageurl\\\\\\\") == \\\\\\\"\\\\\\\") {\\\\n    putMyVar(\\\\\\\"yi_firstpage\\\\\\\", true_url);\\\\n    try {\\\\n      var next = eval(下一页);\\\\n      //log(\\\\\\\"next\\\\\\\");\\\\n      //log(next);\\\\n    } catch {\\\\n      log(\\\\\\\"可能不存在下一页或者下一页定位有问题\\\\\\\");\\\\n      next = \\\\\\\"\\\\\\\";\\\\n    }\\\\n    if (next != \\\\\\\"\\\\\\\") {\\\\n      var nxurl = extMethod.getNextUrl(true_url, next, obj);\\\\n      //log(\\\\\\\"nxurl:\\\\\\\" + nxurl);\\\\n      putMyVar(状态, nxurl);\\\\n      putMyVar(\\\\\\\"yi_pageurl\\\\\\\", nxurl);\\\\n    }\\\\n  }\\\\n}\\\\n\\\\nfunction autoPage() {\\\\n  if(page==1){\\\\n    putMyVar(\\\\\\\"yi_firstpage\\\\\\\", true_url);\\\\n    }\\\\n    try {\\\\n      var next = eval(下一页);\\\\n      //log(\\\\\\\"next\\\\\\\");\\\\n      //log('next:'+next);\\\\n    } catch {\\\\n      log(\\\\\\\"可能不存在下一页或者下一页定位有问题\\\\\\\");\\\\n      next = \\\\\\\"\\\\\\\";\\\\n    }\\\\n    if (next != \\\\\\\"\\\\\\\") {\\\\n      putMyVar(状态, next);\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"解析\\\",\\\"path\\\":\\\"lazy\\\",\\\"rule\\\":\\\"var lazy = $('').lazyRule((MY_HOME) => {\\\\n    var inp = fetch(input,{});\\\\n    var html = pdfh(inp, 'source&&src');\\\\n    var pic = pdfh(inp, '.message&&img,-1&&data-lazy-src')\\\\n    if(html){\\\\n     url = html.match(/http?[^\\\\\\\\s]+/)[0]\\\\n     return url\\\\n         } if(pic) {\\\\n        return \\\\\\\"pics://\\\\\\\"+pdfa(inp, '.message&&img').map(img =>pd(img, 'img&&data-lazy-src')+\\\\\\\"@Referer=\\\\\\\",).join(\\\\\\\"&&\\\\\\\")\\\\n     }else{\\\\n     return 'toast://洗洗睡吧'\\\\n        }\\\\n},MY_HOME)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级页面内容\\\",\\\"path\\\":\\\"er\\\",\\\"rule\\\":\\\"js:\\\\nvar d = []\\\\neval(JSON.parse(request('hiker://page/repair')).rule);\\\\nMY_URL=MY_URL.replace('hiker://empty##','');\\\\nvar temp = guard(MY_URL);\\\\n    if(temp.includes(\\\\\\\"检测中\\\\\\\")){\\\\n         MY_URL = MY_HOME + temp.match(/href =\\\\\\\"(.*?)\\\\\\\"/)[1]\\\\n          }\\\\nvar html = guard(MY_URL);\\\\nlog(MY_URL)\\\\neval(JSON.parse(fetch('hiker://page/lazy', {})).rule);\\\\n\\\\nvar title = pdfh(html,'h4&&Text');\\\\nvar desc = pdfh(html,'.media-body&&.date&&Text')+\\\\\\\"\\\\\\\\t\\\\\\\\t\\\\\\\\t点击尝试播放\\\\\\\";\\\\n   if(title !==null){\\\\n    d.push({\\\\n        title: '““””<middle><font color=#FFA500>'+title+'</font></middle>',\\\\n        desc: desc,\\\\n        url: MY_URL,\\\\n        col_type: 'text_1',\\\\n        extra: {lineVisible: false}\\\\n    })\\\\n}\\\\n\\\\nvar 识别码;\\\\ntry{\\\\n  识别码 = parseDomForHtml(html, 'body&&.fan-info&&a,-1&&Text').replace('识别码: ','');\\\\n           }catch(err){}\\\\n\\\\nvar img = pd(html,'.message&&img&&src||data-lazy-src');\\\\n    if(img !==null){\\\\n        d.push({\\\\n             img: img,\\\\n             url: MY_URL + lazy,\\\\n             col_type: 'pic_1_full',\\\\n                  });\\\\n         }\\\\n\\\\ntry{\\\\nvar k = pdfh(html,'.pg&&a,-2&&Text').replace(/\\\\\\\\./g,'');\\\\nlog(typeof(k))\\\\nfor (var j = 1; j <= k ; j++){\\\\n    d.push({\\\\n        title: '第' + j +'页',\\\\n        url: MY_URL + '?tpage=' + j + lazy,\\\\n        col_type: 'text_5',\\\\n})\\\\n}}catch(err){\\\\n    //console.log('只有一页,凑合看吧', err);\\\\n}\\\\n\\\\n\\\\n\\\\n var fh = pdfh(html,'.fan-info&&Text');\\\\n    if(fh){\\\\nd.push({\\\\n    title: '““””<middle><font color=cyan>'+fh+'</font></middle>',\\\\n    url: 'hiker://search?rule=' + MY_RULE.title + '&s='+pdfh(html, '.fan-info&&a&&Text'),\\\\n    col_type: 'text_1',\\\\n       extra: {lineVisible: false}\\\\n});\\\\n}\\\\n\\\\nif(识别码){\\\\neval(JSON.parse(fetch('hiker://page/tool', {})).rule);\\\\n}\\\\n//预览图\\\\ntry{\\\\n    var list = pdfa(html,\\\\\\\".yulantu&&img,0:9\\\\\\\")\\\\nif(list.length>0){\\\\n   d.push({\\\\n        title: '““””<middle><font color=#ff6877>样品图像</font></middle>',\\\\n        url: MY_URL + $('').lazyRule(() => {\\\\n                    var html = request(input)\\\\n                    var pics = pdfa(html,\\\\\\\".yulantu&&img\\\\\\\").map(item=>pd(item,\\\\\\\"img&&src\\\\\\\"))\\\\n                    return \\\\\\\"pics://\\\\\\\"+pics.join(\\\\\\\"&&\\\\\\\")\\\\n                }),\\\\n        col_type: 'text_1',\\\\n        extra: {lineVisible: false}\\\\n    })\\\\n}\\\\nlist.forEach(item=>{\\\\n     d.push({\\\\n         img: pd(item,\\\\\\\"img&&src\\\\\\\"),\\\\n         url: pd(item,\\\\\\\"img&&src\\\\\\\"),\\\\n         col_type: \\\\\\\"pic_3_square\\\\\\\"\\\\n        })\\\\n       })\\\\n     }catch{}\\\\n\\\\n//磁力\\\\nvar cili = pdfa(html, '.cililian&&blockquote');\\\\nvar cl = pdfa(html, '.cililian&&script:not([data-cfasync])');\\\\nif(cl.length>0){\\\\nfor (var i = 0; i < Math.min(cili.length, cl.length); i++) {\\\\n var title = '““””<middle><font color=yellow>'+pdfh(cili[i],'blockquote--a&&Text')+'</font></middle>'+'““””<middle><font color=#0099FF>'+pdfh(cili[i],'a&&Text').replace(\\\\\\\"[email protected]\\\\\\\",\\\\\\\"\\\\\\\")+'</font></middle>';\\\\n var cl0 = pdfh(cl[i],'script&&Html').split(\\\\\\\"reurl('\\\\\\\")[1].split(\\\\\\\"')\\\\\\\")[0];\\\\nd.push({\\\\n    title: title,\\\\n    url: 'magnet:?xt=urn:btih:'+reurl(cl0),\\\\n    col_type: 'text_center_1',\\\\n       extra: {lineVisible: false}\\\\n});\\\\n}}else{\\\\nfor (var j in cili) {\\\\n var title = pdfh(cili[j],'blockquote&&Text');\\\\nd.push({\\\\n    title: '““””<middle><font color=yellow>'+title+'</font></middle>',\\\\n    url: pdfh(cili[j],'a&&Text'),\\\\n    col_type: 'text_center_1',\\\\n       extra: {lineVisible: false}\\\\n});\\\\n}\\\\n}\\\\n\\\\n\\\\n\\\\n/*\\\\nvar xiaoshuo = JSON.parse(pdfh(html,'.message&&script&&Html').match(/\\\\\\\\[.*?\\\\\\\\]/g)[1]);\\\\nxiaoshuo.forEach(x =>{\\\\n    d.push({\\\\n       title: x.name,\\\\n       desc: x.artist,\\\\n       img: MY_HOME + x.cover,\\\\n       url: MY_HOME + x.url,\\\\n       col_type: 'avatar'\\\\n       })\\\\n   })*/\\\\n\\\\ntry{\\\\nvar urls = html.match(/\\\\\\\\/mp3\\\\\\\\/.*?\\\\\\\\.mp3/g);\\\\nurls = urls.map(function(url) {\\\\n  return MY_HOME + url;\\\\n});\\\\nvar names = html.match(/第.*?集/g);   \\\\n       for (var i = 0; i < Math.min(urls.length, names.length); i++) {\\\\n  d.push({\\\\n    url: urls[i],\\\\n    title: names[i],\\\\n    desc: '有声小说',\\\\n    img: MY_HOME + '/img/play1.png',\\\\n    col_type: 'avatar'\\\\n  });\\\\n}}catch (err) {\\\\n  //console.log('此页面没有有声小说', err);\\\\n};\\\\n\\\\n\\\\nvar content = parseDomForHtml(html, \\\\\\\".message&&.htxt&&Html\\\\\\\");\\\\nif(content){\\\\nd.push({\\\\n    title: content,\\\\n    desc: '',\\\\n    pic_url: '',\\\\n    url: '',\\\\n    col_type: 'rich_text'\\\\n});\\\\n}\\\\n   d.push({\\\\n        title: '““””<middle><font color=#A020F0>相关资源推荐</font></middle>',\\\\n        url: \\\\\\\"copy://\\\\\\\" + 识别码,\\\\n        col_type: 'text_1',\\\\n         extra: {lineVisible: false}\\\\n    });\\\\n\\\\nlet tj = pdfa(html, 'body&&.plugin_list');\\\\ntj.forEach(x => {   \\\\n d.push({\\\\n    title: pdfh(x, 'a&&title'),\\\\n    desc: pdfh(x,'.date&&Text'),\\\\n    img: pd(x,'img&&src'),\\\\n    url: \\\\\\\"hiker://page/er?url=\\\\\\\"+pd(x, 'a&&href'),\\\\n    col_type: 'movie_2',\\\\n      extra:{\\\\n         pageTitle: pdfh(x, 'a&&title'),\\\\n         }\\\\n\\\\n  });\\\\n})\\\\n\\\\n\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级外部搜索\\\",\\\"path\\\":\\\"tool\\\",\\\"rule\\\":\\\"//var title = parseDomForHtml(html, 搜索标签);\\\\n//var title = MY_PARAMS.title;\\\\n//log(title)\\\\n\\\\n//ThissAV\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#FF0000\\\\\\\"> ThisAV</font></middle>',\\\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/logos-and-brands/512/232_Nintendo_Switch_logo-128.png',\\\\n    url: $('').lazyRule((识别码) => {\\\\n                 var av = \\\\\\\"https://thisav.com/cn/\\\\\\\" + 识别码; \\\\n//log(av)\\\\n              try{\\\\n                 var html = fetch(av, {\\\\n                    headers: {\\\\n                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0)'\\\\n                           },timeout:5000\\\\n                           });\\\\n                 eval(html.match(/eval.*?\\\\\\\\n/)[0])\\\\n                    // 获取画质列表，并去最高画质\\\\n                    let group_quality = fetch(source,{headers:{\\\\\\\"origin\\\\\\\":\\\\\\\"https://thisav.com\\\\\\\"}})\\\\n                    hghest_quality = group_quality.match(/^(.*)\\\\\\\\.m3u8$/gm)\\\\n                    return source.replace(\\\\\\\"playlist.m3u8\\\\\\\", hghest_quality[hghest_quality.length-1]) + ';{Origin@https://thisav.com}'         \\\\n                 }catch{return \\\\\\\"toast://挂梯或没有此影片\\\\\\\"}\\\\n                  },识别码),\\\\n    col_type: 'icon_5',\\\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\\\\\"https://thisav.com/cn/\\\\\\\" + 识别码;},识别码)}] }\\\\n});\\\\n\\\\n//MISSAV\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#00FF00\\\\\\\"> MISSAV</font></middle>',\\\\n    pic_url: 'https://cdn1.iconfinder.com/data/icons/fruits-n-vegetables-colored-gradient/128/cauliflower-128.png',\\\\n    url: $('').lazyRule((识别码) => {\\\\n       try{\\\\n             var av = \\\\\\\"https://missav.to/search/movie/\\\\\\\" + 识别码;  \\\\n             var urls = [];    \\\\n             var list = pdfa(fetch(av,{timeout:5000}),\\\\\\\".videos-list&&article\\\\\\\");\\\\n            for(var j in list){\\\\n              urls.push({\\\\n                       url: pdfh(list[j],\\\\\\\"a&&href\\\\\\\")\\\\n                        })\\\\n            }\\\\n            var plays = bf(urls).map(h=>h.match(/src=\\\\\\\"(.*?)\\\\\\\"/)[1].split(\\\\\\\"&\\\\\\\")[0].replace(\\\\\\\"?id=\\\\\\\",\\\\\\\"hls/\\\\\\\") + \\\\\\\".m3u8\\\\\\\")   \\\\n             return {urls:plays}\\\\n       }catch{\\\\n         try{\\\\n             var av = \\\\\\\"https://missav.to/search/movie/\\\\\\\" + 识别码.replace(/\\\\\\\\-|\\\\\\\\_/,\\\\\\\"%20\\\\\\\");  \\\\n             var urls = [];    \\\\n             var list = pdfa(fetch(av,{timeout:5000}),\\\\\\\".videos-list&&article\\\\\\\");\\\\n            for(var j in list){\\\\n              urls.push({\\\\n                       url: pdfh(list[j],\\\\\\\"a&&href\\\\\\\")\\\\n                        })\\\\n            }\\\\n            var plays = bf(urls).map(h=>h.match(/src=\\\\\\\"(.*?)\\\\\\\"/)[1].split(\\\\\\\"&\\\\\\\")[0].replace(\\\\\\\"?id=\\\\\\\",\\\\\\\"hls/\\\\\\\") + \\\\\\\".m3u8\\\\\\\")   \\\\n             return {urls:plays}\\\\n          }catch{return \\\\\\\"toast://没有此影片\\\\\\\"}\\\\n       }   \\\\n                  },识别码),\\\\n    col_type: 'icon_5',\\\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\\\\\"https://missav.to/search/movie/\\\\\\\" + 识别码},识别码)}] }\\\\n});\\\\n\\\\n//njav\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#1E90FF\\\\\\\"> nJav.tv</font></middle>',\\\\n    pic_url: 'https://cdn2.iconfinder.com/data/icons/social-icons-33/128/Facebook_Messenger-128.png',\\\\n    url: $('').lazyRule((识别码) => {\\\\n                 var av = \\\\\\\"https://njav.tv/zh/v/\\\\\\\" + 识别码; \\\\n//log(av)\\\\n                 var html = fetch(av,{timeout:5000})\\\\n                 if(!html || html.includes(\\\\\\\"请检查地址栏中的网址\\\\\\\")){         \\\\n                 return \\\\\\\"toast://挂梯或没有此影片\\\\\\\"\\\\n                   }else{\\\\n                 return \\\\\\\"video://\\\\\\\" + av;\\\\n                    }\\\\n               },识别码),\\\\n    col_type: 'icon_5',\\\\n    extra: {\\\\n                videoExcludeRules: ['240'],\\\\n                blockRules: ['*.doppiocdn.*'],\\\\n                blockRules: ['dmm.co.jp'],\\\\n                //videoRules: ['*m3u8*'],\\\\n                cacheM3u8: true,\\\\n               longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\\\\\"https://njav.tv/zh/v/\\\\\\\" + 识别码;},识别码)}]\\\\n                        }\\\\n});\\\\n\\\\n//av01\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#75127A\\\\\\\"> AV01</font></middle>',\\\\n    pic_url: 'https://cdn2.iconfinder.com/data/icons/owl-10/500/nim532_11_purple_owl_kid_birthday_face_eye-128.png',\\\\n    url: $('').lazyRule((识别码) => {\\\\n                 var av = \\\\\\\"https://www.av01.tv/\\\\\\\" + 识别码; \\\\n//log(av)\\\\n                 var html = fetch(av,{timeout:5000})\\\\n                 var code = pdfh(html,'#plyr_video&&poster')\\\\nlog(code)\\\\n                 if(!code){         \\\\n                 return \\\\\\\"toast://挂梯或没有此影片\\\\\\\"\\\\n                   }else{\\\\n                 return \\\\\\\"video://\\\\\\\" + av;\\\\n                    }\\\\n               },识别码),\\\\n    col_type: 'icon_5',\\\\n    extra: {\\\\n                videoExcludeRules: ['doppiocdn'],\\\\n                videoExcludeRules: ['240'],\\\\n                videoExcludeRules: ['480'],\\\\n                blockRules: ['.doppiocdn.'],\\\\n                blockRules: ['dmm.co.jp'],\\\\n                //videoRules: ['*m3u8*'],\\\\n                cacheM3u8: true,\\\\n               longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\\\\\"https://www.av01.tv/\\\\\\\" + 识别码;},识别码)}]\\\\n                        }\\\\n});\\\\n\\\\n//Jable\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#FF8C00\\\\\\\"> Jable</font></middle>',\\\\n    pic_url: 'https://cdn3.iconfinder.com/data/icons/cat-power-premium/120/cat_foodlove-128.png',\\\\n    url: $('').lazyRule((识别码) => {\\\\n                 var av = \\\\\\\"https://jable.tv/videos/\\\\\\\" + 识别码 + \\\\\\\"/\\\\\\\"; \\\\n//log(av)\\\\n                // request(\\\\\\\"https://jable.tv/\\\\\\\")\\\\n              try{\\\\n                 var html = fetch(av,{timeout:5000})\\\\n                 var url = html.match(/https?:\\\\\\\\/\\\\\\\\/\\\\\\\\S+?\\\\\\\\.m3u8/)[0]\\\\n                 return url\\\\n                 }catch{return \\\\\\\"toast://没有挂梯子或没有此影片\\\\\\\"}\\\\n                  },识别码),\\\\n    col_type: 'icon_5',\\\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\\\\\"https://jable.tv/videos/\\\\\\\" + 识别码 + \\\\\\\"/\\\\\\\";},识别码)}] }\\\\n});\\\\n\\\\n//ThissAV破解\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#FEFE00\\\\\\\">無碼破解</font></middle>',\\\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/social-media-flat-7/64/Social-media_Snapchat-128.png',\\\\n    url: $('').lazyRule((识别码) => {\\\\n                 var av = \\\\\\\"https://thisav.com/cn/\\\\\\\" + 识别码 + \\\\\\\"-uncensored-leak\\\\\\\"; \\\\n//log(av)\\\\n              try{\\\\n                 var html = fetch(av, {\\\\n                    headers: {\\\\n                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0)'\\\\n                           },timeout:5000\\\\n                           });\\\\n                 eval(html.match(/eval.*?\\\\\\\\n/)[0])\\\\n                    // 获取画质列表，并去最高画质\\\\n                    let group_quality = fetch(source,{headers:{\\\\\\\"origin\\\\\\\":\\\\\\\"https://thisav.com\\\\\\\"}})\\\\n                    hghest_quality = group_quality.match(/^(.*)\\\\\\\\.m3u8$/gm)\\\\n                    return source.replace(\\\\\\\"playlist.m3u8\\\\\\\", hghest_quality[hghest_quality.length-1]) + ';{Origin@https://thisav.com}'         \\\\n                 }catch{return \\\\\\\"toast://挂梯或没有此影片\\\\\\\"}\\\\n                  },识别码),\\\\n    col_type: 'icon_5',\\\\n    extra: { longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\\\\\"https://thisav.com/cn/\\\\\\\" + 识别码 + \\\\\\\"-uncensored-leak\\\\\\\";},识别码)}] }\\\\n});\\\\n\\\\n//njav破解\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#1E90FF\\\\\\\"> nJav破解</font></middle>',\\\\n    pic_url: 'https://cdn0.iconfinder.com/data/icons/CuteMonstersPNG/128/blue_monster.png',\\\\n    url: $('').lazyRule((识别码) => {\\\\n                 var av = \\\\\\\"https://njav.tv/zh/v/\\\\\\\" + 识别码 + \\\\\\\"-uncensored-leaked\\\\\\\"; \\\\n//log(av)\\\\n                 var html = fetch(av,{timeout:5000})\\\\n                 if(!html || html.includes(\\\\\\\"请检查地址栏中的网址\\\\\\\")){         \\\\n                 return \\\\\\\"toast://挂梯或没有此影片\\\\\\\"\\\\n                   }else{\\\\n                 return \\\\\\\"video://\\\\\\\" + av;\\\\n                    }\\\\n               },识别码),\\\\n    col_type: 'icon_5',\\\\n    extra: {\\\\n                videoExcludeRules: ['240'],\\\\n                blockRules: ['*.doppiocdn.*'],\\\\n                blockRules: ['dmm.co.jp'],\\\\n                //videoRules: ['*m3u8*'],\\\\n                cacheM3u8: true,\\\\n               longClick: [{title: '查看网址', js: $.toString((识别码)=>{ return \\\\\\\"https://njav.tv/zh/v/\\\\\\\" + 识别码 + \\\\\\\"-uncensored-leaked\\\\\\\";},识别码)}]\\\\n                        }\\\\n});\\\\n\\\\n//Supjav\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#A32986\\\\\\\">Supjav</font></middle>',\\\\n    pic_url: 'https://cdn3.iconfinder.com/data/icons/logos-brands-3/24/logo_brand_brands_logos_skrill-128.png',\\\\n    url: \\\\\\\"x5://https://supjav.com/zh/?s=\\\\\\\" + 识别码,\\\\n    col_type: 'icon_5',\\\\n    extra:{\\\\n                lineVisible:false,\\\\n                longClick: [{title: '召唤雨见', js: $.toString((识别码)=>{ \\\\n/*\\\\nopenAppIntent('com.yujian.ResideMenuDemo', 'cn.yujian.MainActivity', {intentData: 'https://supjav.com/zh/?s=' + 识别码})\\\\n*/\\\\n            return \\\\\\\"yjbrowser://search?q=https://supjav.com/zh/?s=\\\\\\\" + 识别码\\\\n                       },识别码)},{title: '查看网址', js: $.toString((识别码)=>{ \\\\n        return \\\\\\\"https://supjav.com/zh/?s=\\\\\\\" + 识别码\\\\n                       },识别码)}]\\\\n             }\\\\n                  });\\\\n\\\\n//聚搜\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#67E0FA\\\\\\\">聚搜 • R</font></middle>',\\\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/essentials-72/24/002_-_Search-128.png',\\\\n    url: \\\\\\\"hiker://search?s=\\\\\\\" + 识别码 + \\\\\\\"&rule=好看视频&simple=false\\\\\\\",\\\\n    col_type: 'icon_5',\\\\n    extra: {               \\\\n               longClick: [{title: 'Jav.Guru', js: $.toString((识别码)=>{ return \\\\\\\"https://jav.guru/?s=\\\\\\\" + 识别码;},识别码)},{title: 'JavBangers', js: $.toString((识别码)=>{ return \\\\\\\"https://www.javbangers.com/search/\\\\\\\" + 识别码 +'/';},识别码)},{title: '复制识别码', js: $.toString((识别码)=>{ return \\\\\\\"copy://\\\\\\\" + 识别码;},识别码)}]\\\\n                        }\\\\n});\\\\n\\\\n\\\\n//磁力君.简\\\\nd.push({\\\\n    title: '‘‘’’<b><middle><font color=\\\\\\\"#EF4823\\\\\\\">磁力君.简</font></middle>',\\\\n    pic_url: 'https://cdn4.iconfinder.com/data/icons/shopping-doodle/512/Shopping-31-128.png',\\\\n    url: \\\\\\\"hiker://page/sou?rule=磁力君.简&p=fypage&searchTerms=\\\\\\\" + 识别码,\\\\n    col_type: 'icon_5',\\\\n    extra: {               \\\\n               longClick: [{title: '谷歌搜索', js: $.toString((识别码)=>{ return \\\\\\\"https://www.google.com/search?q=\\\\\\\" + 识别码;},识别码)},{title: 'Yandex搜索', js: $.toString((识别码)=>{ return \\\\\\\"https://yandex.com/search/touch/?text=\\\\\\\" + 识别码;},识别码)},{title: '复制识别码', js: $.toString((识别码)=>{ return \\\\\\\"copy://\\\\\\\" + 识别码;},识别码)}]\\\\n                        }\\\\n});\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"0级首页页面\\\",\\\"path\\\":\\\"shou\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nMY_URL = MY_URL.replace('hiker://empty##', '');\\\\neval(JSON.parse(request('hiker://page/repair')).rule);\\\\nvar temp = guard(MY_URL);\\\\n    if(temp.includes(\\\\\\\"检测中\\\\\\\")){\\\\n         MY_URL = MY_HOME + temp.match(/href =\\\\\\\"(.*?)\\\\\\\"/)[1]\\\\n          }\\\\nvar html = guard(MY_URL);\\\\nlog(MY_URL)\\\\n\\\\nvar lis = pdfa(html, '.resouci&&a:not(:matches(美图|更多))');\\\\nlis.forEach(x => {   \\\\n    d.push({\\\\n       title: pdfh(x, 'a&&Text'),\\\\n       url: pd(x, 'a&&href')+'##fypage@rule=js:$.require(\\\\\\\"hiker://page/ss\\\\\\\")',\\\\n       col_type: 'scroll_button',\\\\n  });\\\\n})\\\\n/*\\\\nd.push({\\\\n     col_type: 'blank_block',\\\\n})*/\\\\n\\\\nvar conts = pdfa(html, '.sou-tagyun&&.sou-tag');\\\\nfor (var i = 0; i < conts.length; i++) {\\\\n      var list = pdfa(conts[i], 'body&&a'); \\\\nd.push({\\\\n     col_type: 'blank_block',\\\\n});\\\\n        for (var j = 0; j < list.length; j++) {       \\\\n            d.push({\\\\n                title: pdfh(list[j], 'a&&Text'),\\\\n                url: pd(list[j], 'a&&href')+'##fypage@rule=js:$.require(\\\\\\\"hiker://page/ss\\\\\\\")',\\\\n                col_type: 'scroll_button',            \\\\n            });\\\\n        }\\\\n    }\\\\n\\\\nvar lis = pdfa(html, 'body&&.pic-home&&li');\\\\nlis.forEach(x => {   \\\\n    d.push({\\\\n       title: pdfh(x, 'a&&Text'),\\\\n       img: pd(x, 'img&&src'),\\\\n       url: pd(x, 'a&&href')+'##fypage@rule=js:$.require(\\\\\\\"hiker://page/ss\\\\\\\")',\\\\n       col_type: 'movie_2',\\\\n  });\\\\n})\\\\n\\\\nd.push({\\\\n    title: '<span style=\\\\\\\"color:#ff6600\\\\\\\"><b>🔥识别码视频\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t热门分类</b></span>',\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    col_type: 'rich_text'\\\\n});\\\\n\\\\nvar title = pdfa(html, '.aui-layout-tuijian&&.aui-layout-text');\\\\nvar img = pdfa(html, '.aui-layout-tuijian&&img');\\\\nvar url = pdfa(html, '.aui-layout-tuijian&&a');\\\\nfor (var i = 0; i < Math.min(title.length, img.length,url.length); i++) {\\\\n   d.push({\\\\n       title: pdfh(title[i],'Text'),\\\\n       img: pd(img[i],'img&&src'),\\\\n       url: pd(url[i],'a&&href')+'##fypage@rule=js:$.require(\\\\\\\"hiker://page/ss\\\\\\\")',\\\\n       col_type: 'icon_4_card',\\\\n})\\\\n}\\\\n\\\\nd.push({\\\\n    title: '<span style=\\\\\\\"color:#ff6600\\\\\\\"><b>🔥国产视频\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t热门分类</b></span>',\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    col_type: 'rich_text'\\\\n});\\\\n\\\\nvar title = pdfa(html, '.aui-layout-tuijian,1&&.aui-layout-text');\\\\nvar img = pdfa(html, '.aui-layout-tuijian,1&&img');\\\\nvar url = pdfa(html, '.aui-layout-tuijian,1&&a');\\\\nfor (var i = 0; i < Math.min(title.length, img.length,url.length); i++) {\\\\n   d.push({\\\\n       title: pdfh(title[i],'Text'),\\\\n       img: pd(img[i],'img&&src'),\\\\n       url: pd(url[i],'a&&href')+'##fypage@rule=js:$.require(\\\\\\\"hiker://page/ss\\\\\\\")',\\\\n       col_type: 'icon_4_card',\\\\n})\\\\n}\\\\n\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"一级搜索页面\\\",\\\"path\\\":\\\"ss\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\n/*\\\\naddListener(\\\\\\\"onClose\\\\\\\", () => {\\\\n    for (let it of listMyVarKeys()) {\\\\n        clearMyVar(it);\\\\n    }\\\\n});*/\\\\naddListener(\\\\\\\"onRefresh\\\\\\\", () => {\\\\n    clearMyVar(\\\\\\\"nextPage\\\\\\\");\\\\n});\\\\nvar whost = config.host;\\\\nMY_URL = MY_URL.replace('hiker://empty##', '');\\\\nlet true_url = getVar(MY_RULE.url, MY_URL);\\\\n\\\\nconst page = MY_PAGE;\\\\n//获取上次缓存的下页链接\\\\nlet nextPage = getMyVar(\\\\\\\"nextPage\\\\\\\", \\\\\\\"\\\\\\\");\\\\n//如果有下一页且不是第一页就使用下一页链接\\\\nif (nextPage && MY_PAGE > 1) {\\\\n    true_url = nextPage;\\\\n}\\\\nvar temp = fetch(true_url);\\\\n    if(temp.includes(\\\\\\\"检测中\\\\\\\")){\\\\n         true_url = whost + temp.match(/href =\\\\\\\"(.*?)\\\\\\\"/)[1]\\\\n        // request(whost)\\\\n          }\\\\nvar html = fetch(true_url);\\\\nlog(true_url)\\\\ntry {\\\\n    //缓存下一页\\\\n    let nextUrl = pd(html, \\\\\\\"a:contains(下一页)&&href\\\\\\\");\\\\n    putMyVar(\\\\\\\"nextPage\\\\\\\", nextUrl || \\\\\\\"\\\\\\\");\\\\n    //log(\\\\\\\"下一页：\\\\\\\" + nextUrl)\\\\n} catch (e) {\\\\n    clearMyVar(\\\\\\\"nextPage\\\\\\\");\\\\n    toast(\\\\\\\"好像没有下一页了！\\\\\\\");\\\\n}\\\\n\\\\ntry{\\\\nvar k = pdfh(html,'body&&.pagination&&a,-2&&Text').replace(/\\\\\\\\./g,'');\\\\nlet now = getItem('now', '首页');\\\\n\\\\nvar arr = ['随机','跳页','尾页'+k]; \\\\nfor (var i = 1; i < (k < 101 ? k : 101) ; i += (i == 1) ? 4 : 5){\\\\n  arr.push(i); \\\\n}\\\\nif(k>200){\\\\nfor (var i = 200; i < (k < 1001 ? k : 1001) ; i += 100){\\\\n  arr.push(i); \\\\n}}\\\\nvar names = []\\\\nnames = arr.map(function(item) {\\\\n  if (typeof item === 'number') {\\\\n    return item + \\\\\\\"页\\\\\\\";\\\\n  } else {\\\\n    return item;\\\\n  }\\\\n});\\\\n\\\\nfor (var j = 0; j < Math.min(arr.length, names.length); j++) {\\\\nif(arr[j]=='跳页'){\\\\n             d.push({\\\\r\\\\n            title:now ==names[j]? '““””' + names[j].fontcolor('red') : names[j],\\\\r\\\\n            col_type: \\\\\\\"scroll_button\\\\\\\",\\\\r\\\\n            url: $(23, '请输入要跳转到的页数').input((true_url,k,names,j) => {\\\\r\\\\n                if (isNaN(parseInt(input))) {\\\\r\\\\n                    return 'toast://输入有误,请输入一个1~' + k + '的数字'\\\\r\\\\n                }\\\\r\\\\n                let toPage = parseInt(input);\\\\r\\\\n                if (toPage < 1 || toPage > k) {\\\\r\\\\n                    return 'toast://输入有误,请输入一个1~' + k + '的数字'\\\\r\\\\n                }\\\\n          if(/forum\\\\\\\\-\\\\\\\\d+\\\\\\\\-\\\\\\\\d+/.test(true_url)){\\\\nvar url = true_url.replace(/\\\\\\\\d+\\\\\\\\.htm/, toPage + '.htm');\\\\n              }else{\\\\nvar url = true_url.replace(/\\\\\\\\.htm/, '-' + toPage + '.htm');\\\\n              }\\\\r\\\\n                setItem(\\\\\\\"now\\\\\\\", names[j]);\\\\n                putVar(MY_RULE.url, url);\\\\n                //putMyVar('yi_firstpage', url);\\\\n                refreshPage(true);\\\\r\\\\n                return 'toast://跳越到了第' + toPage + '页'\\\\r\\\\n            },true_url, k,names,j),\\\\r\\\\n        });\\\\n\\\\n}else{\\\\n\\\\nif(arr[j]=='随机'){\\\\n              arr[j] = Math.floor(Math.random() * k) +1   \\\\n}else if(arr[j]=='尾页'+k){\\\\n              arr[j] = k\\\\n}else if(arr[j]==1){\\\\n              names[j] = \\\\\\\"首页\\\\\\\"\\\\n}else if(arr[j]=='跳页'){\\\\n             arr[j] = 223\\\\n}\\\\n\\\\n          if(/forum\\\\\\\\-\\\\\\\\d+\\\\\\\\-\\\\\\\\d+/.test(true_url)){\\\\nvar url = true_url.replace(/\\\\\\\\d+\\\\\\\\.htm/, arr[j] + '.htm');\\\\n              }else{\\\\nvar url = true_url.replace(/\\\\\\\\.htm/, '-' + arr[j] + '.htm');\\\\n              }\\\\n\\\\n    d.push({\\\\n        title:now ==names[j]? '““””' + names[j].fontcolor('red') : names[j],\\\\n        url: url + $('#noLoading#').lazyRule((arr,names,j) => {\\\\n            setItem(\\\\\\\"now\\\\\\\",names[j]);\\\\n            putVar(MY_RULE.url, input);\\\\n            //putMyVar('yi_firstpage', input);\\\\n            refreshPage(true);\\\\n            return 'toast://穿越到了第' + arr[j] + \\\\\\\"页\\\\\\\";\\\\n                    },arr,names,j),\\\\n        col_type: 'scroll_button',\\\\n               })\\\\n}\\\\n}}catch(err){\\\\n    toast(\\\\\\\"好像没有下一页了！\\\\\\\");\\\\n};\\\\n\\\\n\\\\nvar list = pdfa(html, 'body&&.plugin_list');\\\\nlist.forEach(x => {   \\\\n    d.push({\\\\n       title: pdfh(x, 'a&&Text').replace(\\\\\\\"【磁力】\\\\\\\",\\\\\\\"\\\\\\\"),\\\\n       desc: pdfh(x,'.date&&Text'),\\\\n       img: pd(x,'img||a&&src||data-original'),\\\\n       url: \\\\\\\"hiker://page/er?url=\\\\\\\"+pd(x, 'a&&href'),\\\\n       col_type: 'movie_2',\\\\n       extra:{\\\\n          pageTitle:pdfh(x, 'a&&Text'),\\\\n                  }\\\\n  });\\\\n})\\\\n\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"环境\\\",\\\"path\\\":\\\"repair\\\",\\\"rule\\\":\\\"js:\\\\nvar document = {};\\\\nvar window = {\\\\n    location: {\\\\n        reload: function() {\\\\n            return;\\\\n        }\\\\n    }\\\\n};\\\\n\\\\n// 定义一个对象用于存储 cookie 名称和值的键值对\\\\nvar cookies = {};\\\\nObject.defineProperty(document, 'cookie', {\\\\n    enumerable: true,\\\\n    configurable: true,\\\\n    get: function() {\\\\n        return Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join('; ');\\\\n    },\\\\n    set: function(value) {\\\\n        var list = [];\\\\n        if (value.includes(';')) {\\\\n            list = value.split(';');\\\\n        } else {\\\\n            list = [value];\\\\n        }\\\\n        list.forEach(x => {\\\\n            var index = x.indexOf(\\\\\\\"=\\\\\\\");\\\\n            var key = x.substring(0, index).trim();\\\\n            var value = x.substring(index + 1);\\\\n            cookies[key] = value;\\\\n        })\\\\n    }\\\\n});\\\\n\\\\nfunction guard(url, headobj) {\\\\n    var head = headobj ? headobj:{\\\\n        headers: {\\\\n            Cookie: getCookie(url),\\\\n        }\\\\n    }\\\\n    var html = fetch(url, head);\\\\n    if (html.includes('_guard/auto.js')) {\\\\n        document[\\\\\\\"cookie\\\\\\\"] = getCookie(url);\\\\n        eval(fetch(getHome(url) + '/_guard/auto.js'))\\\\n        html = fetch(url, {\\\\n            headers: {\\\\n                Cookie: document[\\\\\\\"cookie\\\\\\\"],\\\\n            }\\\\n        });\\\\n    }\\\\n    //log(document[\\\\\\\"cookie\\\\\\\"])\\\\n    return html\\\\n}\\\\n\\\\nfunction csplit(a, b, c) {\\\\n    b = parseInt(b, 10) || 76;\\\\n    c = c || '\\\\\\\\r\\\\\\\\n';\\\\n    if (b < 1) {\\\\n        return false\\\\n    }\\\\n    return a.match(new RegExp(\\\\\\\".{0,\\\\\\\" + b + \\\\\\\"}\\\\\\\",\\\\\\\"g\\\\\\\")).join(c)\\\\n}\\\\n\\\\nfunction reurl(a) {\\\\n    var b = '';\\\\n    var c = csplit(a, 8).split('\\\\\\\\r\\\\\\\\n');\\\\n    for (var i = 0; i < (c.length - 1); i++) {\\\\n        b = b + String.fromCharCode((parseInt(c[i], 2) - 10).toString(10))\\\\n    }\\\\n    return b\\\\n}\\\"}]\",\"proxy\":\"\"}","picUrl":"https://www.fdns1.xyz/view/img/cang5.png","title":"番·仓________风吹花海轻舞，醉卧番仓梦乡。"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!