API tools faq
paste
xiaomianao666

小程序：DrpyHiker

xiaomianao666
Nov 4th, 2024
188
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 365.54 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@DrpyHiker@{"firstHeader":"class","last_chapter_rule":"","title":"DrpyHiker","author":"Aries","url":"hiker://empty##fypage","version":49,"col_type":"movie_3","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:$.require(\"MianLoad\");","search_url":"hiker://empty?s=**&page=fypage","group":"①推荐","searchFind":"js:\n(function () {\n  let {\n    ui_config,\n  } = $.require(\"UIManage\");\n  ui_config=ui_config.yi;\n\n  let smode = Number(getItem(\"smode\", \"0\"));\n  let temsmode = getMyVar(\"temsmode\", \"\");\n  if (temsmode) {\n    smode = Number(temsmode);\n    clearMyVar(\"temsmode\");\n  }\n  if (!fileExist(\"hiker://files/data/\" + MY_RULE.title + \"/libs_hiker/drpy2.js\")) return setResult([{\n    title: \"请前往小程序主页设置drpyPath\",\n    url: \"hiker://home@\" + MY_RULE.title\n  }]);\n  let runtimeConfig = GM.defineModule(\"runtimeConfig\");\n  let DrpyManage = GM.defineModule(\"DrpyManage\");\n  if (!runtimeConfig.isPrepared()) return setResult([{\n    title: \"请前往小程序主页设置源\",\n    url: \"hiker://home@\" + MY_RULE.title\n  }]);\n\n  if (smode === 0) {\n    let source = runtimeConfig.getCurrentSource();\n    if (!source.searchable) return setResult([{\n      title: \"当前源不支持搜索\",\n      url: \"hiker://empty\"\n    }]);\n    let drpy = DrpyManage.get(source.key);\n\n    let homeList = []\n    try {\n      homeList = JSON.parse(drpy.search(MY_KEYWORD, false, MY_PAGE)).list || [];\n    } catch { }\n    let d = [];\n    let skipEr = drpy.getRule(\"二级\") === \"*\" && getItem(\"skipEr\", \"\");\n\n    for (let it of homeList) {\n      let cid;\n      let id = String(it.vod_id);\n      let url = \"hiker://page/detailed\"+ui_config.mark;\n      if (skipEr) {\n        url = $().lazyRule((source, id, my) => {\n          let url;\n          try {\n            let DrpyManage = GM.defineModule(\"DrpyManage\");\n            let drpy = DrpyManage.getBySource(source);\n            url = JSON.parse(drpy.detail(id)).list[0].vod_play_url.split(\"$\")[1];\n          } catch (e) {\n            //log(e.message);\n            url = id.split(\"@@\")[0];\n          }\n          let result;\n          try {\n            result = $.require(\"videoUrl\").parse(url, id, source);\n          } catch (error) {\n            //log(error.message);\n          }\n          return result;\n        }, source, id, MY_RULE.title);\n        cid = id;\n      }\n\n      d.push({\n        title: it.vod_name,\n        desc: it.vod_remarks + \"·\" + source.name,\n        content: it.vod_content,\n        url: url,\n        pic_url: it.vod_pic,\n        col_type: \"movie_3\",\n        extra: {\n          id: cid,\n          vodId: id,\n          img: it.vod_pic,\n          sname: source.name,\n          skey: source.key,\n        }\n      });\n    }\n    setResult(d);\n  } else {\n    setResult([{\n      title: \"点我开始聚合搜索\" + MY_KEYWORD,\n      url: \"hiker://search?s=\" + MY_KEYWORD,\n      extra: {\n        delegateOnlySearch: true,\n        rules: $.toString(() => {\n          try {\n            let runtimeConfig = GM.defineModule(\"runtimeConfig\", \"runtimeConfig\");\n            let smode = Number(getItem(\"smode\", \"0\"));\n            let list = runtimeConfig.getAllowSearchSource(smode === 2);\n\n            let source = runtimeConfig.getCurrentSource();\n\n            let listi = list.findIndex(x => x.key == source.key);\n\n            let searchsort = Number(getItem(\"searchsort\", \"0\"));\n            let {\n              naturalSort,\n              usingSort\n            } = $.require(\"methods\");\n\n            if (searchsort > 0) {\n              if (searchsort == 1) {\n                naturalSort(list, \"name\");\n              } else if (searchsort == 2) {\n                usingSort.setkey(\"name\");\n                usingSort.get(list)\n              }\n            }\n\n            if (source.searchable && listi != -1) {\n              list.splice(list.indexOf(source), 1);\n              list.unshift(source);\n            }\n\n            let rules = [];\n            for (let it of list) {\n              rules.push({\n                title: it.name,\n                search_url: \"hiker://empty?page=fypage&searchTerms=**\",\n                searchFind: \"js:\" + $.toString((item) => {\n                  let {\n                    ui_config,\n                  } = $.require(\"UIManage\");\n                  ui_config=ui_config.yi;\n                \n                  let drpy = GM.defineModule(\"DrpyManage\").get(item.key);\n                  let homeList = JSON.parse(drpy.search(MY_KEYWORD, false, MY_PAGE)).list || [];\n                  let skipEr = drpy.getRule(\"二级\") === \"*\" && getItem(\"skipEr\", \"\");\n                  let d = [];\n                  for (let it of homeList) {\n                    let cid;\n                    let id = String(it.vod_id);\n                    let url = \"hiker://page/detailed\"+ui_config.mark;\n                    if (skipEr) {\n                      url = $().lazyRule((source, id, my) => {\n                        let url;\n                        try {\n                          let DrpyManage = GM.defineModule(\"DrpyManage\");\n                          let drpy = DrpyManage.getBySource(source);\n                          url = JSON.parse(drpy.detail(id)).list[0].vod_play_url.split(\"$\")[1];                 \n                        } catch (e) {\n                          //log(e.message);\n                          url = id.split(\"@@\")[0];\n                        }\n                        let result;\n                        try {\n                          result = $.require(\"videoUrl\").parse(url, id, source);\n                        } catch (error) {\n                          //log(error.message);\n                        }\n                        return result;\n                      }, item, id,MY_RULE._title);\n                      cid = id;\n                    }\n\n                    d.push({\n                      title: it.vod_name,\n                      desc: it.vod_remarks,\n                      content: it.vod_content,\n                      url: url,\n                      pic_url: it.vod_pic,\n                      col_type: \"movie_3\",\n                      extra: {\n                        id: cid,\n                        vodId: id,\n                        isPolymerize: true,\n                        img: it.vod_pic,\n                        sname: item.name,\n                        skey: item.key,\n                      }\n                    });\n                  }\n                  setResult(d);\n                }, it)\n              });\n            }\n            return JSON.stringify(rules);\n          } catch (e) {\n            log(e.toString());\n          }\n        })\n      }\n    }]);\n  }\n})()","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"/*<$>\n@include start\nhttp://hiker.nokia.press/hikerule/rulelist.json?id=6916&auth=1d35e8f0-22e8-5270-a9d1-826f53f177ad\n@include end\n<$>*/\n","pages":"[{\"col_type\":\"movie_3\",\"name\":\"drpy\",\"path\":\"drpy\",\"rule\":\"const skey = module.importParam;\\n\\nfunction initHiker() {\\n  const isCloseLog = !getItem(\\\"useLog\\\", \\\"\\\");\\n  const localKey = \\\"drpy\\\";\\n  const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n  globalThis.local = {\\n    set(rulekey, k, v) {\\n      storage0.setItem(localKey + \\\"@\\\" + rulekey + \\\"@\\\" + k, v);\\n    },\\n    get(rulekey, k, v) {\\n      return getItem(localKey + \\\"@\\\" + rulekey + \\\"@\\\" + k, \\\"\\\") || v;\\n    },\\n    delete(rulekey, k) {\\n      storage0.clearItem(localKey + \\\"@\\\" + rulekey + \\\"@\\\" + k);\\n    }\\n  };\\n  globalThis.getProxy = function () {\\n    return getMyVar(\\\"Proxy_Url\\\", \\\"http://127.0.0.1:52020/proxy\\\") + \\\"?hikerSkey=\\\" + encodeURIComponent(skey) + \\\"&do=js\\\";\\n  }\\n  eval(getCryptoJS());\\n  globalThis.CryptoJS = CryptoJS;\\n\\n  let $request = request;\\n  let $post = post;\\n\\n  function readFileToString(filePath) {\\n    const StringBuilder = java.lang.StringBuilder;\\n    const BufferedReader = java.io.BufferedReader;\\n    const File = java.io.File;\\n    const FileReader = java.io.FileReader;\\n\\n    let file = new File(filePath);\\n    if (!file.exists()) return \\\"\\\";\\n    let fileContent = new StringBuilder();\\n    let br = null;\\n    try {\\n      br = new BufferedReader(new FileReader(file));\\n      let line;\\n      while ((line = br.readLine()) != null) {\\n        fileContent.append(line).append(\\\"\\\\n\\\");\\n      }\\n    } catch (e) {\\n      fileContent.append(\\\"\\\");\\n    } finally {\\n      try {\\n        if (br != null) {\\n          br.close();\\n        }\\n      } catch (e) { }\\n    }\\n    return String(fileContent.toString());\\n  }\\n  function hasPropertyIgnoreCase(obj, propertyName) {\\n    return Object.keys(obj).some(key =>\\n      key.toLowerCase() === propertyName.toLowerCase()\\n    );\\n  }\\n  \\n  function valueStartsWith(obj, propertyName, prefix) {\\n    const key = Object.keys(obj).find(key =>\\n      key.toLowerCase() === propertyName.toLowerCase()\\n    );\\n    return key !== undefined && obj[key].startsWith(prefix);\\n  }\\n\\n  globalThis.req = function (url, cobj) {\\n    try {\\n      let res = {};\\n      let obj = Object.assign({}, cobj);\\n      if (obj.data) {\\n        obj.body = obj.data;\\n        if ((obj.postType && obj.postType == \\\"form\\\") || (hasPropertyIgnoreCase(obj.headers, \\\"Content-Type\\\") && valueStartsWith(obj.headers, \\\"Content-Type\\\", \\\"application/x-www-form-urlencoded\\\"))) {\\n          let temp_obj = obj.data;\\n          obj.body = Object.keys(temp_obj).map(key => {\\n            return `${key}=${temp_obj[key]}`;\\n          }).join('&');\\n        }\\n        delete obj.data;\\n      }\\n\\n      if (obj.hasOwnProperty(\\\"redirect\\\")) obj.redirect = !!obj.redirect;\\n      if (obj.buffer === 2) {\\n        obj.toHex = true;\\n      }\\n      obj.headers = Object.assign({\\n        Cookie: \\\"#noCookie#\\\"\\n      }, obj.headers);\\n      if (url === \\\"https://api.nn.ci/ocr/b64/text\\\" && obj.headers) {\\n        obj.headers[\\\"Content-Type\\\"] = \\\"text/plain\\\";\\n      }\\n      let isFile = url.startsWith(\\\"file://\\\");\\n      if (isFile && (url.includes(\\\"?type=\\\") || url.includes(\\\"?params=\\\"))) {\\n        url = url.slice(0, url.lastIndexOf(\\\"?\\\"));\\n      }\\n      for (let key in obj.headers) {\\n        if (typeof obj.headers[key] !== \\\"string\\\") {\\n          obj.headers[key] = String(obj.headers[key]);\\n        }\\n      }\\n      let r = \\\"\\\";\\n      if (isFile) {\\n        r = readFileToString(url.replace(\\\"file://\\\", \\\"\\\"));\\n      } else {\\n        r = $request(url, obj);\\n      }\\n      if (obj.withHeaders) {\\n        r = JSON.parse(r);\\n        res.content = r.body;\\n        res.headers = {};\\n        for (let [k, v] of Object.entries(r.headers || {})) {\\n          res.headers[k] = v[0];\\n        }\\n      } else {\\n        res.content = r;\\n      }\\n      if (obj.buffer === 2) {\\n        res.content = CryptoUtil.Data.parseHex(res.content).toBase64(_base64.NO_WRAP);\\n      }\\n      return res;\\n    } catch (e) {\\n      log(\\\"Error\\\" + e.toString());\\n    }\\n  }\\n  /*\\n  const JinJa = $.require(\\\"https://cdn.bootcdn.net/ajax/libs/mustache.js/4.1.0/mustache.js\\\");\\n \\n  const JP = $.require(\\\"https://jsonpath-plus.github.io/JSONPath/dist/index-browser-umd.cjs\\\");\\n  globalThis.cheerio = {\\n      jinja2(template, obj) {\\n          \\n          return $.log(JinJa.render(template, obj));\\n      },\\n      jp(path, json) {\\n          return JP.JSONPath({\\n              path,\\n              json\\n          })[0];\\n      }\\n  }*/\\n  globalThis.pdfa = _pdfa;\\n  \\n  globalThis.pd = _pd;\\n  globalThis.pdfh = _pdfh;\\n  String.prototype.replaceAll = function (search, replacement) {\\n    return this.split(search).join(replacement);\\n  };\\n  let $toString = Function.prototype.toString;\\n  Function.prototype.toString = function () {\\n    return $toString.apply(this).trim();\\n  };\\n  if (isCloseLog) {\\n    // 重写console.log函数\\n    console.log = function () {\\n      // 检查传入参数的数量\\n      if (arguments.length > 1) {\\n        // 如果参数数量大于1，调用原始的console.log函数\\n        //originalLog.apply(console, arguments);\\n      } else {\\n        return;\\n      }\\n      // 如果参数只有一个，则不做任何操作\\n    };\\n  }\\n}\\ninitHiker();\\nconst drpyPath = getPath(\\\"hiker://files/data/\\\" + MY_RULE.title + \\\"/libs_hiker/drpy2.js\\\");\\n\\nif (!fileExist(drpyPath)) {\\n  throw new Error(\\\"缺少drpy.js运行库\\\");\\n}\\nlet drpy = $.require(drpyPath);\\n/*\\nlet currentPath = \\\"\\\";\\nlet $init = drpy.init;\\ndrpy.init = function(ext) {\\n    if (ext === currentPath) return;\\n    $init.call(this, ext);\\n    currentPath = ext;\\n}*/\\nfunction sync(func, sp) {\\n  return new org.mozilla.javascript.Synchronizer(func, sp || {});\\n}\\n//drpy.proxy = sync(drpy.proxy, drpy);\\ndrpy.play = sync(drpy.play, drpy);\\n$.exports = drpy;\"},{\"col_type\":\"movie_1_vertical_pic_blur\",\"name\":\"详细页面\",\"path\":\"detailed\",\"rule\":\"js:\\n(function () {\\n  let cover_col = \\\"movie_1_vertical_pic_blur\\\";\\n  let head_img = \\\"\\\";\\n  if (MY_URL.includes(\\\"#gameTheme#\\\")) {\\n    cover_col = \\\"movie_1_vertical_pic\\\";\\n    head_img = \\\"https://hikerfans.com/img/top.png\\\";\\n  }\\n\\n  let id = MY_PARAMS.vodId;\\n  addListener(\\\"onClose\\\", () => {\\n    GM.clear(\\\"renovateList\\\");\\n    clearMyVar(\\\"sorti\\\");\\n    clearMyVar(\\\"pagenum\\\");\\n    clearMyVar(\\\"nopage\\\");\\n    clearMyVar(\\\"playlist_ready\\\");\\n  });\\n  addListener('onRefresh', $.toString((id) => {\\n    //clearMyVar(id + \\\"erinfo\\\")\\n    clearMyVar(\\\"playlist_ready\\\");\\n    clearMyVar(\\\"showi\\\");\\n  }, id))\\n\\n  let {\\n    ui_config,\\n    getLineShow,\\n  } = $.require(\\\"UIManage\\\");\\n  let er=ui_config.er;\\n\\n  //方法\\n  let {\\n    cacheManage,\\n    isDarkMode,\\n    fontstyle,\\n    backColor,\\n    findLongestElement,\\n    countTotalBytes,\\n    insertArrayAt,\\n    historylog,\\n    stringex,\\n    arrayex,\\n    getEInfo,\\n    erOptions,\\n    substr\\n  } = $.require(\\\"methods\\\");\\n\\n  stringex();\\n  arrayex();\\n  erOptions.set(\\\"skey\\\", MY_PARAMS.skey);\\n  erOptions.set(\\\"id\\\", id);\\n  /*let orginupdateItem = globalThis.updateItem;\\n  globalThis.updateItem = function (key, obj) {\\n    //log(key)\\n    orginupdateItem(key, obj);\\n  }*/\\n\\n  let {\\n    setDesc,\\n    findIcon,\\n  } = $.require(\\\"methods_er\\\");\\n\\n  let sortobj = [{\\n    title: fontstyle(\\\"↿\\\", {\\n      h: false,\\n      c: \\\"#1AAD19\\\",\\n      tags: \\\"b\\\"\\n    }) + fontstyle(\\\"⇂\\\", {\\n      h: false,\\n      tags: \\\"b\\\"\\n    }) + \\\"\\\\t\\\",\\n    img: er.icons.正序\\n  },\\n  {\\n    title: fontstyle(\\\"↿\\\", {\\n      h: false,\\n      tags: \\\"b\\\"\\n    }) + fontstyle(\\\"⇂\\\", {\\n      h: false,\\n      c: \\\"#FF0000\\\",\\n      tags: \\\"b\\\"\\n    }) + \\\"\\\\t\\\",\\n    img: er.icons.倒序\\n  }\\n  ]\\n\\n  var sorti = getMyVar(\\\"sorti\\\", \\\"0\\\");\\n\\n  //log(sortobj)\\n  $.extend({\\n    er_ui: er,\\n    splitPage(totalItems, pageSize) {\\n      pageSize = Number(pageSize);\\n      let result = [];\\n      if (pageSize == 0) {\\n        return [`1-${totalItems}`]\\n      }\\n      for (let i = 1; i <= totalItems; i += pageSize) {\\n        let end = i + pageSize - 1;\\n        if (end > totalItems) {\\n          end = totalItems;\\n        }\\n        result.push(`${i}-${end}`);\\n      }\\n      return result;\\n    },\\n    splitArrayByRanges(array, ranges) {\\n      // 根据范围拆分数组\\n      var result = ranges.map(function (range) {\\n        var parts = range.split('-').map(Number);\\n        var start = parts[0] - 1; // 减1是因为数组索引从0开始\\n        var end = parts[1] - 1;\\n        // 使用Array.prototype.slice来获取子数组\\n        return array.slice(start, end + 1); // 包括结束索引，所以加1\\n      });\\n      return result;\\n    },\\n  })\\n\\n  let source = {};\\n  if (MY_PARAMS.source) {\\n    source = MY_PARAMS.source;\\n  } else {\\n    const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n    source = runtimeConfig.findSource(MY_PARAMS.skey);\\n    MY_PARAMS.source = source;\\n    setPageParams(MY_PARAMS);\\n  }\\n\\n  const DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n\\n  DrpyManage.initPage(\\\"er\\\");\\n\\n  let drpy = DrpyManage.getBySource(source);\\n  let stype = drpy.getRule(\\\"类型\\\");\\n  /*\\nlet info = storage0.getMyVar(id + \\\"erinfo\\\", \\\"\\\");\\n\\nif (info == \\\"\\\") {\\n  info = JSON.parse(drpy.detail(String(id))).list[0];\\n    storage0.putMyVar(id + \\\"erinfo\\\", info)\\n  }\\n  */\\n  let [lfc, lbc] = er.浅来源色.split(/;/).filter(e => e);\\n  let [nfc, nbc] = er.深来源色.split(/;/).filter(e => e);\\n  let darkmode = isDarkMode();\\n  let cs = {\\n    //fc: '#737A80',\\n    fc: lfc,\\n    bc: lbc,\\n    //bc: '#F7F8FA',\\n  }\\n  if (darkmode) {\\n    cs = {\\n      fc: nfc,\\n      bc: nbc,\\n    }\\n  }\\n\\n  let info = cacheManage.get(MY_PARAMS.sname + id);\\n  if (Object.keys(info).length == 0) {\\n    info = JSON.parse(drpy.detail(String(id))).list[0];\\n    if (er.二级缓存) {\\n      cacheManage.set(MY_PARAMS.sname + id, info);\\n    }\\n  }\\n\\n  let [导演, 主演] = [info.vod_director, info.vod_actor]\\n  if (MY_PARAMS.img == undefined || MY_PARAMS.img == \\\"\\\") {\\n    if (info.vod_pic != \\\"\\\") {\\n      setPagePicUrl(info.vod_pic);\\n      MY_PARAMS.img = info.vod_pic;\\n      setPageParams(MY_PARAMS);\\n    }\\n  }\\n  导演 = 导演 == \\\"导演\\\" ? undefined : 导演\\n  主演 = 主演 == \\\"主演\\\" ? undefined : 主演\\n  if (导演 != undefined && 导演 != \\\"\\\") {\\n    导演 = String(导演).Split(/\\\\//g, true).join(\\\" \\\");\\n    导演 = /[:：]/.test(导演) ? 导演 : \\\"导演:\\\" + 导演\\n  }\\n  if (主演 != undefined && 主演 != \\\"\\\") {\\n    主演 = String(主演).Split(/\\\\//g, true).join(\\\" \\\");\\n    主演 = /[:：]/.test(主演) ? 主演 : \\\"主演:\\\" + 主演\\n  }\\n  let [名称, 备注] = [info.vod_name, info.vod_remarks]\\n  if (备注 != undefined && 备注 != \\\"\\\") {\\n    备注 = String(备注).Split(/\\\\//g, true).join(\\\" \\\");\\n    备注 = /[:：]/.test(备注) ? 备注 : \\\"备注:\\\" + 备注;\\n  }\\n  let titles = [名称, 备注];\\n  info.vod_area = String(info.vod_area).Split(/\\\\//g, true).join(\\\" \\\");\\n  info.vod_year = String(info.vod_year).Split(/\\\\//g, true).join(\\\" \\\");\\n  let descs = [导演, 主演, info.vod_area, info.vod_year];\\n\\n  // titles.push(\\n  //   fontstyle(fontstyle(\\\"来源: \\\", { h: false, tags: \\\"b\\\" }) + backColor(MY_PARAMS.sname, cs), { h: false, tags: \\\"small|small\\\" })\\n  // )\\n\\n  insertArrayAt(titles, 1, '““””' + fontstyle(fontstyle(\\\"来源: \\\", { h: false, tags: \\\"b\\\" }) + backColor(MY_PARAMS.sname, cs), { h: false, tags: \\\"small\\\" })\\n  )\\n\\n  let d = [];\\n  if (head_img != \\\"\\\") {\\n    d.push({\\n      pic_url: \\\"https://hikerfans.com/img/top.png\\\",\\n      url: \\\"hiker://empty\\\",\\n      col_type: \\\"pic_1_full\\\"\\n    })\\n  }\\n\\n  d.push({\\n    title: titles.filter(e => e).map((x, i) => i > 1 ? fontstyle(x, {\\n      tags: \\\"small\\\"\\n    }) : x).join(\\\"\\\\n\\\"),\\n    desc: descs.filter(e => e && e != \\\"undefined\\\").join(\\\"\\\\n\\\"),\\n    url: \\\"hiker://empty\\\",\\n    img: info.vod_pic || MY_PARAMS.img,\\n    col_type: cover_col,\\n    extra: {\\n      gradient: false,\\n      lineVisible: false,\\n      longClick: [{\\n        title: \\\"二级设置\\\",\\n        js: $.toString(() => {\\n          return \\\"hiker://page/UIManage?mode=二级#noRecordHistory##noHistory#\\\";\\n        })\\n      }]\\n    }\\n  });\\n\\n  /*d.push({\\n    title: '数据来源',\\n    desc: \\\"\\\" + backColor(MY_PARAMS.sname, cs) + \\\"\\\\t\\\",\\n    img: \\\"https://hikerfans.com/tubiao/messy/110.svg\\\",\\n    url: \\\"hiker://empty\\\",\\n    col_type: \\\"avatar\\\"\\n  })*/\\n  setDesc(d, info.vod_content)\\n\\n  let from = [];\\n  if (info.vod_play_from != undefined) {\\n    from = info.vod_play_from.split(\\\"$$$\\\");\\n  }\\n\\n  let playLazy = $(\\\"\\\").lazyRule((source) => {\\n    return $.require(\\\"videoUrl\\\").parse(input, input.split(\\\"#\\\")[0], source);\\n  }, source);\\n\\n  let pageszie = er.分页;\\n\\n  let playUrlList = [];\\n  //console.log(info.vod_play_url);\\n  let isNovel = stype === \\\"小说\\\";\\n  let playpages = [];\\n\\n  if (info.vod_play_url && info.vod_play_url != \\\"\\\" && info.vod_play_url.split(\\\"$$$\\\").filter(e => e).length > 0) {\\n    let col = \\\"text_4\\\";\\n    let textalign = \\\"\\\";\\n    playUrlList = info.vod_play_url.split(\\\"$$$\\\").map((t, i) => {\\n      let img = \\\"\\\";\\n      let ts = t.split(\\\"#\\\").map((k) => k.split(\\\"$\\\")[0]);\\n      let pages = $.splitPage(ts.length, pageszie);\\n      let tc = countTotalBytes(findLongestElement(ts));\\n      if (ts.filter(e => e != \\\"\\\").length) {\\n        playpages[i] = pages;\\n      }\\n      if (tc > 24) {\\n        col = \\\"text_1\\\";\\n        img = MY_PARAMS.img || \\\"https://hikerfans.com/tubiao/movie/146.svg\\\";\\n      } else if (tc >= 12 && tc < 15) {\\n        col = \\\"text_3\\\";\\n      } else if (tc >= 15) {\\n        col = \\\"text_2\\\";\\n        textalign = \\\"left\\\";\\n      }\\n      let playobj = t.split(\\\"#\\\").map((j, ii) => {\\n        let k = j.split(\\\"$\\\");\\n        let t = k[0];\\n        let uid = (k[1] || k[0]);\\n        return {\\n          stitle: t,\\n          title: fontstyle(t, {\\n            tags: \\\"small\\\"\\n          }),\\n          surl: uid + \\\"#\\\" + from[i],\\n          url: isNovel ? \\\"hiker://page/novel#autoPage##readTheme#\\\" : (uid + \\\"#\\\" + from[i] + playLazy),\\n          col_type: col,\\n          img: img,\\n          /*extra: Object.assign({}, extra, {\\n            \\\"Referer\\\": decodeURIComponent(k[1]),\\n            id: k[1],\\n            //lineVisible: false,\\n            textAlign: textalign,\\n            cls: \\\"playlist\\\",\\n          })*/\\n          extra: {\\n            from: from[i],\\n            source: source,\\n            id: uid,\\n            blockRules: ['bb.*.png', '.jpg', \\\"hm\\\\.baidu\\\\.com\\\\/hm.js\\\"],\\n            videoExcludeRules: ['?url='],\\n            lineVisible: false,\\n            textAlign: textalign,\\n            cls: \\\"playlist\\\",\\n          }\\n        };\\n      });\\n\\n      if ((stype == \\\"漫画\\\" || stype == \\\"小说\\\") && i == 0) {\\n\\n        var downloadlazy = $.toString((key, skey, title) => {\\n          let drpy;\\n          if ($.hiker[\\\"__drpy__\\\"]) {\\n            drpy = $.hiker[\\\"__drpy__\\\"];\\n\\n          } else {\\n            let {\\n              GM\\n            } = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6916&auth=1d35e8f0-22e8-5270-a9d1-826f53f177ad\\\");\\n            GM.setSelfKey(key);\\n            let DrpyManage = GM.defineModule(\\\"DrpyManage\\\", \\\"DrpyManage?rule=\\\" + title);\\n            drpy = DrpyManage.get(skey);\\n            $.hiker[\\\"__drpy__\\\"] = drpy;\\n            $.hiker[\\\"__test__\\\"] = [];\\n          }\\n          input = input.split(\\\"#\\\");\\n          let result = JSON.parse(drpy.play(input[1], input[0]));\\n          if (result.url.startsWith(\\\"pics://\\\")) {\\n            return result.url;\\n          } else if (result.url.startsWith(\\\"novel://\\\")) {\\n            let content = JSON.parse(result.url.replace(\\\"novel://\\\", \\\"\\\")).content;\\n            let cmd5 = md5(content);\\n            let index = 0;\\n            if ((index = $.hiker[\\\"__test__\\\"].indexOf(cmd5)) !== -1) {\\n              log(\\\"重复：\\\" + input + \\\"=>\\\" + index);\\n            }\\n            $.hiker[\\\"__test__\\\"].push(cmd5);\\n            return content;\\n          }\\n          throw new Error(\\\"漫画或正文获取失败\\\");\\n        }, GM.getSelfKey(), MY_PARAMS.skey, MY_RULE.title);\\n\\n        let chapterList = playobj.excludeKeys([\\\"surl\\\", \\\"stitle\\\"], false).transformKeys({\\n          \\\"surl\\\": \\\"url\\\",\\n          \\\"stitle\\\": \\\"title\\\"\\n        });\\n        writeFile(\\\"hiker://files/_cache/dr_dow_list.json\\\", JSON.stringify(chapterList));\\n        d.push({\\n          title: \\\"下载\\\" + stype,\\n          url: 'hiker://page/download.view#noRecordHistory##noRefresh#?rule=本地资源管理',\\n          col_type: 'scroll_button',\\n          extra: {\\n            chapterList: \\\"hiker://files/_cache/dr_dow_list.json\\\",\\n            info: {\\n              bookName: info.vod_name, //漫画名称,\\n              ruleName: MY_RULE.title,\\n              bookTopPic: info.vod_pic,\\n              parseCode: downloadlazy,\\n              bookId: MY_PARAMS.sname,\\n              type: stype === \\\"漫画\\\" ? \\\"comic\\\" : \\\"novel\\\",\\n            },\\n            defaultView: \\\"1\\\"\\n          }\\n        });\\n        d.push({\\n          title: \\\"本地书架\\\",\\n          url: 'hiker://page/Bookrack.view#noRecordHistory#?rule=本地资源管理&ruleName=' + MY_RULE.title,\\n          col_type: 'scroll_button',\\n          extra: {\\n            type: stype === \\\"漫画\\\" ? \\\"comic\\\" : \\\"novel\\\",\\n          }\\n        }, {\\n          col_type: 'blank_block'\\n        });\\n      }\\n\\n      playobj = $.splitArrayByRanges(playobj, pages);\\n      return playobj;\\n    });\\n  } else {\\n    d.push({\\n      col_type: \\\"line\\\"\\n    }, {\\n      title: \\\"暂无播放源或播放列表定位错误\\\",\\n      col_type: \\\"text_center_1\\\",\\n      url: MY_PARAMS.vodId,\\n    });\\n    setResult(d);\\n  }\\n\\n\\n  let currentLocation = 0;\\n\\n  if (from.length) {\\n    erOptions.set(\\\"from\\\", from);\\n    erOptions.set(\\\"total\\\", playUrlList.map(x => x.length));\\n    erOptions.set(\\\"plays\\\", playUrlList.map(x => x.flat().length));\\n  }\\n\\n\\n  function renovateList(location) {\\n    //deleteItemByCls(\\\"playpage\\\");\\n    //deleteItemByCls(\\\"playlist\\\");\\n\\n    if (playUrlList.length == 0) {\\n      return;\\n    }\\n    let his = historylog(\\\"get\\\", MY_PARAMS.skey, md5(MY_PARAMS.vodId));\\n\\n\\n    let pagenum = getMyVar(\\\"pagenum\\\", (his || \\\"0\\\"));\\n\\n    let pcount = playUrlList[location].length;\\n    let list = playUrlList[location][pagenum];\\n    if (!list) {\\n      for (let i = pagenum; i >= 0; i--) {\\n        list = playUrlList[location][i];\\n        if (list) {\\n          pagenum = i;\\n          break;\\n        }\\n      }\\n    }\\n    if (getMyVar(\\\"sorti\\\", \\\"0\\\") == 1) {\\n      list.reverse();\\n    }\\n    $.extend({\\n      temp_list: playUrlList[location],\\n    })\\n    let playp = playpages[location];\\n    if (playp == undefined) {\\n      playp = [];\\n    }\\n    let tplay = playp.slice();\\n\\n    //deleteItemByCls(\\\"playpage\\\")\\n    //playp && playp.length > 1\\n    //erOptions.get(\\\"total\\\").some(x=>x>1)\\n    let bool = (!er.分页逻辑 || er.分页逻辑 == \\\"0\\\" ? erOptions.get(\\\"total\\\").some(x => x > 1) : playp && playp.length > 1);\\n\\n    if (bool) {\\n      if (playp && playp.length > 1) {\\n        erOptions.set(\\\"playp\\\", playp);\\n      }\\n      historylog(\\\"set\\\", MY_PARAMS.skey, md5(MY_PARAMS.vodId), {\\n        title: info.vod_name,\\n        page: pagenum,\\n        date: new Date().getTime()\\n      });\\n      let temp = {\\n        col_type: 'text_1',\\n        extra: {\\n          cls: \\\"pagenav\\\"\\n        }\\n      }\\n\\n      tplay = playp.map((x, i) => {\\n        let obj = Object.assign({}, temp, {\\n          title: '““””' + (pagenum == i ? x.fontcolor(er.线路颜色) : x),\\n          col_type: \\\"scroll_button\\\",\\n          url: $('#noLoading#').lazyRule((i, id, pagenum) => {\\n            let location = getMyVar(id + \\\"sourcei\\\", \\\"0\\\");\\n            if (getMyVar(\\\"pagenum\\\", pagenum) == i) {\\n              return \\\"hiker://empty\\\"\\n            }\\n            putMyVar(\\\"pagenum\\\", String(i));\\n            let err = $.require(\\\"methods\\\").erRefresh;\\n            return err(location);\\n          }, i, id, pagenum),\\n          extra: Object.assign({}, temp.extra, {\\n            id: \\\"pagenum\\\" + i,\\n          })\\n        })\\n        return obj;\\n      })\\n\\n      let fc = \\\"\\\";\\n      if (!(playp && playp.length > 1)) {\\n        fc = \\\"grey\\\";\\n      }\\n\\n      let pageobj = [{\\n        title: fontstyle('上一页', {\\n          c: fc\\n        }),\\n        col_type: \\\"text_4\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((id, pcount, pagenum) => {\\n          let location = getMyVar(id + \\\"sourcei\\\", \\\"0\\\");\\n          let ef = $.require(\\\"methods\\\").getEInfo();\\n          let pcount = ef.max[location];\\n          let pagenum = ef.pagenum;\\n          if (pcount == 1) {\\n            return \\\"hiker://empty\\\";\\n          }\\n          if (pagenum == 0) {\\n            pagenum = pcount - 1;\\n          } else {\\n            pagenum--;\\n          }\\n          putMyVar(\\\"pagenum\\\", String(pagenum));\\n          let err = $.require(\\\"methods\\\").erRefresh;\\n          return err(location);\\n        }, id, pcount, String(pagenum)),\\n        extra: {\\n          cls: \\\"playpage\\\",\\n          id: \\\"playpage@up\\\"\\n        }\\n      }, {\\n        title: fontstyle(playp[pagenum], {\\n          c: fc\\n        }),\\n        col_type: \\\"text_2\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((id, pagenum) => {\\n          let location = getMyVar(id + \\\"sourcei\\\", \\\"0\\\");\\n          let pagenum = getMyVar(\\\"pagenum\\\", pagenum);\\n          let ef = $.require(\\\"methods\\\").getEInfo();\\n          let pcount = ef.max[location];\\n          if (pcount == 1) {\\n            return \\\"hiker://empty\\\";\\n          }\\n          let playp = ef.playp;\\n          let er = $.require(\\\"UIManage\\\").ui_config.er;\\n          er.线路样式 = er.线路样式||'scroll_button';\\n          let pagearr = playp.map((x, i) => i == pagenum ? '““””' + x.fontcolor(er.线路颜色) : x);\\n          return $(pagearr, 3).select((location, er) => {\\n            putMyVar(\\\"pagenum\\\", String(MY_INDEX));\\n            if (er.二级刷新) {\\n              clearMyVar(\\\"playlist_ready\\\");\\n              refreshPage(false);\\n            } else {\\n              GM.get(\\\"renovateList\\\", () => { })(location);\\n            }\\n            return \\\"hiker://empty\\\";\\n          }, location, er)\\n        }, id, pagenum),\\n        extra: {\\n          cls: \\\"playpage\\\",\\n          id: \\\"playpage@pagearr\\\",\\n        }\\n      }, {\\n        title: fontstyle('下一页', {\\n          c: fc\\n        }),\\n        col_type: \\\"text_4\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n          let location = getMyVar(id + \\\"sourcei\\\", \\\"0\\\");\\n          let ef = $.require(\\\"methods\\\").getEInfo();\\n          let pcount = ef.max[location];\\n          let pagenum = ef.pagenum;\\n          if (pcount == 1) {\\n            return \\\"hiker://empty\\\";\\n          }\\n\\n          if (pagenum >= pcount - 1) {\\n            pagenum = 0;\\n          } else {\\n            pagenum++;\\n          }\\n          putMyVar(\\\"pagenum\\\", String(pagenum));\\n          let err = $.require(\\\"methods\\\").erRefresh;\\n          return err(location);\\n        }, id),\\n        extra: {\\n          cls: \\\"playpage\\\",\\n          id: \\\"playpage@next\\\"\\n        }\\n      }]\\n\\n      if (er.分页导航) {\\n        pageobj = pageobj.concat(tplay);\\n      }\\n\\n      let pline = d.findIndex(x => x.extra && x.extra.id == \\\"playpageline\\\");\\n\\n      if (getMyVar(\\\"playlist_ready\\\", \\\"0\\\") == \\\"0\\\") {\\n        if (pline > -1) {\\n          insertArrayAt(d, pline + 1, pageobj);\\n        }\\n        //Array.prototype.push.apply(d,pageobj);\\n        //addItemAfter(\\\"playpageline\\\", pageobj);\\n      } else {\\n        if (getMyVar(\\\"nopage\\\", \\\"0\\\") == \\\"1\\\") {\\n          addItemAfter(\\\"playpageline\\\", pageobj);\\n          clearMyVar(\\\"nopage\\\");\\n        }\\n        if (!er.二级刷新) {\\n          updateItem(\\\"playpage@up\\\", {\\n            title: pageobj[0].title,\\n          })\\n          updateItem(\\\"playpage@pagearr\\\", {\\n            title: pageobj[1].title,\\n          })\\n          updateItem(\\\"playpage@next\\\", {\\n            title: pageobj[2].title,\\n          })\\n        }\\n        if (er.分页导航) {\\n          if (!er.二级刷新) {\\n            let pn = findItemsByCls(\\\"pagenav\\\")\\n            if (pn.length > playp.length) {\\n              pn = pn.slice(playp.length)\\n              pn.map(x => {\\n                deleteItem(x.extra.id)\\n              })\\n            }\\n            if (pn.length < playp.length) {\\n              let pid = pn.at(-1);\\n              let add = tplay.slice(pn.length);\\n              addItemAfter(pid.extra.id, add);\\n            }\\n            tplay.forEach((x, i) => {\\n              updateItem(\\\"pagenum\\\" + i, {\\n                title: x.title,\\n              })\\n            })\\n          }\\n        }\\n      }\\n\\n      // addItemAfter(\\\"playpageline\\\", [{\\n      //   title: '上一页',\\n      //   col_type: \\\"text_4\\\",\\n      //   url: $(\\\"#noLoading#\\\").lazyRule((location, pcount) => {\\n      //     let pagenum = getMyVar(\\\"pagenum\\\", \\\"0\\\");\\n      //     if (pagenum == 0) {\\n      //       pagenum = pcount - 1;\\n      //     } else {\\n      //       pagenum--;\\n      //     }\\n      //     putMyVar(\\\"pagenum\\\", String(pagenum));\\n      //     GM.get(\\\"renovateList\\\", () => { })(location);\\n      //     return \\\"hiker://empty\\\";\\n      //   }, location, pcount),\\n      //   extra: {\\n      //     cls: \\\"playpage\\\"\\n      //   }\\n      // }, {\\n      //   title: playp[pagenum],\\n      //   col_type: \\\"text_2\\\",\\n      //   url: $(pagearr, 3).select((location) => {\\n      //     putMyVar(\\\"pagenum\\\", String(MY_INDEX));\\n      //     GM.get(\\\"renovateList\\\", () => { })(location);\\n      //     return \\\"hiker://empty\\\"\\n      //   }, location),\\n      //   extra: {\\n      //     cls: \\\"playpage\\\"\\n      //   }\\n      // }, {\\n      //   title: '下一页',\\n      //   col_type: \\\"text_4\\\",\\n      //   url: $(\\\"#noLoading#\\\").lazyRule((location, pcount) => {\\n      //     let pagenum = getMyVar(\\\"pagenum\\\", \\\"0\\\");\\n      //     if (pagenum >= pcount - 1) {\\n      //       pagenum = 0;\\n      //     } else {\\n      //       pagenum++;\\n      //     }\\n      //     putMyVar(\\\"pagenum\\\", String(pagenum));\\n      //     GM.get(\\\"renovateList\\\", () => { })(location);\\n      //     return \\\"hiker://empty\\\";\\n      //   }, location, pcount),\\n      //   extra: {\\n      //     cls: \\\"playpage\\\"\\n      //   }\\n      // }])\\n      /*playp = playp.map((x, i) => {\\n         let obj = Object.assign({}, temp, {\\n           title: '““””' + (pagenum == i ? x.fontcolor(\\\"red\\\") : x),\\n           col_type:\\\"scroll_button\\\",\\n           url: $('#noLoading#').lazyRule((i) => {\\n             if (getMyVar(\\\"pagenum\\\") == i) {\\n               return \\\"hiker://empty\\\"\\n             }\\n             putMyVar(\\\"pagenum\\\", String(i));\\n             deleteItemByCls(\\\"playlist\\\");\\n             addItemAfter(\\\"playlists\\\", $.temp_list[i]);\\n             findItemsByCls(\\\"playpage\\\").forEach((x, ii) => {\\n               let title = x.title.replace(/‘|’|“|”|<[^>]+>/g, \\\"\\\");\\n               if (ii == i) {\\n                 title = '““””' + title.fontcolor(\\\"red\\\");\\n               }\\n               updateItem(x.extra.id, {\\n                 title: title,\\n               })\\n             })\\n             return \\\"hiker://empty\\\";\\n           }, i),\\n           extra: Object.assign({}, temp.extra, {\\n             id: \\\"pagenum\\\" + i,\\n           })\\n         })\\n         return obj;\\n       })\\n       addItemAfter(\\\"playpageline\\\", playp)*/\\n    } else {\\n      deleteItemByCls(\\\"pagenav\\\");\\n      deleteItemByCls(\\\"playpage\\\");\\n      putMyVar(\\\"nopage\\\", \\\"1\\\");\\n    }\\n\\n    if (getMyVar(\\\"playlist_ready\\\", \\\"0\\\") == \\\"1\\\") {\\n      let oldIds = (findItemsByCls('playlist') || []).map(it => it.extra.id);\\n      let toDeleteIds = []; //待删除的旧id\\n      let toAddDatas = []; //待新增的新数据\\n      if (oldIds.length > list.length) {\\n        toDeleteIds = oldIds.slice(list.length);\\n      } else if (oldIds.length < list.length) {\\n        toAddDatas = list.slice(oldIds.length)\\n      }\\n      let cnt = Math.min(oldIds.length, list.length);\\n      if (toDeleteIds.length > 0) {\\n        //有删除的先删除\\n        deleteItem(toDeleteIds);\\n        /*toDeleteIds.forEach(id=>{\\n          deleteItem(id);\\n        })*/\\n      }\\n      if (toAddDatas.length > 0) {\\n        //有新增的先新增\\n        addItemAfter(oldIds[cnt - 1], toAddDatas);\\n      }\\n      //showLoading('加载中')\\n      for (let i = 0; i < cnt; i++) {\\n        //最后顺序更新\\n        updateItem(oldIds[i], list[i]);\\n      }\\n    } else {\\n\\n      //log(list.length)\\n      if (list) {\\n        let pls = d.findIndex(x => x.extra && x.extra.id == \\\"playlists\\\");\\n        if (pls > -1) {\\n          insertArrayAt(d, pls + 1, list);\\n        }\\n        //Array.prototype.push.apply(d,list);\\n        //addItemAfter(\\\"playlists\\\", list);\\n        putMyVar(\\\"playlist_ready\\\", \\\"1\\\");\\n      }\\n    }\\n\\n    /*let pagelines = findItemsByCls(\\\"location@\\\");\\n    if (getMyVar(\\\"playlist_ready\\\", \\\"0\\\") == \\\"1\\\") {\\n      pagelines=pagelines.map(x=>{\\n        x.col_type=x.type;\\n        return x;\\n      })\\n      deleteItemByCls(\\\"location@\\\");\\n      addItemBefore(\\\"playpageline\\\", pagelines);\\n    }*/\\n\\n    /*if (list) {\\n      deleteItemByCls(\\\"playlist\\\");\\n      let pls = d.findIndex(x => x.extra && x.extra.id == \\\"playlists\\\");\\n      if (pls > -1) {\\n        insertArrayAt(d, pls + 1, list);\\n      }\\n      //Array.prototype.push.apply(d,list);\\n      addItemAfter(\\\"playlists\\\", list);\\n      putMyVar(\\\"playlist_ready\\\", \\\"1\\\");\\n    }*/\\n    if (!er.二级刷新) {\\n      updateItem(\\\"location@\\\" + currentLocation, {\\n        title: fontstyle(from[currentLocation], {\\n          tags: \\\"small\\\"\\n        }, er.线路样式),\\n      });\\n\\n      updateItem(\\\"location@\\\" + location, {\\n        title: fontstyle(from[location], {\\n          c: er.线路颜色,\\n          tags: \\\"small\\\"\\n        }, er.线路样式)\\n      });\\n    }\\n\\n    let ef = $.require(\\\"methods\\\").getEInfo();\\n    if (!er.二级刷新) {\\n      updateItem(\\\"@sort\\\", {\\n        title: getLineShow(ef),\\n        desc: `<small><span style=\\\"color:${er.线路颜色}\\\">${ef.from[ef.line]}</span></small>`\\n      })\\n    }\\n\\n    currentLocation = location;\\n  }\\n\\n  GM.put(\\\"renovateList\\\", renovateList);\\n\\n  if (from.length) {\\n    let ef = getEInfo();\\n    d.push({\\n      title: getLineShow(ef),\\n      //desc: sortobj[sorti].title,\\n      desc: `<small><span style=\\\"color:${er.线路颜色}\\\">${ef.from[ef.line]}</span></small>`,\\n      img: sortobj[sorti].img,\\n      url: $('#noLoading#').lazyRule((so) => {\\n        let ef = $.require(\\\"methods\\\").getEInfo();\\n\\n        let si = getMyVar(\\\"sorti\\\", \\\"0\\\");\\n        let ii = (si == \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        updateItem(\\\"@sort\\\", {\\n          desc: so[ii].title,\\n          img: so[ii].img,\\n        })\\n\\n        // updateItem(\\\"@sort\\\", {\\n        //   title: \\\"\\\"+\\\"当前线路:\\\" + ef.from[ef.line] + \\\"\\\\t\\\\t共:\\\" + ef.plays[ef.line] + \\\"集\\\\t\\\\t\\\" + ef.spagenum + \\\"/\\\" + ef.max[ef.line],\\n        // })\\n\\n        var plays = findItemsByCls(\\\"playlist\\\").reverse().map(x => {\\n          x.col_type = x.type;\\n          x.extra.id = x.extra.id.endsWith(\\\"⇅\\\") ? x.extra.id.replace(/⇅$/, \\\"\\\") : x.extra.id + \\\"⇅\\\";\\n          return x;\\n        });\\n        let oldIds = (findItemsByCls('playlist') || []).map(it => it.extra.id);\\n\\n        for (let i = 0; i < oldIds.length; i++) {\\n          //最后顺序更新\\n          updateItem(oldIds[i], plays[i]);\\n        }\\n        let newItem = (findItemsByCls('playlist') || []);\\n        for (let i = 0; i < newItem.length; i++) {\\n          //最后顺序更新\\n          updateItem(newItem[i].extra.id, {\\n            extra: Object.assign({}, newItem[i].extra, {\\n              id: newItem[i].extra.id.replace(/⇅$/, \\\"\\\")\\n            })\\n          });\\n        }\\n\\n        // deleteItemByCls(\\\"playlist\\\");\\n        // addItemAfter(\\\"playlists\\\", plays);\\n\\n        putMyVar(\\\"sorti\\\", ii);\\n        //return \\\"toast://\\\" + (ii == \\\"0\\\" ? \\\"正序\\\" : \\\"倒序\\\");\\n        return \\\"hiker://empty\\\";\\n      }, sortobj),\\n      col_type: 'avatar',\\n      extra: {\\n        id: \\\"@sort\\\",\\n      }\\n    })\\n    if (from.length > 1) {\\n      let ci = getMyVar(id + \\\"sourcei\\\", \\\"0\\\");\\n      if (er.线路样式 != \\\"select\\\") {\\n        for (let i in from) {\\n          let iconimg = er.线路样式.includes(\\\"icon\\\") ? findIcon(from[i]) : \\\"\\\";\\n          d.push({\\n            title: (i == ci ? fontstyle(from[i], {\\n              c: er.线路颜色,\\n              tags: \\\"small\\\"\\n            }, er.线路样式) : fontstyle(from[i], {\\n              tags: \\\"small\\\"\\n            }, er.线路样式)),\\n            url: $(\\\"#noLoading#\\\").lazyRule((i, id) => {\\n              if (getMyVar(id + \\\"sourcei\\\", \\\"0\\\") == i) {\\n                return \\\"hiker://empty\\\";\\n              }\\n              putMyVar(id + \\\"sourcei\\\", String(i));\\n              let err = $.require(\\\"methods\\\").erRefresh;\\n              err(i);\\n              return \\\"hiker://empty\\\";\\n            }, i, id),\\n            extra: {\\n              cls: \\\"location@\\\",\\n              id: \\\"location@\\\" + i\\n            },\\n            img: iconimg,\\n            col_type: er.线路样式\\n          });\\n        }\\n      } else {\\n        d.push({\\n          title: from[ci],\\n          desc: from.length + \\\"条线路\\\",\\n          url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n            let {\\n              fontstyle,\\n              getEInfo,\\n            } = $.require(\\\"methods\\\");\\n            let ef = getEInfo();\\n\\n            let from = ef.from;\\n            let max = ef.plays;\\n\\n            let ci = getMyVar(id + \\\"sourcei\\\", \\\"0\\\");\\n            let showi = getMyVar(\\\"showi\\\", \\\"\\\");\\n            let tfrom = from.map((x, i) => {\\n              return ci == i ? fontstyle(x + \\\"[\\\" + max[i] + \\\"]\\\", {\\n                c: $.er_ui.线路颜色,\\n                tags: \\\"small\\\"\\n              }) : fontstyle(x + \\\"[\\\" + max[i] + \\\"]\\\", {\\n                tags: \\\"small\\\"\\n              })\\n            })\\n            if (showi == \\\"\\\") {\\n              putMyVar(\\\"showi\\\", \\\"1\\\");\\n              let show = 1;\\n              let num = tfrom.length;\\n              if (num < 8) {\\n              } else if (num > 8 && num <= 12) {\\n                show = 2;\\n              } else {\\n                show = 3;\\n              }\\n              \\n              return $(tfrom, show).select((ci, f, id) => {\\n                MY_URL=\\\"hiker://empty\\\";\\n                let {\\n                  erRefresh\\n                }=$.require(\\\"methods\\\");\\n                \\n                let {\\n                  findIcon\\n                } = $.require(\\\"methods_er\\\");\\n                \\n                let i = MY_INDEX;\\n                if (i == ci) {\\n                  return \\\"hiker://empty\\\";\\n                }\\n                let name = f[i];\\n                putMyVar(id + \\\"sourcei\\\", String(i));\\n                erRefresh(i);\\n\\n                let iconimg = findIcon(name, $.er_ui);\\n\\n                updateItem(\\\"location@\\\", {\\n                  title: name,\\n                  img: iconimg,\\n                })\\n                clearMyVar(\\\"showi\\\");\\n                return \\\"hiker://empty\\\";\\n              }, ci, from, id)\\n            } else {\\n              clearMyVar(\\\"showi\\\");\\n              return \\\"hiker://empty\\\";\\n            }\\n          }, id),\\n          img: er.线路样式.includes(\\\"select\\\") ? findIcon(from[ci]) : \\\"\\\",\\n          col_type: 'avatar',\\n          extra: {\\n            id: \\\"location@\\\"\\n          }\\n        })\\n      }\\n    }\\n  }\\n\\n  d.push({\\n    col_type: \\\"blank_block\\\",\\n    extra: {\\n      id: \\\"playpageline\\\"\\n    }\\n  })\\n\\n  d.push({\\n    col_type: \\\"line\\\",\\n    extra: {\\n      id: \\\"playlists\\\"\\n    }\\n  });\\n\\n  d.push({\\n    col_type: \\\"blank_block\\\",\\n    extra: {\\n      cls: \\\"playlist2\\\",\\n      id: \\\"playlistsEND\\\"\\n    }\\n  });\\n\\n  let mes = [fontstyle('以上数据来源于网络，如您喜欢，请支持官方！', { c: \\\"grey\\\", tags: \\\"small\\\" })];\\n\\n  if (cacheManage.exist(MY_PARAMS.sname + id)) {\\n    mes.unshift(fontstyle(\\\"当前为缓存,点我刷新\\\", {\\n      c: er.线路颜色, tags: \\\"small\\\"\\n    }))\\n  }\\n\\n  d.push({\\n    title: mes.join(\\\"\\\\n\\\"),\\n    //desc: fontstyle('此规则仅限学习交流使用，请于导入后24小时内删除，任何组织或个人不得以任何方式方法传播此规则的整体或部分！', { c: \\\"#F20C00\\\", tags: \\\"small\\\" }),\\n    url: $(\\\"#noLoading#\\\").lazyRule((id, ms) => {\\n      let er = $.require(\\\"UIManage\\\").ui_config.er;\\n      let {\\n        cacheManage\\n      } = $.require(\\\"methods\\\");\\n      let ca = cacheManage.exist(ms.sname + id);\\n      if (ca) {\\n        cacheManage.del(ms.sname + id);\\n      }\\n      clearMyVar(\\\"playlist_ready\\\");\\n      if (er.二级刷新 || ca) {\\n        refreshPage(false);\\n      }\\n      return \\\"hiker://empty\\\";\\n    }, id, MY_PARAMS),\\n    col_type: 'text_center_1',\\n    extra: {\\n      cls: \\\"playlist2\\\",\\n    }\\n  })\\n\\n  renovateList(getMyVar(id + \\\"sourcei\\\", \\\"0\\\"));\\n  setResult(d);\\n})()\"},{\"col_type\":\"movie_3\",\"name\":\"解析文件\",\"path\":\"configs\",\"rule\":\"const path = \\\"hiker://files/rules/DrpyHiker/parses.json\\\";\\nconst oldpath = \\\"hiker://files/rules/LoyDgIk/parses.json\\\";\\nlet data;\\n\\nfunction getJson() {\\n    if (!fileExist(path) && fileExist(oldpath)) {\\n        data = JSON.parse(readFile(oldpath) || \\\"[]\\\");\\n        saveFile(path, JSON.stringify(data));\\n        //deleteFile(oldpath);\\n    }\\n    if (Array.isArray(data)) {\\n        return data;\\n    }\\n    try {\\n        data = JSON.parse(readFile(path) || \\\"[]\\\");\\n    } catch (e) {\\n        deleteFile(path);\\n        data = [];\\n    }\\n    return data;\\n}\\n\\nfunction saveJson(json) {\\n    saveFile(path, JSON.stringify(json));\\n}\\n\\nfunction getUsefulJson() {\\n    return getJson().filter(v => !v.forbidden);\\n}\\n\\nfunction getForbiddenJson() {\\n    return getJson().filter(v => v.forbidden);\\n}\\n\\n$.exports = {\\n    getJson,\\n    saveJson,\\n    getUsefulJson,\\n    getForbiddenJson,\\n    path,\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"解析管理\",\"path\":\"ruleManage\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle(\\\"解析管理\\\");\\nlet configs = $.require(\\\"configs\\\");\\nlet arr = configs.getJson();\\nlet length = arr.length;\\nd.push({\\n    col_type: \\\"avatar\\\",\\n    title: \\\"提示\\\",\\n    pic_url: \\\"https://hikerfans.com/tubiao/system/27.png\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n        let pop = hikerPop.infoBottom({\\n            options: [\\n                \\\"[建议]：解析只需要保存少量好用的即可，不需要太多。\\\",\\n                \\\"[提示]：解析有时效或重定向的'高级'解析，本程序不支持，建议删除。\\\",\\n                \\\"[Q&A]：为啥在编辑页面测试解析时能用，保存后再视频源中却解析不出来？\\\\n不知道，我的解决办法是建议删除。\\\"\\n            ],\\n        });\\n        return \\\"hiker://empty\\\";\\n    }),\\n});\\nd.push({\\n    title: \\\"新增\\\",\\n    url: \\\"hiker://page/ruleEdit#noRecordHistory##noHistory##noRefresh#\\\",\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_domain_config\\\",\\n    extra: {\\n        pageTitle: \\\"新增解析\\\"\\n    }\\n});\\n\\nd.push({\\n    title: \\\"分享\\\",\\n    url: $(\\\"-1\\\", \\\"输入你要分享解析的序号\\\\n-1全部，-2已启用的，-3已禁用的\\\").input((length) => {\\n        let indexc = input.split(/,|，/);\\n        let indexs = [];\\n        let mo = parseInt(indexc[0]);\\n        if (!(indexc.length !== 0 && mo < 0 && mo > -5)) {\\n            for (let it of indexc) {\\n                let num = parseInt(it);\\n                if (Number.isNaN(num) || num >= length || num < 0) {\\n                    return \\\"toast://数字不合法\\\";\\n                }\\n                indexs.push(num);\\n            }\\n        }\\n\\n        return $([\\\"HIKER\\\", \\\"TXT\\\"].concat(getPastes()), 2, \\\"分享方式\\\").select((mo, indexs, ext) => {\\n            function up(rules) {\\n                let ruleb64 = base64Encode(JSON.stringify(rules));\\n                let getPass = (length, rule, type) => \\\"海阔视界，DRPY解析，共「\\\" + length + \\\"」条，复制整条口令打开软件就会自动导入$\\\" + rule + \\\"$\\\" + type + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input)\\\";\\n                if (getPastes().includes(input)) {\\n                    let u = sharePaste(ruleb64, input);\\n                    return \\\"copy://\\\" + getPass(rules.length, u, \\\"b\\\");\\n                } else {\\n                    let path = \\\"hiker://files/rules/LoyDgIk/share/drpy解析「\\\" + rules.length + \\\"」条.\\\" + (input === \\\"HIKER\\\" ? \\\"hiker\\\" : \\\"txt\\\");\\n                    writeFile(path, getPass(rules.length, ruleb64, \\\"a\\\"));\\n                    return \\\"share://\\\" + path;\\n                }\\n            }\\n            let rules;\\n            if (mo === -1) {\\n                rules = $.require(\\\"configs\\\").getJson();\\n            } else if (mo === -2) {\\n                rules = $.require(\\\"configs\\\").getUsefulJson();\\n            } else if (mo === -3) {\\n                rules = $.require(\\\"configs\\\").getForbiddenJson();\\n            } else {\\n                rules = $.require(\\\"configs\\\").getJson().filter((v, i) => indexs.includes(i));\\n            }\\n            rules = rules.map((v) => {\\n                v.forbidden = undefined;\\n                return v;\\n            });\\n            return up(rules);\\n        }, mo, indexs, indexc[1]);\\n\\n    }, length),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_share_green\\\"\\n});\\nd.push({\\n    title: \\\"重置\\\",\\n    url: $(\\\"你确定重置？\\\\n该操作会删除现有解析，恢复自带解析。\\\").confirm((path) => {\\n        deleteFile(path);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, $.require(\\\"configs\\\").path),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_refresh\\\"\\n});\\nd.push({\\n    title: \\\"清空\\\",\\n    url: $(\\\"你确定全部删除？\\\\n该操作会删除现有解析。\\\").confirm((path) => {\\n        writeFile(path, \\\"[]\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, $.require(\\\"configs\\\").path),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_code_view\\\"\\n});\\n\\nd.push({\\n    //title: '<font color=\\\"#13B61B\\\">▐ </font><b>解析列表<b> (' + String(length).fontcolor(\\\"#ff6601\\\") + \\\")\\\",\\n    col_type: \\\"rich_text\\\",\\n});\\nlet countTitle = d.at(-1);\\n\\nfunction uniqueNested(arr) {\\n    return arr.map(item => {\\n        if (Array.isArray(item)) {\\n            return uniqueNested(item);\\n        }\\n        return item;\\n    }).flat(Infinity).filter((value, index, self) => self.indexOf(value) === index);\\n}\\nvar its = []\\nlet flagi = storage0.getMyVar(\\\"flagi\\\", [\\\"全部\\\"]);\\nlet count = its.length;\\nlet flags = uniqueNested(arr.map(x => x.flag.split(\\\"|\\\")));\\nflags.unshift(\\\"已禁用\\\");\\nflags.unshift(\\\"全部\\\");\\n\\nlet show = getMyVar(\\\"flagshow\\\", \\\"\\\");\\nlet col = show == \\\"展开\\\" ? \\\"flex_button\\\" : \\\"scroll_button\\\";\\nd.push({\\n    title: show == \\\"展开\\\" ? \\\"““””<b>\\\" + \\\"∧\\\".fontcolor(\\\"#1aad19\\\") + \\\"</b>\\\" : \\\"““””<b>\\\" + \\\"∨\\\".fontcolor(\\\"#FF0000\\\") + \\\"</b>\\\",\\n    col_type: col,\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let show = getMyVar(\\\"flagshow\\\", \\\"展开\\\");\\n        putMyVar(\\\"flagshow\\\", show == \\\"展开\\\" ? \\\"收起\\\" : \\\"展开\\\");\\n        refreshPage();\\n        return \\\"hiker://empty\\\";\\n    })\\n})\\n\\n\\nflags.forEach(f => {\\n    d.push({\\n        title: '““””' + (flagi.includes(f) ? f.fontcolor(\\\"#13B61B\\\") : f),\\n        col_type: col,\\n        url: $('#noLoading#').lazyRule((f) => {\\n            let flagi = storage0.getMyVar(\\\"flagi\\\", [\\\"全部\\\"]);\\n            if (/(全部|已禁用)/.test(f)) {\\n                flagi = [f]\\n            } else {\\n                flagi = flagi.filter(x => !/(全部|已禁用)/.test(x));\\n                if (flagi.includes(f)) {\\n                    flagi = flagi.filter(x => x != f);\\n                    if (flagi.length == 0) {\\n                        flagi = [\\\"全部\\\"]\\n                    }\\n                } else {\\n                    flagi.push(f)\\n                }\\n            }\\n            storage0.putMyVar(\\\"flagi\\\", flagi);\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }, f)\\n    })\\n})\\nfor (let i = 0; i < length; i++) {\\n    let it = arr[i];\\n\\n    let flag = it.flag.split(\\\"|\\\");\\n    if (flagi.length > 0 && ![\\\"全部\\\", \\\"已禁用\\\"].includes(flagi[0])) {\\n        if (!flagi.every(f => flag.includes(f))) {\\n            continue;\\n        }\\n    }\\n    if ([\\\"已禁用\\\"].includes(flagi[0])) {\\n        if (!it.hasOwnProperty(\\\"forbidden\\\") || !it.forbidden) {\\n            continue;\\n        }\\n    }\\n    its.push({\\n        title: '““””[' + i + ']<b>  ' + it.name + (it.forbidden ? \\\" #““禁用””\\\".small() : \\\"\\\"),\\n        desc: it.url,\\n        forbidden: it.forbidden,\\n        url: $([\\\"编辑\\\", \\\"分享\\\", \\\"禁用/启用\\\", \\\"移动\\\", \\\"置顶\\\", \\\"删除\\\"], 1, \\\"操作：\\\" + it.name).select((index, length) => {\\n            if (input === \\\"编辑\\\") {\\n                return \\\"hiker://page/ruleEdit#noRecordHistory##noHistory##noRefresh#\\\";\\n            } else if (input === \\\"分享\\\") {\\n                let ops = getPastes();\\n                ops.unshift(\\\"完整口令\\\");\\n                return $(ops, 2, \\\"分享方式\\\").select((index) => {\\n                    let rule = $.require(\\\"configs\\\").getJson()[index];\\n                    rule.user = undefined;\\n                    rule.forbidden = undefined;\\n                    let ruleb64 = base64Encode(JSON.stringify(rule));\\n                    let getPass = (name, rule, type) => \\\"海阔视界，「\\\" + name + \\\"」DRPY解析，复制整条口令打开软件就会自动导入$\\\" + rule + \\\"$\\\" + type + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input)\\\";\\n                    if (input == \\\"完整口令\\\") {\\n                        return \\\"copy://\\\" + getPass(rule.name, ruleb64, \\\"a\\\");\\n                    } else {\\n                        let u = sharePaste(ruleb64, input);\\n                        return \\\"copy://\\\" + getPass(rule.name, u, \\\"b\\\");\\n                    }\\n                }, index);\\n            } else if (input === \\\"移动\\\") {\\n                return $(index + \\\"\\\", \\\"输入位置\\\").input((index, length) => {\\n                    let newIndex = Number(input);\\n                    if (Number.isNaN(newIndex) || newIndex >= length) {\\n                        return \\\"toast://不和规的位置\\\";\\n                    }\\n                    let rules = $.require(\\\"configs\\\").getJson();\\n                    let rule = rules.splice(index, 1)[0];\\n                    rules.splice(newIndex, 0, rule);\\n                    $.require(\\\"configs\\\").saveJson(rules);\\n                    refreshPage(false);\\n                }, index, length);\\n            } else if (input === \\\"置顶\\\") {\\n                let newIndex = 0;\\n                let rules = $.require(\\\"configs\\\").getJson();\\n                let rule = rules.splice(index, 1)[0];\\n                rules.splice(newIndex, 0, rule);\\n                $.require(\\\"configs\\\").saveJson(rules);\\n                refreshPage(false);\\n            } else if (input === \\\"删除\\\") {\\n                return $(\\\"确认删除？\\\").confirm((index) => {\\n                    let rules = $.require(\\\"configs\\\").getJson();\\n                    let rule = rules.splice(index, 1)[0];\\n                    $.require(\\\"configs\\\").saveJson(rules);\\n                    refreshPage(false);\\n                    return \\\"toast://已删除\\\" + rule.name;\\n                }, index);\\n            } else {\\n                let arr = $.require(\\\"configs\\\").getJson();\\n                let rule = arr[index];\\n                rule.forbidden = !rule.forbidden;\\n                $.require(\\\"configs\\\").saveJson(arr);\\n                refreshPage(false);\\n                //return \\\"toast://\\\" + (rule.forbidden ? \\\"禁用\\\" : \\\"启用\\\") + rule.name;\\n            }\\n        }, i, length),\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            i: i,\\n            pageTitle: it.name\\n        }\\n    });\\n}\\n\\ncountTitle.title = '<font color=\\\"#13B61B\\\">▐ </font><b>解析列表<b> (' + ((its.length - count) + \\\"/\\\" + length).fontcolor(\\\"#ff6601\\\") + \\\")\\\";\\n\\nd = d.concat(its);\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"解析编辑\",\"path\":\"ruleEdit\",\"rule\":\"js:\\nvar d = [];\\n\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\"ps_name\\\");\\n    clearMyVar(\\\"ps_url\\\");\\n    clearMyVar(\\\"ps_flag\\\");\\n    clearMyVar(\\\"ps_headers\\\");\\n    clearMyVar(\\\"ps_method\\\");\\n    clearMyVar(\\\"ps_runType\\\");\\n    clearMyVar(\\\"ps_jsonPath\\\");\\n    clearMyVar(\\\"ps_js\\\");\\n}));\\nlet urlIndex = parseInt(getParam(\\\"index\\\", \\\"\\\"));\\nurlIndex = Number.isNaN(urlIndex) ? void(0) : urlIndex;\\nlet index = void(0) === urlIndex ? MY_PARAMS.i : urlIndex;\\nlet isImport = !!getParam(\\\"isImport\\\", \\\"\\\");\\nlet arr = $.require(\\\"configs\\\").getJson();\\nlet obj;\\nif (isImport) {\\n    try {\\n        obj = $.require(\\\"hiker://files/_cache/jiexiSimpleImport.json\\\");\\n        let tip = index !== void(0) ? \\\"更新解析\\\" : \\\"导入解析\\\";\\n        setPageTitle(tip + \\\":\\\" + obj.name);\\n        d.push({\\n            title: \\\"‘‘\\\" + tip + \\\"’’\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n\\n    } catch (e) {\\n        obj = {};\\n        back();\\n        toast(\\\"导入错误\\\");\\n    }\\n} else if (index !== void(0)) {\\n    obj = arr[index];\\n    setPageTitle(\\\"编辑解析:\\\" + obj.name);\\n} else {\\n    obj = {\\n        runType: \\\"WEB\\\",\\n        method: \\\"GET\\\"\\n    };\\n    setPageTitle(\\\"新建解析\\\");\\n}\\n\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"名字(必填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_name\\\", input);\\n        }),\\n        defaultValue: obj.name,\\n        titleVisible: false\\n    }\\n});\\n\\n\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"解析url(必填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_url\\\", input);\\n        }),\\n        defaultValue: obj.url,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"flag(必填)\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 2,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_flag\\\", input);\\n        }),\\n        defaultValue: getMyVar(\\\"ps_flag\\\",obj.flag||\\\"qiyi|imgo|爱奇艺|奇艺|qq|qq 预告及花絮|腾讯|youku|优酷|pptv|PPTV|letv|乐视|leshi|mgtv|芒果|sohu|xigua|fun|风行\\\"),\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"headers(选填)\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 2,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_headers\\\", input);\\n        }),\\n        defaultValue: obj.headers,\\n        titleVisible: false,\\n    }\\n});\\n\\nputMyVar(\\\"ps_runType\\\", obj.runType || \\\"\\\");\\nd.push({\\n    title: \\\"解析模式：\\\" + (obj.runType || \\\"WEB\\\"),\\n    col_type: \\\"text_center_1\\\",\\n    url: $([\\\"WEB\\\", \\\"JSON\\\", \\\"JS\\\"]).select(() => {\\n\\n        putMyVar(\\\"ps_runType\\\", input);\\n        updateItem(\\\"ps_runType\\\", {\\n            title: \\\"解析模式：\\\" + input\\n        });\\n        return \\\"hiker://empty\\\";\\n    }),\\n    extra: {\\n        id: \\\"ps_runType\\\",\\n        lineVisible: false\\n    }\\n});\\n\\n\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"jsonPath(JSON解析模式必填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_jsonPath\\\", input);\\n        }),\\n        defaultValue: obj.jsonPath,\\n        titleVisible: false,\\n    }\\n});\\nputMyVar(\\\"ps_method\\\", obj.method || \\\"\\\");\\nd.push({\\n    title: \\\"JSON请求模式：\\\" + (obj.method || \\\"GET\\\"),\\n    col_type: \\\"text_1\\\",\\n    url: $([\\\"GET\\\", \\\"POST\\\"]).select(() => {\\n\\n        putMyVar(\\\"ps_method\\\", input);\\n        updateItem(\\\"ps_method\\\", {\\n            title: \\\"JSON请求模式：\\\" + input\\n        });\\n        return \\\"hiker://empty\\\";\\n    }),\\n    extra: {\\n        id: \\\"ps_method\\\",\\n        lineVisible: false\\n    }\\n});\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"js(JS模式必填)\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 3,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_js\\\", input);\\n        }),\\n        defaultValue: obj.js,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    title: \\\"删除\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((index, urlIndex) => {\\n        if (index === void(0)) {\\n            return \\\"toast://此项无法删除\\\";\\n        }\\n        if (urlIndex !== void(0)) {\\n            return \\\"toast://正在更新解析，删除请从解析管理进入\\\";\\n        }\\n        confirm({\\n            title: \\\"温馨提示\\\",\\n            content: \\\"确定要删除此解析吗？注意删除后无法恢复\\\",\\n            confirm: $.toString((index) => {\\n                let arr = $.require(\\\"configs\\\").getJson();\\n                arr.splice(index, 1);\\n                $.require(\\\"configs\\\").saveJson(arr);\\n                back(true);\\n                return \\\"toast://删除成功\\\";\\n            }, index)\\n        });\\n        return \\\"hiker://empty\\\"\\n    }, index, urlIndex),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nd.push({\\n    title: \\\"测试\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let testKeyword = getItem(\\\"testUrl\\\", \\\"\\\");\\n        return $(testKeyword, \\\"请输入影视网站地址\\\").input(() => {\\n            setItem(\\\"testUrl\\\", input);\\n            let url = getMyVar(\\\"ps_url\\\", \\\"\\\");\\n            let name = getMyVar(\\\"ps_name\\\", \\\"\\\");\\n            let flag = getMyVar(\\\"ps_flag\\\", \\\"\\\");\\n            let headers = getMyVar(\\\"ps_headers\\\", \\\"\\\");\\n            let runType = getMyVar(\\\"ps_runType\\\", \\\"WEB\\\");\\n            let method = getMyVar(\\\"ps_method\\\", \\\"GET\\\");\\n            let jsonPath = getMyVar(\\\"ps_jsonPath\\\", \\\"\\\").trim() || void 0;\\n            let js = getMyVar(\\\"ps_js\\\", \\\"\\\") || void 0;\\n            if (headers) {\\n                try {\\n                    headers = JSON.parse(headers);\\n                } catch (e) {\\n                    return \\\"headers格式错误:\\\" + e.toString();\\n                }\\n            }\\n            return $.require(\\\"videoUrl\\\").prepareParses([{\\n                name,\\n                url,\\n                flag,\\n                headers,\\n                runType,\\n                method,\\n                jsonPath,\\n                js\\n            }], input,null, true);\\n        });\\n    }),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nd.push({\\n    title: \\\"保存\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((index, isImport) => {\\n        let name = getMyVar(\\\"ps_name\\\", \\\"\\\").trim();\\n        if (!name) {\\n            return \\\"toast://名字得有一个吧\\\";\\n        }\\n        let url = getMyVar(\\\"ps_url\\\", \\\"\\\").trim();\\n        if (!url) {\\n            return \\\"toast://解析地址不能为空\\\";\\n        }\\n        let flag = getMyVar(\\\"ps_flag\\\", \\\"\\\");\\n        if (!flag) {\\n            return \\\"toast://解析地址标识不能为空\\\";\\n        }\\n        let headers = getMyVar(\\\"ps_headers\\\", \\\"\\\").trim();\\n        if (headers) {\\n            try {\\n                headers = JSON.parse(headers);\\n                if(typeof headers!==\\\"object\\\") throw new Error(\\\"错误类型，必须为Object\\\");\\n            } catch (e) {\\n                return \\\"headers格式错误:\\\" + e.toString();\\n            }\\n        }\\n        let runType = getMyVar(\\\"ps_runType\\\", \\\"WEB\\\");\\n        let method = getMyVar(\\\"ps_method\\\", \\\"GET\\\");\\n        let jsonPath = getMyVar(\\\"ps_jsonPath\\\", \\\"\\\").trim() || void 0;\\n        let js = getMyVar(\\\"ps_js\\\", \\\"\\\") || void 0;\\n        if (runType === \\\"JSON\\\" && !jsonPath) {\\n            return \\\"toast://JSON模式下必须填jsonPath\\\";\\n        } else if (runType === \\\"JS\\\" && !js) {\\n            return \\\"toast://JS模式下必须填js\\\";\\n        }\\n        let arr = $.require(\\\"configs\\\").getJson();\\n        let obj1 = {\\n            name,\\n            url,\\n            flag,\\n            headers,\\n            runType,\\n            method,\\n            jsonPath,\\n            js\\n        };\\n        if (index === void(0)) {\\n            if (arr.some(v => v.name === name)) {\\n                return \\\"toast://已经存在该解析\\\";\\n            }\\n            if (obj1.group) {\\n                let group = obj1.group;\\n                let index = arr.findIndex(v => v.group === group);\\n                if (index === -1) {\\n                    arr.unshift(obj1);\\n                } else {\\n                    arr.splice(index, 0, obj1);\\n                }\\n            } else {\\n                if (isImport) {\\n                    arr.push(obj1);\\n                } else {\\n                    arr.unshift(obj1);\\n                }\\n            }\\n        } else {\\n            let namey = arr[index].name;\\n            if (name !== namey) {\\n                if (arr.some(v => v.name === name)) {\\n                    return \\\"toast://已经存在该解析\\\";\\n                }\\n            }\\n            obj1 = Object.assign(arr[index], obj1);\\n            arr.splice(index, 1, obj1);\\n        }\\n        $.require(\\\"configs\\\").saveJson(arr);\\n        back(true);\\n        return \\\"toast://保存成功\\\";\\n    }, index, isImport),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"解析导入\",\"path\":\"import\",\"rule\":\"js:\\nfunction saveCache(json) {\\n    writeFile(\\\"hiker://files/_cache/jiexiSimpleImport.json\\\", JSON.stringify(json));\\n}\\n\\nfunction importParse(pass) {\\n    try {\\n        let [_, rule, type] = pass.split(\\\"$\\\");\\n        if (type === \\\"b\\\") {\\n            rule = parsePaste(rule);\\n        }\\n        let rules = JSON.parse(base64Decode(rule));\\n        if (!Array.isArray(rules)) {\\n            rules = [rules];\\n        }\\n        //rules.reverse();\\n        MY_URL = module.id;\\n        let ruleTitle = getParam(\\\"rule\\\");\\n        let arr = $.require(\\\"configs?rule=\\\" + ruleTitle).getJson();\\n        let newI = 0;\\n        for (let rule of rules) {\\n            let index = arr.findIndex(v => v.name === rule.name);\\n            if (index > -1) {\\n                rule = Object.assign(arr[index], rule);\\n                arr.splice(index, 1, rule);\\n                if (rules.length === 1) {\\n                    saveCache(rule);\\n                    return \\\"hiker://page/ruleEdit#noHistory##noRecordHistory#?isImport=true&index=\\\" + index + \\\"&rule=\\\" + ruleTitle;\\n                    //toast(\\\"已更新规则：\\\" + rule.name);\\n                } else {\\n                    log(\\\"已更新规则：\\\" + rule.name)\\n                }\\n            } else {\\n                newI++;\\n                arr.push(rule);\\n                if (rules.length === 1) {\\n                    saveCache(rule);\\n                    return \\\"hiker://page/ruleEdit#noHistory##noRecordHistory#?isImport=true&rule=\\\" + ruleTitle;\\n                    //toast(\\\"已导入规则：\\\" + rule.name);\\n                } else {\\n                    log(\\\"已导入规则：\\\" + rule.name)\\n                }\\n            }\\n        }\\n        if (rules.length > 1) {\\n            $.require(\\\"configs?rule=\\\" + ruleTitle).saveJson(arr);\\n            toast(\\\"新增：\\\" + newI + \\\" 覆盖更新：\\\" + (rules.length - newI));\\n        }\\n    } catch (e) {\\n        log(e.toString());\\n        toast(\\\"导入失败\\\");\\n    }\\n}\\n\\nfunction importRule(pass) {\\n    try {\\n        let [_, rule, pname] = pass.split(\\\"$\\\");\\n        let path = getPublicItem(\\\"DrpyHiker@input_path\\\", \\\"\\\");\\n        if (!path) {\\n            MY_URL = module.id;\\n            let ruleTitle = getParam(\\\"rule\\\");\\n            toast(\\\"未指定默认保存目录，请先设置保存目录\\\");\\n            return \\\"hiker://page/sharedefaultpath#noRecordHistory##noHistory#?rule=\\\"+ruleTitle;\\n        }\\n        let rules = base64Decode(parsePaste(rule));\\n        if (!rules) toast(\\\"内容为空，导入失败\\\");\\n        path = path.endsWith(\\\"/\\\") ? path : (path + \\\"/\\\");\\n        writeFile(path + pname, rules);\\n        toast(\\\"导入成功请刷新配置\\\");\\n    } catch (e) {\\n        toast(\\\"导入失败:\\\" + e.toString())\\n    }\\n}\\n$.exports = function(pass, mode) {\\n    if (mode) {\\n        return importRule(pass);\\n    } else {\\n        return importParse(pass);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"视频解析\",\"path\":\"videoUrl\",\"rule\":\"function isofficial(url) {\\n  let flag = new RegExp('qq\\\\.com|iqiyi\\\\.com|youku\\\\.com|mgtv\\\\.com|bilibili\\\\.com|sohu\\\\.com|ixigua\\\\.com|pptv\\\\.com|miguvideo\\\\.com|le\\\\.com|1905\\\\.com|fun\\\\.tv');\\n  return flag.test(url);\\n}\\n\\n\\nfunction prepareParses(parses, url, playlist, isTest, flag) {\\n  playlist = playlist || {\\n    urls: [],\\n    names: [],\\n    headers: [],\\n    is: \\\"#isVideo=true#\\\",\\n  };\\n  let Proxy = $.require(\\\"LocalProxy\\\");\\n  let proxyUrl = Proxy.startProxy(MY_RULE.title, GM.getSelfKey());\\n  parses.forEach((v, i) => {\\n    if (!isTest && (v.forbidden || !String(v.flag).split(\\\"|\\\").includes(flag))) return;\\n    playlist.names.push(v.name);\\n    if (v.headers) {\\n      playlist.headers.push(v.headers);\\n    }\\n    if (v.runType === \\\"JSON\\\") {\\n      let param = {\\n        //url: v.url,\\n        method: v.method,\\n        headers: v.headers,\\n        jsonPath: v.jsonPath\\n      };\\n      playlist.urls.push(proxyUrl + \\\"?runType=JSON&url=\\\" + encodeURIComponent(base64Encode(v.url + url)) + \\\"&param=\\\" + encodeURIComponent(base64Encode(JSON.stringify(param))));\\n    } else if (v.runType === \\\"JS\\\") {\\n      playlist.urls.push(proxyUrl + \\\"?runType=JS&url=\\\" + encodeURIComponent(base64Encode(url)) + (isTest ? \\\"&param=\\\" + encodeURIComponent(base64Encode(JSON.stringify(v))) : \\\"&index=\\\" + i));\\n    } else {\\n      playlist.urls.push(\\\"video://\\\" + v.url + url);\\n    }\\n  });\\n  if (!playlist.urls.length) return \\\"web://\\\" + url;\\n  return JSON.stringify(playlist);\\n}\\n\\nfunction useParses(url, flag) {\\n  let parses = $.require(\\\"configs\\\").getJson();\\n\\n  if (!parses.length) return \\\"web://\\\" + url;\\n  let playlist = {\\n    urls: [],\\n    names: [],\\n    headers: [],\\n    is: \\\"#isVideo=true#\\\",\\n  };\\n  try {\\n    let useDanmu = !!getItem(\\\"useDanmu\\\", \\\"\\\");\\n    if (useDanmu) {\\n      playlist.danmu = $.require('dmFun?rule=dm盒子').dmRoute(url);\\n    }\\n  } catch { }\\n  flag = String(flag).replace(/\\\\s/g, \\\"\\\");\\n  return prepareParses(parses, url, playlist, false, flag);\\n}\\n\\nfunction carryJs(play, id) {\\n  var extra = {\\n    \\\"ua\\\": MOBILE_UA\\n  }\\n  let parse = play;\\n  let parse_obj = {\\n    defRules: [\\\"*.mp4\\\", \\\"*.m3u8\\\"],\\n  };\\n  if (parse.hasOwnProperty(\\\"parse_extra\\\")) {\\n    let parse_extra = decodeURIComponent(parse.parse_extra);\\n    parse_obj = Object.assign(parse_obj, parseQuery(parse_extra));\\n    if (parse_obj.hasOwnProperty(\\\"init_script\\\")) {\\n      parse_obj[\\\"init_script\\\"] = base64Decode(parse_obj[\\\"init_script\\\"]);\\n    }\\n  }\\n  if (parse_obj.hasOwnProperty(\\\"is_pc\\\") && parse_obj[\\\"is_pc\\\"] == \\\"1\\\") {\\n    extra[\\\"ua\\\"] = PC_UA;\\n  }\\n  if (parse.hasOwnProperty(\\\"header\\\")) {\\n    extra[\\\"ua\\\"] = parse[\\\"header\\\"][\\\"User-Agent\\\"];\\n    extra[\\\"Referer\\\"] = parse[\\\"header\\\"][\\\"Referer\\\"];\\n    //extra[\\\"redirect\\\"]=false;\\n    /*extra[\\\"js\\\"] = $.toString((js) => {\\n      eval(js)\\n      fba.log(navigator.userAgent)\\n      fba.log(location.href)\\n    }, $.toString(() => {\\n      Object.defineProperty(navigator, 'userAgent', {\\n        get: function () {\\n          return 'My-Custom-UA-String';\\n        }\\n      });\\n    }))*/\\n  }\\n  if (parse_obj.hasOwnProperty(\\\"custom_regex\\\")) {\\n    let current = parse_obj[\\\"defRules\\\"];\\n    extra[\\\"videoRules\\\"] = current.concat(parse_obj.custom_regex.split(/\\\\|/g).filter(e => e))\\n  }\\n  if (parse.hasOwnProperty(\\\"js\\\") && parse.js != \\\"\\\") {\\n    extra[\\\"js\\\"] = $.toString((js, parse, t) => {\\n      if (parse.hasOwnProperty(\\\"init_script\\\")) {\\n        //fba.log(t + \\\":执行init_script\\\");\\n        eval(parse.init_script);\\n      }\\n      //fba.log(navigator.platform);\\n      if (js.includes(\\\"click()\\\")) {\\n        //fba.log(t + \\\":执行js点击\\\")\\n      }\\n      eval(js)\\n    }, parse.js, parse_obj, MY_RULE.title)\\n  }\\n  try {\\n    let item = findItem(id);\\n    updateItem(id, {\\n      extra: Object.assign({}, item.extra, extra)\\n    });\\n  } catch (e) { }\\n}\\n\\nfunction parseQuery(query) {\\n  var obj = {};\\n  query.split(\\\"&\\\").filter(e => e).forEach(function (item) {\\n    var parts = item.split(\\\"=\\\");\\n    obj[parts[0]] = parts[1];\\n  });\\n  return obj;\\n}\\n\\n$.exports.parse = function (input, id, source) {\\n  let drpy = GM.defineModule(\\\"DrpyManage\\\").getBySource(source);\\n  input = input.split(\\\"#\\\");\\n  let splay = JSON.parse(drpy.play(input[1], input[0].replace(\\\"tvbox-xg:\\\", \\\"\\\"), []));\\n  let play = splay;\\n\\n  let mark = drpy.getRule(\\\"类型\\\") === \\\"听书\\\"||drpy.getRule(\\\"title\\\").includes('[听]')  ? \\\"#isMusic=true#\\\" : \\\"#isVideo=true#\\\";\\n  if (typeof play !== \\\"object\\\" || !play.url) {\\n    play = {\\n      url: input[0],\\n      parse: 1\\n    };\\n    if (!play.url.startsWith(\\\"http\\\")) {\\n      return \\\"toast://连接为空\\\";\\n    }\\n  }\\n  play = Object.assign(play, splay);\\n\\n  play.url = String(play.url);\\n  if (play.url.includes(\\\"proxy?do\\\") || play.url.includes(\\\"proxy?hikerSkey\\\")) {\\n    MY_URL = play.url;\\n    play.url = decodeURIComponent(getParam(\\\"url\\\", \\\"\\\"));\\n  }\\n  if (play.url.startsWith(\\\"push://\\\")) {\\n    play.url = play.url.replace(\\\"push://\\\", \\\"\\\");\\n  }\\n  if (play.url.startsWith(\\\"https://pan.quark.cn/\\\")) {\\n    return \\\"hiker://page/quarkList?rule=Quark.简&realurl=\\\" + encodeURIComponent(play.url) + \\\"&sharePwd=\\\";\\n  }\\n  if (play.url.startsWith('https://www.aliyundrive.com/s/') || play.url.startsWith(\\\"https://www.alipan.com/s/\\\")) {\\n    return \\\"hiker://page/aliyun?rule=云盘君.简&page=fypage&realurl=\\\" + encodeURIComponent(play.url);\\n  }\\n  if (play.url.startsWith(\\\"pics://\\\")) {\\n    return play.url;\\n  }\\n  if (play.url.startsWith(\\\"novel://\\\")) {\\n    return $(\\\"hiker://empty#readTheme#\\\").rule((data) => {\\n      let data = JSON.parse(data);\\n      let layout = [];\\n      let content = \\\"　　\\\" + data.content.split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it => it.trim()).join(\\\"<br>　　\\\");\\n      layout.push({\\n        col_type: \\\"rich_text\\\",\\n        title: (\\\"<strong>\\\" + data.title + \\\"</strong>\\\").big(),\\n      });\\n\\n      layout.push({\\n        title: content,\\n        col_type: 'rich_text',\\n        extra: {\\n          textSize: 18,\\n          click: true\\n        }\\n      });\\n      setResult(layout);\\n    }, play.url.replace(\\\"novel://\\\", \\\"\\\"));\\n  }\\n  //log(play);\\n  if (play.parse === 1 || play.jx === 1) {\\n    if (play.url.startsWith(\\\"magnet:\\\")) {\\n      return play.url;\\n    }\\n    id && carryJs(play, id);\\n    if (play.jx === 1 || (isofficial(play.url) && (play.flag || input[1]))) {\\n      return useParses(play.url, play.flag || input[1]);\\n    }\\n    return \\\"video://\\\" + play.url;\\n\\n  } else if (play.parse === 0) {\\n    if (play.url.startsWith(\\\"magnet:\\\")) {\\n      return play.url;\\n    }\\n    //log(play)\\n    var playobj = {};\\n    playobj.urls = [play.url + mark];\\n    if (play.hasOwnProperty(\\\"header\\\")) {\\n      playobj[\\\"headers\\\"] = play.header;\\n    }\\n    if (play.hasOwnProperty(\\\"danmaku\\\")) {\\n      playobj[\\\"danmu\\\"] = play.danmaku;\\n    }\\n    return JSON.stringify(playobj);\\n  } else {\\n    return play.url;\\n  }\\n}\\n$.exports.prepareParses = prepareParses;\"},{\"col_type\":\"movie_3\",\"name\":\"创建订阅\",\"path\":\"createSubscription\",\"rule\":\"js:\\nsetPageTitle(\\\"创建订阅\\\");\\nlet layout = [];\\nlet f = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\naddListener(\\\"onClose\\\", () => {\\n    clearMyVar(\\\"drpyHiker_sub_input\\\");\\n    clearMyVar(\\\"drpyHiker_suburl_input\\\");\\n    clearMyVar(\\\"drpyHiker_subname_input\\\");\\n});\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"订阅名称\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: \\\"\\\",\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_subname_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_subname_input\\\"\\n    }\\n});\\nlet path = joinUrl(getPath(\\\"hiker://files/\\\"), \\\"../\\\".repeat(5)).slice(7);\\nlayout.push({\\n    title: \\\"选择\\\",\\n    url: JSON.stringify(f.fileSelectionUri({\\n        callback: $.toString(() => {\\n            let target = findItem(\\\"drpyHiker_sub_input\\\").extra;\\n            updateItem(\\\"drpyHiker_sub_input\\\", {\\n                extra: Object.assign(target, {\\n                    defaultValue: PATH\\n                })\\n            });\\n            return true;\\n        }),\\n        rootDirPath: path,\\n        initialPath: path,\\n        pattern: 1\\n    })),\\n    col_type: \\\"input\\\",\\n    desc: \\\"储存路径\\\",\\n    extra: {\\n        defaultValue: \\\"\\\",\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_sub_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_sub_input\\\"\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"订阅地址\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: \\\"\\\",\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_suburl_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_suburl_input\\\"\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"确认\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n        let path = getMyVar(\\\"drpyHiker_sub_input\\\", \\\"\\\");\\n        let url = getMyVar(\\\"drpyHiker_suburl_input\\\", \\\"\\\");\\n        let name = getMyVar(\\\"drpyHiker_subname_input\\\", \\\"\\\");\\n        if (!(path && url && name)) {\\n            return \\\"toast://不可为空\\\";\\n        }\\n        let rule = base64Encode(\\\"海阔视界规则分享，当前分享的是：合集规则订阅￥home_sub￥\\\" + name + \\\"@@\\\" + url+`@js=$.require('subscribe?rule=${MY_RULE.title}').parseUrl(input, '${base64Encode(path)}')`);\\n        return \\\"rule://\\\" + rule;\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"解析订阅\",\"path\":\"subscribe\",\"rule\":\"js:\\nfunction generateConfigByGithub(url, path) {\\n    let rope = url.split(\\\"/\\\").slice(3, 5).join(\\\"/\\\");\\n    let html = fetch(url);\\n    \\n    let jsonText = pdfh(html, \\\"#repo-content-pjax-container&&script&&Html\\\");\\n    \\n    let json = JSON.parse(jsonText);\\n    let list = json.payload.tree.items;\\n    let rules = [];\\n    let count = 0;\\n    let names = [];\\n    if (list.length === 0) return \\\"toast://可能删库了\\\";\\n    for (let it of list) {\\n        try {\\n            let name = it.name;\\n            let spath = it.path;\\n            if (!name.endsWith(\\\".js\\\")) continue;\\n            name = name.slice(0, name.lastIndexOf(\\\".\\\"));\\n            let rule = fetch(`https://raw.gitmirror.com/${rope}/master/${spath}`);\\n            if (!((!rule || !rule.includes(\\\"rule\\\")) && !fileExist(path + it.name))) {\\n                writeFile(path + it.name, rule);\\n                rules.push({\\n                    'key': `hipy_js_${name}`,\\n                    'name': `${name}`,\\n                    'type': 3,\\n                    'api': '../libs/drpy2.js',\\n                    'searchable': 1,\\n                    'quickSearch': 1,\\n                    'filterable': 1,\\n                    'ext': \\\"./\\\" + it.name,\\n                });\\n                count++;\\n            }\\n            \\n        } catch (e) {\\n            log(e.toString());\\n        }\\n        names.push(it.name);\\n    }\\n    deletelose(names, path)\\n    \\n    writeFile(path + \\\"index.json\\\", JSON.stringify({\\n        sites: rules\\n    }));\\n    \\n    /*\\n    writeFile(path.replace(/\\\\.js$/,'.json'), JSON.stringify({\\n        sites: rules\\n    }));\\n    */\\n\\n    return \\\"toast://成功更新\\\" + count + \\\"个\\\";;\\n}\\n\\nfunction deletelose(names, path) {\\n    try {\\n        let pathFile = new java.io.File(path);\\n        if (!pathFile.isDirectory()) return;\\n        for (let file of pathFile.listFiles()) {\\n            let name = String(file.getName());\\n            if (!name.endsWith(\\\".js\\\") || names.includes(name)) continue;\\n            deleteFile(file.getPath());\\n        }\\n    } catch (e) {\\n        toast(\\\"清理失效源失败:\\\" + e.toString());\\n    }\\n}\\n\\nfunction generateConfigByIndex(url, path) {\\n    let json = JSON.parse(toCorrectJSONString(request(url)));\\n    let arr = json.sites;\\n    let count = 0;\\n    let i = 0;\\n    let names = [];\\n    for (let it of arr) {\\n        try {\\n            if ((String(it.api).includes(\\\"drpy2.min.js\\\") || String(it.api).includes(\\\"drpy2.js\\\"))) {\\n                let name = it.ext.endsWith(\\\".js\\\") ? decodeURIComponent(it.ext.split(\\\"/\\\").at(-1)) : (it.name + \\\".js\\\");\\n                let rule;\\n                if (String(it.ext).startsWith(\\\"http\\\")) {\\n                    rule = request(it.ext);\\n                } else {\\n                    rule = request(joinUrl(url, it.ext));\\n                }\\n                it.ext = \\\"./\\\" + name;\\n                if (!rule || !rule.includes(\\\"rule\\\")) {\\n                    if (!fileExist(path + name))\\n                        arr.splice(i, 1);\\n                    continue;\\n                };\\n                writeFile(path + name, rule);\\n                names.push(name);\\n                count++;\\n            }\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n        i++;\\n    }\\n    deletelose(names, path);\\n    writeFile(path + \\\"index.json\\\", JSON.stringify(json));\\n    //writeFile(path.replace(/\\\\.js$/,'.json'), JSON.stringify(json));\\n    return \\\"toast://成功更新\\\" + count + \\\"个\\\";\\n}\\n$.exports.parseUrl = function (url, path) {\\n    path = base64Decode(path);\\n    path = path.endsWith(\\\"/\\\") ? path : path + \\\"/\\\";\\n    try {\\n        if (url.startsWith(\\\"https://github.com/hjdhnx/\\\")) {\\n            return generateConfigByGithub(url, path);\\n        } else {\\n            return generateConfigByIndex(url, path);\\n        }\\n    } catch (e) {\\n        log(e.toString());\\n        return \\\"error:\\\" + e.toString();\\n    }\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"运行时配置管理\",\"path\":\"runtimeConfig\",\"rule\":\"js:\\nconst searchAllowPath = \\\"hiker://files/rules/DrpyHiker/searchAllow.json\\\";\\nlet isPrepare = false;\\nlet configs, currentConfig = {},\\n    sourceList, currentSource, searchAllow = [];\\nlet tagClasses;\\nlet sTag = \\\"\\\";\\nlet loadError;\\n\\nfunction init(config) {\\n    if (!config) return null;\\n    if (!config.path) return null;\\n    try {\\n        let file;\\n        let sourceList = [];\\n        if (config.path.startsWith(\\\"file://\\\") && (file = new java.io.File(config.path.replace(\\\"file://\\\", \\\"\\\"))).isDirectory()) {\\n            sourceList = generateConfigByLocal(file);\\n            config.type = \\\"localDir\\\";\\n            //sourceList=[];\\n        } else if (config.path.startsWith(\\\"file://\\\") && config.path.endsWith(\\\".js\\\") && file && file.isFile()) {\\n            sourceList = generateConfigByJs(config.path);\\n            config.type = \\\"indexjs\\\";\\n            //sourceList=[];\\n        } else if (config.path.startsWith(\\\"https://github.com\\\")) {\\n            sourceList = generateConfigByGithub(config.path);\\n            config.type = \\\"githubDir\\\";\\n            //sourceList=[];\\n        } else {\\n            let json = JSON.parse(toCorrectJSONString(fetch(config.path) || \\\"{}\\\"));\\n            if (!Array.isArray(json.sites) || !json.sites.length) {\\n                if (json.hasOwnProperty(\\\"sites\\\") && json.sites.hasOwnProperty(\\\"data\\\")) {\\n                    json.sites = json.sites.data;\\n                } else {\\n                    throw new Error(\\\"从网络获取的配置文件为空，请检查网络\\\");\\n                }\\n            }\\n            sourceList = filterOther(json.sites);\\n            if (sourceList[0].hasOwnProperty(\\\"id\\\")) {\\n                sourceList = sourceList.map(item => {\\n                    if (item.hasOwnProperty(\\\"id\\\") && !item.hasOwnProperty(\\\"key\\\")) {\\n                        item[\\\"key\\\"] = item[\\\"id\\\"];\\n                    }\\n                    return item;\\n                })\\n            }\\n            config.type = \\\"index\\\";\\n        }\\n        file = void 0;\\n        let currentSource, searchAllow;\\n        if (config.cKey) {\\n            currentSource = sourceList.find(v => v.key === config.cKey);\\n            if (!currentSource) {\\n                currentSource = sourceList[0];\\n                //currentConfig.cKey = sourceList[0].key;\\n            }\\n        } else {\\n            currentSource = sourceList[0];\\n            //config.cKey = sourceList[0].key;\\n        }\\n        try {\\n            searchAllow = JSON.parse(fetch(searchAllowPath) || \\\"[]\\\");\\n        } catch (e) {\\n            deleteFile(searchAllowPath);\\n            searchAllow = [];\\n        }\\n        loadError = void 0;\\n        return {\\n            currentSource,\\n            searchAllow,\\n            sourceList\\n        };\\n    } catch (e) {\\n        log(e.toString());\\n        loadError = e;\\n    }\\n\\n    return null;\\n}\\n\\nfunction generateConfigByLocal(dirFile) {\\n    let list = dirFile.listFiles();\\n    let rules = [];\\n\\n    for (let it of list) {\\n        let name = String(it.getName());\\n        let path = it.getPath();\\n        if (!name.endsWith(\\\".js\\\") || it.isDirectory()) continue;\\n        name = name.slice(0, name.lastIndexOf(\\\".\\\"));\\n        rules.push({\\n            'key': `hipy_js_${name}`,\\n            'name': `${name}`,\\n            'type': 3,\\n            'searchable': 1,\\n            'quickSearch': 1,\\n            'filterable': 1,\\n            'ext': `${path}`,\\n        });\\n    }\\n    try {\\n        let mapping = getLoaclMapping(String(dirFile.getPath()));\\n\\n        if (mapping.length) {\\n            for (let it of mapping) {\\n                let index = rules.findIndex(v => v.name === it.key);\\n                if (index === -1) continue;\\n                let item = rules[index];\\n                rules.splice(index, 0, Object.assign({}, item, {\\n                    'key': `hipy_js_${it.tokey}`,\\n                    'name': `${it.tokey}`,\\n                    'ext': item.ext + \\\"?\\\" + it.params,\\n                    del: void 0\\n                }));\\n                item.del = true;\\n            }\\n            rules = rules.filter(v => !v.del);\\n        }\\n    } catch (e) {\\n\\n    }\\n    return rules;\\n}\\n\\nfunction getLoaclMapping(dirFile) {\\n    //key@params@type\\n    let mappingPath = \\\"file://\\\" + joinUrl(dirFile, \\\"./\\\") + \\\"/.mapping.txt\\\";\\n    let mapping = [];\\n    if (!fileExist(mappingPath)) return mapping;\\n    try {\\n        let mappingTxt = fetch(mappingPath);\\n        mappingTxt.split(\\\"\\\\n\\\").forEach(v => {\\n            let [key, params, tokey, type] = v.split(\\\"@\\\");\\n            if (type === \\\"base64\\\") {\\n                params = base64Decode(params);\\n            } else if (type === \\\"uri\\\") {\\n                params = decodeURIComponent(params);\\n            }\\n            mapping.push({\\n                key,\\n                params,\\n                tokey: tokey || key\\n            });\\n        });\\n\\n    } catch (e) { }\\n    return mapping;\\n}\\nfunction evalJs(code, global) {\\n    let Context = org.mozilla.javascript.Context;\\n    let cx = Context.getCurrentContext();\\n    //let global = org.mozilla.javascript.ScriptableObject.getTopLevelScope(this);\\n    /*if(!cx.getLanguageVersion()){\\n        cx.setLanguageVersion(Context.VERSION_ES6);\\n    }*/\\n    global = global || {};\\n    return org.mozilla.javascript.ScriptRuntime.evalSpecial(cx, global, global, [String(code)], \\\"eval code\\\", 1);\\n}\\n\\nfunction generateConfigByJs(jsPath) {\\n\\n    let main = evalJs(request(jsPath).replace(/async\\\\s*?function\\\\s*?main/g, \\\"function main\\\") + \\\"\\\\n;main;\\\", {\\n        pathLib: {\\n            join: joinUrl,\\n            readFile(path) {\\n                path = path.startsWith(\\\"file://\\\") ? path : (\\\"file://\\\" + path);\\n\\n                return fetch(path);\\n            },\\n            readDir(path) {\\n                let names = [];\\n                let file = new java.io.File(path.replace(\\\"file://\\\", \\\"\\\"));\\n\\n                if (!(file.exists() && file.isDirectory())) return names;\\n                for (let it of file.listFiles()) {\\n                    names.push(String(it.getName()));\\n                }\\n                return names;\\n            },\\n            dirname(pa) {\\n                let path = joinUrl(jsPath, pa);\\n                let names = [];\\n                let file = new java.io.File(path);\\n\\n                if (!(file.exists() && file.isDirectory())) return names;\\n                for (let it of dirFile.listFiles()) {\\n                    if (it.isDirectory) {\\n                        names.push(String(it.getName()));\\n                    }\\n                }\\n                return paths;\\n            },\\n            stat() {\\n                return true;\\n            }\\n        },\\n        log: log,\\n        path: jsPath,\\n        path_dir: joinUrl(jsPath, \\\"./\\\")\\n    });\\n    let jsonText = main();\\n    let json = JSON.parse(jsonText);\\n\\n    if (Array.isArray(json)) {\\n        return filterOther(json);\\n    } else if (Array.isArray(json.sites) && json.sites.length) {\\n       // writeFile(joinUrl(jsPath, \\\"./index.json\\\"), jsonText);\\n       /*\\n        if(!/index\\\\.js$/.test(jsPath)){\\n            writeFile(jsPath.replace(/\\\\.js$/,'.json'), jsonText);\\n        }\\n        */\\n        writeFile(jsPath.replace(/\\\\.js$/,'.json'), jsonText);\\n        return filterOther(json.sites || []);\\n    }\\n}\\n\\nfunction generateConfigByGithub(url) {\\n    //url=url.replace(/(#GITHUB#)$/,\\\"\\\");\\n    let prefix = getItem(\\\"githubraw\\\", \\\"https://raw.gitmirror.com\\\");\\n    let rope = url.split(\\\"/\\\").slice(3, 5).join(\\\"/\\\");\\n    let html = fetch(url);\\n    let jsonText = pdfh(html, \\\"#repo-content-pjax-container&&script&&Html\\\");\\n    let json = JSON.parse(jsonText);\\n    let list = json.payload.tree.items;\\n    let rules = [];\\n    for (let it of list) {\\n        let name = it.name;\\n        let path = it.path;\\n        if (!name.endsWith(\\\".js\\\")) continue;\\n        name = name.slice(0, name.lastIndexOf(\\\".\\\"));\\n        rules.push({\\n            'key': `hipy_js_${name}`,\\n            'name': `${name}`,\\n            'type': 3,\\n            'searchable': 1,\\n            'quickSearch': 1,\\n            'filterable': 1,\\n            'ext': `${prefix}/${rope}/master/${path}`,\\n        });\\n        /*\\n        https://github.com/hjdhnx/hipy-server/tree/master/app/t4/files/drpy_js\\n        https://raw.githubusercontent.com/hjdhnx/hipy-server/master/app/t4/files/drpy_js/360%E5%BD%B1%E8%A7%86%5B%E5%AE%98%5D.js*/\\n    }\\n    return rules;\\n}\\n\\nfunction prepare(config) {\\n    let data = init(config);\\n    if (!data) return false;\\n    currentSource = data.currentSource;\\n    searchAllow = data.searchAllow;\\n    sourceList = data.sourceList;\\n    currentConfig = config;\\n    sTag = config.sTag || \\\"\\\";\\n    return true;\\n}\\n\\nfunction filterOther(list) {\\n    let supportType = [0, 1, 4];\\n    return list.filter(it => String(it.api).includes(\\\"drpy2.min.js\\\") || String(it.api).includes(\\\"drpy2.js\\\") || supportType.includes(it.type));\\n}\\n\\n\\nfunction getCurrentConfig() {\\n    return currentConfig || {};\\n}\\n\\nfunction setCurrentConfig(config) {\\n    let cpath = (currentConfig || {}).path;\\n    if (prepare(config)) {\\n        storage0.setItem(\\\"currentConfig\\\", config);\\n        if (cpath != config.path) {\\n            deleteFile(searchAllowPath);\\n            searchAllow = [];\\n            tagClasses = void 0;\\n        }\\n        isPrepare = true;\\n        return true;\\n    } else {\\n        return false;\\n    }\\n}\\n\\nfunction findSource(key) {\\n    let s = sourceList.find(v => v.key === key);\\n    if (s) {\\n        s.ext = getAbsolutePath(String(s.ext));\\n    }\\n    return s;\\n}\\n\\nfunction getCurrentSource() {\\n    return currentSource;\\n}\\n\\nfunction getCurrentSourcePath() {\\n    let path = String(currentSource.ext);\\n    return getAbsolutePath(path);\\n}\\n\\nfunction getAbsolutePath(path) {\\n    path = String(path);\\n    if (path.startsWith(\\\"http\\\") || path.startsWith(\\\"file://\\\")) {\\n        return path;\\n    } else {\\n        return joinUrl(currentConfig.path, path);\\n    }\\n}\\n\\nfunction setCurrentSource(key) {\\n    let source = sourceList.find(v => v.key === key);\\n    if (source) {\\n        currentConfig.cKey = key;\\n        storage0.setItem(\\\"currentConfig\\\", currentConfig);\\n        currentSource = source;\\n        return true;\\n    }\\n    return false;\\n}\\n\\nfunction getCanSearchSource() {\\n    let list = sourceList.filter(v => v.searchable === undefined || v.searchable);\\n    if (getLeach()) {\\n        list = leachList(list);\\n    }\\n    return list;\\n}\\n\\nfunction getLeach() {\\n    let leach;\\n    let gleach = getItem(\\\"leach\\\", \\\"\\\");\\n    let tleach = getMyVar(\\\"tempLeach\\\", \\\"\\\");\\n    if(tleach!=\\\"\\\"){\\n      leach=false;\\n      return leach;\\n    }\\n    if(gleach!=\\\"\\\"){\\n      leach=true;\\n    }\\n    return leach||false;\\n}\\n\\nfunction leachList(list) {\\n    var reg = /([\\\\[【])[密]([】\\\\]])/;\\n    return list.filter(v => !reg.test(v.name));\\n}\\n\\nfunction getAllSource() {\\n    let list = sourceList.slice();\\n    if (getLeach()) {\\n        list = leachList(list);\\n    }\\n    return list;\\n}\\n\\nfunction getAllSources() {\\n    return sourceList;\\n}\\n\\nfunction getSearchAllow() {\\n    return searchAllow;\\n}\\n\\nfunction setSearchAllow() {\\n    if (Array.isArray(searchAllow)) {\\n        saveFile(searchAllowPath, JSON.stringify(searchAllow));\\n    }\\n}\\n\\nfunction getTagClasses() {\\n    if (Array.isArray(tagClasses)) return tagClasses.slice();\\n    tagClasses = [];\\n    if (isPrepare && sourceList) {\\n        sourceList.forEach((v) => {\\n            let tag = String(v.name).split(\\\"]\\\")[0].split(\\\"[\\\")[1];\\n            if (tag && !tagClasses.includes(tag)) {\\n                tagClasses.push(tag);\\n            }\\n        });\\n    }\\n    return tagClasses.slice();\\n}\\n\\nfunction setSearchTag(tag) {\\n\\n    if (tagClasses && tagClasses.includes(tag) || (typeof tag === \\\"string\\\" && !tag)) {\\n        currentConfig.sTag = tag;\\n        storage0.setItem(\\\"currentConfig\\\", currentConfig);\\n        sTag = tag;\\n        return true;\\n    }\\n    return false;\\n}\\n\\nfunction getSearchTag() {\\n    return sTag;\\n}\\n\\n\\n\\n\\nfunction getAllowSearchSource(useSTag) {\\n    let slist;\\n    if (searchAllow.length && !useSTag) {\\n        slist = sourceList.filter(v => searchAllow.includes(v.key));\\n    } else {\\n        slist = sourceList.filter(v => v.searchable);\\n    }\\n    if (useSTag) {\\n        if (sTag) {\\n            slist = slist.filter(v => String(v.name).includes(\\\"[\\\" + sTag + \\\"]\\\"));\\n        } else {\\n            slist = slist.filter(v => !/\\\\[.*?\\\\]/.test(String(v.name)));\\n        }\\n    }\\n    if (slist.length == 0) {\\n        slist = sourceList.slice();\\n    }\\n    if (getLeach()) {\\n        slist = leachList(slist);\\n    }\\n    return slist;\\n}\\n\\nfunction isPrepared() {\\n    return isPrepare;\\n}\\n\\nfunction getLoadError() {\\n    return loadError;\\n}\\n\\nfunction initDefault() {\\n    return prepare(currentConfig.path ? currentConfig : storage0.getItem(\\\"currentConfig\\\", {}));\\n}\\n\\n\\nfunction initAndFilter() {\\n    isPrepare = initDefault();\\n    if (!getMyVar(\\\"tempLeach\\\", \\\"\\\") && getItem(\\\"leach\\\", \\\"\\\") && currentSource) {\\n        if (currentSource.name.includes(\\\"[密]\\\")) {\\n            currentSource = null;\\n        }\\n    }\\n}\\ninitAndFilter();\\n$.exports = {\\n    init,\\n    prepare,\\n    getCurrentConfig,\\n    setCurrentConfig,\\n    getCurrentSource,\\n    getCurrentSourcePath,\\n    setCurrentSource,\\n    getCanSearchSource,\\n    getSearchAllow,\\n    setSearchAllow,\\n    getAllSource,\\n    getAllowSearchSource,\\n    isPrepared,\\n    getAbsolutePath,\\n    getAllSources,\\n    findSource,\\n    getTagClasses,\\n    setSearchTag,\\n    getSearchTag,\\n    getLoadError,\\n    initDefault\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"编辑配置\",\"path\":\"createConfig\",\"rule\":\"js:\\nlet layout = [];\\nsetPageTitle(\\\"创建配置\\\");\\nlet runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\nlet currentconfig = runtimeConfig.getCurrentConfig();\\nlet f = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\naddListener(\\\"onClose\\\", () => {\\n  clearMyVar(\\\"drpyHiker_config_name\\\");\\n  clearMyVar(\\\"drpyHiker_config_path\\\");\\n});\\n\\n//历史配置记录\\nfunction uniqueArrayByProperty(array, property) {\\n  let unique = [];\\n  let map = new Map();\\n  for (let item of array) {\\n    let key = item[property];\\n    if (!map.has(key)) {\\n      map.set(key, true);\\n      unique.push(item);\\n    }\\n  }\\n  return unique;\\n}\\nlet cpath = \\\"hiker://files/rules/DrpyHiker/\\\" + \\\"drpyconfig.json\\\";\\nlet oldpath = \\\"hiker://files/cache/\\\" + \\\"drpyconfig.json\\\"\\nif (!fileExist(cpath) && fileExist(oldpath)) {\\n  let content = JSON.parse(readFile(oldpath)) || [];\\n  saveFile(cpath, JSON.stringify(content));\\n}\\nlet pathconfigs = [];\\ntry {\\n  pathconfigs = JSON.parse(readFile(cpath)) || [];\\n  //putMyVar(\\\"drpyHiker_configs\\\",pathconfigs);\\n} catch (e) {\\n  console.log(e.message);\\n}\\npathconfigs = uniqueArrayByProperty(pathconfigs, \\\"path\\\");\\n//log(pathconfigs)\\n\\nlet configs_obj = {\\n  path: cpath,\\n  configs: pathconfigs\\n}\\n//历史配置记录\\n\\nlayout.push({\\n  col_type: \\\"avatar\\\",\\n  title: \\\"提示\\\",\\n  pic_url: \\\"https://hikerfans.com/tubiao/system/27.png\\\",\\n  url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n    const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n    let pop = hikerPop.infoBottom({\\n      content: \\\"详细\\\",\\n      options: [\\n        \\\"第一空(名称):方便下次找到\\\",\\n        \\\"第二空(路径)[填本地索引地址]:选择JSON/URL选项，点击旁边的选择可以浏览本地文件选择本地包的.json索引文件即可。\\\\n(注意：使用此种方式，在本地文件夹内新增或删除.js源时需要自行配置.json文件)\\\",\\n        \\\"第二空(路径)[填本填远程地址]:直接填写远程链接即可一般是以http开头.json结尾，也可可以输入github仓库的文件夹地址。此种方式可以保持与远程配置者同步更新，但不如本地快。\\\",\\n        \\\"第二空(路径)[填本地文件夹地址]:选择文件夹选项，可以直接输入js源所在#文件夹!!!#的路径，也可以点击旁边选择浏览本地路径选择#文件夹!!!#，使用该种方法，在文件夹新增或删除源时，不用手动配置.json文件，自动读取。(注意：需要刷新配置或重启软件才能读取)\\\",\\n        \\\"[Q&A]为什么订阅链接有很多源，却只识别到了几个源？\\\\n本小程序只支持道长的drpy[js]视频源，其他一概不支持。因此会自动过滤其他源\\\",\\n        \\\"[Q&A]打算支持其他tvbox的源吗？不支持不考虑。请看名字DrpyHiker，只支持drpy，要用其他源，建议删除本小程序，去用各种壳子。\\\"\\n      ]\\n    });\\n    return \\\"hiker://empty\\\";\\n  }),\\n});\\nlayout.push({\\n  col_type: \\\"input\\\",\\n  desc: \\\"名称(必填)\\\",\\n  extra: {\\n    titleVisible: false,\\n    defaultValue: getMyVar(\\\"drpyHiker_config_name\\\", \\\"\\\"),\\n    onChange: $.toString(() => {\\n      putMyVar(\\\"drpyHiker_config_name\\\", input);\\n    }),\\n    id: \\\"drpyHiker_config_name\\\"\\n  }\\n});\\n//let select_mode=\\\"0\\\";\\n\\nlet select_mode = getItem(\\\"select_config_mode\\\", \\\"0\\\");\\nlet nav = [\\\"JSON/URL/JS\\\", \\\"文件夹\\\"];\\n\\nnav.forEach((x, i) => {\\n  layout.push({\\n    title: '““””' + (i == select_mode ? x.fontcolor(\\\"#15B76C\\\") : x),\\n    url: $('#noLoading#').lazyRule((i) => {\\n      setItem(\\\"select_config_mode\\\", i + \\\"\\\");\\n      refreshPage();\\n      return \\\"hiker://empty\\\";\\n    }, i),\\n    col_type: 'scroll_button',\\n  })\\n})\\n\\n\\nlet path = joinUrl(getPath(\\\"hiker://files/\\\"), \\\"../\\\".repeat(5)).slice(7);\\n\\nif (select_mode == \\\"0\\\") {\\n  layout.push({\\n    title: \\\"选择\\\",\\n    url: JSON.stringify(f.fileSelectionUri({\\n      callback: $.toString(() => {\\n        let target = findItem(\\\"drpyHiker_config_path\\\").extra;\\n        updateItem(\\\"drpyHiker_config_path\\\", {\\n          extra: Object.assign(target, {\\n            defaultValue: PATH\\n          })\\n        });\\n        return true;\\n      }),\\n      rootDirPath: path,\\n      initialPath: path,\\n      pattern: 0,\\n      fileType: \\\".json|.js\\\",\\n    })),\\n    col_type: \\\"input\\\",\\n    desc: \\\"路径(URL/JSON/JS/Github)\\\",\\n    extra: {\\n      defaultValue: \\\"\\\",\\n      onChange: $.toString(() => {\\n        putMyVar(\\\"drpyHiker_config_path\\\", input);\\n      }),\\n      id: \\\"drpyHiker_config_path\\\"\\n    }\\n  });\\n}\\nif (select_mode == \\\"1\\\") {\\n  layout.push({\\n    title: \\\"选择\\\",\\n    url: JSON.stringify(f.fileSelectionUri({\\n      callback: $.toString(() => {\\n        let target = findItem(\\\"drpyHiker_config_folder\\\").extra;\\n        updateItem(\\\"drpyHiker_config_folder\\\", {\\n          extra: Object.assign(target, {\\n            defaultValue: PATH\\n          })\\n        });\\n        return true;\\n      }),\\n      rootDirPath: path,\\n      initialPath: path,\\n      pattern: 1,\\n      //fileType: \\\".json\\\",\\n    })),\\n    col_type: \\\"input\\\",\\n    desc: \\\"路径(文件夹)\\\",\\n    extra: {\\n      defaultValue: \\\"\\\",\\n      onChange: $.toString(() => {\\n        putMyVar(\\\"drpyHiker_config_path\\\", input);\\n      }),\\n      id: \\\"drpyHiker_config_folder\\\"\\n    }\\n  });\\n}\\nlayout.push({\\n  col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n  title: \\\"确认\\\",\\n  url: $(\\\"#noLoading#\\\").lazyRule((cobj) => {\\n    let path = getMyVar(\\\"drpyHiker_config_path\\\", \\\"\\\");\\n    let name = getMyVar(\\\"drpyHiker_config_name\\\", \\\"\\\");\\n    if (!(path && name)) {\\n      return \\\"toast://不可为空\\\";\\n    }\\n    path = path.startsWith(\\\"http\\\") ? path : path.startsWith(\\\"/\\\") ? (\\\"file://\\\" + path) : path;\\n    //log(path)\\n    try {\\n      let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n      if (path.startsWith(\\\"http\\\")) {\\n        showLoading(\\\"正在加载配置...\\\");\\n      }\\n      let configc = {\\n        path,\\n        name,\\n      };\\n      if (runtimeConfig.setCurrentConfig(configc)) {\\n        cobj.configs.push({\\n          path,\\n          name,\\n        });\\n        clearItem(\\\"no_loading\\\");\\n        saveFile(cobj.path, JSON.stringify(cobj.configs));\\n\\n        let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n        DrpyManage.clear();\\n        back(false);\\n        $.require(\\\"ChangeSourcePop\\\").show(100);\\n        return \\\"toast://设置成功\\\";\\n      }\\n      return \\\"toast://配置文件有误\\\";\\n    } catch (e) {\\n      return \\\"toast://\\\" + e.toString();\\n    } finally {\\n      hideLoading();\\n    }\\n  }, configs_obj),\\n  col_type: \\\"text_center_1\\\",\\n});\\n\\nif (pathconfigs.length) {\\n  layout.push({\\n    title: '““””' + \\\"<small>历史配置记录 点我进行配置检验</small>\\\",\\n    url: $('#noLoading#').lazyRule((p) => {\\n      //log(p)\\n      function unique(arr) {\\n        const res = new Map();\\n        return arr.filter((a) => !res.has(a) && res.set(a, 1))\\n      }\\n      var results = [];\\n      if (p.length == 0) {\\n        return \\\"toast://无地址\\\";\\n      }\\n      list = p.map(x => x.path);\\n      var task = function (obj) {\\n        let s = Date.now();\\n        let jsFiles = [];\\n        let count = 0;\\n\\n        function filterOther(list) {\\n          return list.filter(it => String(it.api).includes(\\\"drpy2.min.js\\\") || String(it.api).includes(\\\"drpy2.js\\\"))\\n        }\\n        if (obj.url.startsWith(\\\"file:\\\")) {\\n          let code = \\\"no\\\";\\n          let path = obj.url.replace(\\\"file://\\\", \\\"\\\");\\n          let dir = new java.io.File(path);\\n          if (dir.isDirectory()) {\\n            let flist = dir.listFiles();\\n            for (var f of flist) {\\n              // 检查文件名是否以.js结尾\\n              if (f.isFile() && f.getName().toLowerCase().endsWith(\\\".js\\\")) {\\n                jsFiles.push(f);\\n              }\\n            }\\n          }\\n          if (dir.isFile() && fileExist(obj.url)) {\\n            try {\\n              json = JSON.parse(readFile(obj.url));\\n              if (Array.isArray(json.sites) || json.sites.length) {\\n                count = filterOther(json.sites).length;\\n              }\\n            } catch (e) { }\\n            code = \\\"ok\\\";\\n          }\\n          if (jsFiles.length >= 5) {\\n            count = jsFiles.length;\\n            code = \\\"ok\\\";\\n          }\\n          return {\\n            time: (Date.now() - s),\\n            url: obj.url,\\n            count: count,\\n            code: code,\\n            index: obj.i\\n          }\\n        }\\n        var j = JSON.parse(fetch(obj.url, {\\n          withHeaders: true,\\n          timeout: 5000,\\n        }));\\n        let e = Date.now();\\n        let c = e - s;\\n        if (obj.url.includes(\\\"github.com\\\") && j.statusCode == 200) {\\n          try {\\n            var html = j.body;\\n            var json = JSON.parse(pdfh(html, \\\"#repo-content-pjax-container&&script&&Html\\\"));\\n            let list = json.payload.tree.items;\\n            count = list.filter(x => x.name.endsWith(\\\".js\\\")).length;\\n          } catch { }\\n        }\\n        try {\\n          let json = JSON.parse(toCorrectJSONString(j.body) || \\\"{}\\\");\\n          if (Array.isArray(json.sites) || json.sites.length) {\\n            count = filterOther(json.sites).length;\\n          }\\n        } catch (e) { }\\n\\n        return {\\n          time: c,\\n          url: j.url,\\n          count: count,\\n          code: j.statusCode,\\n          index: obj.i,\\n        }\\n      };\\n      let tasks = list.map((x, i) => {\\n        i = i + 1;\\n        return {\\n          func: task,\\n          param: {\\n            url: x,\\n            i: i - 1,\\n          },\\n          id: 'taskid' + i\\n        }\\n      });\\n      var count = success = tasks.length;\\n      be(tasks, {\\n        func: function (obj, id, error, taskResult) {\\n          obj.results.push(taskResult)\\n          count = count - 1;\\n          if (count > 0) {\\n            showLoading(\\\"检测中...剩余地址：\\\" + count)\\n          } else {\\n            hideLoading();\\n          }\\n        },\\n        param: {\\n          hi: 'ccc',\\n          results: results\\n        }\\n      }, success);\\n      //log(results)\\n      results = results.filter(f => f);\\n      results.forEach((x, i) => {\\n        let item = findItem(\\\"path\\\" + x.index);\\n        let regex = /(名称:.*?)(\\\\s+)?\\\\n/g;\\n        let title = \\\"名称:\\\" + p[x.index].name + \\\" \\\";\\n        let url = p[x.index].path;\\n        let msg = \\\"\\\";\\n        let count = x.count != 0 ? \\\" 源数量:\\\" + x.count : \\\"\\\";\\n        if (/no/.test(x.code)) {\\n          msg = item.title.replace(regex, title + \\\"配置有误\\\".fontcolor(\\\"red\\\") + \\\"\\\\n\\\");\\n        } else if (/^(-1|0|404)/.test(x.code)) {\\n          msg = item.title.replace(regex, title + \\\"无法访问\\\".fontcolor(\\\"red\\\") + \\\"\\\\n\\\");\\n        } else if (/^200/.test(x.code)) {\\n          msg = item.title.replace(regex, title + \\\"通讯正常\\\".fontcolor(\\\"#3CB371\\\") + \\\"  延迟:\\\" + x.time + count + \\\"\\\\n\\\");\\n          //url = item.url;\\n        } else {\\n          msg = item.title.replace(regex, title + \\\"配置正确\\\".fontcolor(\\\"#3CB371\\\") + count + \\\"\\\\n\\\");\\n          //url = item.url;\\n        }\\n        updateItem(item.extra.id, {\\n          title: msg,\\n          //url: url,\\n        })\\n      });\\n      return \\\"hiker://empty\\\"\\n    }, pathconfigs),\\n    col_type: \\\"text_center_1\\\"\\n  });\\n  pathconfigs.forEach((item, i) => {\\n    let longC = [{\\n      title: \\\"名称\\\",\\n      js: $.toString((item, p, c) => {\\n        let i = c.findIndex(x => x.name == item.name);\\n        if (i != -1) {\\n          return $(c[i].name, \\\"输入新名称\\\").input((c, p, i) => {\\n            c[i].name = input;\\n            saveFile(p, JSON.stringify(c));\\n            refreshPage();\\n          }, c, p, i)\\n        }\\n      }, item, cpath, pathconfigs)\\n    }, {\\n      title: \\\"路径\\\",\\n      js: $.toString((item, p, c) => {\\n        let i = c.findIndex(x => x.name == item.name);\\n        if (i != -1) {\\n          return $(c[i].path, \\\"输入新路径\\\").input((c, p, i) => {\\n            c[i].path = input;\\n            saveFile(p, JSON.stringify(c));\\n            refreshPage();\\n          }, c, p, i)\\n        }\\n      }, item, cpath, pathconfigs)\\n    }, {\\n      title: \\\"删除\\\",\\n      js: $.toString((item, p, c) => {\\n        let i = c.findIndex(x => x.name == item.name);\\n        if (i != -1) {\\n          c.splice(i, 1);\\n          saveFile(p, JSON.stringify(c));\\n          refreshPage();\\n        }\\n      }, item, cpath, pathconfigs)\\n    }];\\n    if (item.path.startsWith(\\\"http\\\")) {\\n      longC.push({\\n        title: \\\"访问\\\",\\n        js: $.toString((item) => {\\n          if (item.path.startsWith(\\\"http\\\")) {\\n            return \\\"web://\\\" + item.path;\\n          }\\n        }, item)\\n      })\\n    }\\n    let current = \\\"\\\";\\n    if (currentconfig && currentconfig.hasOwnProperty(\\\"path\\\")) {\\n      if (item.path == currentconfig.path) {\\n        current = \\\"➡️\\\";\\n      }\\n    }\\n    layout.push({\\n      title: '““””' + \\\"<small>\\\" + current + \\\"名称:\\\" + item.name + \\\"\\\\n路径:\\\" + item.path + \\\"</small>\\\",\\n      url: $(\\\"#noLoading#\\\").lazyRule(item => {\\n        clearItem(\\\"no_loading\\\");\\n        let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n        let {\\n          path,\\n          name\\n        } = item;\\n        if (path.startsWith(\\\"http\\\")) {\\n          showLoading(\\\"正在加载配置...\\\");\\n        }\\n        if (runtimeConfig.setCurrentConfig({\\n          path,\\n          name,\\n        })) {\\n\\n          let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n          DrpyManage.clear();\\n          back(false);\\n          $.require(\\\"ChangeSourcePop\\\").show(100);\\n          hideLoading();\\n          return \\\"hiker://empty\\\";\\n        } else {\\n          hideLoading();\\n          return \\\"toast://切换失败\\\";\\n        }\\n      }, item),\\n      col_type: \\\"text_1\\\",\\n      extra: {\\n        id: 'path' + i,\\n        longClick: longC\\n      }\\n    });\\n  });\\n}\\n\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"换源弹窗\",\"path\":\"ChangeSourcePop\",\"rule\":\"$.exports.show = function (time) {\\n  if (time) {\\n    java.lang.Thread.sleep(time);\\n  }\\n  let {\\n    ui_config,\\n    getRangeColors,\\n  } = $.require(\\\"UIManage\\\");\\n  ui_config = ui_config.yi;\\n\\n  let {\\n    getLeach,\\n    leachlist\\n  } = $.require(\\\"methods\\\");\\n\\n  let leach = getLeach();\\n  //log(leach)\\n  leachlist(leach);\\n\\n  const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n  let source = runtimeConfig.getCurrentSource() || {};\\n\\n  let name = source.name || \\\"\\\";\\n  const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n  let color = ui_config.换源颜色;\\n  if (color == \\\"random\\\") {\\n    color = getRangeColors();\\n  }\\n\\n  let slist = Array.from(runtimeConfig.getAllSource());\\n\\n  let sourceNameList = slist.map(v => {\\n    return v.name == name ? `““””<span style=\\\"color:${color}\\\">${v.name}</span>` : v.name;\\n  });\\n\\n  hikerPop.setUseStartActivity(false);\\n\\n  function dateFormat(date) {\\n    let text = 'M-dd HH:mm';\\n    return $.dateFormat(date.getTime(), text);\\n  }\\n\\n  let datetime = dateFormat(new Date());\\n  let ps = datetime.split(\\\" \\\")[1].split(':').reduce((acc, val) => acc + parseInt(val, 10), 0);\\n\\n  //排序方法\\n  let {\\n    naturalSort,\\n    usingSort,\\n    removeHtmlTags\\n  } = $.require(\\\"methods\\\");\\n\\n  let spen = 3;\\n  let items = sourceNameList.map((x, i) => {\\n    return {\\n      title: x,\\n      url: i\\n    }\\n  })\\n\\n  let names = items.map(v => v.title);\\n  let sname = names.slice();\\n  if (getItem(\\\"natural\\\", \\\"\\\")) {\\n    names = naturalSort(names);\\n  }\\n  if (getItem(\\\"usingst\\\", \\\"\\\")) {\\n    names = usingSort.get(names);\\n  }\\n\\n  let manage_all = names.slice();\\n  let searchKey = \\\"\\\";\\n  let inputBox;\\n  let pop = hikerPop.selectBottomRes({\\n    options: names,\\n    columns: spen,\\n    title: \\\"选择视频源 当前共:\\\" + items.length + \\\"个视频源\\\",\\n    noAutoDismiss: true,\\n    position: 1,\\n    extraInputBox: (inputBox = new hikerPop.ResExtraInputBox({\\n      hint: \\\"源关键字\\\",\\n      title: \\\"TAG\\\",\\n      onChange(text, manage) {\\n        //log(\\\"onChange:\\\"+text)\\n\\n        if (!/^\\\\[.*\\\\]$/.test(text)) {\\n          putMyVar(\\\"searchSourceTag\\\", \\\"\\\");\\n        }\\n        let flist = names.filter(x => x.includes(text));\\n        manage.list.length = 0;\\n        flist.forEach(x => {\\n          manage.list.push(x);\\n        });\\n        manage.change();\\n\\n      },\\n      defaultValue: getMyVar(\\\"searchSourceTag\\\", \\\"\\\"),\\n      click(s, manage) {\\n        let tagClasses = runtimeConfig.getTagClasses();\\n        if (!tagClasses.length) return \\\"toast://当前配置没有TAG哦。\\\";\\n        tagClasses.unshift(\\\"全部\\\");\\n        hikerPop.selectCenter({\\n          options: tagClasses,\\n          columns: 3,\\n          title: \\\"TAG[\\\" + tagClasses.length + \\\"]\\\",\\n          click(a) {\\n            let tag = a;\\n            if (a == \\\"全部\\\") {\\n              tag = \\\"\\\";\\n            } else {\\n              tag = \\\"[\\\" + a + \\\"]\\\"\\n            }\\n            inputBox.setDefaultValue(tag);\\n            putMyVar(\\\"searchSourceTag\\\", tag);\\n          }\\n        });\\n      },\\n      titleVisible: true\\n    })),\\n    longClick(s, i) {\\n      showSelectOptions({\\n        title: \\\"分享视频源\\\",\\n        options: [\\\"JS文件分享\\\"].concat(getPastes()),\\n        col: 2,\\n        js: $.toString(name => {\\n          const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n          let sources = runtimeConfig.getAllSource();\\n          let source = sources.find(v => v.name == name);\\n          let path = runtimeConfig.getAbsolutePath(source.ext);\\n          let pname = path.split(\\\"/\\\").at(-1);\\n          let rule = fetch(path);\\n          let encodeMode = getItem(\\\"share_encode\\\", \\\"\\\");\\n          if (encodeMode && /var rule|[\\\\u4E00-\\\\u9FA5]+|function|let |var |const |\\\\(|\\\\)|\\\"|'/.test(rule)) {\\n            if (encodeMode === \\\"Gzip\\\") {\\n              let GZIP = $.require(\\\"GZIP\\\");\\n              rule = GZIP.zip(rule);\\n            } else if (encodeMode === \\\"Base64\\\") {\\n              rule = base64Encode(rule);\\n            } else if (encodeMode === \\\"AES\\\") {\\n              const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n              let key = CryptoUtil.Data.parseHex(\\\"686A64686E780A0A0A0A0A0A0A0A0A0A\\\");\\n              let iv = CryptoUtil.Data.parseHex(\\\"647A797964730A0A0A0A0A0A0A0A0A0A\\\");\\n              let textData = CryptoUtil.Data.parseUTF8(rule);\\n              let encrypted0 = CryptoUtil.AES.encrypt(textData, key, {\\n                mode: \\\"AES/CBC/PKCS7Padding\\\",\\n                iv: iv\\n              });\\n              rule = encrypted0.toBase64(_base64.NO_WRAP);\\n            }\\n          }\\n          if (!rule) return \\\"toast://获取失败\\\";\\n          if (MY_INDEX === 0) {\\n            writeFile(\\\"hiker://files/_cache/\\\" + pname, rule);\\n            return \\\"share://hiker://files/_cache/\\\" + pname;\\n          } else {\\n            let url = sharePaste(base64Encode(rule), input);\\n            return \\\"copy://海阔视界，DRPY视频源「\\\" + name + \\\"」复制整条口令打开软件就会自动导入$\\\" + url + \\\"$\\\" + pname + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input, true)\\\";\\n          }\\n        }, removeHtmlTags(s))\\n      });\\n    },\\n    click(s, i, manage) {\\n      pop.dismiss();\\n      setItem(\\\"no_loading\\\", \\\"1\\\");\\n      // manage.list.forEach((v, ii) => (\\n      //   manage.list[ii] = i === ii ? \\\"‘‘\\\" + names[ii] + \\\"’’\\\" : names[ii].replace(/[’‘]/g, \\\"\\\")\\n      // ));\\n      let name = removeHtmlTags(manage.list[i]);\\n\\n      if (name == source.name) {\\n        refreshPage();\\n        return;\\n      }\\n      let sources = runtimeConfig.getAllSource();\\n      let key = sources.find(v => v.name == name).key;\\n\\n      usingSort.set(name);\\n\\n      //manage.change();\\n      let sourceNameList = runtimeConfig.setCurrentSource(key);\\n\\n      clearMyVar(\\\"catei\\\");\\n      clearMyVar(\\\"cate_obj\\\");\\n      clearMyVar(\\\"ishome\\\");\\n      clearMyVar(\\\"links\\\");\\n      refreshPage();\\n\\n    },\\n    menuClick(manage) {\\n      hikerPop.selectCenter({\\n        options: [\\\"改变样式\\\", \\\"倒序\\\", \\\"自然排序:\\\" + (getItem(\\\"natural\\\", \\\"\\\") == \\\"\\\" ? \\\"关闭\\\" : \\\"启用\\\"), \\\"使用排序:\\\" + (getItem(\\\"usingst\\\", \\\"\\\") == \\\"\\\" ? \\\"关闭\\\" : \\\"启用\\\"), \\\"刷新配置\\\", \\\"分享时编码:\\\" + getItem(\\\"share_encode\\\", \\\"不编码\\\"), \\\"青少年模式:\\\" + (leach ? \\\"开启\\\" : \\\"关闭\\\")],\\n        columns: 2,\\n        title: \\\"请选择 时间 \\\" + datetime,\\n        click(s, i) {\\n          if (s == \\\"改变样式\\\") {\\n            spen = spen == 3 ? 1 : (spen == 2 ? 3 : 2);\\n            manage.changeColumns(spen);\\n          } else if (s.includes(\\\"倒序\\\")) {\\n            manage.list.reverse();\\n            names.reverse();\\n            manage.change();\\n          } else if (s.includes(\\\"自然排序\\\")) {\\n            let list = Object.assign([], manage.list);\\n            let natural = getItem(\\\"natural\\\", \\\"\\\");\\n            if (natural == \\\"\\\") {\\n              manage.list.length = 0;\\n              naturalSort(list).forEach(x => {\\n                manage.list.push(x);\\n              });\\n              setItem(\\\"usingst\\\", \\\"\\\")\\n            } else {\\n              manage.list.length = 0;\\n              sname.forEach(x => {\\n                manage.list.push(x);\\n              })\\n            }\\n            manage.change();\\n            setItem(\\\"natural\\\", natural ? \\\"\\\" : \\\"1\\\");\\n          } else if (s.includes(\\\"使用排序\\\")) {\\n            let list = Object.assign([], manage.list);\\n            let usingst = getItem(\\\"usingst\\\", \\\"\\\");\\n            if (usingst == \\\"\\\") {\\n              manage.list.length = 0;\\n              usingSort.get(list).forEach(x => {\\n                manage.list.push(x);\\n              });\\n              setItem(\\\"natural\\\", \\\"\\\")\\n            } else {\\n              manage.list.length = 0;\\n              sname.forEach(x => {\\n                manage.list.push(x);\\n              })\\n            }\\n            manage.change();\\n            setItem(\\\"usingst\\\", usingst ? \\\"\\\" : \\\"1\\\");\\n          } else if (s == \\\"刷新配置\\\") {\\n            hikerPop.runOnNewThread(() => {\\n              function arrayDifference(arr1, arr2) {\\n                const map = new Map(arr2.map(item => [item.key, item]));\\n                return arr1.filter(item => !map.has(item.key));\\n              }\\n\\n              let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\", \\\"runtimeConfig\\\");\\n              let list = runtimeConfig.getAllSource();\\n              if (!runtimeConfig.initDefault()) {\\n                toast(\\\"刷新失败\\\");\\n                return;\\n              };\\n              let nsources = runtimeConfig.getAllSource();\\n\\n              let alist = arrayDifference(nsources, list);\\n              let dlist = arrayDifference(list, nsources);\\n\\n              if (alist.length > 0 || dlist.length > 0) {\\n                let msg = \\\"\\\";\\n                if (alist.length > 0) {\\n                  alist.forEach(x => {\\n                    manage.list.push(x.name);\\n                  })\\n                  log(\\\"新增:\\\" + alist.map(k => k.name).join(\\\",\\\"))\\n                  msg += \\\"新增\\\" + alist.length + \\\"个源\\\";\\n                }\\n                if (dlist.length > 0) {\\n                  dlist.forEach(x => {\\n                    manage.list.splice(manage.list.indexOf(x.name), 1);\\n                  })\\n                  log(\\\"移除:\\\" + dlist.map(k => k.name).join(\\\",\\\"))\\n                  msg += \\\" 移除\\\" + dlist.length + \\\"个源\\\";\\n                }\\n                hikerPop.runOnUIThread(() => {\\n                  manage.change();\\n                  manage.setTitle(\\\"选择视频源 当前共:\\\" + manage.list.length + \\\"个视频源\\\");\\n                });\\n                toast(msg + \\\" 更多详情看log\\\");\\n              } else {\\n                toast(\\\"已刷新\\\");\\n              }\\n            });\\n\\n          } else if (s.includes(\\\"青少年模式\\\")) {\\n            function select() {\\n              showSelectOptions({\\n                \\\"title\\\": \\\"选择\\\",\\n                \\\"options\\\": [\\\"临时关闭\\\", \\\"关闭\\\", \\\"设置密码\\\"],\\n                col: 1,\\n                js: $.toString(() => {\\n\\n                  if (input == \\\"临时关闭\\\") {\\n                    putMyVar(\\\"tempLeach\\\", input);\\n                  } else if (input == \\\"关闭\\\") {\\n                    clearItem(\\\"leach\\\");\\n                  } else {\\n                    return $(\\\"\\\", \\\"设置密码\\\\n指纹不能用时有效\\\").input(() => {\\n                      if (input) {\\n                        setItem(\\\"leachPass\\\", input);\\n                        return \\\"toast://设置成功\\\";\\n                      } else {\\n                        clearItem(\\\"leachPass\\\");\\n                        return \\\"toast://使用默认密码\\\";\\n                      }\\n                    });\\n                  }\\n                })\\n              });\\n            }\\n            let leachPass = getItem(\\\"leachPass\\\", \\\"\\\");\\n            if (s.includes(\\\"关闭\\\")) {\\n\\n              if (hikerPop.canBiometric() !== 0 && !leachPass) {\\n                hikerPop.inputConfirm({\\n                  title: \\\"设置密码\\\",\\n                  hint: \\\"密码\\\",\\n                  confirm(text) {\\n                    if (!text) {\\n                      return \\\"toast://密码不能为空\\\";\\n                    } else {\\n                      setItem(\\\"leachPass\\\", text);\\n                      setItem(\\\"leach\\\", \\\"1\\\");\\n                      clearMyVar(\\\"tempLeach\\\");\\n                      toast(\\\"打开过滤\\\");\\n                    }\\n                  },\\n                });\\n              } else {\\n                setItem(\\\"leach\\\", \\\"1\\\");\\n                clearMyVar(\\\"tempLeach\\\");\\n                toast(\\\"打开过滤\\\");\\n              }\\n            } else {\\n              if (hikerPop.canBiometric() !== 0) {\\n                hikerPop.inputConfirm({\\n                  content: \\\"输入密码进行关闭\\\",\\n                  title: \\\"输入密码\\\",\\n                  hint: \\\"密码\\\",\\n                  confirm(text) {\\n                    if (text === leachPass || (!leachPass && text === String(ps))) {\\n                      select();\\n                    } else {\\n                      return \\\"toast://密码错误\\\";\\n                    }\\n                  },\\n                });\\n              } else {\\n                hikerPop.checkByBiometric(() => {\\n                  hikerPop.runOnNewThread(() => {\\n                    select();\\n                  });\\n                });\\n              }\\n            }\\n            pop.dismiss();\\n            return \\\"hiker://empty\\\";\\n          } else {\\n            showSelectOptions({\\n              title: \\\"编码类型\\\",\\n              options: [\\\"不编码\\\", \\\"Gzip\\\", \\\"Base64\\\", \\\"AES\\\"],\\n              col: 1,\\n              js: $.toString(() => {\\n                if (MY_INDEX === 0) {\\n                  clearItem(\\\"share_encode\\\");\\n                } else {\\n                  setItem(\\\"share_encode\\\", input);\\n                }\\n                return \\\"toast://\\\" + input;\\n              })\\n            });\\n          }\\n        },\\n      });\\n    }\\n  });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"drpy管理\",\"path\":\"DrpyManage\",\"rule\":\"js:\\nconst JSEngine = com.example.hikerview.service.parser.JSEngine;\\nconst runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\nconst drpyMap = new Map();\\nconst GMkey = module.importParam;\\n//log(\\\"初始化DrpyManage\\\");\\nconst proxySemaphore = new java.util.concurrent.Semaphore(3);\\nconst T4Adapter = $.require(\\\"T4Adapter\\\");\\nconst T1Adapter = $.require(\\\"T1Adapter\\\");\\n\\nfunction buildJsEnv(ticket) {\\n    let code = String.raw`\\n    // const my_rule = '\\n    const MY_RULE = ${my_rule};\\n    const my_rule = JSON.stringify(MY_RULE);\\n    const MY_TICKET = \\\"${ticket || \\\"\\\"}\\\";\\n    eval(getJsPlugin());\\n    eval(getJsLazyPlugin());\\n    `;\\n    return code;\\n}\\n\\nfunction sync(func, sp) {\\n    return new org.mozilla.javascript.Synchronizer(func, sp || {});\\n}\\n\\nfunction createDrpy(key) {\\n    JSEngine.getInstance().evalJS(buildJsEnv(MY_TICKET) + \\\"\\\\n!\\\" + $.toString((key, GMkey, MY_TICKET) => {\\n        let drpy = $.require(\\\"drpy\\\", key);\\n        GM.has(GMkey, (DrpyManage) => {\\n            DrpyManage.put(key, drpy);\\n        });\\n    }, key, GMkey, MY_TICKET) + \\\";\\\\n\\\", \\\"\\\", false);\\n}\\n\\nfunction createT3(source) {\\n    let key = source.key;\\n    createDrpy(key);\\n    let drpy = drpyMap.get(key);\\n    drpy.init(runtimeConfig.getAbsolutePath(source.ext));\\n    try {\\n        if (drpy.getRule(\\\"proxy_rule\\\")) {\\n            let Proxy = $.require(\\\"LocalProxy\\\");\\n            let proxyUrl = Proxy.startProxy(MY_RULE.title, GM.getSelfKey());\\n            putMyVar(\\\"Proxy_Url\\\", proxyUrl);\\n        }\\n    } catch (e) { }\\n    return drpy;\\n}\\n\\nfunction createNewDrpy(source) {\\n    if (source.type === 4) {\\n        let t4 = new T4Adapter(source);\\n        t4.init();\\n        drpyMap.set(source.key, t4);\\n        return t4;\\n    } else if (source.type === 1) {\\n        let t1 = new T1Adapter(source);\\n        t1.init();\\n        drpyMap.set(source.key, t1);\\n        return t1;\\n    } else if (source.type === 0) {\\n        let T0Adapter = $.require(\\\"T0Adapter\\\");\\n        let t0 = new T0Adapter(source);\\n        t0.init();\\n        drpyMap.set(source.key, t0);\\n        return t0;\\n    } else {\\n        return createT3(source);\\n    }\\n}\\n\\nfunction get(key) {\\n    return sync(() => {\\n        //log(drpyMap.size)\\n        if (drpyMap.has(key)) {\\n            return drpyMap.get(key);\\n        }\\n        if (drpyMap.size >= 5) {\\n            //log(\\\"请求:\\\" + key)\\n            del(Array.from(drpyMap.keys()).at(0));\\n        }\\n        let source = runtimeConfig.getAllSources().find(v => v.key === key);\\n        let drpy = createNewDrpy(source);\\n\\n        return drpy;\\n    }, this).call();\\n}\\n//source.ext必须为绝对路径\\nfunction getBySource(source) {\\n    return sync(() => {\\n        let key = source.key;\\n        //log(drpyMap.size)\\n        if (drpyMap.has(key)) {\\n            return drpyMap.get(key);\\n        }\\n        if (drpyMap.size >= 5) {\\n            //log(\\\"请求:\\\" + key)\\n            del(Array.from(drpyMap.keys()).at(0));\\n        }\\n        let drpy = createNewDrpy(source);\\n        return drpy;\\n    }, this).call();\\n}\\n\\nfunction put(key, drpy) {\\n    sync(() => drpyMap.set(key, drpy), this).call();\\n}\\n\\nfunction runProxy(drpy, args) {\\n    if (typeof drpy.proxy === \\\"function\\\") {\\n        try {\\n            //let time1 = Date.now();\\n            proxySemaphore.acquire();\\n            //let time2 = Date.now();\\n            //log(\\\"1等待时间:\\\" + (time2 - time1) + \\\"ms\\\");\\n            let res = drpy.proxy.apply(drpy, args);\\n            //let time3 = Date.now();\\n            //log(\\\"2执行代理耗时:\\\" + (time3 - time2) + \\\"ms\\\");\\n            //log(\\\"3总耗时耗时:\\\" + (time3 - time1) + \\\"ms\\\");\\n\\n            return res;\\n        } finally {\\n            proxySemaphore.release();\\n        }\\n    }\\n}\\n\\nfunction del(key) {\\n    sync(() => {\\n        //log(\\\"删除\\\" + key);\\n        drpyMap.delete(key);\\n        /*if (drpyMap.has(key)) {\\n            \\n        }*/\\n    }, this).call();\\n}\\nlet isInitHome = false;\\n//let isInitSearch = false;\\nlet isInitErPage = false;\\n\\nfunction initPage(type) {\\n    switch (type) {\\n        case \\\"home\\\":\\n            isInitHome = true;\\n        //case \\\"search\\\":\\n        //    isInitSearch = true;\\n        case \\\"er\\\":\\n            isIniterPage = true;\\n    }\\n    addListener(\\\"onClose\\\", $.toString((GMkey, type) => {\\n        //log(\\\"onClose\\\");\\n        GM.has(GMkey, DrpyManage => {\\n            //log(\\\"有GMkey\\\");\\n            DrpyManage.clearByType(type);\\n        });\\n    }, GMkey, type));\\n}\\n\\nfunction clearByType(type) {\\n    switch (type) {\\n        case \\\"home\\\":\\n            isInitHome = false;\\n        //case \\\"search\\\":\\n        //    isInitSearch = false;\\n        case \\\"er\\\":\\n            isIniterPage = false;\\n    }\\n\\n    if (!isInitHome && !isInitErPage) {\\n        //log(\\\"开始清理\\\");\\n        drpyMap.clear();\\n        GM.clear(GMkey);\\n    }\\n}\\n\\nfunction clear() {\\n    sync(() => {\\n        drpyMap.clear();\\n    }, this).call();\\n}\\n$.exports = {\\n    initPage,\\n    get,\\n    getBySource,\\n    del,\\n    clear,\\n    put,\\n    runProxy,\\n    clearByType\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"指定搜索弹窗\",\"path\":\"SearchAllowPop\",\"rule\":\"js:\\n$.exports.show = function () {\\n  const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\", \\\"runtimeConfig\\\");\\n  const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n  let searchAllow = runtimeConfig.getSearchAllow();\\n\\n  let canSearchSource = runtimeConfig.getCanSearchSource();\\n  //let sourceNameList = canSearchSource.map(v=>v.name);\\n  let getNames = () => dynamicSource.map(v => searchAllow.includes(v.key) ? \\\"““””\\\" + (v.name + \\\"\\\").fontcolor(\\\"#009966\\\") : v.name);\\n  let spen = 3;\\n\\n  //let dynamicNames = sourceNameList.slice();\\n  let dynamicSource = canSearchSource.slice();\\n  let searchoncount = dynamicSource.filter(v => searchAllow.includes(v.key)).length;\\n  if (searchoncount == 0) {\\n    searchoncount = canSearchSource.length;\\n  }\\n\\n  function popTitle(input) {\\n    let list = input?input:searchoncount;\\n    return \\\"启用搜索源:\\\" + list + \\\"个 共:\\\" + canSearchSource.length + \\\"个搜索源\\\"\\n  }\\n\\n  let searchKey = \\\"\\\";\\n  let inputBox;\\n  hikerPop.selectBottomRes({\\n    options: getNames(),\\n    columns: spen,\\n    title: popTitle(),\\n    noAutoDismiss: true,\\n    position: 1,\\n    height: .9,\\n    extraInputBox: (inputBox = new hikerPop.ResExtraInputBox({\\n      hint: \\\"源关键字 多个用|隔开\\\",\\n      title: \\\"TAG\\\",\\n      onChange(text, manage) {\\n        //log(\\\"onChange:\\\"+text)\\n        searchKey = text;\\n        manage.list.length = 0;\\n        dynamicSource.length = 0;\\n        if (text) {\\n          canSearchSource.forEach((v, i) => {\\n            if (text.split(/\\\\|/).filter(f => f).some(x => v.name.includes(x))) {\\n              dynamicSource.push(v);\\n              manage.list.push(searchAllow.includes(v.key) ? \\\"““””\\\" + (v.name + \\\"\\\").fontcolor(\\\"#009966\\\") : v.name)\\n            }\\n          });\\n        } else {\\n          dynamicSource = canSearchSource.slice();\\n          Object.assign(manage.list, getNames());\\n\\n        }\\n        manage.change();\\n      },\\n      defaultValue: \\\"\\\",\\n      click(s, manage) {\\n        let tagClasses = runtimeConfig.getTagClasses();\\n        if (!tagClasses.length) return \\\"toast://当前配置没有TAG哦。\\\";\\n        hikerPop.selectCenter({\\n          options: tagClasses,\\n          columns: 3,\\n          title: \\\"TAG[\\\" + tagClasses.length + \\\"]\\\",\\n          click(a) {\\n            inputBox.setDefaultValue(\\\"[\\\" + a + \\\"]\\\");\\n          }\\n        });\\n      },\\n      titleVisible: true\\n    })),\\n    click(s, i, manage) {\\n      let key = dynamicSource[i].key;\\n      let index = -1;\\n      if ((index = searchAllow.indexOf(key)) !== -1) {\\n        manage.list[i] = dynamicSource[i].name;\\n        searchAllow.splice(index, 1);\\n      } else {\\n        manage.list[i] = \\\"““””\\\" + (dynamicSource[i].name + \\\"\\\").fontcolor(\\\"#009966\\\");\\n        searchAllow.push(key);\\n      }\\n      manage.setTitle(popTitle(searchAllow.length));\\n      runtimeConfig.setSearchAllow();\\n      manage.change();\\n    },\\n    menuClick(manage) {\\n      hikerPop.selectCenter({\\n        options: [\\\"改变样式\\\", \\\"筛选源\\\", \\\"自然排序\\\", \\\"倒序\\\", \\\"全选\\\", \\\"反选\\\"],\\n        columns: 2,\\n        title: \\\"请选择\\\",\\n        click(s, i) {\\n          if (i === 0) {\\n            spen = spen == 3 ? 1 : (spen == 2 ? 3 : 2);\\n            manage.changeColumns(spen);\\n          } else if (i === 1) {\\n            hikerPop.inputConfirm({\\n              content: \\\"输入关键字 空显示全部\\\",\\n              title: \\\"筛选源\\\",\\n              hint: \\\"源关键字 多个用|隔开\\\",\\n              defaultValue: searchKey,\\n              textarea: false, //多行模式\\n              maxTextarea: true,\\n              noAutoSoft: false,\\n              //hideCancel: true,\\n              confirm(text) {\\n                searchKey = text;\\n                manage.list.length = 0;\\n                dynamicSource.length = 0;\\n                if (text) {\\n                  canSearchSource.forEach((v, i) => {\\n                    if (text.split(/\\\\|/).filter(f => f).some(x => v.name.includes(x))) {\\n                      dynamicSource.push(v);\\n                      manage.list.push(searchAllow.includes(v.key) ? \\\"““””\\\" + (v.name + \\\"\\\").fontcolor(\\\"#009966\\\") : v.name)\\n                    }\\n                  });\\n                } else {\\n                  dynamicSource = canSearchSource.slice();\\n                  Object.assign(manage.list, getNames());\\n\\n                }\\n                manage.change();\\n                //return \\\"toast://输入了\\\" + text;\\n              },\\n\\n            });\\n          } else if (i === 2) {\\n            let list = Object.assign([], manage.list);\\n            manage.list.length = 0;\\n\\n            dynamicSource.sort((a, b) => {\\n              return String(a.name).localeCompare(String(b.name), undefined, {\\n                numeric: true,\\n                sensitivity: 'base'\\n              });\\n            });\\n            Object.assign(manage.list, getNames());\\n            manage.change();\\n          } else if (i == 3) {\\n            manage.list.reverse();\\n            dynamicSource.reverse();\\n            manage.change();\\n          } else if (i == 4) {\\n            dynamicSource.forEach(v => {\\n              if (!searchAllow.includes(v.key)) {\\n                searchAllow.push(v.key);\\n              }\\n            });\\n            manage.setTitle(popTitle(searchAllow.length));\\n            Object.assign(manage.list, getNames());\\n            runtimeConfig.setSearchAllow();\\n            manage.change();\\n          } else if (i == 5) {\\n            let temlist = searchAllow.slice();\\n            searchAllow.length = 0;\\n            dynamicSource.forEach(v => {\\n              if (temlist.includes(v.key)) return;\\n              searchAllow.push(v.key);\\n            });\\n            manage.setTitle(popTitle(searchAllow.length));\\n            Object.assign(manage.list, getNames());\\n            runtimeConfig.setSearchAllow();\\n            manage.change();\\n          }\\n        },\\n      });\\n    }\\n  });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"categorys\",\"rule\":\"js:\\nlet fl = {};\\nlet results = [];\\nlet homelist = [];\\nlet cate = \\\"\\\";\\n\\nfunction getCategorys(layout, drpy, page,hasHaed) {\\n  let {\\n    ui_config,\\n    getRangeColors,\\n  } = $.require(\\\"UIManage\\\");\\n  ui_config = ui_config.yi;\\n\\n  let rule = drpy.getRule();\\n  let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n  let code = drpy.runMain(\\\"let main=\\\" + $.toString((ext) => {\\n    return () => getOriginalJs(request(ext, {\\n      'method': 'GET'\\n    }));\\n  }, runtimeConfig.getCurrentSourcePath()));\\n  \\n  if (hasHaed && /模板:\\\\s+'自动'/.test(code)) {\\n    let result = JSON.parse(request(rule.homeUrl, {\\n      timeout: rule.timeout || 5000,\\n      headers: rule.headers || {},\\n      withHeaders: true,\\n    }));\\n    if ((result.body == undefined || result.body == \\\"\\\") || (result.error != undefined) || /^(-1|404|502|503)$/.test(result.statusCode)) {\\n      clearMyVar(\\\"links\\\");\\n      /*layout.push({\\n        title: \\\"““\\\" + \\\"网站访问异常\\\" + \\\"””\\\",\\n        desc: \\\"0\\\",\\n        url: rule.homeUrl,\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n          longClick: [{\\n            title: \\\"清除ui设置\\\",\\n            js: $.toString(() => {\\n              let {\\n                ui_clear,\\n              } = $.require(\\\"UIManage\\\");\\n              ui_clear(\\\"yi\\\");\\n              refreshPage();\\n            })\\n          }]\\n        }\\n      });*/\\n      throw new Error(\\\"网站访问异常\\\");\\n      //setResult(layout);\\n    }else{\\n      let home=JSON.parse(drpy.home());\\n      if(home.class.length==0){\\n        throw new Error(\\\"访问正常,分类数据获取异常 可尝试刷新源\\\");\\n      }\\n    }\\n  }\\n  \\n  if (Object.keys(rule).length === 0) {\\n    throw new Error(\\\"规则加载失败\\\");\\n  }\\n  \\n  if ((rule.一级 == \\\"\\\" || rule.一级 == undefined) && !rule.推荐) {\\n    clearMyVar(\\\"links\\\");\\n    layout.length = 0;\\n    throw new Error(\\\"该源为搜索源，仅能通过搜索访问数据\\\");\\n  }\\n\\n  let categorys = JSON.parse(drpy.home());;\\n  let filters = categorys.filters;\\n  let cates = categorys.class || [];\\n  if (page == 1) {\\n    homelist = JSON.parse(drpy.homeVod()).list;\\n    if (homelist != undefined && homelist.length) {\\n      putMyVar(\\\"ishome\\\", \\\"1\\\");\\n    }\\n  }\\n  if (cates.length == 0 && (homelist == undefined || homelist.length == 0)) {\\n    clearMyVar(\\\"links\\\");\\n    layout.length = 0;\\n    throw new Error(\\\"分类获取失败可能网络问题\\\");\\n  }\\n  if (getMyVar(\\\"ishome\\\", \\\"0\\\") == \\\"1\\\") {\\n    cates.unshift({\\n      type_name: '推荐',\\n      type_id: 'home',\\n    })\\n  }\\n  putMyVar(\\\"links\\\", \\\"1\\\");\\n  let catei = getMyVar(\\\"catei\\\", \\\"0\\\");\\n  cate = cates[catei].type_id;\\n\\n  var fold = storage0.getItem(\\\"fold\\\", \\\"0\\\");\\n  let color = ui_config.分类颜色;\\n  if (color == \\\"random\\\") {\\n    color = getRangeColors();\\n  }\\n\\n  if (page == 1) {\\n    cates.forEach((item, i) => {\\n      let t = catei == i ? \\\"““””\\\" + \\\"<b>\\\" + item.type_name.fontcolor(color) + \\\"</b>\\\" : item.type_name;\\n      layout.push({\\n        title: t,\\n        url: $('#noLoading#').lazyRule((i, tid) => {\\n          putMyVar(\\\"catei\\\", i);\\n          refreshPage();\\n          return \\\"hiker://empty\\\";\\n        }, i, item.type_id),\\n        col_type: 'scroll_button',\\n        extra: {\\n          tid: item.type_id,\\n          active: catei == i ? true : false,\\n        }\\n      })\\n    })\\n  }\\n\\n  if (cate != 'home' && page == 1) {\\n    let homei = layout.findIndex(x => {\\n      return x.extra && x.extra.tid == \\\"home\\\"\\n    });\\n    if (homei == -1) {\\n      homei = layout.findIndex(x => {\\n        return x.extra && x.extra.tid;\\n      }) - 1;\\n    }\\n    if (filters && filters.hasOwnProperty(cate)) {\\n      if (homei != -1) {\\n        layout.splice(homei + 1, 0, {\\n          title: fold == \\\"0\\\" ? \\\"““””<b>\\\" + \\\"∧\\\".fontcolor(\\\"#1aad19\\\") + \\\"</b>\\\" : \\\"““””<b>\\\" + \\\"∨\\\".fontcolor(\\\"#FF0000\\\") + \\\"</b>\\\",\\n          col_type: \\\"scroll_button\\\",\\n          url: $(\\\"#noLoading#\\\").lazyRule((fold) => {\\n            storage0.setItem(\\\"fold\\\", fold == \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n          }, fold),\\n          extra: {\\n            active: false,\\n          }\\n        })\\n      }\\n\\n      let activei = layout.findIndex(x => x.extra && x.extra.active);\\n      if (activei != -1) {\\n        layout.splice(activei, 0, {\\n          title: \\\"““””\\\" + '🌀',\\n          col_type: 'scroll_button',\\n          url: $('#noLoading#').lazyRule((c) => {\\n            let cate_obj = storage0.getMyVar(\\\"cate_obj\\\", {});\\n            delete cate_obj[c];\\n            storage0.putMyVar(\\\"cate_obj\\\", cate_obj);\\n            refreshPage();\\n            return \\\"toast://清除完成\\\";\\n          }, cate)\\n        })\\n      }\\n\\n      let classify = filters[cate];\\n      var init_cate = new Array(classify.length).fill(\\\"-1\\\");\\n      let cate_obj = storage0.getMyVar(\\\"cate_obj\\\", {});\\n      cate_obj[cate] = cate_obj[cate] ? cate_obj[cate] : init_cate\\n      var cate_temp = cate_obj[cate];\\n      //var filter_def=storage0.getItem(\\\"filter_def\\\", {});\\n      classify.forEach((x, index) => {\\n        layout.push({\\n          col_type: 'blank_block'\\n        })\\n        x.value.forEach((it, i) => {\\n          let t = it.n;\\n          if (cate_temp[index] == i) {\\n            t = \\\"<b><font color=\\\" + color + \\\">\\\" + t + \\\"</font></b>\\\";\\n            fl[x.key] = it.v;\\n          }\\n          if (cate_temp[index] == \\\"-1\\\") {\\n            fl[x.key] = \\\"undefined\\\";\\n          }\\n          if (fold == 1) {\\n            layout.push({\\n              title: '““””' + t,\\n              url: $(\\\"#noLoading#\\\").lazyRule((o) => {\\n                let i = o.i;\\n                storage0.putMyVar(\\\"is_def\\\", \\\"1\\\");\\n                let cate_obj = storage0.getMyVar(\\\"cate_obj\\\", {});\\n\\n                let cate_temp = o.cate_temp;\\n                if (cate_temp.constructor != Array) {\\n                  cate_temp = [];\\n                }\\n                let index = o.index;\\n                let c = cate_temp[index] || \\\"-1\\\";\\n                //log(c)\\n                if (c == i) {\\n                  o.cate_temp[index] = \\\"-1\\\";\\n                } else {\\n                  o.cate_temp[index] = i + \\\"\\\";\\n                }\\n                cate_obj[o.cate] = cate_temp;\\n                //log(cate_temp)\\n                //storage0.putMyVar(\\\"cate_temp\\\", cate_temp);\\n                storage0.putMyVar(\\\"cate_obj\\\", cate_obj);\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n              }, {\\n                index: index,\\n                cate_temp: cate_temp,\\n                i: i,\\n                cate: cate\\n              }),\\n              col_type: 'scroll_button',\\n            })\\n          }\\n        })\\n      })\\n    }\\n  }\\n}\\n\\nfunction getFl() {\\n  fl = Object.keys(fl).filter(key => fl[key] !== \\\"undefined\\\").reduce((res, key) => {\\n    res[key] = fl[key];\\n    return res;\\n  }, {});\\n  return fl\\n}\\n\\nfunction getCateList() {\\n  return {\\n    cate,\\n    homelist\\n  }\\n}\\n\\n\\n$.exports = {\\n  getcatelist: getCateList,\\n  getcategorys: getCategorys,\\n  getfl: getFl\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"本地规则管理\",\"path\":\"LocalDir\",\"rule\":\"js:\\nsetPageTitle(\\\"文件管理\\\");\\nlet path = getPath(String(MY_PARAMS.cpath)).replace(\\\"file://\\\", \\\"\\\");\\nlet fileSelect = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\nfileSelect.fileSelection({\\n    callback: $.toString(() => {\\n        return \\\"editFile://file://\\\" + PATH;\\n    }),\\n    memory: \\\"filepath\\\",\\n    fileType: \\\".js|.txt|.json\\\",\\n    exitSearchRefresh: true,\\n    pattern: 0,\\n    rootDirPath: path,\\n    initialPath: path,\\n}, MY_PARAMS.newWindow ? [] : [{\\n    title: \\\"新窗口打开\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://page/LocalDir#noRecordHistory##noHistory#\\\",\\n    extra: {\\n        cpath: MY_PARAMS.cpath,\\n        newWindow: true,\\n        windowId: MY_RULE.title + \\\"@editfile\\\",\\n        lineVisible: false,\\n        pageTitle: \\\"文件管理\\\"\\n    }\\n}]);\"},{\"col_type\":\"movie_3\",\"name\":\"默认保存选择\",\"path\":\"sharedefaultpath\",\"rule\":\"js:\\nsetPageTitle(\\\"保存路径\\\");\\nlet layout = [];\\nlet f = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\naddListener(\\\"onClose\\\", () => {\\n    clearMyVar(\\\"drpyHiker_share_input\\\");\\n});\\n\\nlet path = joinUrl(getPath(\\\"hiker://files/\\\"), \\\"../\\\".repeat(5)).slice(7);\\nlayout.push({\\n    title: \\\"选择\\\",\\n    url: JSON.stringify(f.fileSelectionUri({\\n        callback: $.toString(() => {\\n            let target = findItem(\\\"drpyHiker_share_input\\\").extra;\\n            updateItem(\\\"drpyHiker_share_input\\\", {\\n                extra: Object.assign(target, {\\n                    defaultValue: PATH\\n                })\\n            });\\n            return true;\\n        }),\\n        rootDirPath: path,\\n        initialPath: path,\\n        pattern: 1\\n    })),\\n    col_type: \\\"input\\\",\\n    desc: \\\"储存路径\\\",\\n    extra: {\\n        defaultValue: getMyVar(\\\"drpyHiker_share_input\\\", getPublicItem(\\\"DrpyHiker@input_path\\\", \\\"\\\")),\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_share_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_share_input\\\"\\n    }\\n});\\n\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"确认\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n        let path = getMyVar(\\\"drpyHiker_share_input\\\", \\\"\\\");\\n\\n        if (!path) {\\n            return \\\"toast://不可为空\\\";\\n        }\\n        setPublicItem(\\\"DrpyHiker@input_path\\\", path);\\n        back(false);\\n        return \\\"toast://设置成功\\\";\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"小说\",\"path\":\"novel\",\"rule\":\"js:\\nlet drpy = GM.defineModule(\\\"DrpyManage\\\").getBySource(MY_PARAMS.source);\\nlet play = JSON.parse(drpy.play(MY_PARAMS.from, MY_PARAMS.id, []));\\n\\nlet data = JSON.parse(play.url.replace(\\\"novel://\\\", \\\"\\\"));\\nlet layout = [];\\nlet content = \\\"　　\\\" + data.content.split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it => it.trim()).join(\\\"<br>　　\\\");\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + (data.title || getPageTitle()) + \\\"</strong>\\\").big(),\\n});\\n\\nlayout.push({\\n    title: content,\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: 18,\\n        click: true\\n    }\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"主页\",\"path\":\"mian\",\"rule\":\"js:\\nfunction load(d, drpy, source, hasHaed) {\\n  let {\\n    ui_config,\\n  } = $.require(\\\"UIManage\\\");\\n  ui_config = ui_config.yi;\\n\\n  let page = MY_PAGE;\\n  let categorys = $.require(\\\"categorys\\\");\\n  categorys.getcategorys(d, drpy, page, hasHaed);\\n  let {\\n    cate,\\n    homelist\\n  } = categorys.getcatelist();\\n  if (getMyVar(\\\"links\\\", \\\"\\\") == \\\"1\\\" && !hasHaed) {\\n    setPreResult(d);\\n    d.length = 0;\\n  }\\n\\n  let fl = categorys.getfl();\\n  let skipEr = drpy.getRule(\\\"二级\\\") === \\\"*\\\" && getItem(\\\"skipEr\\\", \\\"\\\");\\n  let deCol = drpy.getRule(cate == \\\"home\\\" ? \\\"hikerListCol\\\" : \\\"hikerClassListCol\\\");\\n  let homeListCol = getItem(\\\"homeListCol\\\", \\\"\\\") || deCol || \\\"movie_3_marquee\\\";\\n  let stype = drpy.getRule(\\\"类型\\\");\\n  let icon = ui_config.icons.影视;\\n  switch (stype) {\\n    case '漫画':\\n      icon = ui_config.icons.漫画;\\n      break;\\n    case '小说':\\n      icon = ui_config.icons.小说;\\n      break;\\n    default:\\n  }\\n  updateItem(MY_RULE.title + \\\"sourcename\\\", {\\n    img: icon,\\n  });\\n\\n  let list = [];\\n  if (cate == \\\"home\\\") {\\n    if (page == 1) {\\n      list = homelist;\\n    }\\n    if (list === undefined) {\\n      list = [];\\n      clearMyVar(\\\"ishome\\\");\\n    }\\n    if (list.length > 0 && !list.at(0).vod_pic && !list.at(-1).vod_pic && !deCol) {\\n      homeListCol = \\\"text_1\\\";\\n    }\\n  } else {\\n    list = JSON.parse(drpy.category(String(cate), page, true, fl)).list;\\n  }\\n  let url = \\\"hiker://page/detailed\\\" + ui_config.mark;\\n\\n  if (list.length) {\\n    for (let it of list) {\\n      let id = String(it.vod_id);\\n      let cid;\\n      //log(it)\\n      let name = it.vod_name;\\n      if (id === \\\"no_data\\\") {\\n        url = \\\"toast://没有数据\\\";\\n      } else if (typeof id === \\\"string\\\" && id.includes(\\\"msearch:\\\") || id == undefined) {\\n        url = $(\\\"\\\").lazyRule((name) => {\\n          putMyVar(\\\"temsmode\\\", \\\"1\\\");\\n          return \\\"hiker://search?rule=\\\" + MY_RULE.title + \\\"&s=\\\" + name;\\n        }, name);\\n      } else if (skipEr) {\\n        url = $().lazyRule((source, id) => {\\n          let url;\\n          try {\\n            let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n            let drpy = DrpyManage.getBySource(source);\\n            url = JSON.parse(drpy.detail(id)).list[0].vod_play_url.split(\\\"$\\\")[1];\\n          } catch (e) {\\n            url = id.split(\\\"@@\\\")[0];\\n          }\\n          return $.require(\\\"videoUrl\\\").parse(url, id, source);\\n        }, source, id);\\n        cid = id;\\n      }\\n      d.push({\\n        title: name,\\n        desc: it.vod_remarks,\\n        url: url,\\n        img: it.vod_pic,\\n        col_type: homeListCol,\\n        extra: {\\n          img: it.vod_pic,\\n          vodId: id,\\n          sname: source.name,\\n          skey: source.key,\\n          id: cid,\\n          longClick: [{\\n            title: \\\"聚合搜索\\\",\\n            js: \\\"putMyVar('temsmode', '1');'hiker://search?rule=' + MY_RULE.title + '&s=\\\" + name + \\\"';\\\"\\n          }]\\n        }\\n      });\\n    }\\n  }\\n  deleteItem(MY_RULE.title + \\\"load\\\");\\n}\\n\\nfunction setDrpyPath(d) {\\n  d.push({\\n    title: \\\"缺少运行库\\\\n该小程序不能通过云剪贴板分享，只能通过打包分享\\\",\\n    desc: \\\"将运行库放入\\\" + getPath(\\\"hiker://files/data/\\\" + MY_RULE.title + \\\"/libs_hiker/drpy2.js\\\"),\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://empty\\\"\\n  });\\n}\\n\\nfunction setHied(d, name, config) {\\n  let {\\n    ui_config,\\n    ui_expand,\\n    reorderArrayByOrder\\n  } = $.require(\\\"UIManage\\\");\\n  ui_config = ui_config.yi;\\n  let ui_indexs = ui_config.ui;\\n  ui_expand();\\n\\n  let selects = [{\\n    title: \\\"收藏\\\",\\n    icon: ui_config.icons.收藏\\n  }, {\\n    title: \\\"书架-小说\\\",\\n    icon: ui_config.icons.书架小说\\n  }, {\\n    title: \\\"书架-漫画\\\",\\n    icon: ui_config.icons.书架漫画\\n  }]\\n\\n  let favicons = {\\n    get(st) {\\n      st = st || selects;\\n      return $(st, 2, \\\"我的\\\").select(() => {\\n        if (input.includes(\\\"历史\\\")) {\\n          return \\\"hiker://history?rule=\\\" + MY_RULE.title;\\n        } else if (input.includes(\\\"书架-小说\\\")) {\\n          return 'hiker://page/Bookrack.view#noRecordHistory#?rule=本地资源管理&type=novel&ruleName=' + MY_RULE.title;\\n        } else if (input.includes(\\\"书架-漫画\\\")) {\\n          return 'hiker://page/Bookrack.view#noRecordHistory#?rule=本地资源管理&type=comic&ruleName=' + MY_RULE.title;\\n        } else if (input.includes(\\\"收藏\\\")) {\\n          return \\\"hiker://collection?rule=\\\" + MY_RULE.title;\\n        }\\n      })\\n    }\\n  };\\n\\n\\n  Object.defineProperty(favicons, 'select', {\\n    enumerable: false,\\n    configurable: true,\\n    get: function () {\\n      return selects;\\n    },\\n    set: function (value) {\\n      selects.push(value);\\n    }\\n  });\\n  GM.put(\\\"favicons\\\", favicons);\\n\\n  let smode = Number(getItem(\\\"smode\\\", \\\"0\\\"));\\n  let searchsort = Number(getItem(\\\"searchsort\\\", \\\"0\\\"));\\n  let fileSelect = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\n  let uiobj = [];\\n\\n\\n  uiobj.push({\\n    index: 0,\\n    key: \\\"换源\\\",\\n    title: \\\"换源\\\",\\n    col_type: ui_config.col,\\n    img: ui_config.icons.换源,\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n      $.require(\\\"ChangeSourcePop\\\").show();\\n      return \\\"hiker://empty\\\";\\n    }),\\n    extra: {\\n      cpath: config.path,\\n      longClick: [{\\n        title: \\\"更换配置\\\",\\n        js: JSON.stringify(\\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\")\\n      }, {\\n        title: \\\"访问网站\\\",\\n        js: $.toString(() => {\\n          let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n          let source = runtimeConfig.getCurrentSource();\\n          let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n          return \\\"web://\\\" + DrpyManage.get(source.key).getRule(\\\"host\\\");\\n          //refreshPage();\\n        })\\n      }, {\\n        title: \\\"刷新源\\\",\\n        js: $.toString(() => {\\n          clearMyVar(\\\"links\\\");\\n          let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n          let source = runtimeConfig.getCurrentSource();\\n          let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n          DrpyManage.get(source.key).init(runtimeConfig.getAbsolutePath(source.ext));\\n          refreshPage();\\n        })\\n      }, {\\n        title: \\\"重载源\\\",\\n        js: $.toString(() => {\\n          clearMyVar(\\\"links\\\");\\n          let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n          let source = runtimeConfig.getCurrentSource();\\n          let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n          DrpyManage.del(source.key);\\n          refreshPage();\\n        })\\n      }, {\\n        title: \\\"查看源代码\\\",\\n        js: $.toString(() => {\\n          let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n          let source = runtimeConfig.getCurrentSource();\\n          let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n          let code = DrpyManage.get(source.key).runMain(\\\"let main=\\\" + $.toString((ext) => {\\n            return () => getOriginalJs(request(ext, {\\n              'method': 'GET'\\n            }));\\n          }, runtimeConfig.getCurrentSourcePath()));\\n\\n          let path = \\\"hiker://files/_cache/viewSourceCode.js\\\";\\n          writeFile(path, code);\\n          return \\\"editFile://\\\" + path;\\n        })\\n      }].concat(config.type === \\\"localDir\\\" ? [{\\n        title: \\\"编辑参数映射表\\\",\\n        js: $.toString((path) => {\\n          path += \\\"/.mapping.txt\\\";\\n          if (fileExist(path)) {\\n            toast(\\\"保存后刷新配置或重启才会生效\\\");\\n            return \\\"editFile://\\\" + path;\\n          } else {\\n            return $(\\\"不存在映射文件是否创建？\\\").confirm(path => {\\n              writeFile(path, \\\"\\\");\\n              toast(\\\"保存后刷新配置或重启才会生效\\\");\\n              return \\\"editFile://\\\" + path;\\n            }, path);\\n          }\\n        }, config.path)\\n      }, {\\n        title: \\\"本地管理\\\",\\n        js: \\\"'hiker://page/LocalDir#noRecordHistory##noHistory#'\\\"\\n      }] : [])\\n    }\\n  });\\n\\n  uiobj.push({\\n    index: 1,\\n    key: \\\"搜索模式\\\",\\n    title: [\\\"选中\\\", \\\"聚合\\\", config.sTag || \\\"无TAG\\\"][smode],\\n    url: $('#noLoading#').lazyRule(() => {\\n      let smode = Number(getItem(\\\"smode\\\", \\\"0\\\"));\\n      return $([\\\"选中\\\", \\\"聚合\\\", \\\"按TAG\\\"], 1, \\\"搜索模式\\\", smode).select((t) => {\\n        if (MY_INDEX === 2) {\\n          let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n          let tagClasses = runtimeConfig.getTagClasses();\\n          let stag = runtimeConfig.getSearchTag();\\n          let index = 0;\\n          if (!tagClasses.length) return \\\"toast://当前配置没有TAG哦。\\\";\\n          if (stag) {\\n            index = tagClasses.indexOf(stag) + 1;\\n          }\\n          tagClasses.unshift(\\\"[无TAG]\\\");\\n          return $(tagClasses, 3, \\\"搜索TAG[\\\" + tagClasses.length + \\\"]\\\", index).select((t) => {\\n            let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n            let tag = MY_INDEX === 0 ? \\\"\\\" : input;\\n            if (runtimeConfig.setSearchTag(tag)) {\\n              setItem(\\\"smode\\\", \\\"2\\\");\\n              updateItem(t + \\\"@search_mode\\\", {\\n                title: tag || \\\"无TAG\\\",\\n              });\\n              //return \\\"\\\";\\n            } else {\\n              return \\\"toast://设置失败\\\";\\n            }\\n          }, t);\\n        }\\n        setItem(\\\"smode\\\", \\\"\\\" + MY_INDEX);\\n        updateItem(t + \\\"@search_mode\\\", {\\n          title: [\\\"选中\\\", \\\"聚合\\\"][MY_INDEX],\\n        });\\n        return \\\"hiker://empty\\\";\\n      }, MY_RULE.title)\\n    }),\\n    img: ui_config.icons.搜索,\\n    col_type: ui_config.col,\\n    extra: {\\n      id: MY_RULE.title + \\\"@search_mode\\\",\\n      longClick: [{\\n        title: \\\"指定搜索源\\\",\\n        js: $.toString(() => {\\n          $.require(\\\"SearchAllowPop\\\").show();\\n        })\\n      }, {\\n        title: \\\"搜索排序:\\\" + [\\\"无\\\", \\\"自然\\\", \\\"使用\\\"][searchsort],\\n        js: $.toString((searchsort) => {\\n          return $([\\\"不使用\\\", \\\"自然排序\\\", \\\"使用排序\\\"], 1, \\\"搜索排序\\\", searchsort).select(() => {\\n            setItem(\\\"searchsort\\\", String(MY_INDEX));\\n            refreshPage();\\n          })\\n        }, searchsort)\\n      }]\\n    }\\n  });\\n\\n  let settings = [\\\"解析管理\\\", \\\"官方弹幕\\\", \\\"支持作者\\\", \\\"UI管理\\\", \\\"调试日志:\\\" + (!getItem(\\\"useLog\\\", \\\"\\\") ? \\\"关闭\\\" : \\\"开启\\\"), \\\"跳过形式二级:\\\" + (!getItem(\\\"skipEr\\\", \\\"\\\") ? \\\"关闭\\\" : \\\"开启\\\"), \\\"分享导入路径\\\", \\\"创建订阅地址\\\", \\\"切换列表样式\\\", \\\"GitHubRAW地址\\\",\\\"主题:\\\" + getItem(\\\"theme\\\", \\\"默认\\\"),\\\"更换配置\\\"];\\n  let disVisibles = ui_indexs.filter(x => x.index == -1);\\n  if (disVisibles.some(x => x.key == \\\"搜索模式\\\")) {\\n    settings.push(\\\"搜索模式:\\\" + [\\\"选中\\\", \\\"聚合\\\"][smode]);\\n    settings.push(\\\"搜索指定源\\\");\\n    settings.push(\\\"搜索排序:\\\" + [\\\"无\\\", \\\"自然\\\", \\\"使用\\\"][searchsort]);\\n  }\\n  if (disVisibles.some(x => x.key == \\\"收藏\\\")) {\\n    settings.push(\\\"我的\\\");\\n  }\\n\\n  uiobj.push({\\n    key: \\\"设置\\\",\\n    index: 2,\\n    title: \\\"设置\\\",\\n    url: $(settings, 2, \\\"设置\\\").select(() => {\\n      if (\\\"解析管理\\\" == input) {\\n        return \\\"hiker://page/ruleManage#noRecordHistory##noHistory#\\\";\\n      } else if (\\\"官方弹幕\\\" === input) {\\n        let useDanmu = !!getItem(\\\"useDanmu\\\", \\\"\\\");\\n        return $(\\\"当为官源时匹配弹幕(需要danmu盒子支持)\\\\n当前:\\\" + useDanmu + \\\"\\\\n点击确定即可\\\" + (useDanmu ? \\\"关闭\\\" : \\\"开启\\\")).confirm((useDanmu) => {\\n          setItem(\\\"useDanmu\\\", useDanmu ? \\\"\\\" : \\\"1\\\");\\n          return \\\"toast://\\\" + (useDanmu ? \\\"已关闭\\\" : \\\"已开启\\\");\\n        }, useDanmu);\\n      } else if (input.includes(\\\"调试日志\\\")) {\\n        let useLog = !!getItem(\\\"useLog\\\", \\\"\\\");\\n        return $(\\\"开启日志辅助调试，普通使用不需要开启\\\\n当前:\\\" + useLog + \\\"\\\\n点击确定即可\\\" + (useLog ? \\\"关闭\\\" : \\\"开启\\\")).confirm((useLog) => {\\n          setItem(\\\"useLog\\\", useLog ? \\\"\\\" : \\\"1\\\");\\n          let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n          let source = runtimeConfig.getCurrentSource();\\n          if (source) {\\n            let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n            DrpyManage.del(source.key);\\n          }\\n          refreshPage();\\n          return \\\"toast://\\\" + (useLog ? \\\"已关闭\\\" : \\\"已开启\\\");\\n        }, useLog);\\n      } else if (input === \\\"创建订阅地址\\\") {\\n        return \\\"hiker://page/createSubscription#noRecordHistory##noHistory#\\\";\\n      } else if (input === \\\"切换列表样式\\\") {\\n        let collist = [\\\"默认\\\", \\\"movie_3_marquee\\\", \\\"movie_3\\\", \\\"movie_2\\\", \\\"movie_1\\\", \\\"text_1\\\", \\\"avatar\\\", \\\"text_icon\\\", \\\"card_pic_3\\\", \\\"card_pic_3_center\\\", \\\"pic_1_card\\\", \\\"pic_2_card\\\", \\\"movie_1_vertical_pic\\\", \\\"movie_1_left_pic\\\"];\\n        let homeListCol = getItem(\\\"homeListCol\\\", \\\"\\\");\\n        let index = homeListCol ? collist.indexOf(homeListCol) : 0;\\n        return $(collist, 2, \\\"选择样式\\\", index).select(() => {\\n          if (MY_INDEX === 0) {\\n            setItem(\\\"homeListCol\\\", \\\"\\\");\\n          } else {\\n            setItem(\\\"homeListCol\\\", input);\\n          }\\n          refreshPage();\\n        });\\n      } else if (input === \\\"更换配置\\\") {\\n        return \\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\";\\n      } else if (\\\"支持作者\\\" == input) {\\n        return \\\"hiker://page/Donate.v#noRecordHistory##noHistory#\\\";\\n      } else if (\\\"UI管理\\\" == input) {\\n        return \\\"hiker://page/UIManage?mode=一级#noRecordHistory##noHistory#\\\";\\n      } else if (\\\"分享导入路径\\\" == input) {\\n        return \\\"hiker://page/sharedefaultpath#noRecordHistory##noHistory#\\\";\\n      } else if (input.includes(\\\"搜索模式\\\")) {\\n        let smode = Number(getItem(\\\"smode\\\", \\\"0\\\"));\\n        return $([\\\"选中\\\", \\\"聚合\\\"], 1, \\\"搜索模式\\\", smode).select((t) => {\\n          setItem(\\\"smode\\\", \\\"\\\" + MY_INDEX);\\n          refreshPage();\\n          return \\\"hiker://empty\\\";\\n        }, MY_RULE.title)\\n      } else if (input == \\\"搜索指定源\\\") {\\n        return $.require(\\\"SearchAllowPop\\\").show();\\n      } else if (input == \\\"我的\\\") {\\n        let favicons = GM.get(\\\"favicons\\\");\\n        return favicons.get();\\n      } else if (input.includes(\\\"搜索排序\\\")) {\\n        let searchsort = Number(getItem(\\\"searchsort\\\", \\\"0\\\"));\\n        return $([\\\"不使用\\\", \\\"自然排序\\\", \\\"使用排序\\\"], 1, \\\"搜索排序\\\", searchsort).select(() => {\\n          setItem(\\\"searchsort\\\", String(MY_INDEX));\\n          refreshPage();\\n        })\\n      } else if (input.includes(\\\"跳过形式二级\\\")) {\\n        let skipEr = !!getItem(\\\"skipEr\\\", \\\"\\\");\\n        setItem(\\\"skipEr\\\", skipEr ? \\\"\\\" : \\\"1\\\");\\n        refreshPage();\\n        return \\\"toast://已\\\" + (skipEr ? \\\"关闭\\\" : \\\"开启\\\");\\n      } else if (input == \\\"GitHubRAW地址\\\") {\\n        const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n        let def = \\\"https://raw.githubusercontent.com\\\";\\n        hikerPop.inputConfirm({\\n          title: \\\"输入地址\\\",\\n          hint: \\\"为空默认\\\",\\n          content: \\\"默认:\\\" + def,\\n          defaultValue: getItem(\\\"githubraw\\\", def),\\n          confirm(text) {\\n            if (text == \\\"\\\") {\\n              setItem(\\\"githubraw\\\", def);\\n            } else {\\n              setItem(\\\"githubraw\\\", text);\\n            }\\n            let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\", \\\"runtimeConfig\\\");\\n            if (!runtimeConfig.initDefault()) {\\n              toast(\\\"刷新失败\\\");\\n            };\\n            toast(\\\"已保存\\\");\\n          }\\n        })\\n      } else if (input.includes(\\\"主题\\\")) {\\n        let ctheme = getItem(\\\"theme\\\", \\\"默认\\\");\\n        let s = $.themes;\\n        let keys = Object.keys(s);\\n        if (keys.length < 2) {\\n          return \\\"toast://没有其他主题\\\";\\n        }\\n        if (keys.length == 2) {\\n          let name = keys[0];\\n          if (ctheme == keys[0]) {\\n            name = keys[1];\\n          }\\n          setItem(\\\"theme\\\", name);\\n          let theme = $.themes[name];\\n          $.uiTheme.set(theme);\\n          refreshPage();\\n          return \\\"hiker://empty\\\"\\n        }\\n        let themes = Object.keys(s).map(x => {\\n          return x == ctheme ? '““””' + x.fontcolor(\\\"red\\\") : x;\\n        });\\n        return $(themes).select((themes) => {\\n          let name = themes[MY_INDEX];\\n          setItem(\\\"theme\\\", name);\\n          let theme = $.themes[name];\\n          $.uiTheme.set(theme);\\n          refreshPage();\\n        }, themes)\\n      }\\n    }),\\n    img: ui_config.icons.设置,\\n    col_type: ui_config.col,\\n  });\\n  uiobj.push({\\n    index: 3,\\n    key: \\\"历史\\\",\\n    title: \\\"历史\\\",\\n    col_type: ui_config.col,\\n    img: ui_config.icons.历史,\\n    url: \\\"hiker://history?rule=\\\" + MY_RULE.title,\\n  });\\n  uiobj.push({\\n    index: 4,\\n    key: \\\"我的\\\",\\n    title: \\\"收藏\\\",\\n    url: $('#noLoading#').lazyRule(() => {\\n      let favicons = GM.get(\\\"favicons\\\");\\n      return favicons.get();\\n    }),\\n    img: ui_config.icons.我的,\\n    col_type: ui_config.col,\\n  });\\n  uiobj.push({\\n    index: 5,\\n    key: \\\"源名\\\",\\n    title: \\\"当前源:\\\" + (name || \\\"\\\"),\\n    col_type: \\\"avatar\\\",\\n    img: ui_config.icons.影视,\\n    url: \\\"toast://点上面换源\\\",\\n    extra: {\\n      id: MY_RULE.title + \\\"sourcename\\\",\\n    }\\n  });\\n  uiobj.push({\\n    index: 6,\\n    key: \\\"搜索\\\",\\n    title: '搜索',\\n    //desc: '',\\n    desc: '要搜点什么',\\n    url: $.toString(() => {\\n      return 'hiker://search?rule=' + MY_RULE.title + \\\"&s=\\\" + input;\\n    }),\\n    col_type: 'input',\\n    extra: {\\n      defaultValue: getMyVar(\\\"keyword\\\", \\\"\\\"),\\n      onChange: $.toString(() => {\\n        putMyVar(\\\"keyword\\\", input)\\n      })\\n    }\\n  });\\n  storage0.putMyVar(\\\"uiobj\\\", uiobj);\\n\\n  suiobj = uiobj.slice();\\n  uiobj = reorderArrayByOrder(uiobj, ui_indexs);\\n  ui_indexs.map(item => {\\n    if (item.key == \\\"换源\\\" && item.index == -1) {\\n      let obji = suiobj.findIndex(x => x.key == \\\"换源\\\");\\n      let cobji = uiobj.findIndex(x => x.key == \\\"源名\\\");\\n      if (obji != 1 && cobji != -1) {\\n        uiobj[cobji].url = suiobj[obji].url;\\n        if (suiobj[obji].hasOwnProperty(\\\"extra\\\")) {\\n          uiobj[cobji].extra = suiobj[obji].extra;\\n          uiobj[cobji].extra.id = MY_RULE.title + \\\"sourcename\\\";\\n        }\\n      }\\n    }\\n    if (item.key == \\\"源名\\\" && item.index == -1) {\\n      let obji = suiobj.findIndex(x => x.key == \\\"源名\\\");\\n      let cobji = uiobj.findIndex(x => x.key == \\\"换源\\\");\\n      if (obji != 1 && cobji != -1) {\\n        uiobj[cobji].title = name || \\\"换源\\\";\\n      }\\n    }\\n    if (item.key == \\\"历史\\\" && item.index == -1) {\\n      selects.unshift({\\n        \\\"title\\\": \\\"历史\\\",\\n        \\\"icon\\\": ui_config.icons.历史,\\n      })\\n    }\\n  });\\n\\n  uiobj.forEach(item => {\\n    d.push(item)\\n  })\\n\\n  \\n\\n}\\nlet d = [];\\n\\nlet runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\nlet DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\nDrpyManage.initPage(\\\"home\\\");\\naddListener(\\\"onClose\\\", () => {\\n  clearMyVar(\\\"links\\\");\\n  GM.clear(\\\"favicons\\\")\\n});\\n\\ntry {\\n  if (android.os.Build.VERSION.SDK_INT >= 30 && !android.os.Environment.isExternalStorageManager()) {\\n    d.push({\\n      title: \\\"‘‘提示’’\\\",\\n      desc: \\\"当前没有文件管理权限无法正常使用请打开海阔设置=>更多设置=>内部文件管理=>右上角\\\",\\n      url: \\\"hiker://empty\\\",\\n      col_type: \\\"text_center_1\\\"\\n    });\\n  } else if (!runtimeConfig.isPrepared()) {\\n    let loadError = runtimeConfig.getLoadError();\\n    if (loadError) {\\n      d.push({\\n        title: \\\"““配置文件加载失败””\\\",\\n        desc: loadError.toString(),\\n        url: $().lazyRule(() => {\\n          GM.defineModule(\\\"runtimeConfig\\\").initDefault();\\n          refreshPage();\\n          return \\\"hiker://empty\\\";\\n        }),\\n        col_type: \\\"text_center_1\\\",\\n      });\\n      d.push({\\n        title: \\\"更换配置\\\",\\n        url: \\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n          lineVisible: false\\n        }\\n      });\\n    } else {\\n      d.push({\\n        title: \\\"还没有配置视频源\\\",\\n        url: \\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\",\\n        col_type: \\\"text_center_1\\\",\\n      });\\n    }\\n  } else if (fileExist(\\\"hiker://files/data/\\\" + MY_RULE.title + \\\"/libs_hiker/drpy2.js\\\")) {\\n\\n    let source = runtimeConfig.getCurrentSource();\\n    if (MY_PAGE === 1) {\\n      if (source == undefined) {\\n        setHied(d, \\\"\\\", {});\\n        throw new Error(\\\"当前没有选中任何视频源\\\");\\n      } else {\\n        setHied(d, source.name, runtimeConfig.getCurrentConfig() || {});\\n      }\\n    }\\n    //log(DrpyManage.get(source.key))\\n    let hasHaed = false;\\n    if (getMyVar(\\\"links\\\", \\\"\\\") == \\\"\\\") {\\n      d.push({\\n        title: '加载中...',\\n        col_type: 'text_center_1',\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n          lineVisible: false,\\n          id: MY_RULE.title + \\\"load\\\"\\n        }\\n      });\\n      setPreResult(d);\\n      d.length = 0;\\n      hasHaed = true;\\n    }\\n    if (source) {\\n      load(d, DrpyManage.get(source.key), source, hasHaed);\\n    }\\n  } else {\\n    setDrpyPath(d);\\n  }\\n\\n} catch (e) {\\n  d.push({\\n    title: \\\"““\\\" + e.toString() + \\\"””\\\",\\n    desc: e.lineNumber,\\n    url: \\\"hiker://empty\\\",\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n      longClick: [{\\n        title: \\\"清除ui设置\\\",\\n        js: $.toString(() => {\\n          let {\\n            ui_clear,\\n          } = $.require(\\\"UIManage\\\");\\n          ui_clear(\\\"yi\\\");\\n          refreshPage();\\n        })\\n      }]\\n    }\\n  });\\n  d.push({\\n    title: \\\"更换配置\\\",\\n    url: \\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\",\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n      lineVisible: false\\n    }\\n  });\\n  deleteItem(MY_RULE.title + \\\"load\\\");\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"主页处理\",\"path\":\"MianLoad\",\"rule\":\"if (getItem(\\\"firstopen\\\") == MY_RULE.version) {\\n    $.require(\\\"mian\\\");\\n} else if (MY_PAGE === 1) {\\n    let d = []\\n    let time = getItem(\\\"firstopen\\\", \\\"\\\") ? 6 : 20;\\n    let id = Date.now();\\n    let content = `\\n    1. 本小程序所有代码全部开源，且本规则为学习目的，请于导入24小时内删除！！！\\n    2. 本小程序<b>完全免费</b>，如果你是付费购买的恭喜你被骗了。\\n    当然如果有能力想鼓励作者的可以${\\\"支持一下\\\".big().link(\\\"hiker://page/Donate.v#noHistory##noRecordHistory#\\\")}</a>(<small>点击可进入捐赠，可在主页菜单进入</small>)。\\n    3. 本小程序只支持道长的drpy[js]视频源，其他一概不支持。\\n    \\n    <b>开始使用本规则即代表遵守规则条例</b>\\n    `;\\n\\n    d.push({\\n        title: \\\"““””<strong>使用前须知</strong>\\\".big(),\\n        col_type: \\\"text_center_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n\\n    d.push({\\n        title: content.trim().replace(/\\\\n\\\\s*?/g, \\\"<br>\\\"),\\n        \\\"col_type\\\": \\\"rich_text\\\"\\n    }, {\\n        title: `当前版本：${MY_RULE.version} ${getItem(\\\"firstopen\\\", \\\"\\\") && getItem(\\\"firstopen\\\", \\\"\\\") < MY_RULE.version ? \\\"🆕\\\" : \\\"\\\"}`,\\n        col_type: \\\"text_1\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n            hikerPop.updateRecordsBottom($.require(\\\"updateRecords\\\"));\\n\\n            return \\\"hiker://empty\\\";\\n        }),\\n        extra: {\\n            titleVisible: false\\n        }\\n    }, {\\n        col_type: \\\"line\\\"\\n    }, {\\n        title: time + \\\"秒后继续\\\",\\n        url: \\\"toast://请认真阅读以上内容\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: id + \\\"timer\\\"\\n        }\\n    });\\n\\n    setResult(d);\\n    while (time != 0) {\\n        java.lang.Thread.sleep(1000);\\n        time -= 1;\\n        updateItem(id + \\\"timer\\\", {\\n            title: time + \\\"秒后继续\\\"\\n        });\\n    }\\n    updateItem(id + \\\"timer\\\", {\\n        title: \\\"““我同意以上要求””\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((v) => {\\n            setItem(\\\"firstopen\\\", String(v));\\n            GM.clear(\\\"runtimeConfig\\\");\\n            refreshPage();\\n            const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n            hikerPop.updateRecordsBottom($.require(\\\"updateRecords\\\"));\\n            return \\\"toast://感谢您的理解\\\";\\n        }, MY_RULE.version),\\n        col_type: \\\"text_center_1\\\"\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"Ui管理\",\"path\":\"UIManage\",\"rule\":\"js:\\nfunction reorderArrayByOrder(array, order) {\\n  // 创建一个映射，将key值映射到原始数组中的对象\\n  let map = new Map(array.map(obj => [obj.key, obj]));\\n  let reorderedArray = []; // 重新排序后的数组\\n  let removedKeys = new Set(); // 存储需要移除的key值\\n  // 根据order数组来重新排列array数组\\n  order.forEach((item, i) => {\\n    if (item.index === -1) {\\n      // 如果index是-1，将key添加到移除列表中\\n      removedKeys.add(item.key);\\n    } else {\\n      // 如果index不是-1，则将对象添加到结果数组中的指定位置\\n      let obj = map.get(item.key);\\n\\n      if (obj && item.hasOwnProperty(\\\"img\\\") && item.img) {\\n        obj.img = item.img;\\n      }\\n      if (obj && item.hasOwnProperty(\\\"title\\\") && item.title) {\\n        obj.title = item.title;\\n      }\\n      if (obj) {\\n        reorderedArray[i] = obj;\\n      }\\n    }\\n  });\\n  // 添加那些不在order数组中的对象，并排除移除列表中的项\\n  array.forEach(obj => {\\n    if (!removedKeys.has(obj.key) && !reorderedArray.includes(obj)) {\\n      reorderedArray.push(obj);\\n    }\\n  });\\n  // 过滤掉结果数组中的undefined项，并返回\\n  return reorderedArray.filter(obj => obj !== undefined);\\n}\\n/**\\n * 生成一个随机颜色的十六进制表示。\\n * @return {string} 返回一个形如 '#RRGGBB' 的随机颜色字符串。\\n */\\nvar getRangeColors = function () {\\n  return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\n};\\n\\n/**\\n * 深度合并多个对象的属性。\\n * @param {Object} target - 被合并的对象，第一个参数，合并的结果将以此对象为基础。\\n * @returns {Object} - 合并后的对象。\\n */\\nfunction deepMerge(target) {\\n  function isObject(obj) {\\n    return obj && typeof obj === 'object' && !Array.isArray(obj);\\n  }\\n  for (var i = 1; i < arguments.length; i++) {\\n    var source = arguments[i];\\n    for (var key in source) {\\n      if (isObject(source[key])) {\\n        if (!target[key]) {\\n          target[key] = {};\\n        }\\n        deepMerge(target[key], source[key]);\\n      } else {\\n        target[key] = source[key];\\n      }\\n    }\\n  }\\n  return target;\\n}\\n\\n/**\\n * 从源对象中深度删除指定的属性。\\n * @param {Object} source - 要处理的源对象。\\n * @param {Object} exc - 指定要排除的属性，以键值对形式指定。\\n * @returns {Object} - 返回一个新的对象，不包含指定要排除的属性。\\n */\\nfunction deepOmit(source, exc) {\\n  const result = {};\\n  // 遍历顶层键\\n  for (let key in source) {\\n    if (source.hasOwnProperty(key)) {\\n      // 检查顶层键是否应该被排除\\n      if (!(exc.hasOwnProperty(key) && exc[key] === true)) {\\n        // 如果顶层键对应的值是对象，并且有子排除规则，则递归调用 deepOmit\\n        if (typeof source[key] === 'object' && source[key] !== null && exc[key]) {\\n          result[key] = deepOmit(source[key], exc[key]);\\n        } else if (typeof source[key] !== 'object' || source[key] === null || !exc[key]) {\\n          // 如果顶层键对应的值不是对象，或者没有子排除规则，直接复制值\\n          result[key] = source[key];\\n        }\\n      }\\n    }\\n  }\\n  return result;\\n}\\n\\n/**\\n * 判断两个对象是否相等，忽略指定的键。\\n * @param {*} x - 第一个对象。\\n * @param {*} y - 第二个对象。\\n * @param {Array} excludeKeys - 需要忽略比较的键数组。\\n * @returns {boolean} - 如果两个对象相等（考虑嵌套对象）且不包含指定的键，则返回true；否则返回false。\\n */\\nfunction isEqual(x, y, excludeKeys) {\\n  excludeKeys = excludeKeys != undefined ? excludeKeys : [];\\n  const ok = Object.keys;\\n  const tx = typeof x;\\n  const ty = typeof y;\\n  if (x && y && tx === \\\"object\\\" && tx === ty) {\\n    const keysX = ok(x).filter(key => !excludeKeys.includes(key));\\n    const keysY = ok(y).filter(key => !excludeKeys.includes(key));\\n    if (keysX.length !== keysY.length) {\\n      return false;\\n    }\\n    return keysX.every((key) => isEqual(x[key], y[key], excludeKeys));\\n  }\\n  return x === y;\\n}\\n\\nlet themeManage = {\\n  name: \\\"theme.json\\\",\\n  path: \\\"hiker://files/rules/DrpyHiker/\\\",\\n  save(content) {\\n    saveFile(this.path + this.name, content);\\n  },\\n  init() {\\n    let json = {};\\n    if (!fileExist(this.path + this.name)) {\\n      this.save(\\\"{}\\\");\\n    }\\n    try {\\n      json = JSON.parse(readFile(this.path + this.name));\\n    } catch (e) {\\n      json = {};\\n      this.save(\\\"{}\\\");\\n    }\\n    return json;\\n  },\\n  has(ts) {\\n    let json = this.init();\\n    let sjson = deepMerge({}, json);\\n    let keys = Object.keys(ts);\\n    keys.forEach(k => {\\n      if (!json.hasOwnProperty(k)) {\\n        json[k] = ts[k];\\n      }\\n    })\\n    if (Object.keys(sjson).length == 0) {\\n      json = deepMerge(json, sjson);\\n      this.save(JSON.stringify(json));\\n      return json;\\n    }\\n    if (!keys.every(key => sjson.hasOwnProperty(key))) {\\n      this.save(JSON.stringify(json));\\n    }\\n    return json;\\n  },\\n  get(key) {\\n    let json = this.init();\\n    if (key != undefined) {\\n      if (typeof key != \\\"string\\\") {\\n        json = this.has(key);\\n        return json;\\n      }\\n    } else {\\n      return json;\\n    }\\n  },\\n  set(key, value) {\\n    let json = this.init();\\n    if (key != undefined) {\\n      json[key] = value;\\n    }\\n    this.save(JSON.stringify(json));\\n  }\\n}\\n\\nlet defTheme = {\\n  默认: {\\n    yi: {\\n      mark: \\\"#immersiveTheme#\\\",\\n      换源颜色: \\\"#DD9C5A\\\", 分类颜色: \\\"random\\\",\\n      icons: {\\n        换源: \\\"https://hikerfans.com/tubiao/system/130.png\\\",\\n        搜索: \\\"https://hikerfans.com/tubiao/system/149.png\\\",\\n        设置: \\\"https://hikerfans.com/tubiao/system/150.png\\\",\\n        我的: \\\"https://hikerfans.com/tubiao/system/139.png\\\",\\n        收藏: \\\"https://hikerfans.com/tubiao/system/139.png\\\",\\n        历史: \\\"https://hikerfans.com/tubiao/system/136.png\\\",\\n\\n        影视: \\\"https://hikerfans.com/tubiao/ke/150.png\\\",\\n        漫画: \\\"https://hikerfans.com/tubiao/ke/13.png\\\",\\n        小说: \\\"https://hikerfans.com/tubiao/ke/38.png\\\",\\n        书架小说: \\\"https://hikerfans.com/tubiao/q/13.png\\\",\\n        书架漫画: \\\"https://hikerfans.com/tubiao/q/34.png\\\",\\n      }\\n    },\\n    er: {\\n      icons: {\\n        正序: \\\"https://hikerfans.com/tubiao/messy/123.svg\\\",\\n        倒序: \\\"https://hikerfans.com/tubiao/messy/124.svg\\\",\\n        视频: \\\"https://hikerfans.com/tubiao/messy/110.svg\\\"\\n      },\\n      简介样式: \\\"0\\\",\\n      浅来源色: \\\"#FFFFFF;\\\",\\n      深来源色: \\\"#FFFFFF;\\\",\\n      线路颜色: \\\"#DD9C5A\\\",\\n      线路显示: \\\"当前线路: {form}\\\\t\\\\t共:{plays}集\\\\t\\\\t{spage}/{max}\\\",\\n    }\\n  },\\n  \\\"007\\\": {\\n    yi: {\\n      mark: \\\"#gameTheme#\\\",\\n      换源颜色: \\\"#19B89D\\\", 分类颜色: \\\"#19B89D\\\",\\n      icons: {\\n        换源: \\\"https://hikerfans.com/img/drpy/shouye.svg\\\",\\n        搜索: \\\"https://hikerfans.com/img/drpy/sousuo.svg\\\",\\n        设置: \\\"https://hikerfans.com/img/drpy/shezhi.svg\\\",\\n        我的: \\\"https://hikerfans.com/img/drpy/wode.svg\\\",\\n        收藏: \\\"https://hikerfans.com/img/drpy/shoucang.svg\\\",\\n        历史: \\\"https://hikerfans.com/img/drpy/lishi.svg\\\",\\n\\n        影视: \\\"https://hikerfans.com/img/drpy/shipin.svg\\\",\\n        漫画: \\\"https://hikerfans.com/img/drpy/manhua.svg\\\",\\n        小说: \\\"https://hikerfans.com/img/drpy/xiaoshuo.svg\\\",\\n        书架小说: \\\"https://hikerfans.com/img/drpy/xiaoshuo.svg\\\",\\n        书架漫画: \\\"https://hikerfans.com/img/drpy/manhua.svg\\\",\\n      }\\n    },\\n    er: {\\n      icons: {\\n        正序: \\\"https://hikerfans.com/img/drpy/reverse.svg\\\",\\n        倒序: \\\"https://hikerfans.com/img/drpy/correct.svg\\\",\\n        视频: \\\"https://hikerfans.com/img/default.svg\\\"\\n      },\\n      简介样式: \\\"1\\\",\\n      浅来源色: \\\";\\\",\\n      深来源色: \\\";\\\",\\n      线路颜色: \\\"#19B89D\\\",\\n      线路显示: '共:{plays}集,\\\\t\\\\t<span style=\\\"color:#19B89D\\\">{spage}</span>/{max}页',\\n    }\\n  }\\n}\\ndelete defTheme[\\\"007\\\"];\\n\\nlet Theme = themeManage.get(defTheme);\\n\\nlet theme = getItem(\\\"theme\\\", \\\"默认\\\");\\n\\nlet def = {\\n  yi: { \\\"ui\\\": [{ \\\"key\\\": \\\"换源\\\", \\\"index\\\": 0 }, { \\\"key\\\": \\\"搜索模式\\\", \\\"index\\\": 1 }, { \\\"key\\\": \\\"我的\\\", \\\"index\\\": 4, \\\"title\\\": \\\"我的\\\" }, { \\\"key\\\": \\\"设置\\\", \\\"index\\\": 2 }, { \\\"key\\\": \\\"搜索\\\", \\\"index\\\": 6 }, { \\\"key\\\": \\\"源名\\\", \\\"index\\\": -1 }, { \\\"key\\\": \\\"历史\\\", \\\"index\\\": -1 }], \\\"col\\\": \\\"icon_small_4\\\" },\\n  er: { 分页: 40, 历史记录: 200, 分页逻辑: \\\"0\\\", 分页导航: false, 线路样式: \\\"scroll_button\\\", 二级缓存: false, 二级刷新: false }\\n}\\n\\nObject.entries(Theme).forEach(([key, value]) => {\\n  Theme[key] = deepMerge({}, Theme[\\\"默认\\\"], value);\\n})\\n\\n//旧版兼容处理替换key\\nfunction replaceKeysInArray(array, keyMap) {\\n  keyMap = {\\n    '收藏': '我的',\\n  };\\n  array.forEach(item => {\\n    Object.keys(item).forEach(key => {\\n      if (keyMap.hasOwnProperty(item[key])) {\\n        item[key] = keyMap[item[key]];\\n      }\\n    });\\n  });\\n}\\n\\nlet ui_theme = storage0.getItem(\\\"ui_theme\\\", Theme[theme]);\\n//clearItem(\\\"ui_config\\\")\\nlet ui_fig = storage0.getItem(\\\"ui_config\\\", def);\\nreplaceKeysInArray(ui_fig.yi.ui);\\n//log(ui_fig);\\nlet ui_config = deepMerge({}, ui_fig, ui_theme);\\n//log(ui_config)\\n\\nfunction ui_clear(key) {\\n  $.uiConfig.set(def[key], \\\"yi\\\");\\n}\\n//clearItem(\\\"ui_config\\\")\\n\\nfunction getLineShow(ef) {\\n  //log(ef)\\n  let obj = {\\n    s: ef,\\n    line: ef.from.indexOf(ef.from[ef.line]),\\n    lines: ef.from.length,\\n    form: ef.from[ef.line],\\n    plays: ef.plays[ef.line],\\n    spage: ef.spagenum,\\n    max: ef.max[ef.line]\\n  }\\n  function Template(template, data) {\\n    // 用于执行字符串中的表达式\\n    function evaluateExpression(expr) {\\n      try {\\n        // 使用 with 语句将 data 对象放入当前作用域\\n        // 这样可以在表达式中直接使用 data 的属性\\n        with (data) {\\n          return eval(expr);\\n        }\\n      } catch (e) {\\n        return expr; // 如果表达式无法计算，则返回原始字符串\\n      }\\n    }\\n    // 正则表达式匹配 { 表达式 } 格式的占位符\\n    return template.replace(/{(.*?)}/g, (match, expr) => {\\n      //console.log(expr)\\n      // 执行表达式\\n      return evaluateExpression(expr);\\n    });\\n  }\\n  let lshow = Template(ui_config.er.线路显示, obj);\\n  return lshow;\\n}\\n\\n/** \\n * ui $扩展\\n*/\\nfunction ui_expand() {\\n  $.extend({\\n    deepMerge,\\n    themes: Theme,\\n    swapArrayElements(array, index1, index2) {\\n      let result = array.slice();\\n      index1 = array.findIndex(x => x.index == index1);\\n      index2 = array.findIndex(x => x.index == index2);\\n      // 使用临时变量交换两个元素\\n      const temp = result[index1];\\n      result[index1] = result[index2];\\n      result[index2] = temp;\\n      return result;\\n    },\\n    uiConfig: {\\n      uc: ui_fig,\\n      def: def,\\n      deepObjectProperty(obj, path, value) {\\n        var parts = path.split('.');\\n        var current = obj;\\n        for (var i = 0; i < parts.length - 1; i++) {\\n          var part = parts[i];\\n          if (!current[part]) {\\n            current[part] = {};\\n          }\\n          current = current[part];\\n        }\\n        current[parts[parts.length - 1]] = value;\\n      },\\n      get() {\\n        let uc = storage0.getItem(\\\"ui_config\\\", this.uc);\\n        if (Object.keys(uc).length == 0) {\\n          uc = this.def;\\n        }\\n        return uc;\\n      },\\n      set(value, key) {\\n        let uc = this.get();\\n        if (key) {\\n          this.deepObjectProperty(uc, key, value);\\n        } else {\\n          uc = value;\\n        }\\n        storage0.setItem(\\\"ui_config\\\", uc);\\n      },\\n      getIndexs() {\\n        let uc = this.get();\\n        if (uc.yi.ui.length > 0 && uc.yi.ui.some(x => Object.keys(x).length > 0)) {\\n          return uc.yi.ui;\\n        } else {\\n          this.set(this.items, \\\"yi.ui\\\");\\n          return this.items;\\n        }\\n      },\\n    },\\n    uiTheme: {\\n      self: ui_theme,\\n      def: Theme[theme],\\n      deepObjectProperty(obj, path, value) {\\n        var parts = path.split('.');\\n        var current = obj;\\n        for (var i = 0; i < parts.length - 1; i++) {\\n          var part = parts[i];\\n          if (!current[part]) {\\n            current[part] = {};\\n          }\\n          current = current[part];\\n        }\\n        current[parts[parts.length - 1]] = value;\\n      },\\n      get(key, def) {\\n        let ut = storage0.getItem(\\\"ui_theme\\\", this.self);\\n        if (key != undefined) {\\n          return ut[key] || (def || \\\"\\\")\\n        }\\n        if (Object.keys(ut).length == 0) {\\n          uc = this.def;\\n        }\\n        return ut;\\n      },\\n      set(value, key) {\\n        let ut = this.get();\\n        if (key) {\\n          this.deepObjectProperty(ut, key, value);\\n        } else {\\n          ut = value;\\n        }\\n        storage0.setItem(\\\"ui_theme\\\", ut);\\n      },\\n    }\\n  })\\n}\\n\\n$.exports = {\\n  Theme,\\n  deepOmit,\\n  deepMerge,\\n  ui_clear,\\n  ui_expand,\\n  ui_config,\\n  getLineShow,\\n  getRangeColors,\\n  themeManage,\\n  reorderArrayByOrder,\\n}\\n\\nif (getParam(\\\"mode\\\", \\\"\\\") != \\\"\\\") {\\n  addListener('onClose', $.toString(() => {\\n    clearMyVar(\\\"ui_navi\\\");\\n    clearMyVar(\\\"uimode\\\");\\n  }));\\n\\n  function toBoolean(text) {\\n    if (text == undefined || text == null) {\\n      return false;\\n    }\\n    if (text === \\\"true\\\") {\\n      return true;\\n    } else if (text === \\\"false\\\") {\\n      return false;\\n    } else {\\n      return false;\\n    }\\n  }\\n\\n  function buttonImg(bool) {\\n    if (typeof bool == \\\"string\\\") {\\n      if (bool == \\\"true\\\" || bool == \\\"false\\\") {\\n        bool = toBoolean(bool);\\n      }\\n    }\\n    if (bool == true) {\\n      return 'https://hikerfans.com/tubiao/messy/55.svg';\\n    }\\n    if (bool == false || bool == null || bool == undefined) {\\n      return 'https://hikerfans.com/img/drpy/off.svg';\\n    }\\n  }\\n\\n  setPageTitle(\\\"UI管理\\\");\\n  let d = [];\\n  let ui_nav = [\\\"一级\\\", \\\"二级\\\"];\\n  let ui_navi = getMyVar(\\\"ui_navi\\\", getParam(\\\"mode\\\", \\\"一级\\\"));\\n  ui_nav.forEach(x => {\\n    d.push({\\n      title: '““””' + (x == ui_navi ? x.fontcolor(\\\"#20B2AA\\\") : x),\\n      url: $('#noLoading#').lazyRule((it) => {\\n        putMyVar(\\\"ui_navi\\\", it);\\n        refreshPage();\\n        return \\\"hiker://empty\\\";\\n      }, x),\\n      col_type: \\\"text_3\\\"\\n    })\\n  })\\n\\n  ui_expand();\\n\\n  d.push({\\n    title: \\\"主题:\\\" + theme,\\n    url: $('#noLoading#').lazyRule(() => {\\n      let ctheme = getItem(\\\"theme\\\", \\\"默认\\\");\\n      let s = $.themes;\\n      let themes = Object.keys(s).map(x => {\\n        return x == ctheme ? '““””' + x.fontcolor(\\\"#20B2AA\\\") : x;\\n      });\\n      themes.unshift(\\\"编辑主题\\\");\\n      return $(themes).select((themes, s, n) => {\\n        let name = themes[MY_INDEX].replace(/<[^>]*>/g, '').replace(/[“”']/g, \\\"\\\");\\n        if (name == n) {\\n          return \\\"hiker://empty\\\";\\n        }\\n\\n        if (name == \\\"编辑主题\\\") {\\n          return \\\"hiker://page/ThemeEdit\\\"\\n        }\\n        setItem(\\\"theme\\\", name);\\n        $.uiTheme.set(s[name]);\\n        refreshPage();\\n      }, themes, s, ctheme)\\n    }),\\n    col_type: \\\"text_3\\\",\\n    extra: {\\n      pageTitle: \\\"主题编辑\\\",\\n      longClick: [{\\n        title: \\\"重置\\\",\\n        js: $.toString(() => {\\n          return $(\\\"清除所有设置\\\").confirm(() => {\\n            clearItem(\\\"theme\\\");\\n            clearItem(\\\"ui_config\\\");\\n            clearItem(\\\"ui_theme\\\");\\n            return \\\"toast://初始化完成\\\";\\n          })\\n        }),\\n      }]\\n    }\\n  })\\n  d.push({\\n    col_type: \\\"blank_block\\\"\\n  })\\n\\n\\n  if (ui_navi == \\\"一级\\\") {\\n    addListener('onRefresh', $.toString(() => {\\n      clearMyVar(\\\"ui_current\\\");\\n    }))\\n\\n    var uiobj = storage0.getMyVar(\\\"uiobj\\\", []);\\n    var suiobj = uiobj.slice();\\n    let items = uiobj.map(item => {\\n      return {\\n        key: item.key,\\n        index: item.index\\n      }\\n    });\\n    let uimode = getMyVar(\\\"uimode\\\", \\\"0\\\") == \\\"0\\\" ? false : true;\\n\\n    $.uiConfig.items = items;\\n\\n    let indexs = $.uiConfig.getIndexs();\\n\\n    uiobj = uiobj.map(item => {\\n      let k = item.key;\\n      if (item.key == \\\"搜索模式\\\") {\\n        k = \\\"搜索\\\";\\n      }\\n      if (item.key == \\\"源名\\\") {\\n        k = \\\"影视\\\";\\n      }\\n      item.img = $.uiTheme.get().yi.icons[k];\\n      if (!/(icon_1_search|avatar|input)/.test(item.col_type)) {\\n        item.col_type = ui_config.yi.col;\\n      }\\n      return item;\\n    })\\n\\n    uiobj = reorderArrayByOrder(uiobj, indexs);\\n    //log(uiobj)\\n\\n    if (uimode) {\\n      uiobj = uiobj.map((item, i) => {\\n        let longclicks = [];\\n        item.title = item.key;\\n        if (item.col_type == \\\"input\\\") {\\n          item.col_type = \\\"icon_1_search\\\";\\n        }\\n        item.url = $(\\\"#noLoading#\\\").lazyRule((i) => {\\n          let indexs = $.uiConfig.getIndexs();\\n\\n          let item = findItem(MY_RULE.title + \\\"_ui\\\" + i);\\n          if (item.title.includes(\\\"font\\\") || item.title.includes(\\\"➡️\\\")) {\\n            updateItem(item.extra.id, {\\n              title: item.title.replace(/‘|’|“|”|<[^>]+>/g, \\\"\\\").replace(\\\"➡️\\\", \\\"\\\")\\n            });\\n            clearMyVar(\\\"ui_current\\\");\\n            return \\\"hiker://empty\\\";\\n          }\\n\\n          let current = storage0.getMyVar(\\\"ui_current\\\", {});\\n\\n          if (Object.keys(current).length > 0) {\\n            updateItem(item.extra.id, {\\n              title: current.title,\\n              pic: current.pic || \\\"\\\",\\n              desc: current.desc || \\\"\\\",\\n              col_type: current.type,\\n              extra: Object.assign({}, item.extra, {\\n                key: current.extra.key,\\n                index: current.extra.index\\n              })\\n            });\\n            updateItem(current.extra.id, {\\n              title: item.title,\\n              pic: item.pic || \\\"\\\",\\n              desc: item.desc || \\\"\\\",\\n              col_type: item.type,\\n              extra: Object.assign({}, current.extra, {\\n                key: item.extra.key,\\n                index: item.extra.index\\n              })\\n            });\\n\\n            let narr = $.swapArrayElements(indexs, current.extra.index, item.extra.index);\\n\\n            $.uiConfig.set(narr, \\\"yi.ui\\\");\\n            clearMyVar(\\\"ui_current\\\");\\n          } else {\\n            let h = '““””';\\n            let title = item.title;\\n            toast(\\\"选择移动的目标\\\");\\n            if (/text_icon|avatar|icon_small_3/.test(item.type)) {\\n              h = \\\"\\\";\\n              title = title.fontcolor(\\\"#fff\\\");\\n            } else if (/icon_1_search/.test(item.type)) {\\n              h = \\\"\\\";\\n              title = \\\"➡️\\\" + title;\\n            } else {\\n              title = title.fontcolor(\\\"#fff\\\");\\n            }\\n            updateItem(item.extra.id, {\\n              title: h + title,\\n            })\\n            storage0.putMyVar(\\\"ui_current\\\", item);\\n          }\\n          return \\\"hiker://empty\\\";\\n        }, i)\\n        item[\\\"extra\\\"] = {\\n          key: item.key,\\n          cls: MY_RULE.title + \\\"_ui\\\",\\n          id: MY_RULE.title + \\\"_ui\\\" + i,\\n          index: item.index,\\n        }\\n        if (item.key != \\\"设置\\\") {\\n          longclicks.push({\\n            title: \\\"删除\\\",\\n            js: $.toString((key) => {\\n              let items = $.uiConfig.getIndexs();\\n              let i = items.findIndex(x => x.key == key);\\n              if (i != -1) {\\n                items[i][\\\"index\\\"] = -1;\\n              }\\n              $.uiConfig.set(items, \\\"yi.ui\\\");\\n              refreshPage();\\n            }, item.key)\\n          })\\n        }\\n        if (!/icon_1_search|avatar/.test(item.col_type)) {\\n          longclicks.push({\\n            title: \\\"更换图标\\\",\\n            js: $.toString((item) => {\\n              return $(item.img).input((item) => {\\n                let key = item.key;\\n                let items = $.uiConfig.getIndexs();\\n                let i = items.findIndex(x => x.key == key);\\n                let k = key;\\n                if (i != -1) {\\n                  if (key == \\\"搜索模式\\\") {\\n                    k = \\\"搜索\\\";\\n                  }\\n                  $.uiTheme.set(input, \\\"yi.icons.\\\" + k);\\n                  //items[i][\\\"img\\\"] = input;\\n                }\\n                $.uiConfig.set(items, \\\"yi.ui\\\");\\n                let id = findItemsByCls(MY_RULE.title + \\\"_ui\\\").filter(x => x.extra.key == key)[0].extra.id;\\n                updateItem(id, { pic: input })\\n              }, item)\\n            }, item)\\n          })\\n          if (item.key != \\\"换源\\\" && item.key != \\\"搜索模式\\\") {\\n            longclicks.push({\\n              title: \\\"修改名称\\\",\\n              js: $.toString((key) => {\\n                return $(\\\"\\\").input((key) => {\\n                  let items = $.uiConfig.getIndexs();\\n                  let i = items.findIndex(x => x.key == key);\\n                  if (i != -1) {\\n                    items[i][\\\"title\\\"] = input;\\n                  }\\n                  $.uiConfig.set(items, \\\"yi.ui\\\");\\n                  let id = findItemsByCls(MY_RULE.title + \\\"_ui\\\").filter(x => x.extra.key == key)[0].extra.id;\\n                  updateItem(id, { title: input })\\n                }, key)\\n              }, item.key)\\n            })\\n          }\\n        }\\n        item.extra.LongClick = longclicks;\\n        return item;\\n      })\\n    } else {\\n      uiobj = uiobj.map((item, i) => {\\n        item.extra = {\\n          id: MY_RULE.title + \\\"_ui\\\" + i,\\n          cls: MY_RULE.title + \\\"_ui\\\"\\n        }\\n        return item;\\n      })\\n    }\\n    d = d.concat(uiobj);\\n\\n    if (indexs.some(x => x.index == -1) && uimode) {\\n      d.push({\\n        title: \\\"已移除\\\",\\n        col_type: \\\"text_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n          lineVisible: false,\\n        }\\n      })\\n      indexs.filter(x => x.index == -1).forEach((item, i) => {\\n        let map = new Map(suiobj.map(obj => [obj.key, obj]));\\n        let obj = map.get(item.key);\\n        obj.url = $(\\\"\\\").lazyRule((key, index) => {\\n          let items = $.uiConfig.getIndexs();\\n          let i = items.findIndex(x => x.key == key);\\n          if (i != -1) {\\n            items[i][\\\"index\\\"] = index;\\n          }\\n          $.uiConfig.set(items, \\\"yi.ui\\\");\\n          refreshPage();\\n          return \\\"hiker://empty\\\";\\n        }, item.key, obj.index)\\n        obj.title = obj.key;\\n        if (obj.extra == undefined) {\\n          obj.extra = {};\\n        }\\n        obj.extra.id = MY_RULE.title + \\\"_ui\\\" + obj.key;\\n        obj.extra.cls = MY_RULE.title + \\\"_ui\\\";\\n\\n        if (obj.col_type == \\\"input\\\") {\\n          obj.col_type = \\\"icon_1_search\\\";\\n        }\\n        d.push(obj)\\n      })\\n    }\\n\\n    d.push({\\n      col_type: \\\"line\\\"\\n    }, {\\n      title: '““””' + (uimode ? \\\"修改\\\".fontcolor(\\\"#20B2AA\\\") : \\\"修改\\\"),\\n      url: $('#noLoading#').lazyRule(() => {\\n        let uimode = getMyVar(\\\"uimode\\\", \\\"0\\\");\\n        putMyVar(\\\"uimode\\\", uimode == \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        refreshPage();\\n        return \\\"toast://修改\\\" + (uimode == \\\"0\\\" ? \\\"开启:点击按钮交换位置,长按按钮修改或者删除\\\" : \\\"关闭\\\");\\n      }),\\n      col_type: \\\"text_3\\\",\\n    }, {\\n      title: \\\"还原\\\",\\n      col_type: \\\"text_3\\\",\\n      url: $('#noLoading#').lazyRule((def) => {\\n        return $(\\\"是否恢复设置\\\").confirm((def) => {\\n          $.uiConfig.set(def.yi, \\\"yi\\\");\\n          refreshPage(false);\\n          return \\\"toast://还原完成\\\";\\n        }, def)\\n      }, def),\\n    }, {\\n      title: \\\"确认\\\",\\n      col_type: \\\"text_3\\\",\\n      url: $('#noLoading#').lazyRule(() => {\\n        back(true);\\n        return \\\"hiker://empty\\\"\\n      }),\\n      extra: {\\n        LongClick: [{\\n          title: \\\"复制\\\",\\n          js: $.toString(() => {\\n            var uc = $.uiConfig.get();\\n            copy(JSON.stringify(uc.yi));\\n          }),\\n        }, {\\n          title: \\\"导入\\\",\\n          js: $.toString(() => {\\n            var uc = $.uiConfig.get();\\n            return $(\\\"{{clipboard}}\\\").input((uc) => {\\n              var yi = {};\\n              try {\\n                yi = JSON.parse(input);\\n                if (yi.hasOwnProperty(\\\"ui\\\")) {\\n                  uc.yi = yi;\\n                  storage0.setItem(\\\"ui_config\\\", uc);\\n                  refreshPage();\\n                }\\n              } catch (e) {\\n                toast(\\\"格式错误\\\")\\n              }\\n            }, uc)\\n          })\\n        }]\\n      }\\n    })\\n    d.push({\\n      title: \\\"头部组件样式:\\\" + ui_config.yi.col,\\n      col_type: \\\"text_1\\\",\\n      url: $('#noLoading#').lazyRule((ui_config) => {\\n        ui_config = storage0.getItem(\\\"ui_config\\\", ui_config);\\n        let all_cols = [''].concat(getColTypes());\\n        all_cols = all_cols.filter(x =>\\n          /(icon)/.test(x) && x != 'text_icon' &&\\n          x != \\\"icon_1_search\\\");\\n        //log(all_cols)\\n        let col = ui_config.yi.col;\\n        let 按钮样式 = all_cols.map((it) => {\\n          return it === col ? '➡️' + it : it;\\n        });\\n        let tips = '请选择头部按钮样式';\\n        return $(按钮样式, 2, tips).select((ui_config) => {\\n          input = input.replace(\\\"➡️\\\", \\\"\\\");\\n          let objs = (findItemsByCls(MY_RULE.title + \\\"_ui\\\") || []).filter(x => !/(icon_1_search|avatar|input)/.test(x.type));\\n          objs.forEach(x => {\\n            updateItem(x.extra.id, {\\n              col_type: input,\\n            });\\n          });\\n          $.uiConfig.set(input, \\\"yi.col\\\")\\n          updateItem(MY_RULE.title + \\\"_yicol\\\", {\\n            title: \\\"头部组件样式:\\\" + ui_config.yi.col\\n          })\\n        }, ui_config)\\n      }, ui_config),\\n      extra: {\\n        lineVisible: false,\\n        id: MY_RULE.title + \\\"_yicol\\\"\\n      }\\n    })\\n\\n    let dobj = {};\\n    $.uiConfig.get().yi.ui.filter(x => x.index != -1).map(it => {\\n      dobj[it.key] = true\\n    })\\n\\n    Object.entries(deepOmit(ui_theme.yi.icons, dobj)).forEach(([key, value]) => {\\n      d.push({\\n        title: key,\\n        col_type: \\\"icon_5\\\",\\n        img: value,\\n        url: $(value).input((k) => {\\n          $.uiTheme.set(input, \\\"yi.icons.\\\" + k);\\n          refreshPage();\\n          return \\\"hiker://empty\\\";\\n        }, key),\\n        extra: {\\n          defaultValue: value\\n        }\\n      })\\n    })\\n\\n    d.push({\\n      title: \\\"分类颜色\\\",\\n      col_type: \\\"input\\\",\\n      url: $.toString(() => {\\n        let { isValidColor } = $.require(\\\"methods\\\");\\n        if (isValidColor(input)) {\\n          $.uiTheme.set(input, \\\"yi.分类颜色\\\");\\n          refreshPage();\\n        } else {\\n          toast(\\\"请输入正确的颜色值\\\");\\n        }\\n        return \\\"hiker://empty\\\";\\n      }),\\n      extra: {\\n        defaultValue: ui_config.yi.分类颜色\\n      }\\n    })\\n    d.push({\\n      title: \\\"换源颜色\\\",\\n      col_type: \\\"input\\\",\\n      url: $.toString(() => {\\n        let { isValidColor } = $.require(\\\"methods\\\");\\n        if (isValidColor(input)) {\\n          $.uiTheme.set(input, \\\"yi.换源颜色\\\");\\n          refreshPage();\\n        } else {\\n          toast(\\\"请输入正确的颜色值\\\");\\n        }\\n        return \\\"hiker://empty\\\";\\n      }),\\n      extra: {\\n        defaultValue: ui_config.yi.换源颜色\\n      }\\n    })\\n    d.push({\\n      title: \\\"分类颜色\\\",\\n      img: ui_config.yi.分类颜色 == \\\"random\\\" ? getRangeColors() : ui_config.yi.分类颜色,\\n      url: \\\"toast://分类颜色\\\",\\n      col_type: \\\"icon_3_fill\\\",\\n    })\\n    d.push({\\n      title: \\\"换源颜色\\\",\\n      img: ui_config.yi.换源颜色 == \\\"random\\\" ? getRangeColors() : ui_config.yi.换源颜色,\\n      url: \\\"toast://换源颜色\\\",\\n      col_type: \\\"icon_3_fill\\\",\\n    })\\n  }\\n\\n  if (ui_navi == \\\"二级\\\") {\\n    d.push({\\n      title: \\\"每页数量\\\",\\n      desc: \\\"0则表示不分页\\\",\\n      col_type: \\\"input\\\",\\n      url: $.toString(() => {\\n        if (String(input).length > 3) {\\n          return \\\"toast://请输入3位数字以内\\\";\\n        }\\n        if (String(input).length < 2 && input != 0) {\\n          return \\\"toast://请输入2位数字以上\\\";\\n        }\\n        $.uiConfig.set(input, \\\"er.分页\\\");\\n        refreshPage();\\n        return \\\"toast://\\\" + (input > 0 ? \\\"每页数量设置为:\\\" + input : \\\"不分页\\\");\\n      }),\\n      extra: {\\n        onChange: $.toString(() => {\\n          if (String(input).length > 3) {\\n            toast(\\\"请输入3位数字以内\\\");\\n            return \\\"hiker://empty\\\"\\n          }\\n          if (String(input).length < 2 && input != 0) {\\n            toast(\\\"请输入2位数字以上\\\");\\n            return \\\"hiker://empty\\\"\\n          }\\n          $.uiConfig.set(input, \\\"er.分页\\\");\\n        }),\\n        defaultValue: ui_config.er.分页,\\n        type: \\\"number\\\",\\n      }\\n    })\\n\\n    d.push({\\n      title: \\\"历史记录\\\",\\n      desc: \\\"默认200\\\",\\n      col_type: \\\"input\\\",\\n      url: $.toString(() => {\\n        if (String(input).length > 3) {\\n          return \\\"toast://请输入3位数字以内\\\";\\n        }\\n        if (String(input).length < 2) {\\n          return \\\"toast://请输入2位数字以上\\\";\\n        }\\n        $.uiConfig.set(input, \\\"er.历史记录\\\")\\n        refreshPage();\\n        return \\\"toast://历史记录设置为:\\\" + input;\\n      }),\\n      extra: {\\n        defaultValue: ui_config.er.历史记录,\\n        type: \\\"number\\\",\\n      }\\n    })\\n\\n    d.push({\\n      title: \\\"线路样式: \\\" + ui_config.er.线路样式,\\n      col_type: \\\"text_1\\\",\\n      url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let col = $.uiConfig.get().er.线路样式;\\n        let cols = [\\\"\\\"].concat(getColTypes());\\n        cols = cols.filter(x => /text_|button|_fill|icon/g.test(x)/*&!x.includes(\\\"icon\\\")*/);\\n        cols.unshift(\\\"select\\\");\\n        cols = cols.map(x => x == col ? \\\"➡️\\\" + x : x);\\n        return $(cols, 2).select(() => {\\n          input = input.replace(\\\"➡️\\\", \\\"\\\");\\n          $.uiConfig.set(input, \\\"er.线路样式\\\");\\n          refreshPage(false);\\n        })\\n      }),\\n      extra: {\\n        defaultValue: ui_config.er.线路样式,\\n        lineVisible: false\\n      }\\n    })\\n    d.push({\\n      title: \\\"{lines}:线路\\\\t\\\\t{line}:当前序号\\\\t\\\\t{form}:当前线路名称\\\\t\\\\t{plays}:总数{spage}:当前翻页\\\\t\\\\t{max}:最大页数\\\",\\n      col_type: \\\"rich_text\\\",\\n      extra: {\\n        textSize: \\\"15\\\",\\n      }\\n    })\\n    d.push({\\n      title: \\\"线路显示\\\",\\n      col_type: \\\"input\\\",\\n      url: $.toString(() => {\\n        $.uiTheme.set(input, \\\"er.线路显示\\\");\\n        refreshPage(false);\\n        return \\\"toast://\\\" + input;\\n      }),\\n      extra: {\\n        defaultValue: ui_config.er.线路显示,\\n        type: \\\"textarea\\\",\\n        height: -1\\n      }\\n    })\\n\\n    //$.log(getLineShow)\\n\\n    let testobj = { \\\"from\\\": [\\\"动漫专线⑦\\\", \\\"动漫专线⑤\\\", \\\"动漫专线④\\\", \\\"动漫专线③\\\", \\\"动漫专线②\\\", \\\"动漫专线①\\\"], \\\"line\\\": \\\"1\\\", \\\"max\\\": [5, 5, 1, 4, 5, 5], \\\"pagenum\\\": 1, \\\"playp\\\": [\\\"1-40\\\", \\\"41-80\\\", \\\"81-120\\\", \\\"121-160\\\", \\\"161-169\\\"], \\\"plays\\\": [169, 169, 18, 150, 169, 169], \\\"spagenum\\\": 2 }\\n\\n\\n    let lshow = getLineShow(testobj);\\n\\n    d.push({\\n      title: lshow,\\n      col_type: \\\"avatar\\\",\\n      img: getMyVar(\\\"lshow\\\", \\\"0\\\") ? ui_config.er.icons.正序 : ui_config.er.icons.倒序,\\n      url: $(\\\"#noLoading#\\\").lazyRule((icon) => {\\n        let l = getMyVar(\\\"lshow\\\", \\\"0\\\");\\n        updateItem(\\\"lshow\\\", {\\n          img: l == \\\"0\\\" ? icon.倒序 : icon.正序,\\n        })\\n        putMyVar(\\\"lshow\\\", l == \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n        return \\\"hiker://empty\\\";\\n        //return \\\"toast://\\\" + (l == \\\"0\\\" ? \\\"倒序\\\" : \\\"正序\\\");\\n      }, ui_config.er.icons),\\n      extra: {\\n        id: \\\"lshow\\\"\\n      }\\n    })\\n\\n    Object.entries(ui_theme.er.icons).forEach(([key, value]) => {\\n      d.push({\\n        title: key,\\n        col_type: \\\"icon_5\\\",\\n        img: value,\\n        url: $(value).input((k) => {\\n          $.uiTheme.set(input, \\\"er.icons.\\\" + k);\\n          refreshPage();\\n          return \\\"hiker://empty\\\";\\n        }, key),\\n        extra: {\\n          defaultValue: value\\n        }\\n      })\\n    })\\n\\n    d.push({\\n      title: \\\"线路颜色\\\",\\n      col_type: \\\"input\\\",\\n      url: $.toString(() => {\\n        let { isValidColor } = $.require(\\\"methods\\\");\\n        if (isValidColor(input)) {\\n          $.uiTheme.set(input, \\\"er.线路颜色\\\");\\n          refreshPage(false);\\n        } else {\\n          toast(\\\"请输入正确的颜色值\\\");\\n        }\\n        return \\\"hiker://empty\\\";\\n      }),\\n      extra: {\\n        defaultValue: ui_config.er.线路颜色\\n      }\\n    })\\n    d.push({\\n      title: \\\"浅来源色\\\",\\n      col_type: \\\"input\\\",\\n      desc: \\\"字体颜色;背景颜色\\\",\\n      url: $.toString(() => {\\n        if (input.includes(\\\";\\\")) {\\n          $.uiTheme.set(input, \\\"er.浅来源色\\\");\\n          refreshPage(false);\\n        } else {\\n          toast(\\\"请输入正确数值\\\");\\n        }\\n        return \\\"hiker://empty\\\";\\n      }),\\n      extra: {\\n        defaultValue: ui_config.er.浅来源色\\n      }\\n    })\\n    d.push({\\n      title: \\\"深来源色\\\",\\n      col_type: \\\"input\\\",\\n      desc: \\\"字体颜色;背景颜色\\\",\\n      url: $.toString(() => {\\n        if (input.includes(\\\";\\\")) {\\n          $.uiTheme.set(input, \\\"er.深来源色\\\");\\n          refreshPage(false);\\n        } else {\\n          toast(\\\"请输入正确数值\\\");\\n        }\\n        return \\\"hiker://empty\\\";\\n      }),\\n      extra: {\\n        defaultValue: ui_config.er.深来源色\\n      }\\n    })\\n\\n\\n    d.push({\\n      title: \\\"线路颜色\\\",\\n      img: ui_config.er.线路颜色,\\n      url: \\\"toast://线路颜色\\\",\\n      col_type: \\\"icon_3_fill\\\",\\n    })\\n\\n    d.push({\\n      title: \\\"简介样式: \\\" + ui_config.er.简介样式,\\n      col_type: \\\"text_3\\\",\\n      url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let col = $.uiTheme.get().er.简介样式;\\n        let cols = [\\\"0\\\", \\\"1\\\"];\\n        cols = cols.map(x => x == col ? \\\"➡️\\\" + x : x);\\n        return $(cols, 2).select(() => {\\n          input = input.replace(\\\"➡️\\\", \\\"\\\");\\n          $.uiTheme.set(input, \\\"er.简介样式\\\");\\n          refreshPage(false);\\n        })\\n      }),\\n      extra: {\\n        lineVisible: false\\n      }\\n    })\\n\\n    d.push({\\n      title: \\\"分页逻辑\\\",\\n      img: buttonImg((!ui_config.er.分页逻辑 || ui_config.er.分页逻辑 == \\\"0\\\" ? false : true)),\\n      url: $('#noLoading#').lazyRule(() => {\\n        let pa = $.uiConfig.get().er.分页逻辑;\\n        if (pa == undefined || pa == \\\"0\\\") {\\n          pa = \\\"1\\\";\\n        } else if (pa == \\\"1\\\") {\\n          pa = \\\"0\\\";\\n        }\\n        refreshPage(false);\\n        $.uiConfig.set(pa, \\\"er.分页逻辑\\\");\\n        return \\\"hiker://empty\\\";\\n      }),\\n      col_type: \\\"text_icon\\\"\\n    })\\n\\n    d.push({\\n      title: \\\"分页导航\\\",\\n      img: buttonImg(ui_config.er.分页导航),\\n      col_type: \\\"text_icon\\\",\\n      url: $('#noLoading#').lazyRule(() => {\\n        let pa = $.uiConfig.get().er.分页导航;\\n        if (pa) {\\n          pa = false;\\n        } else if (!pa) {\\n          pa = true;\\n        }\\n        refreshPage(false);\\n        $.uiConfig.set(pa, \\\"er.分页导航\\\");\\n        return \\\"hiker://empty\\\";\\n      })\\n    })\\n\\n    d.push({\\n      title: \\\"二级刷新\\\",\\n      img: buttonImg(ui_config.er.二级刷新),\\n      col_type: \\\"text_icon\\\",\\n      url: $('#noLoading#').lazyRule(() => {\\n        let pa = $.uiConfig.get().er.二级刷新;\\n        if (pa) {\\n          pa = false;\\n        } else if (!pa) {\\n          pa = true;\\n        }\\n        refreshPage(false);\\n        $.uiConfig.set(pa, \\\"er.二级刷新\\\");\\n        return \\\"hiker://empty\\\";\\n      })\\n    })\\n\\n    d.push({\\n      title: \\\"二级缓存\\\",\\n      img: buttonImg(ui_config.er.二级缓存),\\n      col_type: \\\"text_icon\\\",\\n      url: $('#noLoading#').lazyRule(() => {\\n        let pa = $.uiConfig.get().er.二级缓存;\\n        if (pa) {\\n          pa = false;\\n        } else if (!pa) {\\n          pa = true;\\n        }\\n        refreshPage(false);\\n        $.uiConfig.set(pa, \\\"er.二级缓存\\\");\\n        return \\\"hiker://empty\\\";\\n      })\\n    })\\n\\n    d.push({\\n      title: \\\"还原\\\",\\n      col_type: \\\"text_2\\\",\\n      url: $('#noLoading#').lazyRule((def) => {\\n        return $(\\\"是否恢复设置\\\").confirm((def) => {\\n          $.uiConfig.set(def.er, \\\"er\\\");\\n          refreshPage(false);\\n          return \\\"toast://还原完成\\\";\\n        }, def)\\n      }, def),\\n    }, {\\n      title: \\\"确认\\\",\\n      col_type: \\\"text_2\\\",\\n      url: $('#noLoading#').lazyRule(() => {\\n        clearMyVar(\\\"playlist_ready\\\");\\n        clearMyVar(\\\"nopage\\\");\\n        back(true);\\n        return \\\"hiker://empty\\\"\\n      }),\\n      extra: {\\n        LongClick: [{\\n          title: \\\"复制\\\",\\n          js: $.toString(() => {\\n            let uc = $.uiConfig.get();\\n            copy(JSON.stringify(uc.er));\\n          }),\\n        }, {\\n          title: \\\"导入\\\",\\n          js: $.toString(() => {\\n            var uc = $.uiConfig.get();\\n            return $(\\\"{{clipboard}}\\\").input((uc) => {\\n              try {\\n                uc.er = JSON.parse(input);\\n                storage0.setItem(\\\"ui_config\\\", uc);\\n                refreshPage(false);\\n              } catch (e) {\\n                toast(\\\"格式错误\\\")\\n              }\\n            }, uc)\\n          })\\n        }]\\n      }\\n    })\\n  }\\n  setResult(d);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"LocalProxy\",\"path\":\"LocalProxy\",\"rule\":\"function proxy() {\\n    function parseVideo(MY_PARAMS, title) {\\n        function toPath(value) {\\n            if (typeof value !== 'string') {\\n                return [];\\n            }\\n            let path = [];\\n            let current = '';\\n            let inBrackets = false;\\n            let escape = false;\\n            for (let i = 0; i < value.length; i++) {\\n                let char = value[i];\\n                if (escape) {\\n                    current += char;\\n                    escape = false;\\n                } else if (char === '\\\\\\\\') {\\n                    escape = true;\\n                } else if (char === '.' && !inBrackets) {\\n                    path.push(current);\\n                    current = '';\\n                } else if (char === '[') {\\n                    inBrackets = true;\\n                } else if (char === ']') {\\n                    inBrackets = false;\\n                } else {\\n                    current += char;\\n                }\\n            }\\n            if (current) {\\n                path.push(current);\\n            }\\n            return path;\\n        }\\n\\n        function getJson(obj, path) {\\n            if (!obj || !Array.isArray(path)) {\\n                return undefined;\\n            }\\n            if (path.length === 0) {\\n                return obj;\\n            }\\n            let current = obj;\\n            for (let i = 0; i < path.length; i++) {\\n                let key = path[i];\\n                if (current === null || current === undefined || typeof current !== 'object') {\\n                    return undefined;\\n                }\\n                current = current[key];\\n            }\\n            return current;\\n        }\\n        try {\\n            let runType = MY_PARAMS.runType[0];\\n            let url = decodeURIComponent(base64Decode(MY_PARAMS.url[0]));\\n            if (runType == \\\"JSON\\\") {\\n\\n                let param = JSON.parse(decodeURIComponent(base64Decode(MY_PARAMS.param[0])));\\n                let json = JSON.parse(request(url, {\\n                    headers: param.headers || {},\\n                    method: param.method || void 0\\n                }));\\n                return JSON.stringify({\\n                    statusCode: 302,\\n                    headers: Object.assign({}, param.headers || {}, {\\n                        \\\"Location\\\": getJson(json, toPath(param.jsonPath)),\\n                    })\\n                });\\n            } else if (runType == \\\"JS\\\") {\\n\\n                let parse;\\n                if (MY_PARAMS.index) {\\n                    parse = $.require(\\\"configs?rule=\\\" + title).getJson()[MY_PARAMS.index[0]];\\n                } else {\\n                    parse = JSON.parse(base64Decode(decodeURIComponent(MY_PARAMS.param[0])));\\n                }\\n                let res = new Function(\\\"url\\\", \\\"self\\\", parse.js)(url, parse);\\n                if (typeof res === \\\"string\\\") {\\n                    return JSON.stringify({\\n                        statusCode: 302,\\n                        headers: {\\n                            \\\"Location\\\": res\\n                        }\\n                    });\\n                } else if ($.type(res) === \\\"object\\\") {\\n                    return JSON.stringify({\\n                        statusCode: 302,\\n                        headers: res\\n                    });\\n                }\\n            }\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n\\n    function doJs(MY_PARAMS, title, gkey) {\\n        let {\\n            GM\\n        } = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6916&auth=1d35e8f0-22e8-5270-a9d1-826f53f177ad\\\");\\n        GM.setSelfKey(gkey);\\n        let DrpyManage = GM.defineModule(\\\"DrpyManage\\\", \\\"DrpyManage?rule=\\\" + title);\\n        let drpy = DrpyManage.get(decodeURIComponent(MY_PARAMS.hikerSkey[0]));\\n        let params = {};\\n        for (let key in MY_PARAMS) {\\n            params[key] = String(MY_PARAMS[key][0]);\\n        }\\n        \\n        \\n        //let result = drpy.proxy(params);\\n        let result = DrpyManage.runProxy(drpy, [params]);\\n       \\n        let [code, media_type, data, headers, isReturnBytes] = result;\\n        headers = Object.assign({}, {\\n            'Content-Type': media_type,\\n        }, headers);\\n        if(typeof data===\\\"string\\\"&&data.startsWith(\\\"data:\\\")&&data.includes(\\\"base64,\\\")){\\n            data = data.split(\\\"base64,\\\")[1];\\n            const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n            data = CryptoUtil.Data.parseBase64(data).toBytes();\\n        }\\n        return {\\n            statusCode: code,\\n            body: data,\\n            headers: headers,\\n        };\\n    }\\n\\n    function entrance(MY_PARAMS, title, gkey) {\\n        if (MY_PARAMS.do && MY_PARAMS.do[0] === \\\"js\\\") {\\n            try {\\n                return doJs(MY_PARAMS, title, gkey);\\n            } catch (e) {\\n                log(e.toString());\\n                return;\\n            }\\n        } else {\\n            return parseVideo(MY_PARAMS, title);\\n        }\\n    }\\n    this.entrance = entrance;\\n}\\n\\nfunction startProxy(title, gkey) {\\n    return startProxyServer($.toString((proxy, title, gkey) => {\\n        return new proxy().entrance(MY_PARAMS, title, gkey);\\n    }, proxy, title, gkey));\\n}\\n$.exports.startProxy = startProxy;\"},{\"col_type\":\"movie_3\",\"name\":\"JavaGZIP\",\"path\":\"GZIP\",\"rule\":\"let FileUtil = com.example.hikerview.utils.FileUtil;\\nlet javaString = java.lang.String;\\nlet Base64 = java.util.Base64;\\nconst GZIPOutputStream = java.util.zip.GZIPOutputStream;\\nconst GZIPInputStream = java.util.zip.GZIPInputStream;\\nconst DeflaterOutputStream = java.util.zip.DeflaterOutputStream;\\nconst InflaterInputStream = java.util.zip.InflaterInputStream;\\nconst DeflaterInputStream = java.util.zip.DeflaterInputStream;\\nconst ByteArrayOutputStream = java.io.ByteArrayOutputStream;\\nconst ByteArrayInputStream = java.io.ByteArrayInputStream;\\nconst Deflater = java.util.zip.Deflater;\\n\\nfunction zip(text, mode) {\\n    mode = mode ? mode : \\\"gzip\\\";\\n    let baseStr = new javaString(text);\\n    // 使用 ByteArrayOutputStream 来捕获压缩后的数据\\n    var baos = new ByteArrayOutputStream();\\n    if (mode == \\\"deflate\\\") {\\n        var deflater = new java.util.zip.Deflater();\\n        deflater.setLevel(java.util.zip.Deflater.BEST_COMPRESSION);\\n        var dos = new java.util.zip.DeflaterOutputStream(baos, deflater);\\n        dos.write(baseStr.getBytes(\\\"UTF-8\\\"));\\n        dos.finish(); // 完成压缩\\n        dos.close();\\n    } else {\\n        var gzos = new java.util.zip.GZIPOutputStream(baos);\\n        gzos.write(baseStr.getBytes(\\\"UTF-8\\\"));\\n        gzos.close(); // 关闭压缩流\\n    }\\n    // 将压缩后的数据转换为 Base64 编码的字符串\\n    var compressedData = baos.toByteArray();\\n    var base64String = java.util.Base64.getEncoder().encodeToString(compressedData);\\n\\n    // 关闭 ByteArrayOutputStream\\n    baos.close();\\n    return String(base64String);\\n}\\n\\nfunction unzip(text, mode) {\\n    mode = mode ? mode : \\\"gzip\\\";\\n    var compressedData = Base64.getDecoder().decode(text);\\n    var bais = new ByteArrayInputStream(compressedData);\\n    var baos = new ByteArrayOutputStream();\\n    var buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, 1024);\\n    if (mode == \\\"gzip\\\") {\\n        var gis = new GZIPInputStream(bais);\\n        let len;\\n        while ((len = gis.read(buffer)) != -1) {\\n            baos.write(buffer, 0, len);\\n        }\\n        gis.close();\\n    } else if (mode == \\\"deflate\\\") {\\n        var iis = new InflaterInputStream(bais);\\n        let len;\\n        while ((len = iis.read(buffer)) != -1) {\\n            baos.write(buffer, 0, len);\\n        }\\n        iis.close();\\n    }\\n    bais.close();\\n    baos.close();\\n    var decompressedString = new javaString(baos.toByteArray(), \\\"UTF-8\\\");\\n    // 打印解压缩后的字符串\\n    return String(decompressedString);\\n}\\n$.exports = {\\n    zip,\\n    unzip\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"支持作者\",\"path\":\"Donate.v\",\"rule\":\"js:\\nlet d = [];\\nsetPageTitle(\\\"捐赠/支持\\\");\\nd.push({\\n    title: \\\"捐赠/支持\\\",\\n    desc: \\\"这个捐赠不能为你带来特权，但您的支持会提高我更新创作的动力。\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"toast://感谢您的支持\\\"\\n});\\nd.push({\\n    title: \\\"十分感谢α大佬的参与开发，以及道长大佬对本程序开发上的指导。\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"toast://感谢您的支持\\\"\\n});\\nd.push({\\n    col_type: \\\"pic_1_full\\\",\\n    url: \\\"https://gitee.com/LoyDgIk/LoyDgIk_Rule/raw/master/67d8f0187f0186c1.png\\\",\\n    pic_url: \\\"https://gitee.com/LoyDgIk/LoyDgIk_Rule/raw/master/67d8f0187f0186c1.png\\\"\\n});\\nd.push({\\n    col_type: \\\"text_center_1\\\",\\n    title: \\\"““””\\\" + \\\"图片加载缓慢请稍等\\\".small().fontcolor(\\\"Gray\\\"),\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"通用方法\",\"path\":\"methods\",\"rule\":\"js:\\n//去除html标签\\nfunction removeHtmlTags(str) {\\n  stringex();\\n  return str.retag();\\n}\\n// 自然排序\\nfunction naturalSort(arr, key) {\\n  stringex();\\n  return arr.sort((a, b) => {\\n    let astr, bstr;\\n    if (typeof a === 'object' && typeof b === 'object' && key) {\\n      astr = a[key].retag();\\n      bstr = b[key].retag();\\n    } else {\\n      astr = a.toString().retag();\\n      bstr = b.toString().retag();\\n    }\\n    return astr.localeCompare(bstr, undefined, {\\n      numeric: true,\\n      sensitivity: 'base'\\n    });\\n  });\\n}\\n\\nfunction getLeach() {\\n    let leach;\\n    let gleach = getItem(\\\"leach\\\", \\\"\\\");\\n    let tleach = getMyVar(\\\"tempLeach\\\", \\\"\\\");\\n    if(tleach!=\\\"\\\"){\\n      leach=false;\\n      return leach;\\n    }\\n    if(gleach!=\\\"\\\"){\\n      leach=true;\\n    }\\n    return leach||false;\\n}\\n\\n\\nfunction leachlist(shouldLeach) {\\n  let leachState = shouldLeach;\\n  Object.defineProperty(Array.prototype, 'leachList', {\\n    value: function () {\\n      let b = \\\"KFtcW+OAkF0pW+Wvhl0oW+OAkVxdXSk=\\\";\\n      var reg = new RegExp(base64Decode(b));\\n      if (leachState) {\\n        return this.filter(v => !reg.test(v.name));\\n      } else {\\n        return this;\\n      }\\n    },\\n    enumerable: false,\\n    writable: true,\\n    configurable: true\\n  });\\n}\\n\\n//使用排序\\nlet usingSort = {\\n  name: \\\"usingSort.json\\\",\\n  path: \\\"hiker://files/rules/DrpyHiker/\\\",\\n  key: undefined,\\n  save(content) {\\n    saveFile(this.path + this.name, content);\\n  },\\n  init() {\\n    let json = {};\\n    if (!fileExist(this.path + this.name)) {\\n      this.save(\\\"{}\\\");\\n    }\\n    try {\\n      json = JSON.parse(readFile(this.path + this.name));\\n    } catch (e) {\\n      json = {};\\n      this.save(\\\"{}\\\");\\n    }\\n    return json;\\n  },\\n  sort() {\\n    let json = this.init();\\n    let sortedEntries = Object.entries(json).sort((a, b) => b[1] - a[1]);\\n    let sortedArray = sortedEntries.map(([key, value]) => {\\n      let obj = {};\\n      obj[key] = value;\\n      return obj;\\n    });\\n    return sortedArray\\n  },\\n  sortKeysByUsage(json, keys, nestedKey) {\\n    stringex();\\n    return keys.sort((a, b) => {\\n      let keyA, keyB, valA, valB;\\n\\n      if (typeof a === 'object' && typeof b === 'object') {\\n        keyA = a[nestedKey];\\n        keyB = b[nestedKey];\\n      } else {\\n        keyA = a.toString().retag();\\n        keyB = b.toString().retag();\\n      }\\n\\n      valA = json[keyA] || 0;\\n      valB = json[keyB] || 0;\\n      if (valB - valA !== 0) {\\n        return valB - valA;\\n      } else {\\n        return naturalSort([keyA, keyB])[0] === keyA ? -1 : 1;\\n      }\\n    });\\n  },\\n  get(keys, key) {\\n    let json = this.init();\\n    //log(this.sort())\\n    if (key == undefined) {\\n      key = this.key;\\n    }\\n    return this.sortKeysByUsage(json, keys, key);\\n  },\\n  setkey(key) {\\n    this.key = key;\\n  },\\n  set(key) {\\n    let json = this.init();\\n    if (json.hasOwnProperty(key)) {\\n      json[key] += 1;\\n    } else {\\n      json[key] = 1;\\n    }\\n    this.save(JSON.stringify(json));\\n  }\\n}\\n\\nfunction isValidColor(color) {\\n  // 匹配十六进制颜色\\n  const hexPattern = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;\\n  const namedColors = {\\n    black: true,\\n    white: true,\\n  };\\n  // 如果是常见颜色名称，返回 true\\n  if (namedColors[color.toLowerCase()]) {\\n    return true;\\n  }\\n  if (color.toLowerCase() === \\\"random\\\") {\\n    return true; // 这里可以进一步处理，例如生成一个随机颜色字符串\\n  }\\n  return hexPattern.test(color)\\n}\\n\\n/**\\n * 字体样式\\n * @param {string} text \\n * @param {object} params \\n * @returns \\n */\\nfunction fontstyle(text, params,col) {\\n  params = params || undefined;\\n  var h = params.h !== false ? '““””' : '';\\n  let ontag=[\\\"icon_small_3\\\"];\\n  if(col!=undefined){\\n    if(ontag.includes(col)){\\n      h='';\\n    }\\n  }\\n  var tags = params.tags || \\\"\\\";\\n  if (params.c != undefined) {\\n    text = text.fontcolor(params.c);\\n  }\\n  if (tags) {\\n    var tagArray = tags.split('|').filter(e => e);\\n    var openTags = '';\\n    var closeTags = '';\\n    for (var i = 0; i < tagArray.length; i++) {\\n      openTags += '<' + tagArray[i] + '>';\\n      closeTags = '</' + tagArray[i] + '>' + closeTags;\\n    }\\n    text = openTags + text + closeTags;\\n  }\\n  return h + text;\\n}\\n\\n/**\\n * 计算字符串的字节数\\n * @param {string} text \\n * @returns \\n */\\nfunction countTotalBytes(text) {\\n  var count = 0;\\n  for (var i = 0; i < text.length; i++) {\\n    var code = text.charCodeAt(i);\\n    if (code >= 0x0100) { // 双字节字符的 Unicode 编码大于 255\\n      count += 2; // 双字节字符计数为2\\n    } else {\\n      count += 1; // 单字节字符计数为1\\n    }\\n  }\\n  return count;\\n}\\n\\n/**\\n * 找到数组中最长的元素\\n * @param {array} arr \\n * @returns \\n */\\nfunction findLongestElement(arr) {\\n  return arr.reduce((a, b) => a.length > b.length ? a : b);\\n}\\n\\n/**\\n * 截取字符串\\n * @param {string} str \\n * @param {number} maxLength \\n * @returns \\n */\\nfunction substr(str, maxLength) {\\n  let len = 0;\\n  for (let i = 0; i < str.length; i++) {\\n    if (str.charCodeAt(i) > 255) {\\n      len += 2;\\n    } else {\\n      len++;\\n    }\\n    if (len > maxLength) {\\n      return str.slice(0, i) + '...';\\n    }\\n  }\\n  return str;\\n}\\n\\n//字体背景\\nfunction backColor(title, colors) {\\n  var def = {\\n    fc: '#737A80',\\n    bc: '#F7F8FA',\\n  }\\n  colors = Object.assign(def, colors);\\n  return '<font color=\\\"' + colors.fc + '\\\"><span style=\\\"background-color: ' + colors.bc + '\\\">' + title + '</span></font>'\\n}\\n\\n/**\\n * 扩展字符串方法\\n */\\nfunction stringex() {\\n  Object.defineProperties(String.prototype, {\\n    retag: {\\n      value: function () {\\n        return this.replace(/<[^>]*>/g, '').replace(/[“”']/g, \\\"\\\");\\n      },\\n      writable:true,\\n      enumerable: false,\\n    },\\n    Split: {\\n      value: function (s, e) {\\n        if (e) {\\n          return this.split(s).filter(item => item !== '');\\n        } else {\\n          return this.split(s);\\n        }\\n      },\\n      writable:true,\\n      enumerable: false,\\n    }\\n  });\\n}\\n\\n/**\\n * 扩展列表方法\\n */\\nfunction arrayex() {\\n  Object.defineProperties(Array.prototype, {\\n    Last: {\\n      value: function () {\\n        return this[this.length - 1];\\n      },\\n      enumerable: false,\\n    },\\n    excludeKeys: {\\n      value: function (keys, exclude, renameCallback) {\\n        // 确定是排除还是只保留键\\n        const shouldExclude = typeof exclude === 'boolean' ? exclude : true;\\n        const keysToHandle = Array.isArray(keys) ? keys : [];\\n\\n        // 使用Array.prototype.map遍历数组中的每个元素\\n        return this.map(item => {\\n          // 如果元素是一个数组，递归调用excludeKeys\\n          if (Array.isArray(item)) {\\n            return item.excludeKeys(exclude, keys, renameCallback);\\n          } else if (typeof item === 'object' && item !== null) {\\n            // 如果元素是一个对象，使用Object.fromEntries和Object.entries来处理键\\n            const entries = Object.entries(item);\\n            const processedEntries = entries.map(([key, value]) => {\\n              // 如果有重命名回调函数，则调用它\\n              if (typeof renameCallback === 'function') {\\n                return [renameCallback(key, value), value];\\n              }\\n              return [key, value];\\n            });\\n            const filteredEntries = shouldExclude ?\\n              processedEntries.filter(([key]) => !keysToHandle.includes(key)) :\\n              processedEntries.filter(([key]) => keysToHandle.includes(key));\\n            return Object.fromEntries(filteredEntries);\\n          } else {\\n            // 如果元素不是对象或数组，直接返回\\n            return item;\\n          }\\n        });\\n      },\\n      enumerable: false, // 设置为不可枚举\\n    },\\n    transformKeys: {\\n      value: function (keyMapping) {\\n        // 使用Array.prototype.map遍历数组中的每个元素\\n        return this.map(item => {\\n          // 如果元素是一个数组，递归调用transformKeys\\n          if (Array.isArray(item)) {\\n            return item.transformKeys(keyMapping);\\n          } else if (typeof item === 'object' && item !== null) {\\n            // 如果元素是一个对象，使用Object.fromEntries和Object.entries来处理键\\n            const entries = Object.entries(item);\\n            const transformedEntries = entries.map(([key, value]) => {\\n              const newKey = keyMapping[key] || key; // 如果键在映射中，使用新键；否则使用原始键\\n              return [newKey, value];\\n            });\\n            return Object.fromEntries(transformedEntries);\\n          } else {\\n            // 如果元素不是对象或数组，直接返回\\n            return item;\\n          }\\n        });\\n      },\\n      enumerable: false, // 设置为不可枚举\\n    }\\n  });\\n}\\n\\n/**\\n * 获取历史记录\\n * @param {string} mode \\n * @param {string} skey \\n * @param {string} id \\n * @param {object} value \\n * @returns \\n */\\nfunction historylog(mode, skey, id, value) {\\n  let er = $.require(\\\"UIManage\\\").ui_config.er;\\n  var name = \\\"history.json\\\";\\n  let json = [];\\n  if (fileExist(name)) {\\n    json = JSON.parse(readFile(name, 0)) || [];\\n  }\\n  if (mode == \\\"get\\\") {\\n    let index = json.findIndex(obj => obj.skey === skey && obj.id === id);\\n    if (index != -1) {\\n      return String(json[index].page);\\n    }\\n  }\\n  let maxcount = er.历史记录;\\n  if (mode == \\\"set\\\") {\\n    if (json.length >= maxcount) {\\n      json = json.slice(0, maxcount - 1);\\n    }\\n    let index = json.findIndex(obj => obj.skey === skey && obj.id === id);\\n    if (index != -1) {\\n      if (json[index].page != value.page) {\\n        json[index].page = value.page;\\n        saveFile(name, JSON.stringify(json), 0);\\n      };\\n    } else {\\n      json.push({\\n        skey: skey,\\n        id: id,\\n        title: value.title,\\n        page: value.page,\\n      })\\n      saveFile(name, JSON.stringify(json), 0);\\n    }\\n  }\\n}\\n\\nfunction isDarkMode() {\\n  const Configuration = android.content.res.Configuration;\\n  let cx = getCurrentActivity();\\n\\n  let theme = cx.getResources().getConfiguration().uiMode & Configuration.UI_MODE_NIGHT_MASK;\\n  return theme == Configuration.UI_MODE_NIGHT_YES;\\n\\n}\\n\\nfunction insertArrayAt(array, index, elementsToInsert) {\\n  if (!Array.isArray(elementsToInsert)) {\\n    elementsToInsert = [elementsToInsert];\\n  }\\n  // 使用splice方法插入数组\\n  array.splice.apply(array, [index, 0].concat(elementsToInsert));\\n}\\n\\nlet erInfo = storage0.getMyVar(\\\"erInfo\\\", \\\"{}\\\");\\n\\nfunction getEInfo() {\\n  let skey = erInfo.skey;\\n  let id = erInfo.id;\\n  let line = getMyVar(id + \\\"sourcei\\\", \\\"0\\\");\\n  let his = historylog(\\\"get\\\", skey, md5(id));\\n  let pagenum = Number(getMyVar(\\\"pagenum\\\", (his || \\\"0\\\")));\\n  let maxs = erInfo.total;\\n  let spagenum = pagenum + 1;\\n  if (maxs && spagenum > maxs[line]) {\\n    spagenum = maxs[line];\\n  }\\n  return {\\n    line,\\n    pagenum,\\n    spagenum: spagenum,\\n    from: erInfo.from,\\n    max: erInfo.total,\\n    playp: erInfo.playp,\\n    plays: erInfo.plays,\\n  }\\n}\\n\\nfunction erRefresh(i) {\\n  let {\\n    ui_config\\n  } = $.require(\\\"UIManage\\\");\\n  \\n  let er = ui_config.er;\\n  if (er.二级刷新) {\\n    clearMyVar(\\\"playlist_ready\\\");\\n    refreshPage(false);\\n  } else {\\n    //toast(i)\\n    GM.get(\\\"renovateList\\\", () => { })(i);\\n  }\\n  return \\\"hiker://empty\\\";\\n}\\n\\nlet cacheManage = {\\n  root: \\\"hiker://files/_cache/\\\" + MY_RULE.title + \\\"/\\\",\\n  getName(id) {\\n    return this.root + md5(id);\\n  },\\n  get(id) {\\n    let name = this.getName(id);\\n    if (fileExist(name)) {\\n      return JSON.parse(fetch(name))\\n    }\\n    return {};\\n  },\\n  set(id, json) {\\n    let name = this.getName(id);\\n    saveFile(name, JSON.stringify(json), 0);\\n  },\\n  del(id) {\\n    let name = this.getName(id);\\n    deleteFile(name);\\n  },\\n  exist(id) {\\n    let name = this.getName(id);\\n    if (fileExist(name)) {\\n      return true;\\n    } else {\\n      return false;\\n    }\\n  }\\n}\\n\\nlet erOptions = {\\n  get(key, def) {\\n    if (key == undefined) {\\n      return erInfo;\\n    }\\n    return erInfo[key] || def;\\n  },\\n  set(key, value) {\\n    erInfo[key] = value;\\n    storage0.putMyVar(\\\"erInfo\\\", erInfo);\\n  }\\n}\\n\\n\\n$.exports = {\\n  getLeach,\\n  leachlist,\\n  erRefresh,\\n  cacheManage,\\n  isDarkMode,\\n  naturalSort,\\n  usingSort,\\n  removeHtmlTags,\\n  fontstyle,\\n  backColor,\\n  isValidColor,\\n  findLongestElement,\\n  countTotalBytes,\\n  insertArrayAt,\\n  historylog,\\n  erOptions,\\n  getEInfo,\\n  substr,\\n  stringex,\\n  arrayex\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"更新日志\",\"path\":\"updateRecords\",\"rule\":\"js:\\n$.exports = [{\\n    title: \\\"2024/07/09 MaxVersion 49\\\",\\n    records: [\\n        \\\"‘‘new’’：UI管理增加主题管理。\\\"\\n    ]\\n},{\\n    title: \\\"2024/07/08 MaxVersion 48\\\",\\n    records: [\\n        \\\"‘‘new’’：UI管理增加二级缓存和刷新选项。\\\"\\n    ]\\n},{\\n    title: \\\"2024/07/07 MaxVersion 47\\\",\\n    records: [\\n        \\\"‘‘new’’：搜索支持跳过二级。\\\"\\n    ]\\n},{\\n    title: \\\"2024/07/05 MaxVersion 46\\\",\\n    records: [\\n        \\\"optimize：优化一些细节。\\\"\\n    ]\\n},{\\n    title: \\\"2024/07/03 MaxVersion 45\\\",\\n    records: [\\n        \\\"‘‘new’’：支持t0、t1接口。\\\"\\n    ]\\n},{\\n    title: \\\"2024/07/01 MaxVersion 44\\\",\\n    records: [\\n        \\\"‘‘new’’：支持t4接口。\\\",\\n    ]\\n},{\\n    title: \\\"2024/06/30 MaxVersion 43\\\",\\n    records: [\\n        \\\"optimize：优化文件读取速率。\\\",\\n        \\\"optimize：优化嗅探。\\\",\\n    ]\\n},{\\n    title: \\\"2024/06/27 MaxVersion 42\\\",\\n    records: [\\n        \\\"‘‘new’’：新增青少年模式。\\\",\\n    ]\\n},{\\n    title: \\\"2024/06/26 MaxVersion 41\\\",\\n    records: [\\n        \\\"‘‘new’’：新二级界面。\\\",\\n    ]\\n},{\\n    title: \\\"2024/06/23 MaxVersion 40\\\",\\n    records: [\\n        \\\"““fix””：修复除第一集外不解析的问题。\\\",\\n    ]\\n},{\\n    title: \\\"2024/06/22 MaxVersion 39\\\",\\n    records: [\\n        \\\"““fix””：修复跳过二级的嗅探链接不正确。\\\",\\n        \\\"““fix””：修复跳过二级的链接为空。\\\",\\n        \\\"optimize：自动弹出更新日志\\\",\\n    ]\\n},{\\n    title: \\\"2024/06/21 MaxVersion 37\\\",\\n    records: [\\n        \\\"‘‘new’’：支持index.js(需要本地包作者兼容性编写)。\\\",\\n        \\\"‘‘new’’：增加参数映射表。\\\",\\n        \\\"““fix””：修复配置.mapping.txt可能会报错的bug。\\\",\\n    ]\\n}, {\\n    title: \\\"2024/06/20 MaxVersion 33\\\",\\n    records: [\\n        \\\"““fix””：修复部分bug。\\\",\\n    ]\\n}, {\\n    title: \\\"2024/06/17 MaxVersion 32\\\",\\n    records: [\\n        \\\"‘‘new’’：增加按tag搜索。\\\",\\n        \\\"““fix””：修复部分源从搜索进入详细页报错。\\\",\\n        \\\"““fix””：修复部分源lazy返回空url时报错。\\\"\\n    ]\\n}, {\\n    title: \\\"2024/06/16  MaxVersion 29\\\",\\n    records: [\\n        \\\"““fix””：升级drpy.js，修复gzip函数。\\\"\\n    ]\\n}, {\\n    title: \\\"2024/06/15  MaxVersion 28\\\",\\n    records: [\\n        \\\"‘‘new’’：增加ui管理。\\\",\\n        \\\"‘‘new’’：主页增加跳过形式(*)二级选项。\\\",\\n        \\\"‘‘new’’：解析管理增加flag分类。\\\",\\n        \\\"optimize：优优化订阅更新策略。\\\",\\n    ]\\n}, {\\n    title: \\\"2024/06/12  MaxVersion 26\\\",\\n    records: [\\n        \\\"‘‘new’’：在换源界面的菜单可以开启分享时是否使用编码。\\\",\\n        \\\"optimize：在选源界面刷新配置后会同步更新数量显示。\\\",\\n    ]\\n}, {\\n    title: \\\"2024/06/10  MaxVersion 25\\\",\\n    records: [\\n        \\\"‘‘new’’：增加更新日志。\\\",\\n        \\\"‘‘new’’：选源长按菜单，增加跳转网页，查看源码。\\\",\\n        \\\"““fix””：修复编辑解析界面测试js解析一直失败。\\\",\\n        \\\"““fix””：修复github订阅，会删除全部规则文件。\\\",\\n        \\\"““fix””：修复解析调用失败。\\\",\\n        \\\"““fix””：修复更换配置时没有及时清空drpy缓存。\\\",\\n        \\\"optimize：更改订阅更新策略，会删除本地失效源。\\\",\\n        \\\"optimize：更新drpy2.js。\\\",\\n        \\\"optimize：优化解析flag匹配。\\\",\\n\\n    ]\\n}, {\\n    title: \\\"2024/06/09 MaxVersion 20\\\",\\n    records: [\\n        \\\"‘‘new’’：支持proxy_rule代理。\\\",\\n        \\\"““fix””：修复云盘链接不调取云盘简。\\\",\\n        \\\"““fix””：修复哔哩影视不能使用解析。\\\",\\n    ]\\n}];\"},{\"col_type\":\"movie_3\",\"name\":\"T4适配器\",\"path\":\"T4Adapter\",\"rule\":\"function T4Adapter(source) {\\n    this.api = source.api;\\n    this.ext = source.ext || \\\"\\\";\\n    this.redirect = !!source.redirect;\\n    this.rule = {\\n        name: source.name,\\n        host: \\\"hiker://empty\\\",\\n        一级: \\\"true\\\",\\n        推荐: \\\"true\\\",\\n        类型: \\\"影视\\\",\\n        //模板: \\\"自动\\\"\\n    };\\n    this.cacheClass = null;\\n    this.vodCount = 0;\\n}\\nObject.assign(T4Adapter.prototype, {\\n    init() {\\n        this.cacheClass = null;\\n        let data = this.getHomeData();\\n        this.rule.类型 = data.type || \\\"影视\\\";\\n        if (Array.isArray(data.list) && data.list.length === 1 && data.list[0].vod_name === \\\"测试\\\") {\\n            delete this.rule.推荐;\\n            data.list = [];\\n        }\\n    },\\n    getHomeData() {\\n        if (this.cacheClass) return this.cacheClass;\\n        let home = JSON.parse(fetch(buildUrl(this.api, {\\n            extend: this.ext,\\n            filter: \\\"true\\\"\\n        }), {\\n            redirect: this.redirect\\n        }));\\n        this.cacheClass = home;\\n\\n        return home;\\n    },\\n    homeVod() {\\n        /*if(this.vodCount){\\n            this.init();\\n        }*/\\n        let data = this.getHomeData();\\n        return JSON.stringify({\\n            list: data.list || []\\n        });\\n        this.vodCount++;\\n    },\\n    home() {\\n        return JSON.stringify(this.getHomeData());\\n    },\\n    category(tid, pg, filter, extend) {\\n        return fetch(buildUrl(this.api, {\\n            ac: \\\"videolist\\\",\\n            t: tid,\\n            pg: \\\"\\\" + pg,\\n            extend: this.ext,\\n            ext: extend ? base64Encode(JSON.stringify(extend)) : \\\"\\\"\\n        }), {\\n            redirect: this.redirect\\n        });\\n    },\\n    detail(vod_url) {\\n        return fetch(buildUrl(this.api, {\\n            ac: \\\"detail\\\",\\n            ids: vod_url,\\n            extend: this.ext,\\n        }), {\\n            redirect: this.redirect\\n        });\\n    },\\n    play(flag, id) {\\n        return fetch(buildUrl(this.api, {\\n            //ac: \\\"detail\\\",\\n            flag: flag,\\n            play: id\\n        }), {\\n            redirect: this.redirect\\n        });\\n    },\\n    search(wd, quick, pg) {\\n        return fetch(buildUrl(this.api, {\\n            wd: wd,\\n            extend: this.ext,\\n            pg: pg\\n        }), {\\n            redirect: this.redirect\\n        });\\n    },\\n    getRule(key) {\\n        return key ? this.rule[key] : this.rule;\\n    },\\n    runMain() {\\n        return \\\"\\\";\\n    }\\n});\\n$.exports = T4Adapter;\"},{\"col_type\":\"movie_3\",\"name\":\"T0适配器\",\"path\":\"T0Adapter\",\"rule\":\"function T0Adapter(source) {\\n    this.source = source;\\n    this.api = source.api;\\n    this.categoryfilter = source.categories;\\n    this.rule = {\\n        name: source.name,\\n        host: source.api,\\n        一级: \\\"true\\\",\\n        推荐: \\\"true\\\",\\n        类型: \\\"影视\\\",\\n        //模板: \\\"自动\\\"\\n    };\\n    this.cacheClass = null;\\n}\\nObject.assign(T0Adapter.prototype, {\\n    init() {\\n        this.cacheClass = null;\\n        let data = this.getHomeData();\\n        if (!Array.isArray(data.list) || !data.list.length) {\\n            delete this.rule.推荐;\\n            data.list = [];\\n        }\\n    },\\n    getHomeData() {\\n        if (this.cacheClass) return this.cacheClass;\\n        let xml = fetch(buildUrl(this.api, {\\n            ac: \\\"class\\\"\\n        })).replace(/\\\\<.*?xml.*?\\\\>/, \\\"\\\");\\n        let home = {\\n            list: [],\\n            class: []\\n        };\\n        let homeXml = new XML(xml);\\n        for each(let item in homeXml.list.video) {\\n            home.list.push({\\n                vod_id: item.id.toString(),\\n                vod_name: item.name.toString(),\\n                vod_time: item.last.toString(),\\n                type_id: item.tid.toString(),\\n                vod_remarks: item.note.toString()\\n            });\\n        }\\n        for each(let item in homeXml.class.ty) {\\n            home.class.push({\\n                type_id: item.@id,\\n                type_name: item.toString(),\\n\\n            });\\n        }\\n        if (Array.isArray(home.class) && Array.isArray(this.categoryfilter)) {\\n            home.class = home.class.filter(v => this.categoryfilter.includes(v.type_name))\\n        }\\n\\n        this.cacheClass = home;\\n\\n        return home;\\n    },\\n    homeVod() {\\n        let data = this.getHomeData();\\n        return JSON.stringify({\\n            list: data.list || []\\n        });\\n    },\\n    home() {\\n        return JSON.stringify(this.getHomeData());\\n    },\\n    category(tid, pg, filter, extend) {\\n        let xml = fetch(buildUrl(this.api, {\\n            ac: \\\"videolist\\\",\\n            t: tid,\\n            pg: \\\"\\\" + pg\\n        })).replace(/\\\\<.*?xml.*?\\\\>/, \\\"\\\");\\n        let homeXml = new XML(xml);\\n        let list = [];\\n        for each(let item in homeXml.list.video) {\\n            list.push({\\n                vod_id: item.id.toString(),\\n                vod_name: item.name.toString(),\\n                vod_time: item.last.toString(),\\n                vod_pic: item.pic.toString(),\\n                vod_remarks: item.note.toString()\\n            });\\n        }\\n        return JSON.stringify({\\n            list\\n        });\\n    },\\n    detail(vod_url) {\\n        let xml = fetch(buildUrl(this.api, {\\n            ac: \\\"detail\\\",\\n            ids: vod_url,\\n        })).replace(/\\\\<.*?xml.*?\\\\>/, \\\"\\\");\\n        let homeXml = new XML(xml);\\n        let list = [];\\n        for each(let item in homeXml.list.video) {\\n            let resitem = {\\n                vod_id: item.id.toString(),\\n                vod_name: item.name.toString(),\\n                vod_time: item.last.toString(),\\n                vod_pic: item.pic.toString(),\\n                vod_remarks: item.note.toString(),\\n                vod_content: item.des.toString(),\\n                vod_actor: item.actor.toString(),\\n                vod_director: item.director.toString(),\\n            };\\n            let from = [];\\n            let play = [];\\n            for each(let playListItem in item.dl.dd) {\\n                from.push(playListItem.@flag);\\n                play.push(playListItem.toString());\\n            }\\n            resitem.vod_play_from = from.join(\\\"$$$\\\");\\n            resitem.vod_play_url = play.join(\\\"$$$\\\");\\n            list.push(resitem);\\n        }\\n        return JSON.stringify({\\n            list\\n        });\\n    },\\n    play(flag, input) {\\n        let parse_url = this.source.playurl || \\\"\\\";\\n        if (/\\\\.(m3u8|mp4)/.test(input)) {\\n            return JSON.stringify({\\n                parse: 0,\\n                url: input\\n            });\\n        } else {\\n            if (parse_url.startsWith('json:')) {\\n                let purl = parse_url.replace('json:', '') + input;\\n                let html = request(purl);\\n                try {\\n                    return JSON.stringify({\\n                        parse: 0,\\n                        url: JSON.parse(html).url\\n                    });\\n                } catch (e) {\\n                    return JSON.stringify({\\n                        parse: 1,\\n                        url: input\\n                    });\\n                }\\n            } else {\\n                return JSON.stringify({\\n                    parse: 1,\\n                    url: parse_url + input\\n                });\\n            }\\n        }\\n    },\\n    search(wd, quick, pg) {\\n        let xml = fetch(buildUrl(this.api, {\\n            wd: wd,\\n            pg: \\\"\\\" + pg\\n        })).replace(/\\\\<.*?xml.*?\\\\>/, \\\"\\\");\\n        let homeXml = new XML(xml);\\n        let list = [];\\n        for each(let item in homeXml.list.video) {\\n            list.push({\\n                vod_id: item.id.toString(),\\n                vod_name: item.name.toString(),\\n                vod_time: item.last.toString(),\\n                vod_pic: item.pic.toString(),\\n                vod_remarks: item.note.toString()\\n            });\\n        }\\n        return JSON.stringify({\\n            list\\n        });\\n    },\\n    getRule(key) {\\n        return key ? this.rule[key] : this.rule;\\n    },\\n    runMain() {\\n        return \\\"\\\";\\n    }\\n});\\n$.exports = T0Adapter;\"},{\"col_type\":\"movie_3\",\"name\":\"T1适配器\",\"path\":\"T1Adapter\",\"rule\":\"function T1Adapter(source) {\\n    this.source = source;\\n    this.api = source.api;\\n    this.categoryfilter = source.categories;\\n    this.rule = {\\n        name: source.name,\\n        host: source.api,\\n        一级: \\\"true\\\",\\n        推荐: \\\"true\\\",\\n        类型: \\\"影视\\\",\\n        //模板: \\\"自动\\\"\\n    };\\n    this.cacheClass = null;\\n}\\nObject.assign(T1Adapter.prototype, {\\n    init() {\\n        this.cacheClass = null;\\n        let data = this.getHomeData();\\n        if (!Array.isArray(data.list) || !data.list.length) {\\n            delete this.rule.推荐;\\n            data.list = [];\\n        }\\n    },\\n    getHomeData() {\\n        if (this.cacheClass) return this.cacheClass;\\n        let home = JSON.parse(fetch(buildUrl(this.api, {\\n            ac: \\\"class\\\"\\n        })));\\n        if (Array.isArray(home.class) && Array.isArray(this.categoryfilter)) {\\n            home.class = home.class.filter(v => this.categoryfilter.includes(v.type_name))\\n        }\\n        this.cacheClass = home;\\n\\n        return home;\\n    },\\n    homeVod() {\\n        let data = this.getHomeData();\\n        return JSON.stringify({\\n            list: data.list || []\\n        });\\n    },\\n    home() {\\n        return JSON.stringify(this.getHomeData());\\n    },\\n    category(tid, pg, filter, extend) {\\n        return fetch(buildUrl(this.api, {\\n            ac: \\\"videolist\\\",\\n            t: tid,\\n            pg: \\\"\\\" + pg\\n        }));\\n    },\\n    detail(vod_url) {\\n        return fetch(buildUrl(this.api, {\\n            ac: \\\"detail\\\",\\n            ids: vod_url,\\n        }));\\n    },\\n    play(flag, input) {\\n        let parse_url = this.source.playurl || \\\"\\\";\\n        if (/\\\\.(m3u8|mp4)/.test(input)) {\\n            return JSON.stringify({\\n                parse: 0,\\n                url: input\\n            });\\n        } else {\\n            if (parse_url.startsWith('json:')) {\\n                let purl = parse_url.replace('json:', '') + input;\\n                let html = request(purl);\\n                try {\\n                    return JSON.stringify({\\n                        parse: 0,\\n                        url: JSON.parse(html).url\\n                    });\\n                } catch (e) {\\n                    return JSON.stringify({\\n                        parse: 1,\\n                        url: input\\n                    });\\n                }\\n            } else {\\n                return JSON.stringify({\\n                    parse: 1,\\n                    url: parse_url + input\\n                });\\n            }\\n        }\\n    },\\n    search(wd, quick, pg) {\\n        return fetch(buildUrl(this.api, {\\n            wd: wd,\\n            pg: \\\"\\\" + pg\\n        }));\\n    },\\n    getRule(key) {\\n        return key ? this.rule[key] : this.rule;\\n    },\\n    runMain() {\\n        return \\\"\\\";\\n    }\\n});\\n$.exports = T1Adapter;\"},{\"col_type\":\"movie_3\",\"name\":\"二级方法\",\"path\":\"methods_er\",\"rule\":\"js:\\nlet {\\n  ui_config,\\n} = $.require(\\\"UIManage?rule\\\"+MY_RULE.title);\\nlet er = ui_config.er;\\n\\nlet { substr } = $.require(\\\"methods?rule\\\"+MY_RULE.title);\\n\\nfunction replaceTags(htmlString, oldTag, newTag) {\\n  // 创建正则表达式，匹配开头的<oldTag>和</oldTag>标签\\n  var regExpStart = new RegExp('<' + oldTag + '[^>]*>', 'g');\\n  var regExpEnd = new RegExp('<\\\\/' + oldTag + '>', 'g');\\n  // 替换开头的<oldTag>标签为<newTag>标签\\n  var newHtmlString = htmlString.replace(regExpStart, '<' + newTag + '>');\\n  // 替换闭合的</oldTag>标签为</newTag>标签\\n  newHtmlString = newHtmlString.replace(regExpEnd, '</' + newTag + '>');\\n  return newHtmlString;\\n}\\n\\n//风格1：简介\\nfunction setDesc1(arr, desc, num) {\\n  //log(desc)\\n  if (desc == undefined) {\\n    return;\\n  }\\n  desc = desc.constructor == Array ? desc.join('<br>') : desc;\\n  if (desc.replace(/(<br>|\\\\s+|<\\\\/?p>|&nbsp;)/g, '').length == 0) {\\n    return;\\n  }\\n\\n  const mark = 'desc';\\n  num = typeof (num) == 'undefined' ? 100 : num\\n  desc = desc.startsWith('　　') ? desc : '　　' + desc;\\n  desc = desc.replace(/'/g, \\\"&#39;\\\");\\n  desc = desc.replace(/\\\\r\\\\n/g, \\\"<br>\\\");\\n  desc = desc.replace(/\\\\n/g, \\\"<br>\\\");\\n  desc = replaceTags(desc, 'p', 'span');\\n  let sdesc = substr(desc, num);\\n\\n  var colors = {\\n    show: \\\"black\\\",\\n    hide: \\\"grey\\\"\\n  }\\n\\n  var lazy = $(`#noLoading#`).lazyRule((dc, sdc, m, cs) => {\\n    var show = storage0.getItem(m, '0');\\n    var title = findItem('desc').title;\\n    var re = /(<\\\\/small><br>.*?>).+/g;\\n    var exp = '展开:';\\n    var ret = '收起:';\\n    if (show == '1') {\\n      updateItem('desc', {\\n        title: title\\n          .replace(ret, exp)\\n          .replace(re, '$1' + sdc + '</small>')\\n          .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.hide + '$2')\\n\\n      })\\n      storage0.setItem(m, '0');\\n    } else {\\n      updateItem('desc', {\\n        title: title\\n          .replace(exp, ret)\\n          .replace(re, '$1' + dc + '</small>')\\n          .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.show + '$2')\\n      })\\n      storage0.setItem(m, '1');\\n    }\\n    return `hiker://empty`\\n  }, desc, sdesc, mark, colors)\\n  var sc = storage0.getItem(mark, '0') == '0' ? '展开:' : '收起:';\\n  var dc = storage0.getItem(mark, '0') == '0' ? sdesc : desc;\\n  var cs = storage0.getItem(mark, '0') == '0' ? colors.hide : colors.show;\\n  arr.push({\\n    title: '' + '<b><font color=\\\"#098AC1\\\">∷剧情简介\\t</font></b>' + \\\"<small><a style='text-decoration: none;' href='\\\" + lazy + \\\"'>\\\" + sc + '</a></small><br><font color=\\\"' + cs + '\\\">' + `${dc}` + '</small>',\\n    col_type: 'rich_text',\\n    extra: {\\n      id: 'desc',\\n      lineSpacing: 6,\\n      textSize: 15,\\n      lineVisible: true,\\n    }\\n  })\\n}\\n//风格2：简介\\nfunction setDesc2(arr, desc) {\\n  // 如果desc未定义，则直接返回\\n  if (desc === undefined) return;\\n  // 确保desc是字符串，如为数组则用<br>连接\\n  desc = Array.isArray(desc) ? desc.join(\\\"<br>\\\") : String(desc);\\n  // 如果desc去除空白和换行后为空，向d添加空白项并返回\\n  if (!desc.replace(/(<br>|\\\\s+)/g, \\\"\\\")) {\\n    d.push(\\n      {\\n        col_type: \\\"big_blank_block\\\"\\n      },\\n      {\\n        col_type: \\\"big_blank_block\\\"\\n      }\\n    );\\n    return;\\n  }\\n  const Color = er.线路颜色;\\n  let emojiReg = /[\\\\uD83C|\\\\uD83D|\\\\uD83E][\\\\uDC00-\\\\uDFFF][\\\\u200D|\\\\uFE0F]|[\\\\uD83C|\\\\uD83D|\\\\uD83E][\\\\uDC00-\\\\uDFFF]|[0-9|*|#]\\\\uFE0F\\\\u20E3|[0-9|#]\\\\u20E3|[\\\\u203C-\\\\u3299]\\\\uFE0F\\\\u200D|[\\\\u203C-\\\\u3299]\\\\uFE0F|[\\\\u2122-\\\\u2B55]|\\\\u303D|[\\\\A9|\\\\AE]\\\\u3030|\\\\uA9|\\\\uAE|\\\\u3030/gi;\\n  // 规范化desc：替换特定字符，移除表情符号\\n  let desDesc = desc\\n    .replace(/s*/g, \\\"\\\")\\n    .replace(/'|[\\\\r\\\\n]/g, \\\"<br>\\\")\\n    .replace(/<[^<>]+>|简介：|详情|/g, \\\"\\\")\\n    .replace(emojiReg, \\\"\\\");\\n  // 构建并推入描述项至d\\n  arr.push({\\n    title: \\\"影片简介\\\",\\n    desc: `<small><span style=\\\"color: ${Color}\\\">展开>></span></small>`,\\n    img: \\\"https://hikerfans.com/img/jj.svg\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(\\n      (jjid, decid, desText, Color) => {\\n        const action = getMyVar(\\\"jjs\\\", \\\"展开\\\") === \\\"展开\\\" ? \\\"收起\\\" : \\\"展开\\\";\\n        putMyVar(\\\"jjs\\\", action);\\n\\n        updateItem({\\n          extra: {\\n            id: jjid\\n          },\\n          desc: `<small><span style=\\\"color: ${Color}\\\">${action}>></span></small>`\\n        });\\n        updateItem({\\n          extra: {\\n            textSize: 14,\\n            lineSpacing: 3,\\n            id: decid\\n          },\\n          title: `<span style=\\\"color:#808080\\\">${action === \\\"收起\\\" ? desText : desText.substr(0, 68) + \\\"...\\\"}</span>`\\n        });\\n\\n        return \\\"hiker://empty\\\";\\n      }, MY_RULE + \\\"_jjid\\\", MY_RULE + \\\"_decid\\\", desDesc, Color\\n    ),\\n    col_type: \\\"avatar\\\",\\n    extra: {\\n      id: MY_RULE + \\\"_jjid\\\"\\n    }\\n  }, {\\n    title: `<span style=\\\"color:#808080\\\">${desDesc.substr(0, 68) + \\\"...\\\"}</span>`,\\n    col_type: \\\"rich_text\\\",\\n    extra: {\\n      textSize: 14,\\n      lineSpacing: 3,\\n      id: MY_RULE + \\\"_decid\\\"\\n    }\\n  });\\n}\\n\\nfunction setDesc(d, desc, num) {\\n  switch (er.简介样式) {\\n    case undefined:\\n    case \\\"0\\\":\\n      setDesc1(d, desc, num)\\n      break;\\n    case \\\"1\\\":\\n      setDesc2(d, desc)\\n      break;\\n  }\\n}\\n\\nfunction findIcon(keyword, er_ui) {\\n  let e = typeof er != \\\"undefined\\\" ? er : er_ui;\\n  // 定义基础域名\\n  const baseHost = \\\"https://hikerfans.com/\\\";\\n  // 图标映射对象，键为平台名称，值为图标URL\\n  const iconMap = {\\n    腾讯qqTX: `${baseHost}img/qq.svg`,\\n    优酷youkuYK: `${baseHost}img/yk.svg`,\\n    爱奇艺iqiyiQY: `${baseHost}img/aqy.svg`,\\n    哔哩bilibili1: `${baseHost}img/bili.svg`,\\n    芒果mgtvimgo: `${baseHost}img/mgtv.svg`,\\n    咪咕miguvideo: `${baseHost}img/mg.svg`,\\n    西瓜ixiguaxg: `${baseHost}img/xg.svg`,\\n    搜狐sohuSH: `${baseHost}img/sh.svg`,\\n    乐视letvleshilevp: `${baseHost}img/le.svg`,\\n    风行FX: `${baseHost}img/fx.svg`,\\n    PPTV: `${baseHost}img/pptv.svg`,\\n    CNTV: `${baseHost}img/cntv.svg`,\\n    电影网m1905: `${baseHost}img/1905.svg`,\\n    抖音douyin: `${baseHost}img/douyin.svg`,\\n    default: e.icons.视频\\n  };\\n\\n  const cleanedKeyword = keyword.replace(/\\\\s+/g, \\\"\\\").replace(/视频$/, \\\"\\\").replace(/TV$/, \\\"\\\").trim().toLowerCase();\\n  // 尝试原始关键词匹配\\n  let matchedKey = Object.keys(iconMap).find(key => new RegExp(cleanedKeyword, \\\"i\\\").test(key));\\n  // 若未找到匹配，尝试连续字符匹配，确保不会误匹配到其他键的片段\\n  if (!matchedKey && cleanedKeyword.length > 1) {\\n    for (let i = cleanedKeyword.length; i > 0; i--) {\\n      // 从最长子串开始尝试\\n      for (let j = 0; j <= cleanedKeyword.length - i; j++) {\\n        const subKeyword = cleanedKeyword.substring(j, j + i);\\n        // 确保子串不是其他键的组成部分\\n        const isUniqueMatch = !Object.keys(iconMap).some(otherKey => otherKey !== subKeyword && otherKey.toLowerCase()\\n          .includes(subKeyword) && !new RegExp(`^${subKeyword}\\\\\\\\w+`).test(otherKey));\\n        if (isUniqueMatch) {\\n          matchedKey = subKeyword;\\n          break;\\n        }\\n      }\\n      if (matchedKey) break;\\n    }\\n    matchedKey = matchedKey ? Object.keys(iconMap).find(key => key.includes(matchedKey)) : null;\\n  }\\n  return matchedKey ? iconMap[matchedKey] : iconMap.default;\\n}\\n\\n$.exports = {\\n  findIcon,\\n  setDesc,\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"主题编辑\",\"path\":\"ThemeEdit\",\"rule\":\"js:\\nvar d = [];\\nlet {\\n  ui_expand,\\n  themeManage,\\n  ui_config\\n} = $.require(\\\"UIManage\\\");\\nlet json = themeManage.get();\\nui_expand();\\njson[\\\"当前\\\"] = $.uiTheme.get();\\n\\nlet nk = getMyVar(MY_URL + \\\"n\\\", \\\"默认\\\");\\nlet item = json[nk];\\n\\n$.extend({\\n  my_url: MY_URL,\\n  _theme: themeManage\\n})\\n\\nlet action = [\\\"导出\\\", \\\"导入\\\", \\\"改名\\\", \\\"删除\\\", \\\"JSON\\\"];\\naction.forEach(x => {\\n  d.push({\\n    title: x,\\n    col_type: \\\"text_5\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((x, nk, item) => {\\n      if (x == \\\"导出\\\") {\\n        return $(nk).input((item) => {\\n          let obj = {};\\n          obj[input] = item;\\n          copy(JSON.stringify(obj))\\n        }, item)\\n      }\\n      if (x == \\\"导入\\\") {\\n        return $(\\\"{{clipboard}}\\\", \\\"请输入主题json\\\").input(() => {\\n          try {\\n            let json = $._theme.get();\\n            let obj = JSON.parse(input);\\n            let success = false;\\n            Object.entries(obj).forEach(([k, v]) => {\\n              if (!json.hasOwnProperty(k)) {\\n                $._theme.set(k, v);\\n                success = true;\\n              } else {\\n                toast(\\\"key:\\\" + k + \\\" 已经存在,跳过\\\");\\n              }\\n            })\\n            if (success) {\\n              refreshPage();\\n              return \\\"toast://导入成功\\\";\\n            } else {\\n              return \\\"hiker://empty\\\";\\n            }\\n          } catch (e) {\\n            return \\\"toast://格式错误\\\";\\n          }\\n        })\\n      }\\n      if (x == \\\"改名\\\") {\\n        if (/^(默认|当前)$/.test(nk)) {\\n          return \\\"toast://不能改名\\\";\\n        } else {\\n          return $(\\\"新名称\\\").input((k) => {\\n            let obj = $._theme.get();\\n            let newObj = Object.keys(obj).reduce((acc, key) => {\\n              if (key === k) {\\n                acc[input] = obj[key];\\n              } else {\\n                acc[key] = obj[key];\\n              }\\n              return acc;\\n            }, {});\\n            $._theme.save(JSON.stringify(newObj));\\n            putMyVar($.my_url + \\\"n\\\", input);\\n            refreshPage();\\n          }, nk)\\n        }\\n      }\\n      if (x == \\\"删除\\\") {\\n        if (/^(默认|当前)$/.test(nk)) {\\n          return \\\"toast://不能删除\\\";\\n        } else {\\n          return $(\\\"确认删除\\\").confirm((k) => {\\n            /**\\n             * 获取对象中给定键的前一个或后一个键。\\n\\n             * 此函数用于遍历对象的键，根据给定的键找到其前一个或后一个键。\\n             * 如果给定的键不存在于对象中，函数将尝试找到大于给定键的第一个键。\\n             * 如果对象中没有大于给定键的键，则返回对象的最后一个键。\\n             * \\n             * @param {Object} obj 要遍历的对象。\\n             * @param {string} key 要查找前一个或后一个键的键。\\n             * @returns {string} 返回找到的前一个或后一个键。\\n             */\\n            function getPreviousOrNextKey(obj, key) {\\n              const keys = Object.keys(obj);\\n              const index = keys.indexOf(key);\\n              if (index > -1) {\\n                // 如果键存在，返回前一个键\\n                return index > 0 ? keys[index - 1] : keys[index + 1]; // 如果是第一个键，返回下一个键\\n              } else {\\n                // 如果键不存在，返回下一个键\\n                const nextIndex = keys.findIndex(k => k > key);\\n                return nextIndex > -1 ? keys[nextIndex] : keys[keys.length - 1]; // 如果没有下一个键，返回最后一个键\\n              }\\n            }\\n\\n            let obj = $._theme.get();\\n            let name = getPreviousOrNextKey(obj, k);\\n            delete obj[k];\\n            $._theme.save(JSON.stringify(obj));\\n\\n            putMyVar($.my_url + \\\"n\\\", name);\\n            refreshPage();\\n          }, nk)\\n        }\\n      }\\n    }, x, nk, item)\\n  })\\n})\\nd.push({\\n  col_type: \\\"big_blank_block\\\"\\n})\\n\\nObject.keys(json).forEach((k, i) => {\\n  let longclicks = [];\\n  if (!/^(默认|当前)$/.test(k)) {\\n    longclicks.push({\\n      title: \\\"改名\\\",\\n      js: $.toString((k) => {\\n        return $(\\\"新名称\\\").input((k) => {\\n          let obj = $._theme.get();\\n          let newObj = Object.keys(obj).reduce((acc, key) => {\\n            if (key === k) {\\n              acc[input] = obj[key];\\n            } else {\\n              acc[key] = obj[key];\\n            }\\n            return acc;\\n          }, {});\\n          $._theme.save(JSON.stringify(newObj));\\n          putMyVar($.my_url + \\\"n\\\", input);\\n          refreshPage();\\n        }, k)\\n      }, k)\\n    })\\n  }\\n  d.push({\\n    title: nk == k ? '““””' + k.fontcolor(\\\"red\\\") : k,\\n    col_type: \\\"scroll_button\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((k) => {\\n      putMyVar(MY_URL + \\\"n\\\", k);\\n      refreshPage();\\n      return \\\"hiker://empty\\\";\\n    }, k),\\n    extra: {\\n      LongClick: longclicks\\n    }\\n  })\\n})\\n\\nlet di = d.findIndex(x => x.title == \\\"JSON\\\");\\nd[di] = Object.assign(d[di], {\\n  url: $(\\\"#noLoading#\\\").lazyRule((content, k) => {\\n    let obj = {};\\n    obj[k] = content;\\n    content = obj;\\n    if (fetch(\\\"hiker://home@JSON编辑器\\\") == null) {\\n      return '海阔视界首页频道规则【JSON编辑器】￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=3424';\\n    } else {\\n      return 'hiker://page/interface#noRefresh##noHistory##noRecordHistory#?rule=JSON编辑器&Json=' + base64Encode(JSON.stringify(content))\\n    }\\n  }, item, nk),\\n})\\nd.splice(di, 1, d[di]);\\n\\nd.push({\\n  title: \\\"““””\\\" + \\\"<small>确认</small>\\\",\\n  col_type: \\\"text_center_1\\\",\\n  url: $(\\\"#noLoading#\\\").lazyRule((item, nk) => {\\n    if (nk == \\\"当前\\\") {\\n      back(true);\\n      return \\\"hiker://empty\\\";\\n    }\\n    setItem(\\\"theme\\\", nk);\\n    $.uiTheme.set(item);\\n    back(true);\\n    return \\\"hiker://empty\\\";\\n  }, item, nk),\\n  extra: {\\n    lineVisible: false,\\n  }\\n})\\n\\n\\nd.push({\\n  title: \\\"\\\",\\n  col_type: \\\"input\\\",\\n  extra: {\\n    defaultValue: JSON.stringify(item, null, 1),\\n    Highlight: true,\\n    type: \\\"textarea\\\",\\n    height: -1\\n  }\\n})\\n\\n\\nsetResult(d);\"}]","icon":"","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!