邀您一起看：诡异药剂师：我的病人皆为恐怖

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥诡异药剂师：我的病人皆为恐怖@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"displayName\":\"漫神·Q\",\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\".acgn-col-17&&em&&Text\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"首页\",\"rule\":\"var d = []\\npdfa(request(URL[1]), 'body&&.mult:has(h2)').forEach(j => {\\n\\n    d.push({\\n        title: pdfh(j, 'h2&&Text'),\\n        url: 'hiker://empty',\\n        col_type: 'text_1'\\n    })\\n    pdfa(j, 'ul&&.card').forEach(i => {\\n        d.push({\\n            title: pdfh(i, '.card-title&&Text'),\\n            img: pd(i, 'img&&src'),\\n            url: pd(i, 'a&&href') + '#immersiveTheme##autoCache#',\\n        })\\n    })\\n})\\nsetResult(d)\"},{\"col_type\":\"scroll_button\",\"name\":\"更新\",\"path\":\"更新\",\"rule\":\"var d = []\\nvar 周 = parseInt((getMyVar('更新', ''))||new Date().getDay()-1)+1\\n周 = 周=='0'?'7':周\\nvar host = request(URL[1] + 'update/' +周 + '.html')\\n\\npdfa(host, 'ul&&li').forEach((j, id) => {\\n    var title = pdfh(j, 'Text').slice(1)\\n    if ((getMyVar('更新', '')||(周-1)) == id)\\n        title = '““' + title + '””'\\n    d.push({\\n        title: title,\\n        url: $(pd(j, 'a&&href')).lazyRule((id) => {\\n            putMyVar('更新', id)\\n            refreshPage()\\n            return 'hiker://empty'\\n        },id),\\n        col_type: 'scroll_button'\\n    })\\n})\\npdfa(host, '.update-list&&li').forEach(i => {\\n    d.push({\\n        title: pdfh(i, '.title&&Text'),\\n        desc: pdfh(i, '.chapter&&Text'),\\n        img: pd(i, 'img&&src'),\\n        url: pd(i, 'a&&href') + '#immersiveTheme#'\\n    })\\n})\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"排行\",\"path\":\"排行\",\"rule\":\"var d = []\\nvar host = request(getMyVar('排行url', URL[1] + 'top/alldj.html'))\\n\\npdfa(host, 'ul&&li').forEach((j, id) => {\\n    var title = pdfh(j, 'Text')\\n    if ((getMyVar('排行', '')) == id)\\n        title = '““' + title + '””'\\n    d.push({\\n        title: title,\\n        url: $(pd(j, 'a&&href')).lazyRule((id) => {\\n            putMyVar('排行', id)\\n            putMyVar('排行url', input)\\n            refreshPage()\\n            return 'hiker://empty'\\n        }, id),\\n        col_type: 'scroll_button'\\n    })\\n})\\npdfa(host, 'body&&.comic-item').forEach(i => {\\n    d.push({\\n        title: pdfh(i, 'h3&&Text'),\\n        img: pd(i, 'img&&src'),\\n        url: pd(i, 'a&&href') + '#immersiveTheme##autoCache#',\\n        // col_type:'text_center_1'\\n    })\\n})\\npdfa(host, 'body&&.list.clearfix').forEach(i => {\\n    d.push({\\n        title: pdfh(i, 'h3&&Text'),\\n        desc: pdfh(i, '.comic-author&&Text') + '\\\\n' + pdfh(i, '.sort-list&&Text'),\\n        url: pd(i, 'a&&href') + '#immersiveTheme##autoCache#',\\n        col_type: 'text_1'\\n    })\\n})\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"图片\",\"path\":\"Picture\",\"rule\":\"var firstPage = request(input, {\\n    headers: {\\n        \\\"content-type\\\": \\\"charst=utf-8\\\",\\n        \\\"User-Agent\\\": MOBILE_UA\\n    }\\n});\\nif (parseDomForHtml(firstPage, \\\"#next,-1&&Text\\\").indexOf(\\\"下一页\\\") == -1) {\\n    var list = pdfa(firstPage, '#imgsec&&.lazy');\\n    var pics = [];\\n    for (var i in list) {\\n        var lists = pd(list[i], '.lazy&&data-src||src') + '@Referer='+MY_URL;\\n        pics.push(lists)\\n    };\\n    \\\"pics://\\\" + pics.join(\\\"&&\\\")\\n} else {\\n    var map = (html, arr) => {\\n        parseDomForArray(html, \\\"#imgsec&&.lazy\\\").map(item => {\\n            arr.push(parseDomForHtml(item, \\\".lazy&&data-src||src\\\") + \\\"@Referer=\\\"+MY_URL);\\n        });\\n    }\\n\\n    var htmlArr = [];\\n    var htmlUrl = [];\\n    for (var p = 2;; p++) {\\n        var html = request(input.replace(\\\".html\\\", \\\"_\\\" + p + \\\".html\\\"));\\n        if (parseDomForHtml(html, \\\"#next,-1&&Text\\\").indexOf(\\\"下一页\\\") > -1) {\\n            htmlArr.push(html);\\n            htmlUrl.push({\\n                url: input.replace(\\\".html\\\", \\\"_\\\" + p + \\\".html\\\"),\\n                options: {\\n                    headers: {\\n                        \\\"content-type\\\": \\\"charst=utf-8\\\",\\n                        \\\"User-Agent\\\": MOBILE_UA\\n                    }\\n                }\\n            })\\n        } else {\\n            htmlArr.push(html);\\n            htmlUrl.push({\\n                url: input.replace(\\\".html\\\", \\\"_\\\" + p + \\\".html\\\"),\\n                options: {\\n                    headers: {\\n                        \\\"content-type\\\": \\\"charst=utf-8\\\",\\n                        \\\"User-Agent\\\": MOBILE_UA\\n                    }\\n                }\\n            })\\n            break;\\n        }\\n    }\\n\\n    //var htmlArr = batchFetch(htmlUrl);\\n\\n    var picArr = [];\\n    map(firstPage, picArr);\\n    htmlArr.map(item => map(item, picArr));\\n    \\\"pics://\\\" + picArr.join(\\\"&&\\\");\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"工具\",\"path\":\"t\",\"rule\":\"function getDomain(domain) {\\n    if (domain == null) {\\n        domain = getMyVar(\\\"domain\\\", config.dom);\\n    }\\n    let hosts = domain.split(\\\"@\\\");\\n    let headers = null;\\n    let host = domain;\\n    if (hosts.length > 1) {\\n        domain = hosts[0];\\n        headers = {\\n            Host: hosts[1]\\n        };\\n        host = hosts[1];\\n    }\\n    return {\\n        domain: domain,\\n        host: host,\\n        headers: headers\\n    }\\n}\\n\\n$.exports = {\\n    getDomain: getDomain\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"书库\",\"path\":\"书库\",\"rule\":\"var d = []\\nMY_URL = 'https://2cycomic.com/booklists/9/全部/3/1.html';\\n\\nvar getRangeColors = function() {       \\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);     \\n}\\n\\nconst 分类颜色 = getRangeColors()\\n\\nconst 大类定位 = 'body&&dl'//'body&&#tag-list'\\n\\nconst 拼接分类 = ''\\n\\nconst 小类定位 = 'body&&a:not(:contains(首页)):not(:contains(排行榜))'\\n\\nconst 分类标题 = 'a&&Text'\\n\\nconst 分类链接 = 'a&&href'\\n\\nlet true_url = getMyVar(MY_RULE.url, MY_URL)\\n\\nlet page = MY_PAGE\\n//if (getMyVar(MY_RULE.url)) {\\ntrue_url = true_url\\n    .replace('/1.html', '/'+page + '.html')\\n//}\\nvar html = request(true_url)\\n\\neval(JSON.parse(request('hiker://page/dtfl?rule=聚漫🔮')).rule)\\n\\nlet arr = pdfa(html, \\\"body&&.wrapper&&li\\\");\\nfor (let it of arr) {\\n    d.push({\\n        title: pdfh(it, \\\"p&&Text\\\"),\\n        url: pd(it, \\\"a&&href\\\") + \\\"#immersiveTheme##autoCache#\\\",\\n        col_type: \\\"movie_3\\\",\\n        desc: pdfh(it, \\\".chapter&&Text\\\"),\\n        pic_url: pdfh(it, \\\"img&&src\\\") + '@Referer=https://2cycomic.com',\\n    });\\n}\\nsetResult(d)\"}],\"params\":\"{}\",\"saved\":false,\"title\":\"聚漫🔮\",\"version\":0,\"url\":\"https://2cycomic.com/book/49377/#immersiveTheme##autoCache#;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\",\"col_type\":\"movie_1\",\"find_rule\":\"js:\\nvar d = [];\\nvar html = getResCode();\\neval(JSON.parse(request('hiker://page/comicFunctionFile.js?rule=聚漫🔮')).rule)\\n\\n//1⃣先抓头部,抓错可能全不显示(๑>؂<๑）改下面中文\\ncover('.name&&Text', '.author&&Text', '.types&&Text', '.card-box-head&&Text', '#js_desc_content&&Text', 'body&&.thumbnail&&img&&src', MY_URL,true);\\n\\n//3⃣最后处理漫画模式\\n//var lazy = `@lazyRule=.js:var html=request(input,{headers:{\\\"content-type\\\":\\\"UTF-8\\\",\\\"User-Agent\\\":\\\"Mozilla/5.0 (Linux；； Android 10)\\\"},method:\\\"GET\\\"});var list=pdfa(html, 'body&&#imgsec&&.lazy');var pics = [];for (var i in list) {var lists =pd(list[i],'.lazy&&data-src');pics.push(lists + '@Referer=')};\\\"pics://\\\" + pics.join(\\\"&&\\\")`;\\n\\nvar lazy = $(\\\"\\\").lazyRule(() => eval(JSON.parse(request('hiker://page/Picture')).rule));\\n\\nfunction 解析() {\\r\\n    var html = request(input, {\\r\\n        headers: {\\r\\n            \\\"User-Agent\\\": MOBILE_UA\\r\\n        }\\r\\n    });\\r\\n    var pics = pdfa(html, \\\".acgn-reader-chapter__item-box&&img\\\").map(h => pdfh(h, \\\"img&&data-src||src\\\"));\\r\\n    if (/下一页/.test(html)) {\\r\\n        for (var k = 2;; k++) {\\r\\n            var html_tmp = request(input.replace(\\\".html\\\", \\\"_\\\" + k + \\\".html\\\"), {\\r\\n                headers: {\\r\\n                    \\\"User-Agent\\\": MOBILE_UA\\r\\n                }\\r\\n            });\\r\\n            pics = pics.concat(pdfa(html_tmp, \\\".acgn-reader-chapter__item-box&&img\\\").map(h => pdfh(h, \\\"img&&data-src||src\\\")));\\r\\n            if (!/下一页/.test(html_tmp)) {\\r\\n                break;\\r\\n            }\\r\\n        }\\r\\n    }\\r\\n\\r\\n    return \\\"pics://\\\" + pics.join(\\\"@Referer=https://pic4.yemancomic.com/&&\\\") + \\\"@Referer=https://pic4.yemancomic.com/\\\";\\r\\n}\\nlet downloadlazy = $.toString(解析);\\n//2⃣再抓列表\\nvar list = parseDomForArray(html, 'body&&#js_chapter_list&&li');\\n\\n\\nlet doList = list.map((item)=>({\\n    title: pdfh(item,\\\"title&&Text\\\"),\\n    url: parseDom(item,\\\"a&&href\\\"),\\n    \\n}));\\nd.push({\\n    title: '‘‘’’🗳<font color=\\\"#f47983\\\"> 书架</font> ',\\n    url: \\\"hiker://page/Bookrack.view?rule=本地资源管理&ruleName=\\\"+MY_RULE.title,\\n    col_type: 'text_2'\\n});\\n\\nd.push({\\n    title: '‘‘’’📥<strong><font color= \\\"#098AC1\\\">' + \\\"下载\\\" + '</front></strong>',\\n    url: \\\"hiker://page/download.view#noRecordHistory##noRefresh#?rule=本地资源管理\\\",\\n    col_type: \\\"text_2\\\",\\n    extra: {\\n        chapterList: doList,\\n        info:{\\n            bookName: pdfh(html,\\\".name&&Text\\\"),\\n            ruleName: MY_RULE.title,\\n            bookTopPic: pdfh(html,\\\"body&&.thumbnail&&img&&src\\\"),\\n            parseCode: downloadlazy\\n        },\\n        defaultView:\\\"1\\\"\\n    }\\n});\\n\\nchapter(list, 'title&&Text', 'a&&href', 1);\\nsetResult(d);\",\"group\":\"聚漫🔮\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"首页\\\",\\\"path\\\":\\\"首页\\\",\\\"rule\\\":\\\"var d = []\\\\npdfa(request(URL[1]), 'body&&.mult:has(h2)').forEach(j => {\\\\n\\\\n    d.push({\\\\n        title: pdfh(j, 'h2&&Text'),\\\\n        url: 'hiker://empty',\\\\n        col_type: 'text_1'\\\\n    })\\\\n    pdfa(j, 'ul&&.card').forEach(i => {\\\\n        d.push({\\\\n            title: pdfh(i, '.card-title&&Text'),\\\\n            img: pd(i, 'img&&src'),\\\\n            url: pd(i, 'a&&href') + '#immersiveTheme##autoCache#',\\\\n        })\\\\n    })\\\\n})\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"scroll_button\\\",\\\"name\\\":\\\"更新\\\",\\\"path\\\":\\\"更新\\\",\\\"rule\\\":\\\"var d = []\\\\nvar 周 = parseInt((getMyVar('更新', ''))||new Date().getDay()-1)+1\\\\n周 = 周=='0'?'7':周\\\\nvar host = request(URL[1] + 'update/' +周 + '.html')\\\\n\\\\npdfa(host, 'ul&&li').forEach((j, id) => {\\\\n    var title = pdfh(j, 'Text').slice(1)\\\\n    if ((getMyVar('更新', '')||(周-1)) == id)\\\\n        title = '““' + title + '””'\\\\n    d.push({\\\\n        title: title,\\\\n        url: $(pd(j, 'a&&href')).lazyRule((id) => {\\\\n            putMyVar('更新', id)\\\\n            refreshPage()\\\\n            return 'hiker://empty'\\\\n        },id),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n})\\\\npdfa(host, '.update-list&&li').forEach(i => {\\\\n    d.push({\\\\n        title: pdfh(i, '.title&&Text'),\\\\n        desc: pdfh(i, '.chapter&&Text'),\\\\n        img: pd(i, 'img&&src'),\\\\n        url: pd(i, 'a&&href') + '#immersiveTheme#'\\\\n    })\\\\n})\\\\n\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"排行\\\",\\\"path\\\":\\\"排行\\\",\\\"rule\\\":\\\"var d = []\\\\nvar host = request(getMyVar('排行url', URL[1] + 'top/alldj.html'))\\\\n\\\\npdfa(host, 'ul&&li').forEach((j, id) => {\\\\n    var title = pdfh(j, 'Text')\\\\n    if ((getMyVar('排行', '')) == id)\\\\n        title = '““' + title + '””'\\\\n    d.push({\\\\n        title: title,\\\\n        url: $(pd(j, 'a&&href')).lazyRule((id) => {\\\\n            putMyVar('排行', id)\\\\n            putMyVar('排行url', input)\\\\n            refreshPage()\\\\n            return 'hiker://empty'\\\\n        }, id),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n})\\\\npdfa(host, 'body&&.comic-item').forEach(i => {\\\\n    d.push({\\\\n        title: pdfh(i, 'h3&&Text'),\\\\n        img: pd(i, 'img&&src'),\\\\n        url: pd(i, 'a&&href') + '#immersiveTheme##autoCache#',\\\\n        // col_type:'text_center_1'\\\\n    })\\\\n})\\\\npdfa(host, 'body&&.list.clearfix').forEach(i => {\\\\n    d.push({\\\\n        title: pdfh(i, 'h3&&Text'),\\\\n        desc: pdfh(i, '.comic-author&&Text') + '\\\\\\\\n' + pdfh(i, '.sort-list&&Text'),\\\\n        url: pd(i, 'a&&href') + '#immersiveTheme##autoCache#',\\\\n        col_type: 'text_1'\\\\n    })\\\\n})\\\\n\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"图片\\\",\\\"path\\\":\\\"Picture\\\",\\\"rule\\\":\\\"var firstPage = request(input, {\\\\n    headers: {\\\\n        \\\\\\\"content-type\\\\\\\": \\\\\\\"charst=utf-8\\\\\\\",\\\\n        \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n    }\\\\n});\\\\nif (parseDomForHtml(firstPage, \\\\\\\"#next,-1&&Text\\\\\\\").indexOf(\\\\\\\"下一页\\\\\\\") == -1) {\\\\n    var list = pdfa(firstPage, '#imgsec&&.lazy');\\\\n    var pics = [];\\\\n    for (var i in list) {\\\\n        var lists = pd(list[i], '.lazy&&data-src||src') + '@Referer='+MY_URL;\\\\n        pics.push(lists)\\\\n    };\\\\n    \\\\\\\"pics://\\\\\\\" + pics.join(\\\\\\\"&&\\\\\\\")\\\\n} else {\\\\n    var map = (html, arr) => {\\\\n        parseDomForArray(html, \\\\\\\"#imgsec&&.lazy\\\\\\\").map(item => {\\\\n            arr.push(parseDomForHtml(item, \\\\\\\".lazy&&data-src||src\\\\\\\") + \\\\\\\"@Referer=\\\\\\\"+MY_URL);\\\\n        });\\\\n    }\\\\n\\\\n    var htmlArr = [];\\\\n    var htmlUrl = [];\\\\n    for (var p = 2;; p++) {\\\\n        var html = request(input.replace(\\\\\\\".html\\\\\\\", \\\\\\\"_\\\\\\\" + p + \\\\\\\".html\\\\\\\"));\\\\n        if (parseDomForHtml(html, \\\\\\\"#next,-1&&Text\\\\\\\").indexOf(\\\\\\\"下一页\\\\\\\") > -1) {\\\\n            htmlArr.push(html);\\\\n            htmlUrl.push({\\\\n                url: input.replace(\\\\\\\".html\\\\\\\", \\\\\\\"_\\\\\\\" + p + \\\\\\\".html\\\\\\\"),\\\\n                options: {\\\\n                    headers: {\\\\n                        \\\\\\\"content-type\\\\\\\": \\\\\\\"charst=utf-8\\\\\\\",\\\\n                        \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                    }\\\\n                }\\\\n            })\\\\n        } else {\\\\n            htmlArr.push(html);\\\\n            htmlUrl.push({\\\\n                url: input.replace(\\\\\\\".html\\\\\\\", \\\\\\\"_\\\\\\\" + p + \\\\\\\".html\\\\\\\"),\\\\n                options: {\\\\n                    headers: {\\\\n                        \\\\\\\"content-type\\\\\\\": \\\\\\\"charst=utf-8\\\\\\\",\\\\n                        \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                    }\\\\n                }\\\\n            })\\\\n            break;\\\\n        }\\\\n    }\\\\n\\\\n    //var htmlArr = batchFetch(htmlUrl);\\\\n\\\\n    var picArr = [];\\\\n    map(firstPage, picArr);\\\\n    htmlArr.map(item => map(item, picArr));\\\\n    \\\\\\\"pics://\\\\\\\" + picArr.join(\\\\\\\"&&\\\\\\\");\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"工具\\\",\\\"path\\\":\\\"t\\\",\\\"rule\\\":\\\"function getDomain(domain) {\\\\n    if (domain == null) {\\\\n        domain = getMyVar(\\\\\\\"domain\\\\\\\", config.dom);\\\\n    }\\\\n    let hosts = domain.split(\\\\\\\"@\\\\\\\");\\\\n    let headers = null;\\\\n    let host = domain;\\\\n    if (hosts.length > 1) {\\\\n        domain = hosts[0];\\\\n        headers = {\\\\n            Host: hosts[1]\\\\n        };\\\\n        host = hosts[1];\\\\n    }\\\\n    return {\\\\n        domain: domain,\\\\n        host: host,\\\\n        headers: headers\\\\n    }\\\\n}\\\\n\\\\n$.exports = {\\\\n    getDomain: getDomain\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"书库\\\",\\\"path\\\":\\\"书库\\\",\\\"rule\\\":\\\"var d = []\\\\nMY_URL = 'https://2cycomic.com/booklists/9/全部/3/1.html';\\\\n\\\\nvar getRangeColors = function() {       \\\\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);     \\\\n}\\\\n\\\\nconst 分类颜色 = getRangeColors()\\\\n\\\\nconst 大类定位 = 'body&&dl'//'body&&#tag-list'\\\\n\\\\nconst 拼接分类 = ''\\\\n\\\\nconst 小类定位 = 'body&&a:not(:contains(首页)):not(:contains(排行榜))'\\\\n\\\\nconst 分类标题 = 'a&&Text'\\\\n\\\\nconst 分类链接 = 'a&&href'\\\\n\\\\nlet true_url = getMyVar(MY_RULE.url, MY_URL)\\\\n\\\\nlet page = MY_PAGE\\\\n//if (getMyVar(MY_RULE.url)) {\\\\ntrue_url = true_url\\\\n    .replace('/1.html', '/'+page + '.html')\\\\n//}\\\\nvar html = request(true_url)\\\\n\\\\neval(JSON.parse(request('hiker://page/dtfl?rule=聚漫🔮')).rule)\\\\n\\\\nlet arr = pdfa(html, \\\\\\\"body&&.wrapper&&li\\\\\\\");\\\\nfor (let it of arr) {\\\\n    d.push({\\\\n        title: pdfh(it, \\\\\\\"p&&Text\\\\\\\"),\\\\n        url: pd(it, \\\\\\\"a&&href\\\\\\\") + \\\\\\\"#immersiveTheme##autoCache#\\\\\\\",\\\\n        col_type: \\\\\\\"movie_3\\\\\\\",\\\\n        desc: pdfh(it, \\\\\\\".chapter&&Text\\\\\\\"),\\\\n        pic_url: pdfh(it, \\\\\\\"img&&src\\\\\\\") + '@Referer=https://2cycomic.com',\\\\n    });\\\\n}\\\\nsetResult(d)\\\"}]\"}","picUrl":"https://pic.yydsmh.com/man8/guiyiyaojishi.jpg","title":"诡异药剂师：我的病人皆为恐怖"}