小程序：𝐒𝐮𝐩𝐣𝐚𝐯🪜

海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@𝐒𝐮𝐩𝐣𝐚𝐯🪜@{"last_chapter_rule":"","title":"𝐒𝐮𝐩𝐣𝐚𝐯🪜","author":"R","url":"hiker://empty##https://supjav.com/zh/##fypage","version":20240511,"col_type":"movie_3","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\naddListener(\"onClose\", () => {\n    clearMyVar(\"nextPage\");\n});\n/*\naddListener(\"onRefresh\", () => {\n    clearMyVar(\"nextPage\");\n});\n*/\nvar d = []\nMY_URL = MY_URL.split(\"##\")[1]\nlet true_url = getMyVar(\"url\", MY_URL);\nlet nextPage = getMyVar(\"nextPage\", \"\");\nif (nextPage && MY_PAGE > 1) {\n    true_url = nextPage;\n}\nvar html = fetch(true_url,{headers:JSON.parse(getMyVar('headers'))})\n//log(html)\ntry {\n    let nextUrl = pd(html, \".pagination&&li[class=active]+li&&a&&href\");\n    if (!nextUrl ==\"\")\n    putMyVar(\"nextPage\", nextUrl || \"\");\n} catch (e) {\n    clearMyVar(\"nextPage\");\n   // toast(\"好像没有下一页了！\");\n}\nlog(true_url)\n//log(\"下一页  ：\"+nextPage)\nfunction getHead(title,color) {\n        return '‘‘’’<strong><font color=\"' + color + '\">' + title + '</front></strong>';\n         }\n\n$.require(\"category\")()\n\nif ( true_url ==\"https://supjav.com/zh/\" ){\nif (MY_PAGE == 1) {\n$.require(\"home\")\n}\n} else if (/tag|maker|cast/.test(true_url)) {\n$.require(\"tabs\")\n} else {\n$.require(\"list\")()\n}\n\nsetResult(d)","search_url":"https://supjav.com/zh/page/fypage?s=**","group":"9秋名山","searchFind":"js:\n$.require(\"yi\")","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"if (!getMyVar('headers')){\nputMyVar('headers',{\"Cookie\":\"cf_clearance=3Swn.IzcaQ7gepcMHoKkmM3bs_J26x.BWW6HBTlUtz0-1705266030-0-2-a659b38c.639c85dc.f158ec6c-160.2.1705266030\",\"User-Agent\":\"Mozilla/5.0 (iPhone; CPU iPhone OS 16_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Mobile/15E148 Safari/604.1\",\"Referer\":\"https://supjav.com/\"})\n}","pages":"[{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"category\",\"rule\":\"$.exports = () => {\\naddListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"sort\\\");   \\n        clearMyVar(\\\"pagi\\\");   \\n       // clearMyVar(\\\"url\\\");   \\n}));\\naddListener(\\\"onRefresh\\\", () => {\\n        clearMyVar(\\\"sort\\\");   \\n        clearMyVar(\\\"pagi\\\");   \\n        clearMyVar(\\\"url\\\");   \\n        clearMyVar(\\\"tab\\\");   \\n});\\nif (MY_PAGE == 1) {\\n    d.push({\\n        title: \\\"🔍\\\",\\n        url: $.toString((r) => {\\n            putMyVar('keyword', input);\\n            return 'hiker://search?rule=' + r + '&s=' + input;\\n        }, MY_RULE.title),\\n        desc: '曾经沧海难为水,除却巫山不是云',\\n        col_type: \\\"input\\\",\\n        extra: {\\n            defaultValue: getMyVar('keyword', '') || \\\"\\\",\\n        }\\n    });\\n        var tabs = pdfa(html, \\\".nav&&li:not(li:has(.sub-menu)):not(:has(a[target])):not(:has(a[title]))\\\");\\n   for (var i in tabs) {\\n        var title = pdfh(tabs[i],'Text')\\n        d.push({\\n            title: getMyVar('tab', '0') == i ? getHead(title,'#FF6699') : title,\\n            col_type: 'scroll_button',\\n            url: pd(tabs[i], 'a&&href') + $(\\\"#noLoading#\\\").lazyRule(( i) => {\\n                putMyVar('tab', i)\\n                putMyVar(\\\"url\\\", input);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }, i)\\n        })\\n    if (i==5) {\\n         d.push({\\n            col_type: \\\"blank_block\\\"\\n            })\\n        }\\n    }\\n         d.push({\\n            col_type: \\\"blank_block\\\"\\n            })\\n}\\n     var pagination = pdfa(html, \\\".pagination&&li:not(.prev-page):not(.next-page)\\\");\\n    var currentu = pdfh(html,\\\"link[hreflang=zh]&&href\\\")\\n\\n    var firstu = currentu.replace(/\\\\/page\\\\/\\\\d+/,\\\"\\\")\\n    var active = currentu.match(/\\\\/page\\\\/(\\\\d+)/) ? currentu.match(/\\\\/page\\\\/(\\\\d+)/)[1] : 1;\\n    var lastu = pdfh(pagination.pop(),\\\"a&&href\\\") || currentu\\n    var lastp = lastu.match(/\\\\/page\\\\/(\\\\d+)/) ? lastu.match(/\\\\/page\\\\/(\\\\d+)/)[1] : 1;\\n\\nif (!currentu.includes(\\\"popular\\\")){\\n     lastu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + (lastp - 2))\\n     lastp = lastp -2\\n}\\n\\nvar pagi;\\n    if (active==1) {\\n       pagi = 0\\n} else if (active == lastp) {\\n       pagi = 2\\n} else {\\n       pagi = 1\\n}\\n    var title = [\\\"首\\\",\\\"跳页:\\\" + active,\\\"尾页:\\\" + lastp]\\n    var urls = [firstu,MY_URL,lastu]\\nif ( currentu !== \\\"https://supjav.com/zh/\\\" ){\\n   for (var j in title) {\\n\\n    var url = urls[j] + $(\\\"#noLoading#\\\").lazyRule((j) => {    \\n                putMyVar(\\\"url\\\", input);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }, j)\\n\\n    if (j==1) {\\n    url = $('','除首页和尾页之外的页码').input((lastu,lastp)=>{\\n        if (parseInt(input) > 1 && parseInt(input) < parseInt(lastp) && parseInt(input) % 1 == 0) {\\n                var jumpu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\"+ input)\\n                putMyVar(\\\"url\\\", jumpu);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n} else {\\n                return \\\"toast://请输入正确的页码\\\"}\\n           },lastu,lastp)                  \\n      }\\n\\n        d.push({\\n            title: pagi == j ? getHead(title[j],'#FF6699') : title[j],           \\n            url: url,\\n            col_type: 'scroll_button',                 \\n        })\\n}}\\n\\nif (MY_PAGE == 1) {\\n     var sott = currentu.replace(/.*?(=(.*)|$)/,\\\"$2\\\")\\n     var sort = pdfa(html, \\\".sort&&a\\\");\\n     sott = sott === \\\"\\\" ? pdfh(sort[0],'Text').toLowerCase() : sott;\\n   for (var j in sort) {\\n        var title = pdfh(sort[j],'Text')\\n        d.push({\\n            title: sott  == title.toLowerCase() ? getHead(title,'#FF6699') : title,\\n            col_type: 'scroll_button',\\n            url: pd(sort[j], 'a&&href') + $(\\\"#noLoading#\\\").lazyRule((j) => {\\n                putMyVar(\\\"url\\\", input);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }, j)\\n        })\\n}\\n\\n}\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"列表\",\"path\":\"list\",\"rule\":\"$.exports = () => {\\nvar list = pdfa(html, \\\".posts&&.post\\\");\\nlist.forEach(item=>{\\n   var img = pd(item,\\\"img&&data-original\\\");\\n   var title = pdfh(item,\\\"a&&title\\\").replace(\\\"[中文字幕]\\\",\\\"🇨🇳\\\").replace(\\\"[无码破解]\\\",\\\"🔥\\\").replace(\\\"[4K]\\\",\\\"🖥\\\").replace(\\\"[英文字幕]\\\",\\\"🇺🇸\\\");\\n       d.push({\\n               title: title,\\n               desc: pdfh(item,\\\".meta--.date&&Text\\\"),\\n               img: img.replace(/(http.*?\\\\.(?:jpg|webp|png|jpeg)).*/,\\\"$1\\\"),\\n               url: pdfh(item,\\\"a&&href\\\") + '@rule=js:$.require(\\\"er\\\")',\\n               col_type: \\\"movie_2\\\",\\n               extra: {pageTitle:title}\\n         })\\n})\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"标签\",\"path\":\"tabs\",\"rule\":\"var getRangeColors = function() {\\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\n}\\nvar lists = pdfa(html, \\\".categorys&&.child\\\");\\nlists.forEach(item=>{\\n       d.push({\\n               title: '““””' + pdfh(item,\\\"a&&Text\\\").fontcolor(getRangeColors()),         \\n               url: pdfh(item,\\\"a&&href\\\") + '##fypage@rule=js:$.require(\\\"yi\\\")',\\n               col_type: \\\"text_2\\\",\\n         })\\n})\"},{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"home\",\"rule\":\"var tab1 = pdfa(html, 'body&&.recommend'); \\nvar tab2 = pdfa(html, 'body&&.contents&&.content'); \\nvar tabs = tab1.concat(tab2)\\nvar conts = tabs\\n\\nfor (var i = 0; i < conts.length; i++) {\\n      var list = pdfa(conts[i], '.posts&&.post'); \\n     d.push({\\n        title: '<middle><font color=#FFA500>'+pdfh(tabs[i], '.archive-title&&Text').replace(\\\"+ More\\\",\\\"\\\")+'</font></middle>',\\n        desc: '<middle><font color=red>+\\\\t\\\\t\\\\t\\\\t  𝐌𝐨𝐫𝐞</font></middle>',\\n        img: \\\"https://img.vinua.cn/images/IIenX.png\\\",\\n        url: pd(tabs[i],'a&&href') + '##fypage@rule=js:$.require(\\\"yi\\\")',\\n        col_type: \\\"avatar\\\",\\n        extra: {lineVisible:false}\\n    });\\n\\n        for (var j = 0; j < list.length; j++) {     \\n  var img =  i == 0? pd(list[j],'img&&src') : pd(list[j],'img&&data-original');  \\n  var title = pdfh(list[j], 'a&&title').replace(\\\"[中文字幕]\\\",\\\"🇨🇳\\\").replace(\\\"[无码破解]\\\",\\\"🔥\\\").replace(\\\"[4K]\\\",\\\"🖥\\\").replace(\\\"[英文字幕]\\\",\\\"🇺🇸\\\");\\n            d.push({\\n                title: title,\\n                desc: pdfh(list[j], '.meta--.date&&Text'),\\n                img: img.replace(/(http.*?\\\\.(?:jpg|webp|png|jpeg)).*/,\\\"$1\\\"),\\n                url: pd(list[j], 'a&&href') + '@rule=js:$.require(\\\"er\\\")',\\n                col_type: 'movie_2',\\n                extra: {pageTitle:title}\\n            });\\n        }\\n    }\"},{\"col_type\":\"movie_3\",\"name\":\"一级\",\"path\":\"yi\",\"rule\":\"js:\\naddListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"ysort\\\");   \\n        clearMyVar(\\\"yurl\\\");   \\n        clearMyVar(\\\"nextPag\\\");   \\n}));\\nvar d = []\\nMY_URL = getMyVar(\\\"yurl\\\", MY_URL.replace(/##\\\\d+/,\\\"\\\"));\\nlet nextPag = getMyVar(\\\"nextPag\\\", \\\"\\\");\\nif (nextPag && MY_PAGE > 1) {\\n    MY_URL = nextPag;\\n}\\nvar html = fetch(MY_URL)\\ntry {\\n    var nextUrll = pd(html, \\\".next-page&&a&&href\\\");\\n    if (!nextUrll ==\\\"\\\")\\n    putMyVar(\\\"nextPag\\\", nextUrll || \\\"\\\");\\n} catch (e) {\\n    clearMyVar(\\\"nextPag\\\");\\n   // toast(\\\"好像没有下一页了！\\\");\\n}\\nlog(MY_URL)\\n\\n//log(\\\"下一页  ：\\\"+nextPag)\\nfunction getHead(title,color) {\\n        return '‘‘’’<strong><font color=\\\"' + color + '\\\">' + title + '</front></strong>';\\n         }\\n\\nif(MY_TYPE != \\\"search\\\") {\\n     var pagination = pdfa(html, \\\".pagination&&li:not(.prev-page):not(.next-page)\\\");\\n    var currentu = pdfh(html,\\\"link[hreflang=zh]&&href\\\")\\n\\n    var firstu = currentu.replace(/\\\\/page\\\\/\\\\d+/,\\\"\\\")\\n    var active = currentu.match(/\\\\/page\\\\/(\\\\d+)/) ? currentu.match(/\\\\/page\\\\/(\\\\d+)/)[1] : 1;\\n    var lastu = pdfh(pagination.pop(),\\\"a&&href\\\") || currentu\\n    var lastp = lastu.match(/\\\\/page\\\\/(\\\\d+)/) ? lastu.match(/\\\\/page\\\\/(\\\\d+)/)[1] : 1;\\n\\nvar pagi;\\n    if (active==1) {\\n       pagi = 0\\n} else if (active == lastp) {\\n       pagi = 2\\n} else {\\n       pagi = 1\\n}\\n    var title = [\\\"首\\\",\\\"跳页:\\\" + active,\\\"尾页:\\\" + lastp]\\n    var urls = [firstu,MY_URL,lastu]\\nif ( currentu !== \\\"https://supjav.com/zh/\\\" ){\\n   for (var j in title) {\\n\\n    var url = urls[j] + $(\\\"#noLoading#\\\").lazyRule((j) => {    \\n                putMyVar(\\\"yurl\\\", input);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }, j)\\n\\n    if (j==1) {\\n    url = $('','除首页和尾页之外的页码').input((lastu,lastp)=>{\\n        if (parseInt(input) > 1 && parseInt(input) < parseInt(lastp) && parseInt(input) % 1 == 0) {\\n                var jumpu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\"+ input)\\n                putMyVar(\\\"yurl\\\", jumpu);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n} else {\\n                return \\\"toast://请输入正确的页码\\\"}\\n           },lastu,lastp)                  \\n      }\\n\\n        d.push({\\n            title: pagi == j ? getHead(title[j],'#FF6699') : title[j],           \\n            url: url,\\n            col_type: 'scroll_button',                 \\n        })\\n}}\\n}\\n\\nif (MY_PAGE == 1) {\\n     var sort = pdfa(html, \\\".sort&&a\\\");\\n   for (var j in sort) {\\n        var title = pdfh(sort[j],'Text')\\n        d.push({\\n            title: getMyVar('ysort', '0') == j ? getHead(title,'#FF6699') : title,\\n            col_type: 'scroll_button',\\n            url: pd(sort[j], 'a&&href') + $(\\\"#noLoading#\\\").lazyRule((j) => {\\n                putMyVar('ysort', j)\\n                putMyVar(\\\"yurl\\\", input);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }, j)\\n        })\\n}\\n}\\n\\nvar list = pdfa(html, \\\".posts&&.post\\\");\\nlist.forEach(item=>{\\n   var img = pd(item,\\\"img&&data-original\\\");\\n   var title = pdfh(item,\\\"a&&title\\\").replace(\\\"[中文字幕]\\\",\\\"🇨🇳\\\").replace(\\\"[无码破解]\\\",\\\"🔥\\\").replace(\\\"[4K]\\\",\\\"🖥\\\").replace(\\\"[英文字幕]\\\",\\\"🇺🇸\\\");\\n       d.push({\\n               title: title,\\n               desc: pdfh(item,\\\".meta--.date&&Text\\\"),\\n               img: img.replace(/(http.*?\\\\.(?:jpg|webp|png|jpeg)).*/,\\\"$1\\\"),\\n               url: pdfh(item,\\\"a&&href\\\") + '@rule=js:$.require(\\\"er\\\")',\\n               col_type: \\\"movie_2\\\",\\n               extra: {pageTitle:title}\\n         })\\n})\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"二级\",\"path\":\"er\",\"rule\":\"js: var d = []\\nMY_URL = MY_URL.replace('hiker://empty##', '');\\nlog(MY_URL)\\nvar html = fetch(MY_URL);\\n\\neval(JSON.parse(fetch('hiker://page/lazy', {}))\\n    .rule);\\n\\nvar title = pdfh(html, '.archive-title&&Text')\\n    .replace(\\\"[中文字幕]\\\", \\\"🇨🇳\\\")\\n    .replace(\\\"[无码破解]\\\", \\\"🔥\\\")\\n    .replace(\\\"[4K]\\\", \\\"🖥\\\")\\n    .replace(\\\"[英文字幕]\\\", \\\"🇺🇸\\\");\\nvar 识别码 = title.match(/\\\\w+(?:-|_)\\\\w+(?:\\\\s+\\\\d+)?|\\\\w+(?!\\\\n)\\\\s+\\\\w+/)[0]\\nif (title !== null) {\\n    d.push({\\n        title: '““””<middle><font color=#e57a1a>' + title + '</font></middle>',\\n        url: \\\"copy://\\\" + 识别码,\\n        col_type: 'text_1',\\n        extra: {\\n            lineVisible: false,\\n            longClick: [{\\n                title: '网页',\\n                js: $.toString(() => {\\n                    return \\\"web://\\\" + MY_URL\\n                })\\n            }, {\\n                title: '百度翻译',\\n                js: $.toString((title) => {\\n                    return \\\"x5://https://fanyi.baidu.com/#jp/zh/\\\" + title\\n                }, title)\\n            }, {\\n                title: 'Deepl翻译',\\n                js: $.toString((title) => {\\n                    return \\\"x5://https://www.deepl.com/zh/translator-mobile#ja/zh/\\\" + title\\n                }, title)\\n            }, {\\n                title: '谷歌翻译',\\n                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\\nvar img = pd(html, \\\".post-meta&&img&&src\\\");\\nif (img !== null) {\\n    d.push({\\n        img: img,\\n        url: \\\"hiker://empty\\\",\\n        col_type: 'pic_1_full',\\n        extra: {\\n            longClick: [{\\n                title: '复制图片',\\n                js: $.toString((img) => {\\n                    return \\\"copy://\\\" + img\\n                }, img)\\n            }, {\\n                title: '打开图片',\\n                js: $.toString((img) => {\\n                    return img\\n                }, img)\\n            }, {\\n                title: '下载图片',\\n                js: $.toString((img) => {\\n                    return \\\"download://\\\" + img\\n                }, img)\\n            }]\\n        }\\n    });\\n}\\n\\nd.push({\\n    title: '““””<span style=\\\"color: #FFFFFF;\\\"><small>𝐒𝐄𝐑𝐕𝐄𝐑 ：已屏蔽JPA等无用线路</small></span>',\\n    url: 识别码 + $('#noLoading#')\\n        .lazyRule(() => {\\n        return \\\"hiker://page/yj?rule=𝐉𝐚𝐯𝐃𝐁&url=https://\\\" + globalMap0.getVar('javdb0', 'javdb.com') + \\\"/search？？f=all＆＆page=fypage＆＆q=\\\" + input\\n    }),\\n    col_type: 'text_1',\\n    extra: {\\n        lineVisible: false,\\n        pageTitle: 识别码\\n    }\\n});\\n\\n//已经解析的线路\\nvar Playlined = [\\\"TV\\\", \\\"FST\\\", \\\"ST\\\", \\\"VOE\\\", \\\"DS\\\", \\\"Streamtape\\\", \\\"VTU\\\"]\\n\\nlet btns = pdfa(html, '.btns&&.btnst')\\nif (btns.length == 1) {\\n    btnst = pdfa(btns[0], 'body&&div')\\n} else {\\n    btnst = pdfa(btns[1], 'body&&.cd-server')\\n}\\nbtnst.forEach((cds, index) => {\\n    let server = pdfa(cds, 'body&&a:not(:matches(JPA|JS|SSB|NS|Mixdrop|NinjaStream|MD|GoUnlimited))'); //屏蔽线路🈲🈲🈲🈲🈲🈲\\n    if (btnst.length > 1) {\\n        d.push({\\n            title: '““””' + \\\"CD\\\".bold()\\n                .fontcolor(\\\"#8A2BE2\\\") + (index + 1)\\n                .toString()\\n                .bold()\\n                .fontcolor(\\\"#8A2BE2\\\") + \\\":\\\".fontcolor(\\\"#8A2BE2\\\"),\\n            url: \\\"hiker://empty\\\",\\n            col_type: 'scroll_button',\\n        });\\n    }\\n    server.forEach((list, index) => {\\n        var title = pdfh(list, 'Text');\\n        d.push({\\n            title: Playlined.indexOf(title) >= 0 ? '\\\\t““””' + '-'.fontcolor(\\\"#277686\\\") + title.bold()\\n                .fontcolor(\\\"#277686\\\") + '-\\\\t'.fontcolor(\\\"#277686\\\") : '\\\\t-““””' + title.bold() + '-\\\\t',\\n            url: pdfh(list, 'a&&data-link') + lazy,\\n            col_type: 'scroll_button',\\n        });\\n    })\\n    d.push({\\n        col_type: 'blank_block'\\n    })\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\n})\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\n})\\n\\nlet info = pdfa(html, '.post-meta&&.cats&&a');\\ninfo.forEach((list, index) => {\\n    var title = pdfh(list, 'Text');\\n    d.push({\\n        title: index == 1 ? '‘‘Maker:’’' + title : (index > 1 ? '‘‘Cast:’’' + title : title),\\n        url: pd(list, 'a&&href') + '##fypage@rule=js:$.require(\\\"yi\\\")',\\n        col_type: 'scroll_button',\\n        extra: {\\n            pageTitle: title\\n        }\\n    });\\n    if (index == 1) {\\n        d.push({\\n            col_type: \\\"blank_block\\\"\\n        })\\n    }\\n})\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\n})\\nd.push({\\n    col_type: \\\"blank_block\\\"\\n})\\nlet tags = pdfa(html, '.post-meta&&.tags&&a');\\ntags.forEach((list, index) => {\\n    var title = pdfh(list, 'Text');\\n    d.push({\\n        title: '““' + title + '””',\\n        url: pd(list, 'a&&href') + '##fypage@rule=js:$.require(\\\"yi\\\")',\\n        col_type: 'flex_button',\\n        extra: {\\n            pageTitle: title\\n        }\\n    });\\n})\\n\\nd.push({\\n    title: '<span style=\\\"color: #FFFFFF;\\\">𝐘𝐨𝐮 𝐌𝐚𝐲 𝐀𝐥𝐬𝐨 𝐋𝐢𝐤𝐞</span>',\\n    col_type: 'rich_text'\\n});\\n\\nvar list = pdfa(html, \\\".posts&&.post\\\");\\nlist.forEach(item => {\\n    var img = pd(item, \\\"img&&data-original\\\");\\n    var title = pdfh(item, \\\"a&&title\\\")\\n        .replace(\\\"[中文字幕]\\\", \\\"🇨🇳\\\")\\n        .replace(\\\"[无码破解]\\\", \\\"🔥\\\")\\n        .replace(\\\"[4K]\\\", \\\"🖥\\\")\\n        .replace(\\\"[英文字幕]\\\", \\\"🇺🇸\\\");\\n    d.push({\\n        title: title,\\n        desc: pdfh(item, \\\".meta--.date&&Text\\\"),\\n        img: img.replace(/(http.*?\\\\.(?:jpg|webp|png|jpeg)).*/, \\\"$1\\\"),\\n        url: pdfh(item, \\\"a&&href\\\") + '@rule=js:$.require(\\\"er\\\")',\\n        col_type: \\\"movie_2\\\",\\n        extra: {\\n            pageTitle: title\\n        }\\n    })\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\n})\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"解析\",\"path\":\"lazy\",\"rule\":\"var lazy = $('').lazyRule(() => {\\n    //JPA等线路挂了已屏蔽，需要可去二级恢复\\n    //TV线路//FST线路//VOE线路//ST线路//DS线路//VTU线路\\n    var id = input.split('').reverse().join('');\\n    var url = `https://lk1.supremejav.com/supjav.php?c=${id}`;\\n    var referer = `https://lk1.supremejav.com/supjav.php?l=${input}`;\\n    var location = JSON.parse(fetch(url, {\\n        headers: {\\n            \\\"Referer\\\": referer,\\n        },\\n        onlyHeaders: true\\n    })).url.replace(/#.*/, \\\"\\\")\\n\\n    if (location.includes(\\\"emturbovid\\\")) {\\n        //TV线路\\n        var domain = getHome(location)\\n        var path = fetch(location, {\\n            headers: {\\n                'Referer': referer\\n            }\\n        }).match(/'.*?(\\\\/.*?\\\\.m3u8)/)[1]\\n        var playUrl = path.includes(\\\"com\\\") ? \\\"https:\\\" + path : getHome(location) + path\\n        return playUrl + \\\";{Referer@\\\" + location + \\\"}\\\"\\n    } else if (/cindyeyefinal|fc2stream|michaelapplysome/.test(location)) {\\n        //FST线路//VOE线路\\n        var urlPlay = fetch(location, {\\n            headers: {\\n                'Referer': referer\\n            }\\n        }).match(/https?.*?m3u8[^\\\"]+/)[0]\\n        return urlPlay + \\\";{Referer@\\\" + location + \\\"}\\\"\\n    } else if (location.includes(\\\"streamtape\\\")) {\\n        //ST线路\\n        var html = fetch(location, {\\n            headers: {\\n                'Referer': referer\\n            }\\n        })\\n        var pattern = html.match(/\\\\('#(.*)'\\\\)/)[1]\\n        var src = \\\"var srclink = \\\" + html.match(new RegExp(\\\"'\\\" + pattern + \\\".*?=([^;]+)\\\"))[1]\\n        eval(src)\\n        var link = \\\"https:\\\" + srclink + \\\"&stream=1\\\"\\n        var urlPlay = JSON.parse(fetch(link, {\\n            headers: {\\n                \\\"Referer\\\": location,\\n            },\\n            onlyHeaders: true\\n        })).url\\n        return urlPlay + \\\";{Referer@\\\" + location + \\\"}\\\"\\n    } else if (/d0000d|dood|ds2play/.test(location)) {\\n        //DS线路\\n        var html = fetch(location, {\\n            headers: {\\n                'Referer': referer\\n            }\\n        })\\n        var pass_md5 = getHome(location) + html.match(/\\\\/pass_md5[^\\\"']+/)[0]\\n        var token = html.match(/cookieIndex.*?\\\\'(.*?)\\\\'/)[1]\\n        var data = fetch(pass_md5, {\\n            headers: {\\n                \\\"Referer\\\": location\\n            }\\n        })\\n\\n        function makePlay(token) {\\n            for (var a = \\\"\\\",\\n                    t = \\\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\\\",\\n                    n = t.length,\\n                    o = 0; 10 > o; o++)\\n                a += t.charAt(Math.floor(Math.random() * n));\\n            return a + \\\"?token=\\\" + token + \\\"&expiry=\\\" + Date.now();\\n        };\\n        var urlPlay = data + makePlay(token)\\n        return urlPlay + \\\"#isVideo=true#;{Referer@\\\" + location + \\\"}\\\"\\n    } else if (location.includes(\\\"vtbe.to\\\")) {\\n        //VTU线路\\n        function evaldecode(text) {\\n            var code = '';\\n            var s = text.replace(/^eval/, '')\\n                .replace('return p', 'code+=p')\\n            eval(s);\\n            return code;\\n        }\\n\\n        const hostRegex = (url) => {\\n            const match = url.match(/^(?:https?:\\\\/\\\\/)?(?:www\\\\.)?([a-zA-Z0-9-]{1,63}\\\\.)+[a-zA-Z]{2,6}/i);\\n            return match ? match[0] : url;\\n        };\\n\\n        let host = hostRegex(referer)\\n\\n        var html = fetch(location, {\\n            headers: {\\n                Referer: host,\\n            }\\n        })\\n        var iframe = pdfa(html, \\\"iframe\\\");\\n        \\n        if (iframe.length>0) {\\n            html = fetch(pdfh(iframe[0], \\\"iframe&&src\\\"), {\\n                headers: {\\n                    Referer: host,\\n                }\\n            })\\n        }\\n\\n        var scripts = pdfa(html, \\\"body&&script\\\");\\n        let script = scripts.filter(x => x.includes('eval')).map(m => pdfh(m, \\\"script&&Html\\\"))[0];\\n        if(script==undefined){\\n            return 'toast://无数据'\\n        }\\n        \\n        let m3u8 = /file:\\\"(.*?)\\\"/g.exec(evaldecode(script))[1];\\n        return m3u8;\\n\\n    } else {\\n        log(\\\"革命尚未成功,同志仍需努力=>\\\" + location)\\n        return \\\"confirm://咳,本线路这个地址并没有解析，日志已打印出，敬请查看.js:'hiker://empty' \\\"\\n    }\\n})\"}]","icon":"https://img.vinua.cn/images/zrwK4.webp","proxy":""}