小程序：吾爱吃瓜

海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@吾爱吃瓜@{"last_chapter_rule":"","title":"吾爱吃瓜","author":"","url":"hiker://empty##/fyAll/fypage/","version":0,"col_type":"movie_1","class_name":"首页&今日吃瓜&点击率榜&热搜黑料","type":"video","class_url":"page&category/jrcg&category/djvb&category/rshl","area_name":"猎奇重口&反差黑料&必撸优品&明星黑料&学生校园","area_url":"category/lqzk&category/fchl&category/blyp&category/mxhl&category/xsxy","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar d = [];\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: putMyVar('keyword', '') || \"\",\n            onChange: $.toString(() => {\n                putMyVar('keyword', '');\n            })\n        }\n    });\n}\n//var html = getResCode()\nvar host = config.host\nMY_URL = MY_URL.replace(\"hiker://empty##\",host)\nvar html = fetch(MY_URL)\nlog(MY_URL)\nrc('https://mirror.ghproxy.com/https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\nkey = 'f5d965df75336270';\niv = '97b60394abc2fbe1';\n\nvar list = pdfa(html, 'body&&article:not(:has(meta[content=51黑料官方])):not(:has(meta[content=广告]))');\nfor (var j in list) {\nvar title = pdfh(list[j], 'h2&&Text')\nvar img = pdfh(list[j], 'script&&Html')\nvar date = pdfh(list[j],'.post-card-info&&Text')\nif (title != ''&& date!=\"\"){\n    d.push({\n        title: pdfh(list[j], 'h2&&Text'),\n        img: img ? img.match(/\\'(.*?)\\'/)[1] + '@js=' + imgDec(key, iv, 'AES'):'https://images.xoowbs.com/upload/xiao/20230812/2023081218191369411.png',\n        desc: pdfh(list[j],'.wraps&&Text') + '\\t\\t' + date.match(/\\d+\\s年\\s\\d+\\s月\\s\\d+\\s日/),\n        url: pd(list[j], 'a&&href')+  '@rule=js:$.require(\"hiker://page/erji\")',\n        col_type: 'movie_1'\n    });\n  }}\n\nsetResult(d)","search_url":"hiker://empty##/search/**/fypage/","group":"②🌹","searchFind":"js:\nvar d = [];\n//var html = getResCode()\nvar host = config.host\nMY_URL = MY_URL.replace(\"hiker://empty##\",host)\nvar html = fetch(MY_URL)\nlog(MY_URL)\nrc('https://mirror.ghproxy.com/https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\nkey = 'f5d965df75336270';\niv = '97b60394abc2fbe1';\n\nvar list = pdfa(html, 'body&&article:not(:has(meta[content=51黑料官方])):not(:has(meta[content=广告]))');\nfor (var j in list) {\nvar title = pdfh(list[j], 'h2&&Text')\nvar img = pdfh(list[j], 'script&&Html')\nif (title != ''){\n    d.push({\n        title: pdfh(list[j], 'h2&&Text'),\n        img: img ? img.match(/\\'(.*?)\\'/)[1] + '@js=' + imgDec(key, iv, 'AES'):'https://images.xoowbs.com/upload/xiao/20230812/2023081218191369411.png',\n        desc: pdfh(list[j],'.wraps&&Text') + '\\t\\t' + pdfh(list[j],'.post-card-info&&Text').match(/\\d+\\s年\\s\\d+\\s月\\s\\d+\\s日/),\n        url: pd(list[j], 'a&&href')+  '@rule=js:$.require(\"hiker://page/erji\")',\n        col_type: 'movie_2'\n    });\n  }}\n\nsetResult(d)","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"pic_1","sdetail_find_rule":"","ua":"mobile","preRule":"//    https://www.52cg.guru/\n//    https://52cg.day/\n\n\nvar 更新间隔 = 7\nlet time = new Date().getTime().toString()\nlet 时间间隔 = time-getItem('time', new Date().getTime().toString())\n//log(\"当前时间戳\"+time)\n//log(\"间隔时间戳\"+时间间隔)\nlet 间隔天数 = Math.floor(时间间隔 / (24 * 60 * 60 * 1000));\nlet 间隔时数 = Math.floor(时间间隔 / (60 * 60 * 1000));\nlet 间隔分数 = Math.floor(时间间隔 / ( 60 * 1000));\nlet 间隔秒数 = Math.floor(时间间隔 / 1000);\n    //log(\"间隔时间====\"+间隔秒数+\"秒\")\n\nif (间隔天数>=更新间隔 || !getItem('link', '').startsWith('http')) {\n    let fabu = \"https://www.52cg.guru/\"\n    let js1 = pdfh(fetch(fabu),\"script&&Html\")\n    let js2 = pdfh(fetch(fabu),\"script,1&&Html\").replace(\"document.write\\(\",\"\").replace(\"\\)\\;\",\"\")\n    eval(js1)\n    var tips = pdfh(eval(js2),\"body&&script,1&&Html\").replace(/location\\.protocol/g,\"\\\"https\\:\\\"\")\n    var Vx = fetch(fabu + \"js/Vx.js?t=v8\")\n    eval(Vx)\n    eval(tips)\n    //log(lineAry)实时线路\n    //log(backupLine)备用地址\n    var url = lineAry[Math.floor(Math.random() * lineAry.length)]\n    let link = url\n\n    setItem('time', time);\n    setItem('link', link);\n    //toast('更新域名');\n    log(\"最新地址:\"+link)\n     confirm({\n        title:'吾爱吃瓜', \n        content:'已更新网址为\\n'+link, \n        confirm:$.toString(()=>{}), \n        cancel:$.toString(()=>{})\n    })\n\n    }\n\ninitConfig({\n    host: getItem('link', 'https://www.52chigua1.com/')\n});","pages":"[{\"col_type\":\"flex_button\",\"name\":\"二级\",\"path\":\"erji\",\"rule\":\"js:\\nvar d = [];\\nvar html = getResCode()\\nrc('https://mirror.ghproxy.com/https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\nkey = 'f5d965df75336270';\\niv = '97b60394abc2fbe1';\\n\\n//标题\\nd.push({\\n    title: '‘‘’’<strong>' + pdfh(html, '.post-title&&Text') + '</strong>',\\n    desc: '‘‘’’<small>' + parseDomForHtml(html, '.post-meta&&Text') + '</small>',\\n    url: MY_URL,\\n    col_type: 'text_center_1',\\n});\\n\\nd.push({\\n    col_type: 'line',\\n});\\n\\n//视频\\n    var list = parseDomForArray(html, '.post-content&&.dplayer');\\nfor (let j in list) {\\n    d.push({\\n        title: '““视频””' + (Number(j) + 1),\\n        url: pdfh(html, '.dplayer&&data-config') + `@lazyRule=.js:\\n           JSON.parse(input).url`,\\n        col_type: 'text_2',\\n    });\\n}\\n\\n\\n\\n//正文\\n\\nvar texts = pdfa(html, 'body&&.post-content>p:not(:has(.content-file)):not(p:matches(如遇视频无法播放)~p):not(:matches(如遇视频无法播放))');\\ntexts.forEach((item, index) => {\\n    if (pdfh(item, 'p&&Text') && !pdfh(item, 'p&&Text').startsWith(\\\"#\\\")) {\\n        d.push({\\n            title: pdfh(item, 'p&&Text'),\\n            url: pdfh(item, 'a&&href') + '@rule=js:$.require(\\\"hiker://page/erji\\\")',\\n            col_type: 'rich_text',\\n        });\\n    }\\n    var imgs = pdfa(item, 'p&&img').map(h => pdfh(h, 'img&&data-xkrkllgl'));\\n    imgs.forEach(item2 => {\\n        d.push({\\n            title: '',\\n            img: item2 + '@js=' + imgDec(key, iv, 'AES'),\\n            url: item2 + '@js=' + imgDec(key, iv, 'AES'),\\n            col_type: 'pic_1_full'\\n        });\\n    });\\n});\\n\\nsetResult(d)\"}]","icon":"data:image/png;base64,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","proxy":""}