Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@𝐒𝐮𝐩𝐣𝐚𝐯@{"last_chapter_rule":"","title":"𝐒𝐮𝐩𝐣𝐚𝐯","author":"R","url":"hiker://empty##https://supjav.com/zh/##fypage","version":20250421,"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:\n    addListener(\"onClose\", () => {\n        clearMyVar(\"nextPage\");\n    });\n/*\naddListener(\"onRefresh\", () => {\n    clearMyVar(\"nextPage\");\n});\n*/\nvar d = []\n//var res = []\nMY_URL = MY_URL.split(\"##\")[1]\nvar true_url = getMyVar(\"url\", MY_URL);\nlet nextPage = getMyVar(\"nextPage\", \"\");\nif (nextPage && MY_PAGE > 1) {\n    true_url = nextPage;\n} else if (MY_PAGE > 1) {\n    true_url = \"没有下一页哦😑\"\n}\n//var html = fetch(true_url, JSON.parse(getMyVar('headers')))\n//var html = fetchCodeByWebView(true_url)\n\nlog(true_url)\n\neval(JSON.parse(fetch('hiker://page/fetch', {}))\n    .rule);\nvar html = Supfetch(true_url)\n\n    //log(html)\ntry {\n    let nextUrl = pd(html, \".pagination&&.active+li&&a&&href\");\n    putMyVar(\"nextPage\", nextUrl);\n} catch (e) {\n    clearMyVar(\"nextPage\");\n    // toast(\"好像没有下一页了！\");\n}\n\nfunction getHead(title, color) {\n    return '‘‘’’<strong><font color=\"' + color + '\">' + title + '</front></strong>';\n}\n\n$.require(\"category\")()\n\nif (html.includes(\"请稍候…\") || html.includes(\"Just a moment\") || html.includes(\"<title>Error</title>\") || (!html && MY_PAGE == 1)) {\n    d.push({\n        title: '““””' + '先点此获取Cookie后，再回到此页面'.fontcolor('#FF00FF').big(),\n        url: $('').lazyRule((true_url) => {\n                   putMyVar(\"fetch\", \"1\");            \n                   return true_url           \n                },true_url),\n        col_type: 'text_center_1',\n        extra: {\n            lineVisible: false,\n        }\n    }, {\n        title: '““””' + '点此刷新'.fontcolor('#FF0000').big(),\n        url: $('#noLoading#').lazyRule(() => {\n            refreshPage()\n            return \"hiker://empty\"\n        }),\n        col_type: 'text_center_1',\n        extra: {\n            lineVisible: false,\n        }\n    }, /*{\n        title: '““””' + '<u>(稳定+快)机场</u>'.fontcolor('#FF6699').big().big() + '\\nxx元/T/月，最低x元/T'.fontcolor('green').big(),\n        desc: '香港节点可以过supjav.com验证',\n        url: \"\",\n        col_type: 'text_center_1',\n        extra: {\n            lineVisible: false,\n        }\n    }*/);\n}\n\nvar getRangeColors = function() {\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\n}\n\nif (true_url == \"https://supjav.com/zh/\") {\n    if (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//setPreResult(res)\nsetResult(d)","search_url":"https://supjav.com/zh/page/fypage?s=**","group":"②生","searchFind":"js:\nMY_URL = MY_URL.replace(/fc2-?ppv-?|fc2-?/i,\"\")\n$.require(\"yi\")","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"/*\nif (!getMyVar('headers')){\nputMyVar('headers',{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}\n*/\nvar 更新间隔 = 1\nlet time = new Date().getTime().toString()\n\nfunction countCrossedDays(date1, date2) {\n    var d1 = new Date(Number(date1));\n    var d2 = new Date(Number(date2));\n    // 获取完整日期部分\n    var start = new Date(d1.getFullYear(), d1.getMonth(), d1.getDate());\n    var end = new Date(d2.getFullYear(), d2.getMonth(), d2.getDate());\n    // 判断开始和结束日期\n    var timeDifference = Math.abs(end - start);\n    // 计算跨越的天数\n    var crossedDays = Math.ceil(timeDifference / (1000 * 60 * 60 * 24));\n    return crossedDays; // 返回跨越的天数\n}\nvar 跨越天数 = countCrossedDays(time, getItem('time', new Date().getTime()))\n//log(跨越天数)\nif (跨越天数 >= 更新间隔) {\n    setItem('time', time);\n\n    function localversion() {\n        try {\n            return MY_RULE.version\n        } catch {\n            return 'underfind'\n        }\n    }\n\n    function remoteversion() {\n        try {\n            eval(fetch(base64Decode('aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL0Fwb2xsb1Jpb28vUi9tYXN0ZXIvSGlrZXIv') + MY_RULE.title))\n            return Apollo.version\n        } catch {\n            return 'underfind'\n        }\n    }\n    if ((remoteversion() != 'underfind' && remoteversion() != localversion()) || localversion() == 'underfind') {\n        showLoading('检测到新版本，更新中...')\n        //java.lang.Thread.sleep(3000);\n        hideLoading()\n        eval(fetch(base64Decode('aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL0Fwb2xsb1Jpb28vUi9tYXN0ZXIvSGlrZXIv') + MY_RULE.title));\n        confirm({\n            title: '更新提示',\n            content: '检测到小程序版本低于服务器版本，是否立即更新',\n            confirm: $.toString((up) => {\n                return parsePaste(up);\n            }, Apollo.update),\n            cancel: $.toString(() => {\n                refreshPage()\n            })\n        })\n    }\n}","pages":"[{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"category\",\"rule\":\"$.exports = () => {\\n    addListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"sort\\\");\\n        clearMyVar(\\\"pagi\\\");\\n        // clearMyVar(\\\"url\\\");   \\n    }));\\n    /*addListener(\\\"onRefresh\\\", () => {\\n        clearMyVar(\\\"sort\\\");\\n        clearMyVar(\\\"pagi\\\");\\n        clearMyVar(\\\"url\\\");\\n        clearMyVar(\\\"tab\\\");\\n    });*/\\n\\n    eval(JSON.parse(fetch('hiker://page/yiyan', {})).rule);\\n\\n    if (MY_PAGE == 1) {\\n        d.push({\\n            title: \\\"🔍\\\",\\n            url: $.toString((r) => {\\n                if (input.trim() != \\\"\\\") {\\n                    putMyVar('keyword', input);\\n                    var searchUrl = \\\"https://supjav.com/zh/?s=\\\" + input.replace(/fc2-?ppv-?|fc2-?/i, \\\"\\\")\\n                    putMyVar(\\\"url\\\", searchUrl);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\"\\n                } else {\\n                    return `confirm://${r}.js:'hiker://empty'`\\n                }\\n            }, day_say),\\n            desc: day_say, // '曾经沧海难为水,除却巫山不是云',\\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();\\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    \\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 ? currentu.replace(/\\\\/page\\\\/\\\\d+/, \\\"\\\") : \\\"https://supjav.com/zh/\\\"\\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\\n    if (!currentu.includes(\\\"popular\\\")) {\\n        lastu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + (lastp - 0))\\n        lastp = lastp - 0\\n    }\\n\\n    var longClick = [{\\n        title: \\\"首页\\\",\\n        js: $.toString((firstu) => {\\n            putMyVar(\\\"url\\\", firstu);\\n            refreshPage();\\n            return 'hiker://empty'\\n        }, firstu),\\n    }, {\\n        title: \\\"上页\\\",\\n        js: $.toString((active, currentu) => {\\n            if (active > 1) {\\n                var jumpu = currentu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + (parseInt(active) - 1))\\n                putMyVar(\\\"url\\\", jumpu);\\n                refreshPage();\\n                return 'hiker://empty'\\n            }\\n        }, active, currentu),\\n    }, {\\n        title: \\\"第\\\" + active + \\\"页\\\",\\n        js: \\\"\\\",\\n    }, {\\n        title: \\\"跳转\\\",\\n        js: $.toString((lastu, lastp) => {\\n            return $('', '除首页和尾页之外的页码').input((lastu, lastp) => {\\n                if (parseInt(input) > 0 && parseInt(input) <= parseInt(lastp) && parseInt(input) % 1 == 0) {\\n                    var jumpu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + input)\\n                    putMyVar(\\\"url\\\", jumpu);\\n                    refreshPage();\\n                    return 'hiker://empty'\\n                } else {\\n                    return \\\"toast://请输入正确的页码\\\"\\n                }\\n            }, lastu, lastp)\\n        },lastu, lastp),\\n    }, {\\n        title: \\\"尾页\\\" + lastp,\\n        js: $.toString((lastp, lastu) => {\\n            putMyVar(\\\"url\\\", lastu);\\n            refreshPage();\\n            return 'hiker://empty'\\n        }, lastp, lastu),\\n    }];\\n\\n    putMyVar(\\\"longClick\\\",longClick)\\n\\n    var 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]\\n    if (currentu !== \\\"https://supjav.com/zh/\\\" && true_url != \\\"没有下一页哦😑\\\") {\\n\\n        for (var j in title) {\\n            var url = urls[j] + $(\\\"#noLoading#\\\").lazyRule((j) => {\\n                putMyVar(\\\"url\\\", input);\\n                refreshPage();\\n                return 'hiker://empty'\\n            }, j)\\n\\n            if (j == 1) {\\n                url = $('', '除首页和尾页之外的页码').input((lastu, lastp) => {\\n                    if (parseInt(input) > 0 && parseInt(input) <= parseInt(lastp) && parseInt(input) % 1 == 0) {\\n                        var jumpu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + input)\\n                        putMyVar(\\\"url\\\", jumpu);\\n                        refreshPage();\\n                        return 'hiker://empty'\\n                    } else {\\n                        return \\\"toast://请输入正确的页码\\\"\\n                    }\\n                }, lastu, lastp)\\n            }\\n            if (MY_PAGE == 1) {\\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    }\\n\\n    if (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();\\n                    return 'hiker://empty'\\n                }, j)\\n            })\\n        }\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"列表\",\"path\":\"list\",\"rule\":\"$.exports = () => {\\n    var list = pdfa(html, \\\".posts&&.post\\\");\\n    list.forEach(item => {\\n        var img = pd(item, \\\"img&&data-original\\\");\\n        var title = pdfh(item, \\\"a&&title\\\").replace(\\\"[中文字幕]\\\", \\\"🇨🇳\\\").replace(\\\"[\\\\u65e0\\\\u7801破解]\\\", \\\"🔥\\\").replace(\\\"[4K]\\\", \\\"🖥\\\").replace(\\\"[英文字幕]\\\", \\\"🇺🇸\\\").replace(\\\"【SupJAV-独家】\\\", \\\"\\\");\\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                desc: pdfh(item, \\\".meta--.date&&Text\\\"),\\n                pageTitle: title,\\n                longClick: JSON.parse(getMyVar(\\\"longClick\\\",\\\"\\\"))\\n            }\\n        })\\n    })\\n    d.push({\\n        col_type: \\\"big_blank_block\\\"\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"标签\",\"path\":\"tabs\",\"rule\":\"var 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        extra: {\\n            longClick: JSON.parse(getMyVar(\\\"longClick\\\", \\\"\\\"))\\n        }\\n    })\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\n})\\nd.push({\\n    col_type: \\\"big_blank_block\\\"\\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: (i == 0 ? \\\"长按功能\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\" : \\\"\\\") + '<middle><font color=red>+\\\\t\\\\t\\\\t\\\\t  𝐌𝐨𝐫𝐞</font></middle>',\\n        img: \\\"https://img.vinua.cn/images/IIenX.png\\\",\\n        url: pdfh(tabs[i], 'a&&href').replace(\\\"com/popular\\\",\\\"com/zh/popular\\\") + $(\\\"#noLoading#\\\").lazyRule((i) => {\\n                    putMyVar('tab', i + 1)\\n                    putMyVar(\\\"url\\\", input);\\n                    refreshPage();\\n                    return 'hiker://empty'\\n                }, i), //'##fypage@rule=js:$.require(\\\"yi\\\")',\\n        col_type: \\\"avatar\\\",\\n        extra: {\\n            lineVisible: false,\\n            longClick: i == 0 ? [{\\n                title: '读取源码默认方式',\\n                js: $.toString(() => {\\n                    putMyVar(\\\"fetch\\\", \\\"0\\\");\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                })\\n            }] : \\\"\\\"\\n        }\\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(\\\"[\\\\u65e0\\\\u7801破解]\\\", \\\"🔥\\\").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: {\\n                desc: pdfh(list[j], '.meta--.date&&Text'),\\n                pageTitle: title\\n            }\\n        });\\n    }\\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        })\"},{\"col_type\":\"movie_3\",\"name\":\"一级\",\"path\":\"yi\",\"rule\":\"js:\\n    addListener(\\\"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} else if (MY_PAGE > 1) {\\n    MY_URL = \\\"没有下一页哦😑\\\"\\n}\\n//var html = fetchCodeByWebView(MY_URL)\\n//var html = fetch(MY_URL)\\n\\neval(JSON.parse(fetch('hiker://page/fetch', {}))\\n    .rule);\\nvar html = Supfetch(MY_URL)\\n\\ntry {\\n    var nextUrll = pd(html, \\\".pagination&&.active+li&&a&&href\\\");\\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 = MY_URL.replace(/\\\\/page\\\\/\\\\d+/, \\\"\\\")\\n    var active = currentu.match(/\\\\/page\\\\/(\\\\d+)/) ? currentu.match(/\\\\/page\\\\/(\\\\d+)/)[1] : 1;\\n    var lastu = pdfh(pagination.pop(), \\\"a&&href\\\") || MY_URL\\n    var lastp = lastu.match(/\\\\/page\\\\/(\\\\d+)/) ? lastu.match(/\\\\/page\\\\/(\\\\d+)/)[1] : 1;\\n\\n    var longClick = [{\\n        title: \\\"首页\\\",\\n        js: $.toString((firstu) => {\\n            putMyVar(\\\"yurl\\\", firstu);\\n            refreshPage();\\n            return 'hiker://empty'\\n        }, firstu),\\n    }, {\\n        title: \\\"上页\\\",\\n        js: $.toString((active, currentu) => {\\n            if (active > 1) {\\n                var jumpu = currentu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + (parseInt(active) - 1))\\n                putMyVar(\\\"yurl\\\", jumpu);\\n                refreshPage();\\n                return 'hiker://empty'\\n            }\\n        }, active, currentu),\\n    }, {\\n        title: \\\"第\\\" + active + \\\"页\\\",\\n        js: \\\"\\\",\\n    }, {\\n        title: \\\"跳转\\\",\\n        js: $.toString((lastu, lastp) => {\\n            return $('', '除首页和尾页之外的页码').input((lastu, lastp) => {\\n                if (parseInt(input) > 0 && parseInt(input) <= parseInt(lastp) && parseInt(input) % 1 == 0) {\\n                    var jumpu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + input)\\n                    putMyVar(\\\"yurl\\\", jumpu);\\n                    refreshPage();\\n                    return 'hiker://empty'\\n                } else {\\n                    return \\\"toast://请输入正确的页码\\\"\\n                }\\n            }, lastu, lastp)\\n        }, lastu, lastp),\\n    }, {\\n        title: \\\"尾页\\\" + lastp,\\n        js: $.toString((lastp, lastu) => {\\n            putMyVar(\\\"yurl\\\", lastu);\\n            refreshPage();\\n            return 'hiker://empty'\\n        }, lastp, lastu),\\n    }];\\n\\n    var 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]\\n    if (currentu !== \\\"https://supjav.com/zh/\\\" && MY_URL != \\\"没有下一页哦😑\\\") {\\n\\n        for (var j in title) {\\n            var url = urls[j] + $(\\\"#noLoading#\\\").lazyRule((j) => {\\n                putMyVar(\\\"yurl\\\", input);\\n                refreshPage();\\n                return 'hiker://empty'\\n            }, j)\\n\\n            if (j == 1) {\\n                url = $('', '除首页和尾页之外的页码').input((lastu, lastp) => {\\n                    if (parseInt(input) > 0 && parseInt(input) <= parseInt(lastp) && parseInt(input) % 1 == 0) {\\n                        var jumpu = lastu.replace(/\\\\/page\\\\/\\\\d+/, \\\"/page/\\\" + input)\\n                        putMyVar(\\\"yurl\\\", jumpu);\\n                        refreshPage();\\n                        return 'hiker://empty'\\n                    } else {\\n                        return \\\"toast://请输入正确的页码\\\"\\n                    }\\n                }, lastu, lastp)\\n            }\\n            if (MY_PAGE == 1) {\\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    }\\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();\\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(\\\"[\\\\u65e0\\\\u7801破解]\\\", \\\"🔥\\\").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: {\\n            desc: pdfh(item, \\\".meta--.date&&Text\\\"),\\n            pageTitle: title,\\n            longClick: longClick\\n        }\\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)\\n//var html = fetchCodeByWebView(MY_URL);\\n//var html = fetch(MY_URL)\\n\\neval(JSON.parse(fetch('hiker://page/fetch', {}))\\n    .rule);\\nvar html = Supfetch(MY_URL)\\n\\neval(JSON.parse(fetch('hiker://page/lazy', {}))\\n    .rule);\\n\\nvar title = pdfh(html, '.archive-title&&Text')\\n    .replace(\\\"[中文字幕]\\\", \\\"🇨🇳\\\")\\n    .replace(\\\"[\\\\u65e0\\\\u7801破解]\\\", \\\"🔥\\\")\\n    .replace(\\\"[4K]\\\", \\\"🖥\\\")\\n    .replace(\\\"[英文字幕]\\\", \\\"🇺🇸\\\");\\nvar 识别码 = title.replace(\\\"FC2PPV \\\",\\\"\\\").match(/\\\\w+(?:-|_)\\\\w+|\\\\w+\\\\d\\\\w+|\\\\w+\\\\s\\\\w+/)[0]\\nif (title !== null) {\\n    d.push({\\n        title: '““””<small><font color=#e57a1a>' + title + '</font></small>',\\n        url: \\\"hiker://empty\\\" + $('#noLoading#').lazyRule((title) => {\\ntitle = title.replace(/FC2PPV\\\\s\\\\d+/,\\\"\\\").replace(/\\\\w+-\\\\d+\\\\s/,\\\"\\\")\\n//动态刷新\\nvar desc = findItem('transdesc').desc\\n          if(!desc){\\n    var translates = $.require(\\\"trans\\\").translate(title)\\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(title)   \\n          return \\\"confirm://\\\" + translates + \\\".js:'hiker://empty' \\\"   */\\n                },title),\\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\\nvar img = pd(html, \\\".post-meta&&img&&src\\\");\\nif (img !== null) {\\n    d.push({\\n        img: img,\\n        url: MY_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: \\\"><small>𝐒𝐄𝐑𝐕𝐄𝐑 ：已屏蔽JPA等无用线路。____'+MY_PARAMS.desc+'</small></span>',\\n    url: 识别码 + $('')\\n        .lazyRule(() => {\\n        return \\\"hiker://page/yi?rule=𝐒𝐮𝐩𝐣𝐚𝐯&url=\\\" + \\\"https://supjav.com/zh/?s=\\\" + input\\n    }),\\n    col_type: 'text_1',\\n    extra: {\\n        lineVisible: false,        \\n    }\\n});\\nd.push({\\n    col_type: \\\"blank_block\\\"\\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|NinjaStream|MD|GoUnlimited|Mixdrop))'); //屏蔽线路🈲🈲🈲🈲🈲🈲\\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, indexx) => {\\n        var title = pdfh(list, 'Text');\\n        d.push({\\n            title: Playlined.indexOf(title) >= 0 ? '\\\\t\\\\t\\\\t““””' + title.bold()\\n                .fontcolor(\\\"#277686\\\") + '\\\\t\\\\t\\\\t': '““””' + title.bold(),\\n            url: pdfh(list, 'a&&data-link') + lazy,\\n            col_type: 'scroll_button',\\n            extra: {\\n                cls: \\\"playlist \\\" + index + indexx\\n              }\\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\\nd.push({\\n    title: \\\"‘‘\\\"+识别码+\\\"’’\\\",\\n    url: 识别码 + $('')\\n        .lazyRule(() => {\\n        return \\\"hiker://page/yj?rule=𝐉𝐚𝐯𝐃𝐁&url=\\\" + getPublicItem('javdb0', 'https://javdb.com') + \\\"/search？？f=all＆＆page=fypage＆＆q=\\\" + input\\n    }),//\\\"https://t.me/Supjavcom#ignoreVideo=true#\\\",\\n    col_type: \\\"scroll_button\\\",\\n    extra: {\\n               pageTitle: 识别码,\\n               longClick: [{\\n                   title: \\\"复制识别码\\\",\\n                   js: $.toString((识别码) => {\\n                    return \\\"copy://\\\" + 识别码\\n                }, 识别码)\\n                 }]\\n    }\\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,\\nlongClick: index > 1 ? [{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    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    url: \\\"hiker://empty\\\",\\n    col_type: 'text_1',\\n    extra: {\\n        lineVisible: false,\\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\\\")\\n        .replace(\\\"[中文字幕]\\\", \\\"🇨🇳\\\")\\n        .replace(\\\"[\\\\u65e0\\\\u7801破解]\\\", \\\"🔥\\\")\\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            desc: pdfh(item, \\\".meta--.date&&Text\\\")\\n        }\\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        })\\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    // 定义一个解析分辨率的函数\\n    function getResolution(name) {\\n        var match = name.match(/(\\\\d+)/); // 提取降级分辨率\\n        return match ? parseInt(match[1], 10) : 0; // 如果没有匹配则返回0\\n    }\\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    log(\\\"线路地址：\\\" + location)\\n\\n    if (location.includes(\\\"emturbovid\\\")) {\\n\\n        //①TV线路\\n        var domain = getHome(location)\\n        var path = fetch(location, {\\n            headers: {\\n                'Referer': referer\\n            }\\n        });\\n        var playUrl = path.match(/https?.*?\\\\.m3u8/)[0];\\n        var group_quality = fetch(playUrl, {\\n            headers: {\\n                'Referer': location\\n            }\\n        });\\n        //log(group_quality)\\n        hghest_quality = group_quality.match(/^[^#\\\\s]+$/gm).map(v => v.includes(\\\"http\\\") ? v + \\\"#isVideo=true#\\\" : playUrl.replace(/[^\\\\/]+$/, v))\\n        //log(hghest_quality)\\n        name_quality = group_quality.match(/RESOLUTION=.*?\\\\,/gm).map(n => n.replace(/RESOLUTION=|\\\\,/g, \\\"\\\"))\\n\\n        // 按分辨率降序排序 分辨率 数组，并同时调整 hghest_quality\\n        var sortedData = name_quality.map((name, index) => ({\\n                name,\\n                url: hghest_quality[index]\\n            }))\\n            .sort((a, b) => getResolution(b.name) - getResolution(a.name));\\n        // 分开排序后的 names 和 urls 数组\\n        var sortedNames = sortedData.map(item => item.name);\\n        var sortedUrls = sortedData.map(item => item.url);\\n        let playlist = JSON.stringify({\\n            names: sortedNames,\\n            urls: sortedUrls,\\n            headers: new Array(hghest_quality.length).fill({\\n                Referer: \\\"\\\"\\n            })\\n        });\\n        return playlist;\\n\\n    } else if (/cindyeyefinal|fc2stream|michaelapplysome/.test(location)) {\\n\\n        //②FST线路\\n        var html = fetch(location, {\\n            headers: {\\n                'Referer': referer\\n            }\\n        });\\n        var script = pdfh(html, \\\"body>script&&Html\\\").replace(\\\"eval\\\", \\\"\\\")\\n        var uas = eval(script)\\n        var playUrl = uas.match(/\\\"(https?.*m3u8.*?)\\\"/)[1]\\n        var group_quality = fetch(playUrl, {\\n            headers: {\\n                'Referer': location\\n            }\\n        });\\n        group_quality = group_quality.split(\\\"\\\\n\\\\n\\\")[0]\\n        // log(group_quality)\\n        hghest_quality = group_quality.match(/^[^#\\\\s]+$/gm).map(v => v.includes(\\\"http\\\") ? v + \\\"#isVideo=true#\\\" : playUrl.replace(/[^\\\\/]+$/, v))\\n        //log(hghest_quality)\\n        name_quality = group_quality.match(/RESOLUTION=.*?\\\\,/gm).map(n => n.replace(/RESOLUTION=|\\\\,/g, \\\"\\\"))\\n\\n        // 按分辨率降序排序 分辨率 数组，并同时调整 hghest_quality\\n        var sortedData = name_quality.map((name, index) => ({\\n                name,\\n                url: hghest_quality[index]\\n            }))\\n            .sort((a, b) => getResolution(b.name) - getResolution(a.name));\\n        // 分开排序后的 names 和 urls 数组\\n        var sortedNames = sortedData.map(item => item.name);\\n        var sortedUrls = sortedData.map(item => item.url);\\n        let playlist = JSON.stringify({\\n            names: sortedNames,\\n            urls: sortedUrls,\\n            headers: new Array(hghest_quality.length).fill({\\n                Referer: \\\"\\\"\\n            })\\n        });\\n        return playlist;\\n\\n    } else if (location.includes(\\\"streamtape\\\")) {\\n\\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 playUrl = JSON.parse(fetch(link, {\\n            headers: {\\n                \\\"Referer\\\": location,\\n            },\\n            onlyHeaders: true\\n        })).url\\n        return playUrl + \\\";{Referer@\\\" + location + \\\"}\\\"\\n\\n    } else if (/voe/.test(location)) {\\n\\n        //⑥VOE线路\\n        var html = fetch(location, {\\n            headers: {\\n                'Referer': referer\\n            }\\n        });\\n        //log(html)\\n        try {\\n            var currentUrl = html.match(/href =.*?(https?[^'\\\"]+)/)[1];\\n            //log(currentUrl)\\n        } catch {\\n            return 'toast://网页链接失效无法访问。';\\n        }\\n\\n        function x5rule(jiexurl, srcurl) {\\n            showLoading(\\\"网页访问检索中，请稍候...\\\");\\n            var video = 'webRule://' + jiexurl + '@' + $.toString((srcurl) => {\\n                    if (document.getElementsByClassName(\\\"spin\\\").length != 0) {\\n                        document.getElementsByClassName(\\\"spin\\\")[0].click()\\n                    }\\n                    var urls = _getUrls();\\n                    if (window.__count == null || window.__count == undefined) {\\n                        window.__count = 0\\n                    }\\n                    if (window.__count >= 23) {\\n                        return srcurl\\n                    }\\n                    window.__count = window.__count + 1;\\n                    if (window.__count > 1 && window.__count <= 3 && window.__count != null && window.__count != undefined) {\\n                        if (document.querySelector('body').innerText.search(/触发了防盗链|未授权|接口防盗|请到主站观看/) != -1) {\\n                            if (!srcurl) {\\n                                fba.log('尝试跳防盗验证一');\\n                                location.href = location.href;\\n                            } else {\\n                                fba.log('尝试跳防盗验证二');\\n                                location.href = srcurl\\n                            }\\n                        };\\n                    } else if (window.__count > 3 && window.__count != null && window.__count != undefined) {\\n                        if (urls.length < 1) {\\n                            fba.hideLoading();\\n                            return 'toast://检索失败，可能链接无法访问。';\\n                        } else if (urls.length == 1) {\\n                            fba.log('尝试直链与JSON解析');\\n                            if (urls[0].match(/dycdn\\\\-tos\\\\.pstatp|\\\\.m3u8|\\\\.mp4|\\\\.flv|netease\\\\.com|video_mp4|type\\\\=m3u8|pt\\\\=m3u8|\\\\/video\\\\/tos\\\\//) && !urls[0].match(/\\\\.html|m3u8\\\\.tv|m3u8\\\\.pw|\\\\&next|ac\\\\=dm|\\\\=http|https\\\\:\\\\/\\\\/[\\\\d]\\\\.m3u8|\\\\?url\\\\=\\\\/m3u8/)) {\\n                                //fy_bridge_app.log(urls[0])\\n                                return urls[0]\\n                            }\\n                        } else {\\n                            fba.log('日志检索第' + window.__count + '次');\\n                            for (var i in urls) {\\n                                if (urls[i].match(/dycdn\\\\-tos\\\\.pstatp|\\\\.m3u8|\\\\.mp4|\\\\.flv|netease\\\\.com|video_mp4|type\\\\=m3u8|pt\\\\=m3u8|\\\\/video\\\\/tos\\\\//) && !urls[i].match(/\\\\.html|m3u8\\\\.tv|m3u8\\\\.pw|\\\\&next|ac\\\\=dm|\\\\=http|https\\\\:\\\\/\\\\/[\\\\d]\\\\.m3u8|\\\\?url\\\\=\\\\/m3u8|\\\\.css|\\\\.js\\\\?/)) {\\n                                    //fy_bridge_app.log(urls[i])\\n                                    if (fy_bridge_app.getHeaderUrl) {\\n                                        return fy_bridge_app.getHeaderUrl(urls[i]).replace(\\\";{\\\", \\\"#ignoreImg=true##isVideo=true#;{\\\");\\n                                    } else {\\n                                        return urls[i] + '#isVideo=true#'\\n                                    }\\n                                }\\n                            } //end for i\\n                        }\\n                    }\\n                },\\n                srcurl);\\n            return video\\n        }\\n\\n        return x5rule(currentUrl, currentUrl);\\n        //return playUrl + \\\";{Referer@\\\" + currentUrl + \\\"}\\\"\\n\\n    } else if (/d0000d|dood|ds2play|vidply|do7go|all3do/.test(location)) {\\n\\n        //④DS线路\\n        var html = fetchCodeByWebView(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 playUrl = data + makePlay(token)\\n        return playUrl + \\\"#isVideo=true#;{Referer@\\\" + location + \\\"}\\\"\\n\\n    } else if (location.includes(\\\"vtbe.to\\\")) {\\n\\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        var hostRegex = (url) => {\\n            var 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        let host = hostRegex(referer)\\n        var html = fetch(location, {\\n            headers: {\\n                Referer: host,\\n            }\\n        })\\n        var iframe = pdfa(html, \\\"iframe\\\");\\n        if (iframe.length > 0) {\\n            html = fetch(pdfh(iframe[0], \\\"iframe&&src\\\"), {\\n                headers: {\\n                    Referer: host,\\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        let m3u8 = /file:\\\"(.*?)\\\"/g.exec(evaldecode(script))[1];\\n        return m3u8;\\n\\n    } else {\\n        log(\\\"革命尚未成功,同志仍需努力!\\\")\\n        return \\\"confirm://咳,本线路这个地址并没有解析，日志已打印出，敬请查看.js:'hiker://empty' \\\"\\n    }\\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\"},{\"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 >= 10) {\\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\":\"fetch\",\"rule\":\"function Supfetch(url) {\\n    var html;\\n    if (getMyVar(\\\"fetch\\\", \\\"0\\\") == \\\"0\\\") {\\n        html = html = fetch(url, {\\n            headers: {\\n                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0)'\\n            }\\n        })\\n    } else {\\n        html = fetchCodeByWebView(url)\\n    /*html = fetchCodeByWebView(url, {\\n                checkJs: $.toString(() => {\\n                    if (document.querySelector('.posts .post')) {\\n                        let cok = fba.getCookie(window.location.href);\\n                        fba.writeFile('hiker://files/rules/Apollo/Cookie/supjav_cookie.txt', cok);\\n                        return document.querySelector('.posts .post');\\n                    };\\n                })\\n            }); */\\n    }\\n    return html;\\n}\"}]","icon":"https://img.vinua.cn/images/zrwK4.webp","proxy":""}
Add Comment
Please, Sign In to add comment
