API tools faq
paste
xiaomianao666

小程序：𝐉𝐚𝐯𝐃𝐁

xiaomianao666
Oct 26th, 2024
593
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 151.12 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@𝐉𝐚𝐯𝐃𝐁@{"last_chapter_rule":"","title":"𝐉𝐚𝐯𝐃𝐁","author":"α模板&R","url":"hiker://empty##https://javdb368.com/##fypage","version":20240805,"col_type":"movie_3","class_name":"","type":"video","class_url":"云6oooole/xxxxxx/xozxdwji5rrhrl6v","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar d = [];\naddListener(\"onClose\", $.toString(() => {\n    let keys = listMyVarKeys();\n    for (let it of keys) {\n        clearMyVar(it);\n    }\n}));\n\nconst 下一页 = \"pd(html, '.pagination&&a[rel=next]&&href')\";\nconst page = MY_PAGE;\neval(JSON.parse(request('hiker://page/yi')).rule)\n\nvar 定位信息 = [{\n    大类定位: '.navbar-start&&.navbar-link',\n    增加: ['<a href=\"' + MY_HOME + '/\">首页</A>','<a href=\"/about\">收藏</A>'],\n    小类: 'body&&a:not(:matches(🔥))',\n    链接处理: (u) => {\n        let url = u.replace(/type(\\/\\d+)\\.html/, 'show$1-----------.html');\n        return url\n    }\n},{\n    一级定位: '.navbar-item[href=/login]',\n},{\n    一级定位: \"@js:\" + $.toString(() => {    \n    if(!/about|rankings|tags|series|makers|login|actors/.test(true_url)){\n    var list = pdfa(html, 'body&&.navbar-dropdown:has(hr)');   \n} else {\n    var list = []\n}\n    return list\n     }),\n    小类: 'body&&a:not(:matches(支付記錄|個人信息))',\n}, {\n    一级定位: \"@js:\" + $.toString(() => {\n            if(/search/.test(true_url)){\n            var list = []\n} else {\n            var list=pdfa(html, 'body&&.tabs||.buttons.has-addons');\n            if(!/about|rankings|tags|series|makers|users|login|actors/.test(true_url)){\n            listf = pdfa(list[0],\"body&&a\")\n            listb = listf.concat(['<a href=\"/users/recent_videos\">𝐅𝐂𝟐</A>'])\n            list[0] = listb.join(\",\");\n             };\n            var si = 2\n            lista = pdfa(list[si],\"body&&a\")\n            element = lista.splice(2,1)[0]\n            lista.unshift(element);\n            list[si] = lista.join(\",\");}\n            return list\n    }),\n    小类: 'body&&a:not(:matches(热播|250|封面|猜你|FC2))',\n   标题: 'Text.js:input.replace(\"含\",\"\").replace(\"中字可播放\",\"中字\").replace(\"可播放\",\"可播\")',\n}, {\n    //一级定位: '#tags&&dt',\n    一级定位: \"@js:\" + $.toString(() => {\n    var list = pdfa(html,'#tags&&dt');\n    for(var i in list){\n      var lista = pdfa(list[i],'body&&.tag');\n      title = pdfh(list[i],'strong&&Text')\n      lista[0] = lista[0].replace(\">全部<\",\">\" + title + \"<\")\n/*\nif(i==0){\n      element = lista.splice(3,1)[0]\n      lista.unshift(element);\n      list[0] = lista.join(\",\")\n}*/\nfor(var j in lista){\n      lista[j] = lista[j].replace(/button/g,'a').replace(\"onclick\",\"href\").replace(\"window.location.href=\",\"\").replace(/\\'/g,\"\").replace(/(<a.*?)(?:class=\"delete is-small\" )(.*?>)/,`$1$2♈️`).replace(\"javascript:;\",true_url)\n}\n      list[i] = lista.join(\",\")\n}\n    return list\n}),\n    小类: 'body&&.tag:not(:matches(更多))',\n    标题: 'Text',\n},{\n    一级定位: '.actor-filter&&.filter-slider:matches(身高)',\n    小类: 'body&&.filter-slider',\n    补充: [\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C147&cup=0%2C15&bust=70%2C120&waist=50%2C90&hips=70%2C120\">130-147',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=147%2C160&cup=0%2C15&bust=70%2C120&waist=50%2C90&hips=70%2C120\">147-160',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=160%2C165&cup=0%2C15&bust=70%2C120&waist=50%2C90&hips=70%2C120\">160-165',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=165%2C169&cup=0%2C15&bust=70%2C120&waist=50%2C90&hips=70%2C120\">165-169',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=169%2C175&cup=0%2C15&bust=70%2C120&waist=50%2C90&hips=70%2C120\">169-175',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=175%2C185&cup=0%2C15&bust=70%2C120&waist=50%2C90&hips=70%2C120\">175-185',\n],\n    标题: 'Text',\n    链接: 'input&&id.js:input.replace(\"af-height-input\",\"/actors/censored\")',\n},{\n    一级定位: '.actor-filter&&.filter-slider:matches(罩杯)',\n    小类: 'body&&.filter-slider',\n    补充: [\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C185&cup=0%2C1&bust=70%2C115&waist=50%2C90&hips=70%2C120\">A',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C185&cup=1%2C3&bust=70%2C115&waist=50%2C90&hips=70%2C120\">BC',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C185&cup=3%2C4&bust=70%2C115&waist=50%2C90&hips=70%2C120\">D',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C185&cup=4%2C6&bust=70%2C115&waist=50%2C90&hips=70%2C120\">EF',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C185&cup=6%2C8&bust=70%2C115&waist=50%2C90&hips=70%2C120\">GH',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C185&cup=8%2C10&bust=70%2C115&waist=50%2C90&hips=70%2C120\">IJ',\n'<input id=\"/actors/censored?t=filter&age=19%2C65&height=130%2C185&cup=10%2C15&bust=70%2C115&waist=50%2C90&hips=70%2C120\">K~',\n],\n    标题: 'Text',\n    链接: 'input&&id.js:input.replace(\"af-cup-input\",\"/actors/censored\")',\n}]\n\nMY_URL = MY_URL.split('##')[1]\nlet true_url = getTruelink(MY_RULE.url, MY_URL, page);\n\nlog(true_url)\n\nvar html = fetch(true_url, {\n    headers: {\n        cookie: fetchPC('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt') || '',\n        \"User-Agent\": \"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\",      \n    },\n    redirect: false\n});\n\n//log(html)\n\n/*\nif (/redirected/.test(html)&&!/\\/fc2/.test(true_url)) {\n writeFile('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt', '');\n    html = fetch(true_url, {\n        headers: {\n            cookie: fetchPC('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt') || '',        \n        },\n        redirect: false\n    })\n}\n*/\neval(JSON.parse(request('hiker://page/search')).rule)\n\nconst dc = dynamicClass({\n    分类颜色: getRangeColors()\n});\ndc.开启折叠(false)\ndc.开启搜索(false)\ndc.创建动态分类(定位信息)\n\nif (/Just\\sa\\smoment/.test(html)) {\nd.push({\n        title: '““””' + '获取cookie'.fontcolor('#FF00FF').big(),\n        url: true_url + $('').rule(() => {\n            var d = [];\n            d.push({\n                col_type: 'x5_webview_single',\n                url: MY_URL,\n                desc: 'list&&screen',\n                extra: {\n                    \"User-Agent\": \"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\",//PC_UA,             \n                    showProgress: false,\n                    js: $.toString((u) => {\n                        function check() {\n                            //let nodes = document.querySelectorAll('#tags');\n                            var co = fba.getCookie(u);\n//var ua = fba.getUa()\n//fba.log('co::::::' + ua);\n                           // fba.log('co::::::' + co);\nvar htmlContent = document.documentElement.innerHTML;\n\nif(/永久域名/.test(htmlContent)) {\n  \n                           \n                                fba.parseLazyRule($$$().lazyRule((co) => {\n                                    writeFile('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt', co);\n                                    toast('已获取cookie，切换到首页');\n                                    back(true);\n                                }, co));\n                            } else {\n                                setTimeout(check, 500);\n                            }\n                        }\n                        check();\n                    }, MY_URL)\n                }\n            });\n            return setResult(d);\n        }),\n        col_type: 'text_center_1'\n    });\n}\n\nvar parseRule = {\n    list: 'body&&.item',\n    title: '.video-title&&Text',\n    desc1: '.tags&&Text',\n    desc: '.meta&&Text',\n    img: 'img||a&&src||data-original',\n    url: 'a&&href',\n    ref: '@Referer=',\n    col_type: 'movie_2',\n    imt: false,\n    //backimg: true,\n}\n\nvar parseRule1 = {\n    list: 'body&&.actor-box', \n    title: 'a&&title',\n    desc: '.meta&&Text',\n    img: 'img||a&&src||data-original',\n    url: 'a&&href',\n    ref: '@Referer=',\n    col_type: 'card_pic_3',\n    imt: false,\n    //backimg: true,\n}\n\nvar parseRule2 = {\n    list: '#series&&.box',\n    title: 'strong&&Text',\n    desc: 'span&&Text',\n    img: 'a&&href.js:input.replace(input,\"https://hikerfans.com/tubiao/movie/30.svg\")',\n    url: 'a&&href',\n    ref: '@Referer=',\n    col_type: 'avatar',\n    imt: false,\n    //backimg: true,\n}\n\nvar parseRule3 = {\n    list: '#makers&&.box',\n    title: 'strong&&Text',\n    desc: 'span&&Text',\n    img: 'a&&href.js:input.replace(input,\"https://hikerfans.com/tubiao/movie/30.svg\")',\n    url: 'a&&href',\n    ref: '@Referer=',\n    col_type: 'avatar',\n    imt: false,\n    //backimg: true,\n}\n\nvar parseRule4 = {\n    list: '#directors&&.box',\n    title: 'strong&&Text',\n    desc: 'span&&Text',\n    img: 'a&&href.js:input.replace(input,\"https://img.vinua.cn/images/Xa2hD.png\")',\n    url: 'a&&href',\n    ref: '@Referer=',\n    col_type: 'avatar',\n    imt: false,\n    //backimg: true,\n}\n\nvar parseRule5 = {\n    list: '#codes&&.box',\n    title: 'strong&&Text',\n    desc: 'span&&Text',\n    img: 'a&&href.js:input.replace(input,\"https://img.vinua.cn/images/OTM4k.png\")',\n    url: 'a&&href',\n    ref: '@Referer=',\n    col_type: 'avatar',\n    imt: false,\n    //backimg: true,\n}\n\nvar parseRule6 = {\n    list: '#lists&&a',\n    title: 'strong&&Text',\n    desc: 'a&&title',\n    img: 'a&&href.js:input.replace(input,\"https://hikerfans.com/tubiao/movie/30.svg\")',\n    url: 'a&&href',\n    ref: '@Referer=',\n    col_type: 'avatar',\n    imt: false,\n    //backimg: true,\n}\n\nif (true_url.includes('/about')){\neval(JSON.parse(request('hiker://page/收藏')).rule)\n}\n\nif (true_url.includes('/logout')){\nwriteFile('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt', '');\n    toast('账号已登出');\n}\n\nif (true_url.includes('/login')){\neval(JSON.parse(request('hiker://page/登录')).rule)\n}\n\nCreate.ruleList(d, html, parseRule);\n\nCreate.List(d, html, parseRule1);\n\nCreate.List(d, html, parseRule2);\n\nCreate.List(d, html, parseRule3);\n\nif (/search|collection_directors/.test(true_url)){\nCreate.List(d, html, parseRule4);}\n\nif (true_url.includes('collection_codes')){\nCreate.List(d, html, parseRule5);}\n\nif (true_url.includes('search?f=list')){\nCreate.List(d, html, parseRule6);}\n\nautoPage();\n\nsetResult(d)","search_url":"/search?f=all&page=fypage&q=**","group":"✨","searchFind":"js:\n$.require(\"yj\")\n/*\nhiker://empty##**\nvar d = [];\nlet HOME = \"hiker://empty##\" + MY_RULE.url.split(\"##\")[1];\nlet key = MY_URL.split(\"##\")[1];\nd.push({\n    title: \"点我开始搜索\" + key,\n    url: HOME + \"search?f=all&page=fypage&q=\" + key + '@rule=js:$.require(\"yj\")',\n    extra: {\n        pageTitle: key,\n        key: key\n    }\n});\n*/\nsetResult(d);","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"*","ua":"mobile","preRule":"var 开启翻译 = \"小牛翻译\";//true,\"彩云小译\"，\"小牛翻译\"，\"AI翻译\"\n\n//小牛翻译API：https://niutrans.com/text_trans\n//上面网址注册获取免费api\nvar api = \"3a12ec50409c213b78383fda90c07304\";\n//上面双引号里填入免费api;\n\nsetItem('api',api);\nsetItem('switchtrans',开启翻译);\n\nvar 更新间隔 = 1 ;//(天)\nlet time = new Date().getTime().toString()\nlet 时间间隔 = time-getItem('time', new Date().getTime().toString())\n\nlet 间隔天数 = Math.floor(时间间隔 / (24 * 60 * 60 * 1000));\n\nif (间隔天数>=更新间隔 ) {\n            setItem('time', time);\n            let HOME = MY_RULE.url.match(/https?:\\/\\/[^#/?&]+\\//)[0];\n            var html = fetch(HOME + 'about',{dns:'https://1.1.1.1/dns-query'});\n            var url = pdfh(html,'.sub-header&&.content&&a[href~=com]&&href')\n//log('免翻地址：'+url)\nif (HOME !== url) {\n    confirm({\n        title: \"更新提示\",\n        content: \"有最新免翻地址,是否更新\",\n        confirm: $.toString((url) => {\n            var currentDate = new Date();\n            var year = currentDate.getFullYear();\n            var month = String(currentDate.getMonth() + 1).padStart(2, '0');\n            var day = String(currentDate.getDate()).padStart(2, '0');\n            MY_RULE.version = `${year}${month}${day}`;\n            /(https?:\\/\\/[^#/?&]+\\/)/.test(MY_RULE.url);\n            MY_RULE.url = MY_RULE.url.replace(RegExp.$1, url);\n            return \"rule://\" + base64Encode(\"海阔视界￥home_rule￥\" + JSON.stringify(MY_RULE));            \n        },url),\n        cancel: () => {\n            return \"toast://😇\";\n        }\n    });\n   }\n}\n\nif ( getItem(\"version\") !== MY_RULE.version.toString()) {\nsetItem(\"version\",MY_RULE.version.toString());\nwriteFile('hiker://files/rules/Apollo/𝐂𝐨𝐝𝐞𝐋𝐚𝐳𝐲.js', '');\n}\n\nputMyVar('yongjiu','https://javdb.com')\nputMyVar('fc2',\"hiker://empty\")\nhost = MY_RULE.url.match(/https?:\\/\\/[^#/?&]+/)[0];\nsetPublicItem('javdb0',host);\n\nregisterDNS({\n    \"javdb.com\": \" https://dns.google/dns-query\"\n});","pages":"[{\"col_type\":\"movie_3\",\"name\":\"①一级分类列表\",\"path\":\"yi\",\"rule\":\"js:\\n/*\\nby α(zetalpha)\\n一级封装\\n动态分类 列表创建 自动下一页\\nver 20231017 1.0\\n*/\\n\\n//随机颜色\\nvar getRangeColors = function() {\\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\n}\\n\\n//动态分类\\nfunction dynamicClass(options) {\\n    const obj = {\\n        //默认值\\n        layout: \\\"undefined\\\",\\n        html: \\\"empty\\\",\\n        page: 0,\\n        分类颜色: \\\"#FA7298\\\",\\n        折叠: \\\"““””<b>\\\" + \\\"∧\\\".fontcolor(\\\"#1aad19\\\") + \\\"</b>\\\",\\n        展开: \\\"““””<b>\\\" + \\\"∨\\\".fontcolor(\\\"#FF0000\\\") + \\\"</b>\\\",\\n        open: true,\\n        state: MY_RULE.url,\\n        search: false,\\n        clears: [],\\n        clearall: [\\\"yi_firstpage\\\"],\\n        debug: false,\\n\\n        预设(param) {\\n            if (param == undefined) {\\n                param = [];\\n            }\\n            Object.keys(param).forEach((property) => {\\n                // 对每个属性名执行操作\\n                const value = param[property]; // 获取属性值\\n                // 在这里执行您的操作\\n                this[property] = value;\\n                if (this.debug) {\\n                    console.log(property + \\\":\\\" + value);\\n                }\\n            });\\n        },\\n        evalJSRule(item,\\n            jsRule) {\\n            let rule = jsRule.replace(\\\"@js:\\\",\\n                \\\"\\\");\\n            rule = rule.trim();\\n            //log($.stringify(rule))\\n            let input = item;\\n            if (rule.startsWith(\\\"(\\\")) {\\n                eval(\\\"result = \\\" + rule);\\n            } else {\\n                /**\\n                 * 还原成 $.toString(...) 的最终结果，达到最终处理方式跟上面的 if 一致的目的\\n                 */\\n                eval(\\\"result = \\\" + \\\"(() => {\\\" + rule + \\\"})()\\\");\\n            }\\n            return result || \\\"\\\";\\n        },\\n        getTitle(src, category) {\\n            let title = \\\"\\\";\\n            let titleRule = category || \\\"a&&Text\\\";\\n            if (titleRule.startsWith(\\\"@js:\\\")) {\\n                title = this.evalJSRule(src, titleRule);\\n            } else {\\n                title = parseDomForHtml(src, titleRule);\\n            }\\n            return title || \\\"\\\";\\n        },\\n        getUrl(src, category) {\\n            let url = \\\"\\\";\\n            let urlRule = category.链接 || \\\"a&&href\\\";\\n            if (urlRule.startsWith(\\\"@js:\\\")) {\\n                url = this.evalJSRule(src, urlRule);\\n            } else {\\n                url = pd(src, urlRule);\\n            }\\n            if (typeof category.链接处理 == \\\"function\\\") {\\n                url = category.链接处理(url);\\n            }\\n            return url || \\\"\\\";\\n        },\\n        isNull(param) {\\n            if (param == null) {\\n                return this;\\n            }\\n            return false;\\n        },\\n        isBoolean(variable) {\\n            if (typeof variable !== \\\"boolean\\\") {\\n                throw new Error(\\\"开启折叠请传入布尔值\\\");\\n            }\\n        },\\n        清除(list) {\\n            if (this.isNull(list)) {\\n                return this;\\n            }\\n            if (list.constructor == String) {\\n                throw new Error(\\\"清除报错:请传列表\\\");\\n            }\\n            this.clears = list;\\n            return this;\\n        },\\n        全清(list) {\\n            if (this.isNull(list)) {\\n                return this;\\n            }\\n            var c = this.clearall;\\n            list = c.concat(list);\\n            this.clearall = list;\\n            return this;\\n        },\\n        源码(input) {\\n            this.html = input;\\n            return this;\\n        },\\n        界面(input) {\\n            this.layout = input;\\n            return this;\\n        },\\n        页码(input) {\\n            this.page = input;\\n            return this;\\n        },\\n        状态(input) {\\n            this.state = input;\\n            return this;\\n        },\\n        开启搜索(input) {\\n            if (input == undefined) {\\n                input = true;\\n            }\\n            this.search = input;\\n            return this;\\n        },\\n        开启折叠(input) {\\n            if (input == undefined) {\\n                input = true;\\n            }\\n            this.isBoolean(input);\\n            this.open = input;\\n            return this;\\n        },\\n        setTitle(k, i, t) {\\n            return k == i ? \\\"““””\\\" + t.fontcolor(this.分类颜色) : t;\\n        },\\n        action(obj) {\\n            return [{\\n                title: \\\"清除状态\\\",\\n                js: $.toString((obj) => {\\n                    log(obj);\\n                    clearMyVar(obj.state);\\n                    clearMyVar(\\\"head.cate\\\");\\n                    clearMyVar('cate_button');\\n                    obj.all.forEach((item) => {\\n                        clearMyVar(item);\\n                    });\\n                    obj.cl.forEach((item) => {\\n                        clearMyVar(item);\\n                    });\\n                    refreshPage();\\n                }, obj),\\n            }, ];\\n        },\\n        checkParam() {\\n            var obj = {};\\n            if (this.page == 0 && typeof page == \\\"undefined\\\") {\\n                throw new Error(\\\"请传入页码\\\");\\n            } else {\\n                if (typeof page == \\\"undefined\\\") {\\n                    obj[\\\"页码\\\"] = this.page;\\n                } else {\\n                    obj[\\\"页码\\\"] = page;\\n                }\\n            }\\n            if (this.html == \\\"empty\\\" && typeof html == \\\"undefined\\\") {\\n                throw new Error(\\\"请传入源码\\\");\\n            } else {\\n                if (typeof html == \\\"undefined\\\") {\\n                    obj[\\\"源码\\\"] = this.html;\\n                } else {\\n                    obj[\\\"源码\\\"] = html;\\n                }\\n            }\\n            if (this.layout == \\\"undefined\\\" && typeof d == \\\"undefined\\\") {\\n                throw new Error(\\\"请传入界面\\\");\\n            } else {\\n                if (typeof d == \\\"undefined\\\") {\\n                    obj[\\\"界面\\\"] = this.layout;\\n                } else {\\n                    obj[\\\"界面\\\"] = d;\\n                }\\n            }\\n            return obj;\\n        },\\n        创建动态分类(ruleObj) {\\n            let items = [];\\n            let cates = [];\\n            if (ruleObj == undefined) {\\n                ruleObj = [];\\n            }\\n            //初始化变量开始\\n            const param = this.checkParam();\\n            const page = param.页码;\\n            const html = param.源码;\\n            const d = param.界面;\\n            const 状态 = this.state;\\n            const search = this.search;\\n            const empty = \\\"hiker://empty\\\";\\n            const 折叠状态 = this.open;\\n            var 展开 = this.展开;\\n            var 折叠 = this.折叠;\\n            var 全清 = this.clearall;\\n            var 清除 = this.clears;\\n            //初始化变量结束\\n            let init_cate = new Array(20).fill(\\\"0\\\");\\n            const fold = getMyVar(MY_RULE.group, \\\"0\\\");\\n            const cate_temp = JSON.parse(\\n                getMyVar(\\\"head.cate\\\", JSON.stringify(init_cate))\\n            );\\n            if (search && page == 1) {\\n                items.push({\\n                    title: \\\"\\\",\\n                    url: \\\"'hiker://search?rule=\\\" + MY_RULE.title + \\\"&s='+input\\\",\\n                    desc: \\\"搜索关键词\\\",\\n                    col_type: \\\"input\\\",\\n                    extra: {\\n                        defaultValue: getMyVar(\\\"keyword\\\", \\\"\\\"),\\n                        onChange: $.toString(() => {\\n                            putMyVar(\\\"keyword\\\", input);\\n                        }),\\n                    },\\n                });\\n            }\\n            const categories = [];\\n            ruleObj.forEach((x) => {\\n                var list = [];\\n                //log(x)\\n                if (x.json != undefined) {\\n                    x.json.map(k => {\\n                        categories.push(JSON.stringify(k).replace(/^\\\\[|\\\\]$/g, ''))\\n                    })\\n                    //categories.push(x.json)\\n                }\\n                if (x.一级定位) {\\n                    if (x.一级定位.startsWith(\\\"@js:\\\")) {\\n                        list = this.evalJSRule(html, x.一级定位);\\n                    } else {\\n                        list = pdfa(html, x.一级定位);\\n                    }\\n                }\\n                if (x.大类定位) {\\n                    if (x.大类定位.startsWith(\\\"@js:\\\")) {\\n                        list = this.evalJSRule(html, x.大类定位);\\n                    } else {\\n                        list = [pdfa(html, x.大类定位).join('\\\\n')];\\n                    }\\n                }\\n\\n\\n        var 一级 = list.map((s) => {\\n          var slist = [];\\n          if (!(\\\"小类\\\" in x)) {\\n            x.小类 = \\\"body&&a:not(:matches(首页)):not(a:not([href]))\\\";\\n          }\\n          if (x.小类.startsWith(\\\"@js:\\\")) {\\n            slist = this.evalJSRule(s, x.小类);\\n          } else {\\n            slist = pdfa(s, x.小类);\\n          }\\n          //--额外处理--\\n          if (('增加' in x)) {\\n            if (x.增加.constructor == String) {\\n              x.增加 = eval(x.增加);\\n            }\\n            slist = x.增加.concat(slist);\\n          }\\n          if (('补充' in x)) {\\n            if (x.补充.constructor == String) {\\n              x.补充 = eval(x.补充);\\n            }\\n            slist = slist.concat(x.补充);\\n          }\\n          //--额外处理--\\n          var 定位 = slist.map((item) => {\\n            var title = this.getTitle(item, x.标题);\\n            var url = this.getUrl(item, x);\\n            var obj = {\\n              title: title, url: url\\n            };\\n            if (('ext' in x)) {\\n              obj['ext'] = x.ext;\\n            }\\n            return JSON.stringify(obj);\\n          });\\n          return 定位;\\n        });\\n                //log(一级)\\n                //log(一级.length)\\n                if (一级.length == 1) {\\n                    categories.push(一级.join(\\\"\\\\n\\\"));\\n                } else {\\n                    一级.forEach((item) => {\\n                        categories.push(item.join(\\\",\\\"));\\n                    });\\n                }\\n                //log(categories)\\n            });\\n            if (折叠状态) {\\n                if (page == 1) {\\n                    items.push({\\n                        title: fold === \\\"1\\\" ? 折叠 : 展开,\\n                        url: $(\\\"#noLoading#\\\").lazyRule(\\n                            (title, fold, u, all, exps) => {\\n                                var fold = getMyVar(MY_RULE.group, fold);\\n\\n                                var [展开, 折叠] = exps;\\n\\n                                if (fold == 1) {\\n                                    var cx = findItemsByCls(title + 'cate_button');\\n                                    storage0.putMyVar('cate_button', cx);\\n                                    deleteItemByCls(title + 'cate_button');\\n\\n                                } else {\\n                                    var cx = storage0.getMyVar('cate_button', []).map(x => {\\n                                        x['col_type'] = x['col_type'] ? x['col_type'] : x['type'];\\n                                        return x;\\n                                    });\\n                                    addItemAfter(title + 'cate_line', cx)\\n                                }\\n\\n                                /*all.forEach((item) => {\\n                                  clearMyVar(item);\\n                                });*/\\n                                updateItem(title + 'cate_exp', {\\n                                    title: fold == 1 ? 展开 : 折叠,\\n                                })\\n\\n                                putMyVar(MY_RULE.group, fold === \\\"1\\\" ? \\\"0\\\" : \\\"1\\\");\\n\\n                                //refreshPage(false);\\n                                return \\\"hiker://empty\\\";\\n                            },\\n                            MY_RULE.title,\\n                            fold,\\n                            状态,\\n                            全清, [展开,\\n                                折叠\\n                            ],\\n                        ),\\n                        col_type: \\\"scroll_button\\\",\\n                        extra: {\\n                            id: MY_RULE.title + 'cate_exp',\\n                            longClick: this.action({\\n                                state: 状态,\\n                                all: 全清,\\n                                cl: 清除,\\n                            }),\\n                        },\\n                    });\\n                }\\n            }\\n            if (page == 1) {\\n                categories.forEach((category, index) => {\\n                    //log(category)\\n                    let sub_categories = [];\\n                    /*if (小类定位.includes(\\\";\\\")) {\\n                      sub_categories = pdfa(category, 小类定位.split(\\\";\\\")[0]);\\n                      if (sub_categories.length == 0) {\\n                        sub_categories = pdfa(category, 小类定位.split(\\\";\\\")[1]);\\n                      }\\n                    } else {*/\\n                    //log(index)\\n                    sub_categories = JSON.parse(`[${category}]`);\\n                    //log(sub_categories)\\n                    // sub_categories = pdfa(category, 小类定位);\\n                    //}\\n                    if (index === 0) {\\n                        //大类\\n                        sub_categories.forEach((item, key) => {\\n\\n                            //let title = pdfh(item, _大类标题);\\n                            let title = item.title;\\n\\n                            if (typeof 排除 != \\\"undefined\\\" && 排除 != \\\"\\\") {\\n                                title = title.replace(newRegExp(排除, \\\"g\\\"), \\\"\\\");\\n                            }\\n                            let json = ''\\n                            json = item.url;\\n\\n                            let params = {\\n                                cate_temp: cate_temp,\\n                                key: key,\\n                                page: page,\\n                                clears: 清除,\\n                                json: json,\\n                                state: 状态,\\n                                allclears: 全清,\\n                            };\\n\\n                            //let url = pd(item, _大类链接);\\n                            let url = item.url;\\n                            /*if (大类处理) {\\n                              url = 一级分类处理(url);\\n                            }*/\\n                            //log(url)\\n                            items.push({\\n                                title: this.setTitle(key.toString(), cate_temp[index], title),\\n                                col_type: \\\"scroll_button\\\",\\n                                url: $(\\\"hiker://empty#noLoading#\\\").lazyRule((params) => {\\n                                        let new_cate = [];\\n                                        params.clears.forEach((item) => {\\n                                            clearMyVar(item);\\n                                        });\\n                                        params.allclears.forEach((item) => {\\n                                            clearMyVar(item);\\n                                        });\\n                                        clearMyVar('cate_button');\\n\\n                                        params.cate_temp.forEach((cate, index) => {\\n                                            new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\");\\n                                        });\\n                                        putMyVar(\\\"head.cate\\\", JSON.stringify(new_cate));\\n                                        if (params.json.constructor === Object) {\\n                                            putMyVar(\\\"dt_\\\" + params.json.type, params.json.value);\\n                                        } else {\\n                                            putMyVar(params.state, params.json);\\n                                        }\\n                                        refreshPage(true);\\n                                        return \\\"hiker://empty\\\";\\n                                    },\\n                                    params),\\n                            });\\n                        });\\n                        items.push({\\n                            col_type: \\\"blank_block\\\",\\n                            extra: {\\n                                id: MY_RULE.title + 'cate_line',\\n                            }\\n                        });\\n                    } else {\\n                        //小类\\n                        sub_categories.forEach((item, key) => {\\n                            var extrapos = false;\\n                            /*if (item.includes('type=\\\"@extra\\\"')) {\\n                              extrapos = true;\\n                              //log('附加定位')\\n                            }*/\\n\\n                            if (extrapos) {\\n                                var title = pdfh(item, \\\"a&&Text\\\");\\n                                if (typeof 排除 != \\\"undefined\\\" && 排除 != \\\"\\\") {\\n                                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n                                }\\n                                var json = {\\n                                    type: pdfh(item, \\\"a&&state\\\"),\\n                                    value: pdfh(item, \\\"a&&value\\\"),\\n                                };\\n                            } else {\\n                                //var title = pdfh(item, 分类标题);\\n                                var title = item.title;\\n                                if (typeof 排除 != \\\"undefined\\\" && 排除 != \\\"\\\") {\\n                                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n                                }\\n\\n                                var json = \\\"\\\";\\n                                /*switch (true) {\\n                                  case 分类链接.includes(\\\"@@@\\\"):\\n                                    json = {\\n                                      type: pdfh(item, 分类链接.split(\\\"@@@\\\")[0]),\\n                                      value: pdfh(item, 分类链接.split(\\\"@@@\\\")[1]),\\n                                    };\\n                                    break;\\n                                  case 分类链接.includes(\\\"@@\\\"):\\n                                    json = {\\n                                      type: 分类链接.split(\\\"@@\\\")[0],\\n                                      value: pdfh(item, 分类链接.split(\\\"@@\\\")[1]),\\n                                    };\\n                                    break;\\n                                  default:\\n                                    json = item.url;\\n                                    // json = pd(item, 分类链接);\\n                                    break;\\n                                }*/\\n                                json = item.url;\\n                                /*var json=分类链接.includes('@@@')?{\\n                                      type:pdfh(item,分类链接.split('@@@')[0]),\\n                                      value:pdfh(item,分类链接.split('@@@')[1]),\\n                                  }:pd(item,分类链接);\\n                                  json=分类链接.includes('@@')?{\\n                                      type:分类链接.split('@@')[0],\\n                                      value:pdfh(item,分类链接.split('@@')[1]),\\n                                  }:pd(item,分类链接);*/\\n                            }\\n\\n                            let params = {\\n                                cate_temp: cate_temp,\\n                                index: index,\\n                                key: key,\\n                                page: page,\\n                                json: json,\\n                                state: 状态,\\n                                allclears: 全清,\\n                            };\\n                            cates.push({\\n                                title: this.setTitle(key.toString(), cate_temp[index], title),\\n                                url: title == \\\"𝐅𝐂𝟐\\\" ? \\\"hiker://page/fc2?url=\\\" + getMyVar(\\\"fc2\\\") + \\\"#fypage#noHistory#\\\" : $(\\\"hiker://empty\\\" + \\\"#noLoading#\\\").lazyRule((params) => {\\n                                        params.allclears.forEach((item) => {\\n                                            clearMyVar(item);\\n                                        });\\n                                        clearMyVar('cate_button');\\n\\n                                        params.cate_temp[params.index] = params.key.toString();\\n                                        putMyVar(\\\"head.cate\\\", JSON.stringify(params.cate_temp));\\n                                        if (params.json.constructor === Object) {\\n                                            putMyVar(\\\"dt_\\\" + params.json.type, params.json.value);\\n                                        } else {\\n                                            putMyVar(params.state, params.json);\\n                                        }\\n                                        refreshPage();\\n                                        return \\\"hiker://empty\\\";\\n                                    },\\n                                    params),\\n                                col_type: \\\"scroll_button\\\",\\n                                extra: {\\n                                    cls: MY_RULE.title + 'cate_button',\\n                                }\\n                            });\\n                        });\\n                        cates.push({\\n                            col_type: \\\"blank_block\\\",\\n                            extra: {\\n                                cls: MY_RULE.title + 'cate_button',\\n                            }\\n                        });\\n                    }\\n                });\\n            }\\n            if (fold === \\\"1\\\" || 折叠状态 == false) {\\n                items = items.concat(cates);\\n            }\\n            if (fold === \\\"0\\\") {\\n                storage0.putMyVar('cate_button', cates)\\n            }\\n            if (typeof setPreResult != 'undefined') {\\n                items = d.concat(items);\\n                //清空继承数组\\n                d.length = 0;\\n                setPreResult(items);\\n            } else {\\n                items.forEach(item => {\\n                    d.push(item);\\n                })\\n            }\\n        },\\n    };\\n    obj.预设(options);\\n    return obj;\\n}\\n\\nvar 状态 =\\n    typeof 状态标记 != \\\"undefined\\\" && 状态标记 != \\\"\\\" ? 状态标记 : MY_RULE.url;\\n\\nlet dt_debug = false;\\n\\naddListener(\\n    \\\"onClose\\\",\\n    $.toString(() => {})\\n);\\n\\nvar Create = {\\n    nextPage: function() {\\n        var result = false;\\n        try {\\n            var next = eval(下一页);\\n            //log('n:'+next)\\n            if (next == \\\"\\\") {\\n                throw new Error('下一页链接为空')\\n            }\\n            result = true;\\n            if (true_url == next) {\\n                result = false;\\n            }\\n        } catch (e) {\\n            //log(\\\"可能不存在下一页或者下一页定位有问题\\\");\\n            //log(\\\"错误信息:\\\" + e.message);\\n        }\\n        if ((next == \\\"\\\" || next == undefined) && page == 1) {\\n            next = true_url;\\n        } else {\\n            //result=false;\\n            next = getMyVar(状态);\\n        }\\n        //log('l'+true_url)\\n        //log('n'+next)\\n        if (page != 1) {\\n            if (true_url == next && !result) {\\n                result = false;\\n            } else {\\n                result = true;\\n            }\\n        }\\n        return result;\\n        //putMyVar(状态, next);\\n    },\\n    getBackImage: function(imgurl) {\\n        var result = imgurl;\\n        try {\\n            result = /url(?:\\\\s+)?\\\\((.*?)\\\\)/g\\n                .exec(imgurl)[1]\\n                .replace(/('|\\\"|&quot;)/gm, \\\"\\\");\\n        } catch {}\\n        return result;\\n    },\\n    httpHandle: function(input) {\\n        if (input.startsWith(\\\"http\\\")) {\\n            return input;\\n        } else if (input.startsWith(\\\"//\\\")) {\\n            return \\\"https:\\\" + input;\\n        } else if (input.startsWith(\\\"/\\\")) {\\n            return MY_HOME + input;\\n        }\\n    },\\n    imgHandle: function(item, rule) {\\n        var img = \\\"\\\";\\n        if (rule.img.startsWith(\\\"pd\\\")) {\\n            img = eval(rule.img);\\n        } else if (rule.backimg) {\\n            img = pdfh(item, rule.img);\\n            img = this.getBackImage(img);\\n            img = this.httpHandle(img);\\n        } else {\\n            img = pdfh(item, rule.img);\\n            if (!img.startsWith(\\\"http\\\")) {\\n                img = pd(item, rule.img);\\n                img = this.httpHandle(img);\\n            }\\n        }\\n        return img + rule.ref;\\n    },\\n    urlHandle: function(item, rule) {\\n        var href = \\\"\\\";\\n        if (rule.url.startsWith(\\\"pd\\\")) {\\n            href = eval(rule.url);\\n        } else {\\n            href = pd(item, rule.url);\\n        }\\n        href = rule.imt ? href + \\\"#immersiveTheme#\\\" : href;\\n        return href;\\n    },\\n    setContent: function(item, input) {\\n        let output = \\\"\\\";\\n        if (input == undefined) {\\n            return output;\\n        }\\n        if (input.startsWith(\\\"pd\\\")) {\\n            output = eval(input);\\n        } else {\\n            output = pdfh(item, input);\\n        }\\n        return output;\\n    },\\n    refresh: function() {\\n        addListener(\\n            \\\"onRefresh\\\",\\n            $.toString((u) => {\\n                clearMyVar(\\\"yilist\\\");\\n                //var p = storage0.getMyVar('spage', '');\\n                //putMyVar(u, p);\\n            }, 状态)\\n        );\\n    },\\n    getBooleanValue: function(value, defaultValue) {\\n        return value !== undefined ? Boolean(value) : (defaultValue !== undefined ? defaultValue : true);\\n    },\\n    debuglog: function(i, item, rule, obj) {\\n        log('----------' + (i + 1) + ':调试开始----------');\\n        if (item.constructor == Object) {\\n            item = JSON.stringify(item);\\n        }\\n        log('item内容:\\\\r\\\\n' + item + '\\\\r\\\\n' +\\n            `\\\\n\\\\ttitle定位:  ${rule.title}  ---> 结果:  ${obj.title}` +\\n            `\\\\n\\\\tdesc定位:  ${rule.desc}  ---> 结果:  ${obj.desc}` +\\n            `\\\\n\\\\timg定位:  ${rule.img}  ---> 结果:  ${obj.img}` +\\n            (rule.content != undefined ? `\\\\n\\\\tcontent定位:  ${rule.content}  ---> 结果:  ${obj.content}` : '') +\\n            `\\\\n\\\\turl定位:  ${rule.url}  ---> 结果:  ${obj.url}`\\n        );\\n        log('----------' + (i + 1) + ':调试结束----------');\\n    },\\n    jsonList: function(arr, json, rule) {\\n        if (json.constructor != Object) {\\n            try {\\n                json = JSON.parse(json);\\n            } catch {}\\n        }\\n        if (json[rule.list] == undefined) {\\n            arr.push({\\n                title: '““””<font color=\\\"grey\\\"><small>无内容</small></font>',\\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"text_center_1\\\",\\n                extra: {},\\n            });\\n            return;\\n        }\\n        var debug = this.getBooleanValue(rule.debug, false);\\n        var empty = this.getBooleanValue(rule.empty);\\n        if (debug) {\\n            log('定位列表:' + rule.list);\\n        }\\n        json[rule.list].forEach((item, i) => {\\n            var title = eval(rule.title);\\n            var desc = eval(rule.desc);\\n            var content = eval(rule.content);\\n            var img = eval(rule.img) + rule.ref;\\n            var href = eval(rule.url);\\n            var url = rule.imt ? href + \\\"#immersiveTheme#\\\" : href;\\n            var lazy = rule.lazy ? rule.lazy : \\\"\\\";\\n\\n            var dd = {\\n                title: title,\\n                desc: desc,\\n                content: content,\\n                pic_url: img,\\n                url: (empty ? \\\"hiker://empty##\\\" : '') + url,\\n                col_type: rule.col_type,\\n                extra: {\\n                    pageTitle: title,\\n                    img: img,\\n                },\\n            };\\n\\n            if (debug) {\\n                var rx = {\\n                    title,\\n                    desc,\\n                    img,\\n                    content,\\n                    url\\n                };\\n                this.debuglog(i, item, rule, rx);\\n            }\\n\\n            if (lazy != \\\"\\\") {\\n                dd[\\\"url\\\"] = href + lazy;\\n            }\\n            arr.push(dd);\\n        });\\n    },\\n    ruleList: function(arr, html, rule) {\\n        var list = pdfa(html,\\n            rule.list);\\n        var debug = this.getBooleanValue(rule.debug,\\n            false);\\n        var empty = this.getBooleanValue(rule.empty);\\n        if (debug) {\\n            log('定位列表:' + rule.list);\\n        }\\n        list.forEach((item, i) => {\\n            var title = this.setContent(item, rule.title);\\n            var desc = this.setContent(item, rule.desc);\\n            var desc1 = this.setContent(item, rule.desc1);\\n            var desc2 = this.setContent(item, rule.desc2);\\n            var img = this.imgHandle(item, rule);\\n            var url = this.urlHandle(item, rule);\\n            var content = this.setContent(item, rule.content);\\n\\n            if (debug) {\\n                var rx = {\\n                    title,\\n                    desc,\\n                    img,\\n                    content,\\n                    url\\n                };\\n                this.debuglog(i, item, rule, rx);\\n            }\\n\\n            var lazy = rule.lazy ? rule.lazy : \\\"\\\";\\n            var dd = {\\n                title: title,\\n                desc: desc1.replace(\\\"含中字磁鏈\\\",\\\"含中字\\\") + \\\"\\\\t\\\\t\\\" + desc,\\n                pic_url: img,\\n                url: (empty ? 'hiker://empty##' : '') + url + '#noHistory#@rule=js:$.require(\\\"ej\\\")',\\n                content: content,\\n                col_type: rule.col_type,\\n                extra: {\\n                    pageTitle: title,\\n                    img: img,\\n                                        longClick: [{\\n                        title: '【跳页】',\\n                        js: $.toString((true_url) => {\\n                            return $('', '1到81之间的的页码')\\n                                .input((true_url) => {\\n                                if (parseInt(input) > 1 && parseInt(input) < 81 && parseInt(input) % 1 == 0) {\\n                                    var jumpu = true_url.replace(/(\\\\?page=\\\\d+|\\\\&page=\\\\d+|$)/, (match) => {\\n                                        if (match.startsWith('?page=') || match.startsWith('&page=')) {\\n                                            return match.charAt(0) + 'page=' + input;\\n                                        } else {\\n                                            return (true_url.includes('?') ? '&page=' : '?page=') + input;\\n                                        }\\n                                    });\\n                                    putVar(MY_RULE.url, jumpu);\\n                                    putMyVar('yi_firstpage', jumpu);\\n                                    refreshPage(false);\\n                                    return 'toast://你已经穿越到了' + input + '页'\\n                                } else {\\n                                    return \\\"toast://请输入正确的页码\\\"\\n                                }\\n                            }, true_url)\\n                        },\\n                        true_url)\\n                    }]\\n                }\\n            };\\n            if (lazy != \\\"\\\") {\\n                dd[\\\"url\\\"] = url + lazy;\\n            }\\n            arr.push(dd);\\n        });\\n    },\\n    List: function(arr, html, rule, param) {\\n        param = param ? param : {};\\n        var auto = param.auto ? param.auto : false;\\n        var show = param.show ? param.show : false;\\n        if (page == 1) {\\n            //this.spage.set(true_url);\\n        }\\n        this.refresh();\\n        var debug = this.getBooleanValue(rule.debug, false);\\n        var empty = this.getBooleanValue(rule.empty);\\n        var list = pdfa(html, rule.list);\\n        if (debug) {\\n            log('定位列表:' + rule.list);\\n        }\\n        //log(this.nextPage())\\n        if ((storage0.getMyVar('yi_isnext', 't') == 't' && list.length > 0) || page == 1) {\\n            list.forEach((item, i) => {\\n                deleteItem(\\\"pagenum\\\");\\n                deleteItem(\\\"pageline\\\");\\n                var id = \\\"\\\";\\n                var cls = \\\"\\\";\\n                var title = this.setContent(item, rule.title);\\n                var desc = this.setContent(item, rule.desc);\\n                var img = this.imgHandle(item, rule);\\n                var url = this.urlHandle(item, rule);\\n                var content = this.setContent(item, rule.content);\\n\\n                if (debug) {\\n                    var rx = {\\n                        title,\\n                        desc,\\n                        img,\\n                        content,\\n                        url\\n                    };\\n                    this.debuglog(i, item, rule, rx);\\n                }\\n\\n                if (i == list.length - 1) {\\n                    id = \\\"lastid_\\\" + page;\\n                    cls = \\\"lastmark\\\";\\n                }\\n                d.push({\\n                    title: title,\\n                    desc: desc,\\n                    pic_url: img,\\n                    url: (empty ? \\\"hiker://empty##\\\" : '') + url + '?page=fypage#noHistory#@rule=js:$.require(\\\"yj\\\")',\\n                    content: content,\\n                    col_type: rule.col_type,\\n                    extra: {\\n                        pageTitle: title,\\n                        img: img,\\n                        id: id,\\n                        cls: cls,\\n                        longClick: [{\\n                        title: '【跳页】',\\n                        js: $.toString((true_url) => {\\n                            return $('', '1到31之间的的页码')\\n                                .input((true_url) => {\\n                                if (parseInt(input) > 1 && parseInt(input) < 81 && parseInt(input) % 1 == 0) {\\n                                    var jumpu = true_url.replace(/(\\\\?page=\\\\d+|\\\\&page=\\\\d+|$)/, (match) => {\\n                                        if (match.startsWith('?page=') || match.startsWith('&page=')) {\\n                                            return match.charAt(0) + 'page=' + input;\\n                                        } else {\\n                                            return (true_url.includes('?') ? '&page=' : '?page=') + input;\\n                                        }\\n                                    });\\n                                    putVar(MY_RULE.url, jumpu);\\n                                    putMyVar('yi_firstpage', jumpu);\\n                                    refreshPage(false);\\n                                    return 'toast://你已经穿越到了' + input + '页'\\n                                } else {\\n                                    return \\\"toast://请输入正确的页码\\\"\\n                                }\\n                            }, true_url)\\n                        },\\n                        true_url)\\n                    }]\\n                    },\\n                });\\n                if (i == list.length - 1 && show) {\\n                    d.push({\\n                        col_type: \\\"line\\\",\\n                        extra: {\\n                            id: \\\"pageline\\\",\\n                        },\\n                    });\\n\\n                    d.push({\\n                        title: \\\"““””<small>加载中...</small>\\\",\\n                        url: \\\"hiker://empty\\\",\\n                        col_type: \\\"text_center_1\\\",\\n                        extra: {\\n                            id: \\\"pagenum\\\",\\n                        },\\n                    });\\n                }\\n            });\\n        } else {\\n            updateItem(\\\"pagenum\\\", {\\n                title: '““””<font color=\\\"grey\\\"><small>到底了</small></font>',\\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"text_center_1\\\",\\n                extra: {\\n                    id: \\\"last\\\",\\n                },\\n            });\\n        }\\n/*\\n        if (list.length == 0 && page == 1) {\\n            d.push({\\n                col_type: \\\"line\\\",\\n            });\\n            d.push({\\n                title: '““””<font color=\\\"grey\\\"><small>无内容</small></font>',\\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"text_center_1\\\",\\n                extra: {},\\n            });\\n        }*/\\n        if (this.nextPage()) {\\n            //log('t');\\n            storage0.putMyVar('yi_isnext', 't');\\n        } else {\\n            //log('f');\\n            storage0.putMyVar('yi_isnext', 'f');\\n        }\\n        if (auto) {\\n            //createNextPage();\\n            autoPage();\\n        }\\n    },\\n};\\n\\nvar extMethod = {\\n    ToParams: function() {\\n        var json = arguments[0];\\n        return Object.keys(json)\\n            .map((key) => key + \\\"=\\\" + json[key])\\n            .join(\\\"&\\\");\\n    },\\n    urlParse: function(u) {\\n        var dict = {};\\n        dict.Source = u;\\n        let params = (url) => {\\n            let queryParams = {};\\n            let reg = /([^?=&]+)=([^?=&]+)/g;\\n            url.replace(reg, function() {\\n                queryParams[arguments[1]] = arguments[2];\\n            });\\n            return queryParams;\\n        };\\n        var javaUrl = JavaImporter(java.net.URL);\\n        with(javaUrl) {\\n            var url = new URL(u);\\n            dict.Protocol = url.getProtocol();\\n            dict.Host = url.getHost();\\n            dict.Port = url.getPort();\\n            dict.File = url.getFile();\\n            dict.Path = url.getPath();\\n            dict.Ref = url.getRef();\\n            dict.Hosts = `${dict.Protocol}://${url.getHost()}`;\\n        }\\n        dict.Params = params(u);\\n        return dict;\\n    },\\n    isEqual: function(x, y) {\\n        const ok = Object.keys,\\n            tx = typeof x,\\n            ty = typeof y;\\n        return x && y && tx === \\\"object\\\" && tx === ty ?\\n            ok(x).length === ok(y).length &&\\n            ok(x).every((key) => this.isEqual(x[key], y[key])) : x === y;\\n    },\\n    findDifferentIndex: function(str1, str2) {\\n        const diffChars = [];\\n        for (let i = 0; i < str2.length; i++) {\\n            if (str1[i] !== str2[i]) {\\n                diffChars.push({\\n                    index: i,\\n                    s1: str1[i],\\n                    s2: str2[i],\\n                });\\n            }\\n        }\\n        return diffChars;\\n    },\\n    replaceCharAt: function(str, index, replacement) {\\n        if (index < 0 || index >= str.length) {\\n            return str;\\n        }\\n        //log(index)\\n        const arr = str.split(\\\"\\\");\\n        arr[index] = replacement;\\n        return arr.join(\\\"\\\");\\n    },\\n    getObjectKeysDiff: function(obj1, obj2) {\\n        const differentKeys = [];\\n        for (let key in obj1) {\\n            if (!obj2.hasOwnProperty(key) || obj1[key] !== obj2[key]) {\\n                differentKeys.push(key);\\n            }\\n        }\\n        for (let key in obj2) {\\n            if (!obj1.hasOwnProperty(key)) {\\n                differentKeys.push(key);\\n            }\\n        }\\n        return differentKeys;\\n    },\\n    getNextUrl: function(source, target, params) {\\n        var u1 = this.urlParse(source);\\n        var u2 = this.urlParse(target);\\n        var pa = undefined;\\n        if (typeof params == \\\"object\\\") {\\n            pa = params.hasOwnProperty(\\\"特征\\\") ? params.特征 : undefined;\\n        }\\n        var nexturl = source;\\n        var ca = Object.keys(u2.Params).length == 0 ? \\\"\\\" : \\\"?\\\";\\n        if (pa != undefined) {\\n            var rs = String(u2.Path).replace(new RegExp(pa), \\\"$1fypage\\\");\\n            nexturl = u2.Hosts + rs + ca + this.ToParams(u2.Params);\\n        } else {\\n            if (this.isEqual(u1.Params, u2.Params)) {\\n                if (dt_debug) {\\n                    log(u1.Path);\\n                    log(u2.Path);\\n                }\\n                var df = this.findDifferentIndex(String(u1.Path), String(u2.Path));\\n                if (dt_debug) {\\n                    log(df);\\n                }\\n                if (df.length == 1) {\\n                    var re = df[0].index;\\n                } else {\\n                    var f = df.filter((x) => /\\\\d+/.test(x.s2));\\n                    var re = f[0].index;\\n                }\\n                var eq = this.replaceCharAt(String(u2.Path), re, \\\"fypage\\\");\\n                nexturl = u2.Hosts + eq + ca + this.ToParams(u2.Params);\\n            } else {\\n                var ep = this.getObjectKeysDiff(u1.Params, u2.Params)\\n                if (ep.length == 1) {\\n                    u1.Params[ep[0]] = 'fypage'\\n                } else {\\n                    log(ep);\\n                }\\n                var eq = String(u1.Path).replace(/\\\\d+/, \\\"fypage\\\");\\n                nexturl = u1.Hosts + eq + ca + this.ToParams(u1.Params);\\n            }\\n        }\\n        //log('next:'+nexturl)\\n        return nexturl;\\n    },\\n};\\n\\nfunction getTruelink(mark, url, page) {\\n    var p = getMyVar(mark, url).replace(\\\"fypage\\\", page);\\n    if (page == 1) {\\n        return getMyVar(\\\"yi_firstpage\\\", p);\\n    } else if (p != \\\"\\\") {\\n        return p;\\n    } else {\\n        return url;\\n    }\\n}\\n//构建\\nfunction createNextPage() {\\n    let startnum = 1;\\n    var obj = arguments[0];\\n    if (true_url != getMyVar(\\\"yi_pageurl\\\", \\\"\\\")) {\\n        clearMyVar(\\\"yi_pageurl\\\");\\n    }\\n    if (page == startnum && getMyVar(\\\"yi_pageurl\\\") == \\\"\\\") {\\n        putMyVar(\\\"yi_firstpage\\\", true_url);\\n        try {\\n            var next = eval(下一页);\\n            //log(\\\"next\\\");\\n            //log(next);\\n        } catch {\\n            log(\\\"可能不存在下一页或者下一页定位有问题\\\");\\n            next = \\\"\\\";\\n        }\\n        if (next != \\\"\\\") {\\n            var nxurl = extMethod.getNextUrl(true_url, next, obj);\\n            //log(\\\"nxurl:\\\" + nxurl);\\n            putMyVar(状态, nxurl);\\n            putMyVar(\\\"yi_pageurl\\\", nxurl);\\n        }\\n    }\\n}\\n\\nfunction autoPage() {\\n    if (page == 1) {\\n        putMyVar(\\\"yi_firstpage\\\", true_url);\\n    }\\n    try {\\n        var next = eval(下一页);\\n        //log(\\\"next\\\");\\n        //log('next:'+next);\\n    } catch {\\n      //  log(\\\"可能不存在下一页或者下一页定位有问题\\\");\\n        next = \\\"没有下一页哦😐\\\";\\n    }\\n    if (next != \\\"\\\") {\\n        putMyVar(状态, next);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"③二级外部解析\",\"path\":\"tool\",\"rule\":\"\\n   var codelazy = fetch('hiker://files/rules/Apollo/𝐂𝐨𝐝𝐞𝐋𝐚𝐳𝐲.js') || \\\"\\\";\\n\\n   function downcode() {\\n       var js = fetch(\\\"https://raw.githubusercontent.com/ApolloRioo/R/master/𝐂𝐨𝐝𝐞𝐋𝐚𝐳𝐲\\\");\\n       writeFile('hiker://files/rules/Apollo/𝐂𝐨𝐝𝐞𝐋𝐚𝐳𝐲.js', js);\\n       toast(\\\"远程数据已更新到本地\\\")\\n       codelazy = fetch('hiker://files/rules/Apollo/𝐂𝐨𝐝𝐞𝐋𝐚𝐳𝐲.js')\\n   }\\n   if (!codelazy) {\\n       downcode()\\n   }\\n   try {\\n       eval(codelazy)\\n   } catch {\\n       downcode()\\n       eval(codelazy)\\n       log(\\\"读取失败更新远程数据\\\")\\n   }\\n   CodeLazy(识别码)\"},{\"col_type\":\"movie_3\",\"name\":\"解析\",\"path\":\"lazy\",\"rule\":\"var lazy = $('').lazyRule((MY_HOME) => {\\n    var inp = fetch(input,{}); \\n    return \\\"pics://\\\"+pdfa(inp, '.preview-images&&a,1:').map(img =>pd(img, 'a&&href')+\\\"@Referer=\\\",).join(\\\"&&\\\")  \\n},MY_HOME)\"},{\"col_type\":\"movie_3\",\"name\":\"①一级页面内容\",\"path\":\"yj\",\"rule\":\"js:\\nvar d = [];\\n\\naddListener(\\\"onClose\\\", () => {\\n        clearMyVar(\\\"url\\\");\\n        clearMyVar(\\\"nextPage\\\");\\n        clearItem('now')\\n        clearItem('no')\\n        clearItem('pages')\\n});\\naddListener(\\\"onRefresh\\\", () => {\\n    clearMyVar(\\\"url\\\");\\n    clearMyVar(\\\"nextPage\\\");\\n    clearItem('now');\\n    clearItem('no');\\n    clearItem('pages')\\n});\\n\\nMY_URL=MY_URL.replace('hiker://empty##','');\\nlet true_url = getMyVar(\\\"url\\\", MY_URL);\\nconst page = MY_PAGE;\\n//获取上次缓存的下页链接\\nlet nextPage = getMyVar(\\\"nextPage\\\", \\\"\\\");\\n//如果有下一页且不是第一页就使用下一页链接\\nif (nextPage && MY_PAGE > 1) {\\n    true_url = nextPage;\\n}\\nlog(true_url);\\n//var html = request(true_url);\\nvar html = fetch(true_url, {\\n    headers: {\\n        cookie: fetchPC('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt') || '',\\n        \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\\\",      \\n    },\\n    redirect: false\\n});\\nif (/Just\\\\sa\\\\smoment/.test(html)) {\\nd.push({\\n        title: '““””' + '获取cookie'.fontcolor('#FF00FF').big(),\\n        url: true_url + $('').rule(() => {\\n            var d = [];\\n            d.push({\\n                col_type: 'x5_webview_single',\\n                url: MY_URL,\\n                desc: 'list&&screen',\\n                extra: {\\n                    \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\\\",//PC_UA,             \\n                    showProgress: false,\\n                    js: $.toString((u) => {\\n                        function check() {\\n                            //let nodes = document.querySelectorAll('#tags');\\n                            var co = fba.getCookie(u);\\n//var ua = fba.getUa()\\n//fba.log('co::::::' + ua);\\n                          //  fba.log('co::::::' + co);\\nvar htmlContent = document.documentElement.innerHTML;\\n\\nif(/永久域名/.test(htmlContent)) {\\n  \\n                           \\n                                fba.parseLazyRule($$$().lazyRule((co) => {\\n                                    writeFile('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt', co);\\n                                    toast('已获取cookie，切换到首页');\\n                                    back(true);\\n                                }, co));\\n                            } else {\\n                                setTimeout(check, 500);\\n                            }\\n                        }\\n                        check();\\n                    }, MY_URL)\\n                }\\n            });\\n            return setResult(d);\\n        }),\\n        col_type: 'text_center_1'\\n    });\\n}\\ntry {\\n    //缓存下一页\\n    let nextUrl = pd(html, \\\"a:contains(下一)&&href\\\");\\n    putMyVar(\\\"nextPage\\\", nextUrl || \\\"hiker://empty\\\");\\n    //log(\\\"下一页：\\\" + nextUrl)\\n} catch (e) {\\n    //clearMyVar(\\\"nextPage\\\");\\n    let nextUrl = \\\"hiker://empty\\\";\\n    toast(\\\"好像没有下一页了！\\\");\\n}\\n\\nvar pages;\\nif(MY_PAGE==1 && !true_url.includes(\\\"search\\\")){\\n//演员图\\ntry{\\n  try{\\n    var img =  pdfh(html,\\\".section-columns&&.image&&.avatar&&style\\\");\\n    }catch{ \\n    var img = \\\"https://thumbsnap.com/i/sySMQ7Mg.jpg\\\";}\\nvar 描述1 = pdfh(html, \\\".section-columns&&h2--.section-meta,-1&&Text\\\");\\nvar 描述2 = pdfh(html, \\\".section-columns&&h2&&.section-meta,-1&&Text\\\");\\nvar num = 描述2.match(/\\\\d+/)[0] || '1'\\nvar pages = Math.floor(num / 40);\\nif (num % 40 !== 0) {\\n  pages += 1;\\n}\\n\\nvar listActors = JSON.parse(fetchPC('hiker://files/rules/apollo/javdb/javdb_actor.txt') || '[]');\\nvar str = 描述1 + '@@' + img + '@@' + pdfh(html,'link[rel=canonical]&&href') + '?page=fypage';\\nif (listActors.indexOf(str) == '-1') {\\n    var t = '<b><small><font color=#1E90FF>🤍未收藏🤍</font></small>'\\n} else {\\n    var t = '<b><small><font color=#FF00FF>💝已收藏💝</font></small>'\\n}\\n\\n    d.push({\\n        title: \\\"JavDB\\\",\\n        desc: \\\"0\\\",\\n        img: img,\\n        url: 'copy://' + 描述1 + ',hiker://page/yj?url=' + MY_URL.replace(/\\\\/\\\\/\\\\w+\\\\./,'//javdb.').replace('page=1','page=fypage') + '&rule=𝐉𝐚𝐯𝐃𝐁,' + img,\\n        col_type: \\\"card_pic_2\\\",\\n         })\\n     d.push({\\n    title: '‘‘’’<b><small><font color=\\\"#fe5c4b\\\">离思五首·其四·唐·元稹\\\\n\\\\t\\\\t\\\\t\\\\t曾经沧海难为水，\\\\n\\\\t\\\\t\\\\t\\\\t除却巫山不是云。\\\\n\\\\t\\\\t\\\\t\\\\t取次花丛懒回顾，\\\\n\\\\t\\\\t\\\\t\\\\t半缘修道半缘君。\\\\n</font></small><b><small><font color=\\\"cyan\\\"> ' + 描述1.slice(0,13) + '</font></small><b><small><font color=\\\"#1E90FF\\\">\\\\n ' + 描述2 + '\\\\t\\\\t</font></small>' + t + '<b><small><font color=\\\"#FFE100\\\">\\\\n也许有' + pages + '页，没骗你吧</font></small>',\\n    desc: '0',\\n    //img: 'hiker://empty',\\n    col_type: \\\"card_pic_2\\\",\\n    url: $('#noLoading#').lazyRule((name) => {\\n                var str = fetchPC('hiker://files/rules/apollo/javdb/javdb_actor.txt');\\n                if (!str) {\\n                    var list = [name];\\n                    writeFile('hiker://files/rules/apollo/javdb/javdb_actor.txt', JSON.stringify(list));\\n                } else {\\n                    var list = JSON.parse(str);\\n                    if (list.indexOf(name) == '-1') {\\n                       // list.push(name);\\n                        list.unshift(name);\\n                        writeFile('hiker://files/rules/apollo/javdb/javdb_actor.txt', JSON.stringify(list));\\n                    }else{\\n                      var index = list.indexOf(name);\\n                      list.splice(index, 1);\\n                      writeFile('hiker://files/rules/apollo/javdb/javdb_actor.txt', JSON.stringify(list));\\n                      }\\n                }\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, str),\\n    extra: {\\\"gradient\\\":true}\\n});\\n    }catch{}\\n       if (typeof pages !== 'undefined' && pages !== null) {\\n          setItem('pages', pages.toString());\\n         } \\n\\n//演员分类\\n   try{\\n        var category = pdfa(html,\\\".actor-tags&&.tag\\\")\\n        for(var j in category){\\n      category[j] = category[j].replace(/button/g,'a').replace(\\\"onclick\\\",\\\"href\\\").replace(\\\"window.location.href=\\\",\\\"\\\").replace(/\\\\'/g,\\\"\\\").replace(\\\"javascript:;\\\",true_url)\\n}\\n\\n       category.forEach((item,index)=>{\\n           var title = pdfh(item,\\\"Text\\\");\\n           var url = pd(item,\\\"a&&href\\\");\\n           url = url.includes('?page')?url:(url.includes('?')?url + \\\"&page=1\\\":url + \\\"?page=1\\\")\\n           d.push({\\n               title: item.includes(\\\"is-link\\\") ? '““””' + title.fontcolor('cyan') + \\\"♈️\\\": title,\\n               url: url + $('').lazyRule((title) => {                  \\n                   putMyVar(\\\"url\\\", input);\\n                   refreshPage();\\n                   return 'hiker://empty';\\n     },title),\\n            col_type: \\\"scroll_button\\\",\\n            extra: { 'backgroundColor': '#666666'}\\n                })\\nif(index==4){\\n    d.push({col_type: \\\"blank_block\\\"})\\n}\\n         })\\n        }catch{}\\n //分割\\n    d.push({\\n      col_type: \\\"blank_block\\\"\\n        })\\n}\\n\\nif(!true_url.includes(\\\"search\\\")){\\nvar pages = getItem('pages');\\n}\\ntry{\\nlet now = getItem('now');\\nif(pages>1&&pages<37){\\nfor (var j = 1; j <= pages; j ++){\\nvar url = true_url.replace(/page=\\\\d+/, 'page='+j);\\n    d.push({\\n        title: j ==MY_PAGE || now ==( j + '页')? '““””' + (j + '页').fontcolor('red') : (j + '页'),\\n        url:$(url).lazyRule((j) => {\\n            setItem(\\\"now\\\",( j + '页'));\\n            putMyVar(\\\"url\\\", input);\\n            refreshPage();\\n            return 'hiker://empty';\\n     },j),\\n        col_type: 'scroll_button',\\n})\\n}\\n}else if(pages>37){\\nfor (var j = 1; j <= 61; j +=(j==1)?2:3){\\nvar url = true_url.replace(/page=\\\\d+/, 'page='+j);\\n    d.push({\\n        title: j ==MY_PAGE || now ==( j + '页')? '““””' + (j + '页').fontcolor('red') : (j + '页'),\\n        url:$(url).lazyRule((j) => {\\n            setItem(\\\"now\\\",( j + '页'));\\n            putMyVar(\\\"url\\\", input);\\n            refreshPage();\\n            return 'hiker://empty';\\n     },j),\\n        col_type: 'scroll_button',\\n})\\n}\\n}\\n}catch{}\\n\\n\\nlet list = pdfa(html, 'body&&.item');\\nif(list.length>0){\\nlist.forEach(x => {   \\nlet img = !true_url.includes(\\\"search\\\") ? pd(x,'img||a&&src||data-original') : pd(x,'img||a&&src||data-original').replace(\\\"covers\\\",\\\"thumbs\\\");\\n d.push({\\n    title: pdfh(x, '.video-title&&Text'),\\n    desc: pdfh(x,'.meta&&Text'),\\n    img: img,\\n    url: 'hiker://page/ej?url='+pd(x, 'a&&href')+'#noHistory#',\\n    col_type: img.includes(\\\"/thumbs/\\\")?'movie_3':'movie_2',\\n    extra: {\\npageTitle: pdfh(x, '.video-title&&Text'),\\nimg:img,\\nlongClick: [{\\n    title: '【跳页】',\\n    js: $.toString((true_url) => {\\n        return $('', '1到81之间的的页码')\\n            .input((true_url) => {\\n            if (parseInt(input) > 1 && parseInt(input) < 81 && parseInt(input) % 1 == 0) {\\n                var jumpu = true_url.replace(/(\\\\?page=\\\\d+|\\\\&page=\\\\d+|$)/, (match) => {\\n                    if (match.startsWith('?page=') || match.startsWith('&page=')) {\\n                        return match.charAt(0) + 'page=' + input;\\n                    } else {\\n                        return (true_url.includes('?') ? '&page=' : '?page=') + input;\\n                    }\\n                });\\n                putMyVar(\\\"url\\\", jumpu);              \\n                refreshPage(false);\\n                return 'toast://你已经穿越到了' + input + '页'\\n            } else {\\n                return \\\"toast://请输入正确的页码\\\"\\n            }\\n        }, true_url)\\n    },\\n    true_url)\\n}]\\n}\\n  });\\n})\\n}else{\\n/*\\n  function getBigText(text, count) {\\n    if (count > 0) {\\n        for (let i = 0; i < count; i++) {\\n            text = text.big();\\n        }\\n    } else {\\n        for (let i = 0; i < -count; i++) {\\n            text = text.small();\\n        }\\n    }\\n    return text;\\n    }\\nd.push({\\n    title: \\\"““””\\\"+getBigText(\\\"<big><font color='#FEBD6F'>已经超过了最终页码</font></big><br><small><font color='#FB6C73'>不信点击打开网页</font></small>\\\", 5),\\n    col_type: 'text_center_1',\\n    url: $('#noLoading#').lazyRule((true_url) => {\\nreturn true_url\\n     },true_url),\\n    extra:{lineVisible:false}\\n    })\\n*/\\n}\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"②二级页面内容\",\"path\":\"ej\",\"rule\":\"js:\\n        addListener(\\\"onClose\\\", () => {\\n            clearMyVar(\\\"piclist\\\");          \\n        });\\nvar getRangeColors = function() {\\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\n}\\n\\nvar d = []\\nMY_URL=MY_URL.replace('hiker://empty##','');\\nlog(MY_URL)\\n//var html = fetch(MY_URL);\\nvar html = fetch(MY_URL, {\\n    headers: {\\n        cookie: fetchPC('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt') || '',\\n        \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\\\",      \\n    },\\n    redirect: false\\n});\\n\\nif (/Just\\\\sa\\\\smoment/.test(html)) {\\nd.push({\\n        title: '““””' + '获取cookie'.fontcolor('#FF00FF').big(),\\n        url: MY_URL + $('').rule(() => {\\n            var d = [];\\n            d.push({\\n                col_type: 'x5_webview_single',\\n                url: MY_URL,\\n                desc: 'list&&screen',\\n                extra: {\\n                    \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\\\",//PC_UA,             \\n                    showProgress: false,\\n                    js: $.toString((u) => {\\n                        function check() {\\n                            //let nodes = document.querySelectorAll('#tags');\\n                            var co = fba.getCookie(u);\\n//var ua = fba.getUa()\\n//fba.log('co::::::' + ua);\\n                            //fba.log('co::::::' + co);\\nvar htmlContent = document.documentElement.innerHTML;\\n\\nif(/永久域名/.test(htmlContent)) {\\n  \\n                           \\n                                fba.parseLazyRule($$$().lazyRule((co) => {\\n                                    writeFile('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt', co);\\n                                    toast('已获取cookie，切换到首页');\\n                                    back(true);\\n                                }, co));\\n                            } else {\\n                                setTimeout(check, 500);\\n                            }\\n                        }\\n                        check();\\n                    }, MY_URL)\\n                }\\n            });\\n            return setResult(d);\\n        }),\\n        col_type: 'text_center_1'\\n    });\\n}\\n\\ntry{\\nvar title = pdfh(html,'h2&&strong&&Text') + ' ' + pdfh(html,'h2&&.current-title&&Text');\\nvar desct = pdfh(html,'h2&&.current-title&&Text');\\n   if(title !==null && !title.includes(\\\"開通VIP \\\")){\\n    d.push({\\n        title: '““””<small><font color=#E57A1A>'+title+'</font></small>',\\n        url: \\\"hiker://empty\\\" + $('#noLoading#').lazyRule((desct) => {\\n//动态刷新\\nvar desc = findItem('transdesc').desc\\n          if(!desc){\\n    var translates = $.require(\\\"trans\\\").translate(desct)\\n      updateItem(\\\"transdesc\\\",{\\n          desc: '““””'+translates.fontcolor(\\\"red\\\"),\\n})\\n}else{\\nupdateItem(\\\"transdesc\\\",{\\n          desc: '',\\n})\\n}       \\n                   return \\\"hiker://empty\\\"      \\n/*       \\n          var translates = $.require(\\\"trans\\\").translate(desct)   \\n          return \\\"confirm://\\\" + translates + \\\".js:'hiker://empty' \\\"   */\\n                },desct),\\n        col_type: 'text_1',\\n        extra: {\\n                lineVisible: false,\\n                id: 'transdesc',\\n                longClick: [{title: '网页', js: $.toString(()=>{ \\n        return \\\"web://\\\" + MY_URL\\n                       })},{title: '复制', js: $.toString((title)=>{ \\n        return \\\"copy://\\\" + title;\\n                       },title)},{title: '百度翻译', js: $.toString((title)=>{ \\n        return \\\"x5://https://fanyi.baidu.com/#jp/zh/\\\" + title\\n                       },title)},{title: 'Deepl翻译', js: $.toString((title)=>{ \\n        return \\\"x5://https://www.deepl.com/zh/translator-mobile#ja/zh/\\\" + title\\n                       },title)},{title: '谷歌翻译', js: $.toString((title)=>{ \\n        return \\\"x5://https://translate.google.com/?hl=zh-CN&sl=ja&tl=zh-CN&text=\\\" + title\\n                       },title)}]\\n}\\n    })\\n}\\n\\n//setPageTitle(title) //fc页面获取标题\\n\\nvar 识别码 = pdfh(html, 'body&&.first-block&&.value&&Text').toLowerCase();\\nvar pageUrl = pdfh(html,'link[rel=canonical]&&href');\\nvar img = pd(html,'.column-video-cover&&img&&src');\\nvar pics = pdfa(html,\\\".preview-images&&.tile-item,1:n\\\").map(item=>pdfh(item,\\\"a&&href\\\"))\\n//var img = MY_PARAMS.img;\\n        d.push({\\n             img: img,\\n             url: \\\"copy://\\\" + img,\\n             col_type: 'pic_1_full',\\n             extra:{\\n                lineVisible:false,\\n                longClick: [{title: 'DMM', js: $.toString((识别码)=>{\\n            return \\\"https://pics.dmm.co.jp/mono/movie/adult/\\\" + 识别码.replace(/-|_/,'') + '/' + 识别码.replace(/-|_/,'') + \\\"pl.jpg\\\"\\n                       },识别码)},{title: '图片预览', js: $.toString((pics)=>{                    \\n                    return pics !=\\\"\\\" ? \\\"pics://\\\"+pics.join(\\\"&&\\\") : \\\"toast://没有图片预览哦😐\\\"\\n                       },pics)},{title: '打开图片', js: $.toString((img)=>{ \\n        return img\\n                       },img)},{title: '复制页面', js: $.toString((img,title,pageUrl)=>{ \\n        return \\\"copy://\\\"+ title + \\\",hiker://page/ej?url=\\\" + pageUrl +\\\"&rule=𝐉𝐚𝐯𝐃𝐁,\\\" + img\\n                       },img,title,pageUrl)}]\\n             }\\n                  });\\n\\neval(JSON.parse(fetch('hiker://page/yiyan', {})).rule);\\n\\nvar score = pdfh(html,\\\".panel&&.panel-block:matches(評分:)&&Text\\\")\\nvar star = pdfa(html,\\\".panel&&.panel-block:matches(評分:)&&i:not(.gray)\\\")\\nvar arr = []\\nfor (let i = 0; i < 5; i++) {\\nif(i<star.length){\\n    arr.push('🔥');\\n  } else {\\n    arr.push('🥶');\\n  }\\n}\\nvar scores = score.match(/由(\\\\d+)人評價/) ? score.match(/由(\\\\d+)人評價/)[1].toString() : \\\"223\\\"\\nd.push({\\ntitle: scores < 300 ? '““””' + day_say.split(\\\"\\\").map(b=>b.fontcolor(getRangeColors()).small()).join(\\\"\\\") : \\\"““””評分：\\\" + arr.join(\\\"\\\") + \\\"\\\\t\\\\t\\\" +  score.replace(\\\"評分:\\\",\\\"\\\").fontcolor(\\\"#DBDBDB\\\"),\\nurl: $('').lazyRule((pics) => {                   \\n                    return pics !=\\\"\\\" ? \\\"pics://\\\"+pics.join(\\\"&&\\\") : \\\"confirm://没有图片预览哦😐.js:'hiker://empty' \\\"           \\n                },pics),\\ncol_type: \\\"text_1\\\",\\nextra:{lineVisible:false}\\n})\\n\\n//外部资源调用\\neval(JSON.parse(fetch('hiker://page/tool', {})).rule);\\n\\nd.push({\\n    col_type: 'blank_block'\\n})\\n\\n        try {\\n               var list = pdfa(html, \\\".preview-images&&.tile-item,1:\\\")\\n          //  if (list.length<1) {\\nd.push({\\n    col_type: 'big_blank_block'\\n},{\\n    col_type: 'big_blank_block'\\n})\\n//}\\n            if (list.length>0) {\\n                var picnum = \\\"\\\";\\n                d.push({\\n                    title: '““””' + (picnum + list.length +\\\" P\\\").fontcolor(\\\"#1E90FF\\\").small(),\\n                    col_type: \\\"scroll_button\\\",\\n                    extra: {\\n                        lineVisible: false,                      \\n                    },\\n                    url: \\\"hiker://empty\\\" + $(\\\"\\\")\\n                        .lazyRule((list) => {\\n                        try {\\n                            if (getMyVar(\\\"piclist\\\", \\\"收起\\\") == \\\"收起\\\") {\\n                                addItemAfter('picnum', {\\n                                    title: '““””' + \\\"【收起图片】\\\".fontcolor(\\\"#FF00FF\\\"),\\n                                    url: \\\"hiker://empty\\\" + $(\\\"\\\")\\n                                        .lazyRule((list) => {\\n                                        for (var i = list.length - 1; i >= 0; i--) {\\n                                            deleteItem('previewpic' + i);\\n                                        }\\n                                        deleteItem('nopiclist');\\n                                        putMyVar(\\\"piclist\\\", \\\"收起\\\");\\n                                        return \\\"hiker://empty\\\"\\n                                    }, list),\\n                                    col_type: \\\"text_center_1\\\",\\n                                    extra: {\\n                                        lineVisible: false,\\n                                        id: \\\"nopiclist\\\"\\n                                    }\\n                                })\\n                                for (var i = list.length - 1; i >= 0; i--) {\\n                                    addItemAfter('picnum', {\\n                                        url: 'hiker://empty',\\n                                        img: pdfh(list[i], \\\"a&&href\\\"),\\n                                        col_type: \\\"pic_1_full\\\",\\n                                        extra: {\\n                                            id: 'previewpic' + i\\n                                        }\\n                                    });\\n                                }\\n                                putMyVar(\\\"piclist\\\", \\\"展开\\\");\\n                            } else {\\n                                for (var i = list.length - 1; i >= 0; i--) {\\n                                    deleteItem('previewpic' + i);\\n                                }\\n                                deleteItem('nopiclist');\\n                                putMyVar(\\\"piclist\\\", \\\"收起\\\");\\n                            }\\n                            return \\\"hiker://empty\\\"\\n                        } catch {\\n                            return \\\"hiker://empty\\\"\\n                        }\\n                    }, list),                   \\n                })\\n            }\\n        } catch {}\\n\\nvar listVideos = JSON.parse(fetchPC('hiker://files/rules/apollo/javdb/javdb_video.txt') || '[]');\\nvar str = title + '@@' + img + '@@' + pageUrl;\\nif (listVideos.indexOf(str) == '-1') {\\n    var t = '““””<b><font color=#FFE100>💛未收藏💛'\\n} else {\\n    var t = '““””<b><font color=#FF00FF>💖已收藏💖'\\n}\\n\\nlet info = pdfa(html, '.panel&&.panel-block:matches(番號|日期|時長)');\\ninfo.forEach((list, index) => {\\n    d.push({\\n        title: index == 0 ? '““””' + pdfh(list, 'strong&&Text').fontcolor('#FFE100') : pdfh(list, 'strong&&Text'),\\n        url: index == 0 ? \\\"copy://\\\" + 识别码.toUpperCase() : 'hiker://empty',\\n        col_type: 'scroll_button',\\n    });\\n    d.push({\\n        title: index == 0 ? (pdfa(list, '.value&&a').length > 0 ? ( '““””<font color=#FFE100>' + pdfh(list, '.value&&a&&Text') + '</font>' + '““””<font color=green>' + pdfh(list, '.value--a&&Text') + '</font>' ) : '““””<font color=#FFE100>' + pdfh(list, '.value&&Text') + '</font>') : pdfh(list, '.value&&Text'),\\n        url: index == 0 ? (pd(html, '.video-detail&&.first-block&&a&&href') ? pd(html, '.video-detail&&.first-block&&a&&href') + '?page=fypage&sort_type=5@rule=js:$.require(\\\"hiker://page/yj\\\")' : \\\"hiker://empty\\\" ): 'hiker://empty',\\n        col_type: \\\"scroll_button\\\",\\n        extra: index == 0 ? {\\n            pageTitle: \\\"番号系列：\\\" + pdfh(html, '.video-detail&&.first-block&&a&&Text'),\\n            longClick: [{\\n                title: '谷歌搜索',\\n                js: $.toString((识别码) => {\\n                    return \\\"https://www.google.com/search?q=\\\" + 识别码;\\n                }, 识别码)\\n            }, {\\n                title: '磁力搜标题',\\n                js: $.toString((title) => {\\n                    return \\\"hiker://page/sou?rule=磁力君.简&p=fypage&searchTerms=\\\" + title\\n                }, title)\\n            }]\\n        } : ''\\n    });\\n    if (index == 0) {\\n        d.push({\\n            title: t,\\n            url: $('#noLoading#').lazyRule((name) => {\\n                var str = fetchPC('hiker://files/rules/apollo/javdb/javdb_video.txt');\\n                if (!str) {\\n                    var list = [name];\\n                    writeFile('hiker://files/rules/apollo/javdb/javdb_video.txt', JSON.stringify(list));\\n                } else {\\n                    var list = JSON.parse(str);\\n                    if (list.indexOf(name) == '-1') {\\n                       // list.push(name);\\n                        list.unshift(name);\\n                        writeFile('hiker://files/rules/apollo/javdb/javdb_video.txt', JSON.stringify(list));\\n                    }else{\\n                      var index = list.indexOf(name);\\n                      list.splice(index, 1);\\n                      writeFile('hiker://files/rules/apollo/javdb/javdb_video.txt', JSON.stringify(list));\\n                      }\\n                }\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, str),\\n            col_type: 'scroll_button',\\n            extra: {id: \\\"picnum\\\"}\\n        });\\nd.push({\\ncol_type:\\\"blank_block\\\"\\n})\\n    }\\n});\\n\\n//片商\\ntry {\\n    d.push({\\n        title: \\\"片商:\\\",\\n        url: 'hiker://empty',\\n        col_type: 'scroll_button',\\n    })\\n    var makers = pdfh(html, '.panel&&.panel-block:matches(片商)&&.value&&Text');\\n    d.push({\\n        title: '‘‘’’<b><middle><font color=\\\"#1E90FF\\\">' + makers + '</font></middle></b>',\\n        url: pd(html, '.panel&&.panel-block:matches(片商)&&a&&href') + '&page=fypage@rule=js:$.require(\\\"hiker://page/yj\\\")', //链接\\n        col_type: 'scroll_button',\\n        extra: {\\n            pageTitle: makers\\n        }\\n    })\\n} catch {}\\n\\n    d.push({\\n        col_type: \\\"blank_block\\\",\\n    })\\n//演员\\nvar arts = parseDomForArray(html, 'body&&.panel-block:contains(演員:)&&a');\\nif(arts.length>0){\\n    d.push({\\n           title: \\\"演員:\\\",\\n           url: 'hiker://empty',\\n           col_type: 'scroll_button',\\n})\\nfor (var i in arts) {\\n    var title = parseDomForHtml(arts[i], 'Text');\\n    d.push({\\n        title: '‘‘’’<b><middle><font color=\\\"#c13141\\\">'+title+'</font></middle></b>',\\n        url: parseDom(arts[i], 'a&&href') + '?page=fypage@rule=js:$.require(\\\"hiker://page/yj\\\")',\\n        col_type: 'scroll_button',\\n        extra: {\\n            pageTitle: title,\\n          longClick: [{title: '复制演员', js: $.toString((title)=>{ return \\\"copy://\\\" + title;},title)},{title: '谷歌搜索', js: $.toString((title)=>{ return \\\"https://www.google.com/search?q=\\\" + title +\\\" 身高\\\";},title)},{title: '百度搜索', js: $.toString((title)=>{ return \\\"https://www.baidu.com/s?wd=\\\" + title;},title)},{title: '磁力搜演员', js: $.toString((title)=>{ \\n        return \\\"hiker://page/sou?rule=磁力君.简&p=fypage&searchTerms=\\\" + title\\n                       },title)}]\\n        }\\n})\\n}\\n}\\n\\n//导演\\ntry {\\n    var director = pdfh(html, '.panel&&.panel-block:matches(導演)&&.value&&Text');\\n    if (director) {\\n        d.push({\\n            title: \\\"導演:\\\",\\n            url: 'hiker://empty',\\n            col_type: 'scroll_button',\\n        })\\n        d.push({\\n            title: '‘‘’’<b><middle><font color=\\\"#1E90FF\\\">' + director + '</font></middle></b>',\\n            url: pd(html, '.panel&&.panel-block:matches(導演)&&a&&href') + '?page=fypage@rule=js:$.require(\\\"hiker://page/yj\\\")', //链接\\n            col_type: 'scroll_button', //组件样式\\n            extra: {\\n                pageTitle: director\\n            }\\n        });\\n    }\\n} catch {}\\n\\n//类别\\nvar arts = parseDomForArray(html, 'body&&.panel-block:contains(類別)&&a');\\nif(arts.length>0){\\nd.push({\\ncol_type:\\\"blank_block\\\"\\n})\\n    d.push({\\n       title: \\\"類別:\\\",\\n       url: 'hiker://empty',\\n       col_type: 'scroll_button',      \\n});\\nfor (var i in arts) {\\n    d.push({\\n        title: '‘‘’’<b><middle><font color=\\\"#1E8884\\\">'+parseDomForHtml(arts[i], 'Text')+'</font></middle></b>',\\n        url: parseDom(arts[i], 'a&&href') + '&page=fypage@rule=js:$.require(\\\"hiker://page/yj\\\")',//链接\\n        col_type: 'scroll_button',//组件样式\\n        extra: {\\n            pageTitle: parseDomForHtml(arts[i], 'Text')\\n        }\\n})\\n}\\nd.push({\\ncol_type:\\\"blank_block\\\"\\n})\\n}\\n\\n//系列\\nvar arts = parseDomForArray(html, 'body&&.panel-block:contains(系列)&&a');\\nif(arts.length>0){\\nd.push({\\n        col_type: \\\"blank_block\\\",\\n    })\\n    d.push({\\n       title: \\\"系列:\\\",\\n       url: \\\"toast://点了也么有用🥲\\\",\\n       col_type: 'scroll_button',\\n})\\nfor (var i in arts) {\\n    d.push({\\n        title: '‘‘’’<b><middle><font color=\\\"#00d0f4\\\">'+parseDomForHtml(arts[i], 'Text').slice(0,18)+'</font></middle></b>',\\n        url: parseDom(arts[i], 'a&&href') + '?page=fypage@rule=js:$.require(\\\"hiker://page/yj\\\")',//链接\\n        col_type: 'scroll_button',//组件样式\\n        extra: {\\n            pageTitle: parseDomForHtml(arts[i], 'Text')\\n        }\\n})\\n}\\nd.push({\\ncol_type:\\\"blank_block\\\"\\n})\\n}\\n\\n//预览视频\\n   d.push({\\n        title: '““””<middle><font color=#13B66A>📺預覽①</font></middle>',\\n        url: MY_URL + $('').lazyRule((识别码) => {\\n             try{\\n                    var html = request(input)\\n                    var url = pdfh(html,\\\".message-body&&source&&src\\\")\\n                   if( !url.startsWith(\\\"http\\\")&&url!==\\\"\\\"){\\n                        url = \\\"https:\\\" + url\\n                         }else if(url==\\\"\\\"){\\n                    return \\\"toast://沒有預覽咯\\\"\\n                        }\\n                    return url\\n             }catch{return \\\"toast://沒有預覽咯\\\"}\\n                  },识别码),\\n        col_type: 'flex_button',        \\n                 })\\n   d.push({\\n        title: '““””<middle><font color=#13B66A>📺預覽②</font></middle>',\\n        url: \\\"hiker://empty\\\" + $('').lazyRule((识别码) => {\\n             try{\\n                    var search = \\\"https://javsubtitled.com/zh/search?keywords=\\\" + 识别码\\n                    var codeurl = \\\"https://javsubtitled.com/\\\" + pdfh(request(search),\\\"body&&.videobox&&a&&href\\\")\\n                    var playlist = fetch(codeurl).match(/https?:\\\\/\\\\/\\\\S+\\\\.m3u8/)[0]\\n                    var playhd = fetch(playlist).match(/[^\\\"\\\\n]+\\\\.m3u8/g).pop()\\n                    var url = playlist.replace(\\\"playlist.m3u8\\\",playhd)\\n                    return url\\n             }catch{return \\\"toast://挂梯或沒有預覽咯\\\"}\\n                  },识别码),\\n        col_type: 'flex_button',       \\n                 })\\nvar 短評 = pdfh(html,\\\".tabs&&li[data-movie-tab-target=reviewTab]&&Text\\\")\\nvar cili = parseDomForArray(html, 'body&&.item.columns.is-desktop');\\nvar tabs = [\\\"磁鏈(\\\" + cili.length + \\\")\\\",短評];\\n\\nfunction setTabs(tabs, taburl) {\\n    var Color1 = \\\"#13B66A\\\";\\n    function getHead(title) {\\n        return '‘‘’’<strong><font color=\\\"' + Color1 + '\\\">' + title + '</front></strong>';\\n         }\\n    var Color2 = \\\"#FF00FF\\\";\\n    function getHear(title) {\\n        return '‘‘’’<strong><font color=\\\"' + Color2 + '\\\">' + title + '</front></strong>';\\n        }\\n\\n    for (var i in tabs) {\\n        var tabname = tabs[i];\\n        d.push({\\n            title: getMyVar(taburl, '0') == i ? getHear(tabname) : getHead(tabname),\\n            col_type: 'flex_button',\\n            url: $(\\\"#noLoading#\\\").lazyRule((tabname, taburl, i) => {\\n                putMyVar(taburl, i)\\n                refreshPage(false);\\n                return 'hiker://empty'\\n             }, tabname, taburl, i)\\n               })\\n            }\\n    }\\n\\nvar lists = [];\\nfunction setLists(lists, index) {\\n    function playLists() {\\n       if (index == 0) {\\n//磁力内容\\ntry{\\ncili.forEach(video => {\\n//var title = parseDomForHtml(video, 'a&&Text');\\ntry{\\nvar size = parseDomForHtml(video, '.meta&&Text').match(/\\\\d+(?:\\\\.\\\\d+)?[gm](b)?/i)[0]\\n}catch{\\nvar size = '0.00GB'\\n}\\nvar tag = parseDomForHtml(video, '.tags&&Text')\\nvar url = pdfh(video, 'a&&href').split(\\\"&\\\")[0]\\nvar title = pdfh(video,\\\".name&&Text\\\")\\nvar match = 识别码.match(/(.*?)-(.*)/);\\nif (match) {\\n    match1 = match[1];\\n    match2 = match[2];\\n    var regex = new RegExp('.*?(' + match1 + '[-|_|\\\\s]?' + match2 + '.*)', 'i');\\n    title = title.replace(regex, '$1');\\n}\\n    d.push({\\n        title: title\\n                  .replace(\\\".torrent\\\",\\\"\\\")\\n                  .replace(\\\".mp4\\\",\\\"\\\")\\n                  .replace(/@/g,\\\"\\\\t\\\\t\\\")\\n                  .replace(/mp4/gi,\\\"\\\"),\\n        desc: tag.replace(/\\\\s/,\\\"\\\") + '\\\\t📀' + size + '\\\\t\\\\t🗓' +parseDomForHtml(video, '.time&&Text'),\\n        pic_url: 'https://img.vinua.cn/images/Ocqpj.png',\\n        url: url,\\n        col_type: 'avatar',\\n        extra: {\\n                    longClick: [{\\n                        title: '幻影',\\n                        js: $.toString((url) => {\\n                            openAppIntent('com.xingsu.downloader', 'com.e4a.runtime.android.mainActivity', {\\n                                intentData: url\\n                            })\\n                            return \\\"hiker://empty\\\";\\n                        }, url)\\n                    }, {\\n                        title: '闪存云',\\n                        js: $.toString((url) => {\\n                            openAppIntent('com.shanxiazaidown', 'com.e4a.runtime.android.mainActivity', {\\n                                intentData: url\\n                            })\\n                            return \\\"hiker://empty\\\";\\n                        }, url)\\n                    }, {\\n                        title: '二驴',\\n                        js: $.toString((url) => {\\n                            openAppIntent('com.qikcloud.qik', 'com.e4a.runtime.android.mainActivity', {\\n                                intentData: url\\n                            })\\n                            return \\\"hiker://empty\\\";\\n                        }, url)\\n                    }, {\\n                        title: '悟空',\\n                        js: $.toString((url) => {\\n                            openAppIntent('com.yfoo.wkDownloader', 'com.yfoo.wkDownloader.MainActivity', {\\n                                intentData: url\\n                            })\\n                            return \\\"hiker://empty\\\";\\n                        }, url)\\n                    }, {\\n                        title: '小白',\\n                        js: $.toString((url) => {\\n                            openAppIntent('xb.download.com', 'io.dcloud.PandoraEntry', {\\n                                intentData: url\\n                            })\\n                            return \\\"hiker://empty\\\";\\n                        }, url)\\n                    }, {\\n                        title: '迅雷',\\n                        js: $.toString((url) => {\\n                            openAppIntent('com.xunlei.downloadprovider.lite', 'com.xunlei.downloadprovider.launch.LaunchActivity', {\\n                                intentData: url\\n                            })\\n                            return \\\"hiker://empty\\\";\\n                        }, url)\\n                    },{\\n                        title: 'Pikpak',\\n                        js: $.toString((url) => {\\n                            return \\\"pikpakapp://mypikpak.com/xpan/main_tab?tab=1&add_url=\\\" + url;\\n                        }, url)\\n                    }]\\n}\\n    });\\n})\\n}catch{}\\n       }else if (index == 1) {\\ntry{\\n       var url = pd(html,\\\".tabs&&li[data-movie-tab-target=reviewTab]&&a&&data-url\\\")\\n       var h = fetch(url, {\\n    headers: {\\n        cookie: fetchPC('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt') || '',\\n        \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\\\",      \\n    },\\n    redirect: false\\n});\\n       var list = pdfa(h,\\\".message-body&&.review-item:has(.review-title)\\\")\\n       list.forEach(item=>{\\n         var desc = '<middle><font color=#FF8C00>' + pdfh(item,\\\".review-title--.likes--.report&&Text\\\") + '</font></middle>';              \\n            d.push({\\n                title: desc + '<br>' + '<small><font color=#ff6877>\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t' + pdfh(item,\\\".content&&Text\\\") + '</font></small>',                \\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"rich_text\\\",\\n                extra: {lineVisible:false}\\n               })\\n         })\\n            d.push({\\n                title: '““””<small><font color=#13B66A>更多短評可成为VIP或至官方App中查看</font></small>',\\n                url: $('').lazyRule((识别码) => {               \\n         openAppIntent('xxx.pornhub.fuck', 'xxx.pornhub.fuck.MainActivity', {intentData: 识别码})\\n            return \\\"copy://\\\" + 识别码\\n                  },识别码),\\n                col_type: \\\"text_center_1\\\",\\n                extra: {lineVisible:false}\\n               })\\n}catch{}\\n        }\\n            }\\n        playLists()        \\n            }\\n\\nsetTabs(tabs, MY_URL);\\nsetLists(lists, getMyVar(MY_URL, '0'));\\n\\n\\n\\ntry{\\nvar list = parseDomForArray(html, 'body&&.message:matches(還出演過)&&.tile-small&&a');\\nd.push({\\n    title: '<span style=\\\"color: #FF00FF;\\\">TA(們)還出演過</span>',\\n    pic_url: \\\"https://lanmeiguojiang.com/tubiao/ke/100.png\\\",\\n    col_type: 'rich_text'\\n});\\nlist.forEach((video,index) => {\\n    var title = parseDomForHtml(video, '.video-number&&Text') + ' ' + parseDomForHtml(video, 'a&&title');\\n    d.push({\\n        title:  title,\\n        //desc: parseDomForHtml(video, '.video-number&&Text'),\\n        img: parseDom(video, 'img&&src').replace(\\\"thumbs\\\",\\\"covers\\\") + \\\"@Referer=\\\",\\n        url: parseDom(video, 'a&&href') + '@rule=js:$.require(\\\"ej\\\")',\\n        col_type: 'movie_2',\\n        extra: {\\n            pageTitle: title,\\nimg: parseDom(video, 'img&&src').replace(\\\"thumbs\\\",\\\"covers\\\") \\n        }\\n  });\\n})   \\n     if (list.length % 2 != 0) {\\n            d.push({\\n                title: \\\"🗯Random🗯\\\",\\nimg: 'https://thumbsnap.com/i/3uqjc1qq.gif',\\n                url: \\\"hiker://empty\\\",               \\n                col_type: \\\"movie_2\\\"\\n            })\\n        }\\n} catch (err) {\\n  //console.log('没有出演列表', err);\\n};\\n\\ntry{\\nvar list = parseDomForArray(html, 'body&&.message:matches(你可能也喜歡)&&.tile-small&&a');\\nd.push({\\n    title: '<span style=\\\"color: #FF00FF;\\\">你可能也喜歡</span>',\\n    pic_url: \\\"https://lanmeiguojiang.com/tubiao/ke/100.png\\\",\\n    col_type: 'rich_text'\\n});\\nlist.forEach(video => {\\n    var title = parseDomForHtml(video, '.video-number&&Text') + ' ' + parseDomForHtml(video, 'a&&title');\\n    d.push({\\n        title:  title,\\n        //desc: parseDomForHtml(video, '.video-number&&Text'),\\n        img: parseDom(video, 'img&&src').replace(\\\"thumbs\\\",\\\"covers\\\") + \\\"@Referer=\\\",\\n        url: parseDom(video, 'a&&href') + '@rule=js:$.require(\\\"ej\\\")',\\n        col_type: 'movie_2',\\n        extra: {\\n            pageTitle: title,\\nimg: parseDom(video, 'img&&src').replace(\\\"thumbs\\\",\\\"covers\\\")\\n        }\\n  });\\n})   \\n     if (list.length % 2 != 0) {\\n            d.push({\\n                title: \\\"🗯Random🗯\\\",\\nimg: 'https://thumbsnap.com/i/MU5UaB4Y.gif',\\n                url: \\\"hiker://empty\\\",               \\n                col_type: \\\"movie_2\\\"\\n            })\\n        }\\n} catch (err) {\\n  //console.log('没有推荐列表', err);\\n};\\n\\n}catch{\\nvar 识别码 = getPageTitle().split(\\\" \\\")[0].replace(\\\"FC2\\\",\\\"FC2-PPV\\\");\\nvar img = MY_PARAMS.img;\\n        d.push({\\n             img: img,\\n             url: \\\"copy://\\\" + img,\\n             col_type: 'pic_1_full',\\n})\\n    d.push({\\n        title:  \\\"fc2需要VIP登录\\\",\\n        desc: \\\"300大洋，才显示页面，谷歌搜索一下或戳下面图标\\\",\\n        url: \\\"https://www.google.com/search?q=\\\" + 识别码,\\n        col_type: 'text_center_1',\\n        extra:{lineVisible:false}\\n        });\\neval(JSON.parse(fetch('hiker://page/tool', {})).rule);\\n\\n}\\n/*\\nfor (var b = 0; b < 2; b++) {\\nd.push({\\n    col_type: 'big_blank_block'\\n})\\n}*/\\nd.push({\\n            title: '““””' + \\\"我是有底线的\\\".fontcolor(\\\"grey\\\")\\n                .small(),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        })\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"④一级收藏页面\",\"path\":\"收藏\",\"rule\":\"function getHead(title,color) {\\n    return '‘‘’’<strong><big><font color=\\\"'+color+'\\\">' + title + '</front></big></strong>';\\n}\\n\\nvar label = getVar(\\\"label\\\") ? getVar(\\\"label\\\") : \\\"影片\\\";\\nif (MY_PAGE == 1) {\\n    d.push({\\n        title: label == \\\"影片\\\" ? getHead(\\\"=⋙影片⋘=\\\",\\\"#FF00FF\\\") : getHead(\\\"=⋙影片⋘=\\\",\\\"#D3D3D3\\\"),\\n       img: \\\"https://cdn1.iconfinder.com/data/icons/ui-user-interface-9/1000/Video_Camera-128.png\\\",\\n        url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('label','影片');refreshPage(false);'toast://切换成功'\\\",\\n        col_type: 'icon_2_round'\\n    });\\n}\\n    d.push({\\n        title: label == \\\"演員\\\" ? getHead(\\\"=⋙演員⋘=\\\",\\\"#FF00FF\\\") : getHead(\\\"=⋙演員⋘=\\\",\\\"#D3D3D3\\\"),\\n        img: \\\"https://cdn2.iconfinder.com/data/icons/valentine-day-16/512/706_pen_love_heart_wedding_valentine_valentines_day_love-128.png\\\",\\n        url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('label','演員');refreshPage(false);'toast://切换成功'\\\",\\n        col_type: 'icon_2_round'\\n    });\\n\\n\\nvar u = label == \\\"影片\\\" ? 'hiker://files/rules/apollo/javdb/javdb_video.txt' : 'hiker://files/rules/apollo/javdb/javdb_actor.txt';\\nvar str = readFile(u, 0);\\nif (str) {\\n    var list = JSON.parse(str);\\n    list.forEach((list) => {\\n        d.push({\\n            title: list.split('@@')[0],\\n            img: list.split('@@')[1],\\n            url: label == \\\"演員\\\"?'hiker://page/yj':'hiker://page/ej',\\n            col_type: label == \\\"演員\\\" ? 'card_pic_3' : 'movie_2',\\n           extra: {\\n              url: list.split('@@')[2].replace(getMyVar('yongjiu'),MY_HOME),\\n              pageTitle: list.split('@@')[0],\\n              longClick: [{\\n                  title: '取消收藏',\\n                  js: $.toString((list, u) => {\\n                      var data = JSON.parse(fetchPC(u) || '[]');\\n                      data = data.filter(x => x != list);\\n                      writeFile(u, JSON.stringify(data));\\n                      refreshPage();\\n                      return \\\"hiker://empty\\\";\\n                  }, list, u)\\n              }],\\n          }\\n        });\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"④一级页面登录\",\"path\":\"登录\",\"rule\":\"\\n//if(fetch('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt')){\\n\\n\\nif(html.includes(\\\"登出\\\")){\\n        d.push({\\n            title: '““””<big><font color=#FF00FF>账号已登录</font></big>',\\n            desc: '““””' + '切换分类刷新页面内容'.fontcolor('#FF00FF').big(),\\n            url: 'hiker://empty',\\n            col_type: 'text_center_1',\\n        });\\n    }else{\\n\\n    d.push({\\n        title: '““””' + '点击登录账号'.fontcolor('#FF00FF').big(),\\n        url: true_url + $('').rule(() => {\\n            var d = [];\\n            d.push({\\n                col_type: 'x5_webview_single',\\n                url: MY_URL,\\n                desc: 'list&&screen',\\n                extra: {\\n                    \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 12; SM-G9750 Build/SP1A.210812.016; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/89.0.4389.72 MQQBrowser/6.2 TBS/046279 Mobile Safari/537.36\\\",//PC_UA,             \\n                    showProgress: false,\\n                    js: $.toString((u) => {\\n                        function check() {\\n                            //let nodes = document.querySelectorAll('#tags');\\n                            var co = fba.getCookie(u);\\n//var ua = fba.getUa()\\n//fba.log('co::::::' + ua);\\n                         //   fba.log('co::::::' + co);\\n                            if (co.includes('remember_me_token')) {\\n                                fba.parseLazyRule($$$().lazyRule((co) => {\\n                                    writeFile('hiker://files/rules/Apollo/Cookie/javdb_cookie.txt', co);\\n                                    toast('账号已登录');\\n                                    back(true);\\n                                }, co));\\n                            } else {\\n                                setTimeout(check, 500);\\n                            }\\n                        }\\n                        check();\\n                    }, MY_URL)\\n                }\\n            });\\n            return setResult(d);\\n        }),\\n        col_type: 'text_center_1'\\n    });\\n\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"search\",\"rule\":\"        if (page === 1) {\\n            var tabs = [\\\"影片\\\", \\\"演员\\\", \\\"可播放\\\", \\\"中字\\\", \\\"磁链\\\", \\\"清单\\\"]\\n            var lists = [\\\"all\\\", \\\"actor\\\", \\\"playable\\\", \\\"cnsub\\\", \\\"download\\\", \\\"list\\\"]\\n\\n                function setTabs(tabs) {\\n                    for (var i in tabs) {\\n                        d.push({\\n                            title: getMyVar(\\\"tab\\\", '0') == i ? '‘‘’’<strong><font color=\\\"#4EB7E4\\\">' + tabs[i] + '</font></strong>' : tabs[i],\\n                            col_type: 'flex_button',\\n                            url: $(\\\"#noLoading#\\\")\\n                                .lazyRule((i, lists) => {\\n                                putMyVar(\\\"tab\\\", i)\\n                                if (getMyVar('key') == \\\"\\\") {\\n                                    let keys = listMyVarKeys();\\n                                    for (let it of keys) {\\n                                        clearMyVar(it);\\n                                    }\\n                                    putMyVar(\\\"tab\\\", i)\\n                                } else {\\n                               putMyVar('yi_firstpage', getPublicItem('javdb0') + \\\"/search?f=\\\" + lists[i] + \\\"&q=\\\" + getMyVar('key'));\\n                                }\\n                                refreshPage(false);\\n                                return 'hiker://empty'\\n                            }, i, lists)\\n                        })\\n                    }\\n                }\\n\\n                function setLists(lists, index) {\\n                    function playLists() {\\n                        d.push({\\n                            title: \\\"💎\\\" + tabs[index] + \\\"💎\\\",\\n                            desc: '搜索你想要的',\\n                            col_type: 'input',\\n                            url: $.toString((lists, index) => {\\n                                putMyVar('key', input)\\n                                if (input == \\\"\\\") {\\n                                    let keys = listMyVarKeys();\\n                                    for (let it of keys) {\\n                                        clearMyVar(it);\\n                                    }\\n                                } else {\\n                                putMyVar('yi_firstpage', getPublicItem('javdb0')+\\\"/search?f=\\\" + lists[index] + \\\"&q=\\\" + input);\\n                                }\\n                                refreshPage(true);\\n                                return 'hiker://empty'\\n                            }, lists, index),\\n                            extra: {\\n                                defaultValue: getMyVar('key', ''),\\n                                onChange: \\\"putMyVar('key', input)\\\"\\n                            }\\n                        })\\n                    }\\n                    playLists()\\n                }\\n            setTabs(tabs, true_url);\\n            setLists(lists, getMyVar('tab', '0'));\\n        };\"},{\"col_type\":\"movie_3\",\"name\":\"①一级外部Fc2\",\"path\":\"fc2\",\"rule\":\"js: \\n//sex8086@gmail.com\\n//https://javlist.me/post.php\\n\\naddListener(\\\"onClose\\\", () => {\\n       // clearMyVar(\\\"fcurl\\\");\\n});\\n\\n    var d = []\\n\\n    \\n    setResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"每日一言\",\"path\":\"yiyan\",\"rule\":\"//author:粉妹\\nfunction save_day_say_cache() {\\n    let day_say_cache = {}\\n    let day_say_html = fetch('https://v1.hitokoto.cn', {\\n        headers: {\\n            'User-Agent':\\n                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',\\n        },\\n    })\\n    day_say_html = JSON.parse(day_say_html)\\n    day_say_cache['content'] = day_say_html['hitokoto']\\n    day_say_cache['time'] = Math.floor(Date.now() / 1000)\\n    storage0.putMyVar('daysay', day_say_cache)\\n    return day_say_html['hitokoto']\\n}\\n\\n    let day_say = ''\\n    try {\\n        let day_say_cache = {}\\n        let day_time = 0\\n        if (storage0.getMyVar('daysay')) {\\n            day_say_cache = storage0.getMyVar('daysay', {})\\n            day_time = day_say_cache['time']\\n            if (Math.floor(Date.now() / 1000) - day_time >= 600) {\\n                day_say = save_day_say_cache()\\n            } else {\\n                day_say = day_say_cache['content']\\n            }\\n        } else {\\n            day_say = save_day_say_cache()\\n        }\\n    } catch {\\n        day_say = ''\\n    }\"},{\"col_type\":\"movie_3\",\"name\":\"翻译\",\"path\":\"trans\",\"rule\":\"    //翻译\\n    function translate(text){\\n        var switchtrans = getItem('switchtrans','小牛翻译');\\n        if (switchtrans == true || switchtrans == \\\"彩云小译\\\") {\\n            try {\\n                var to = 'zh'\\n                var from = 'auto'\\n\\n                    function init_data(source_lang, target_lang) {\\n                        return {\\n                            source: '',\\n                            detect: true,\\n                            os_type: 'ios',\\n                            device_id: 'F1F902F7-1780-4C88-848D-71F35D88A602',\\n                            trans_type: source_lang + '2' + target_lang,\\n                            media: 'text',\\n                            request_id: 424238335,\\n                            user_id: '',\\n                            dict: true,\\n                        }\\n                    }\\n\\n                    function getRandomNumber() {\\n                        const rand = Math.floor(Math.random() * 99999) + 100000\\n                        return rand * 1000\\n                    }\\n                const post_data = init_data(from, to)\\n                post_data.source = text\\n                post_data.request_id = getRandomNumber()\\n                let res = fetch('https://interpreter.cyapi.cn/v1/translator', {\\n                    method: 'POST',\\n                    header: {\\n                        'Content-Type': 'application/json',\\n                        'x-authorization': 'token ssdj273ksdiwi923bsd9',\\n                        'user-agent': 'caiyunInterpreter/5 CFNetwork/1404.0.5 Darwin/22.3.0',\\n                    },\\n                    body: post_data,\\n                })\\n                let result = JSON.parse(res)\\n                    .target\\n                return result + \\\"【☁️】\\\"\\n            } catch {\\n                log(\\\"翻译失败，使用原文\\\");\\n                return text\\n            }\\n        } else if (switchtrans == \\\"小牛翻译\\\") {\\n            try {\\n                var url = \\\"https://api.niutrans.com/NiuTransServer/translation\\\";\\n                var api = getItem('api');\\n                if (api) {\\n                    if (text != \\\"\\\") {\\n                        var lang = \\\"https://test.niutrans.com/NiuTransServer/language?src_text=\\\" + text + \\\"&source=text\\\";\\n                        var from = JSON.parse(fetch(lang, {\\n                            timeout: 1000\\n                        }))\\n                            .language;\\n                        var result = post(url, {\\n                            body: {\\n                                src_text: text,\\n                                from: from,\\n                                to: \\\"zh\\\",\\n                                apikey: api,\\n                            },\\n                            timeout: 1223\\n                        });\\n                        var data = JSON.parse(result)\\n                        if (data.tgt_text) {\\n                            return data.tgt_text + \\\"【🐮】\\\"\\n                        } else {\\n                            log(\\\"翻译失败，使用原文\\\");\\n                            return text\\n                        }\\n                    } else {\\n                        log(\\\"翻译失败，原文为空\\\");\\n                        return text\\n                    }\\n                } else {\\n                    toast(\\\"预处理请填写翻译api\\\")\\n                    return text\\n                }\\n            } catch {\\n                log(\\\"翻译失败，使用原文\\\");\\n                return text\\n            }\\n        } else {\\n            return text\\n        }\\n    };\\n\\n$.exports.translate = translate\"}]","icon":"https://img.vinua.cn/images/zrLkQ.png","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!