邀您一起看：顶点小说🅛

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥顶点小说🅛@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"function ClassTab(classArray, params) {\\n    Object.assign(this, params)\\n    this.arr = classArray.map(v => this.init(v))\\n    this.sign = '$' + MY_RULE.title + '_' + (this.name || '') + '_'\\n    this.color = this.color || '#12b668'\\n    this.boundary = this.boundary || 'blank_block'\\n}\\nClassTab.prototype = {\\n    constructor: ClassTab,\\n    load(el) {\\n        let folded = getVar('fold_' + this.sign, '')\\n        if (this.fold) el.push({\\n            title: '““””<span style=\\\"color:#049eff\\\">' + (folded ? '▶' : '▼'),\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\n                putVar('fold_' + sign, { '': 'T', 'T': '' } [folded])\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, this.sign, folded),\\n            col_type: 'scroll_button'\\n        })\\n        let arr = folded ? [this.arr[0]] : this.arr\\n        arr.forEach((v) => {\\n            let { id, class_name, class_url } = v,\\n                selected = JSON.stringify(this.getClass(id))\\n            class_name.forEach((name, i) => {\\n                let url = class_url[i],\\n                    now = JSON.stringify({ name: name, url: url })\\n                el.push({\\n                    title: (selected == now ? '““””<span style=\\\"color:' + this.color + '\\\"><b>' : '') + name,\\n                    url: $('#noLoading#').lazyRule((sign, id, now) => {\\n                        putVar(sign + id, now)\\n                        putVar(sign, now)\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, this.sign, id, now),\\n                    col_type: 'scroll_button'\\n                })\\n            })\\n            el.push({ col_type: this.boundary })\\n        })\\n    },\\n    init(classObject) {\\n        if (typeof classObject.class_name == 'string')\\n            classObject.class_name = classObject.class_name.split('&')\\n        if (typeof classObject.class_url == 'string')\\n            classObject.class_url = classObject.class_url.split('&')\\n        return classObject\\n    },\\n    push(classObject) {\\n        this.arr.push(this.init(classObject))\\n    },\\n    getClass(id) {\\n        let defaultClass = this.arr.find(item => item.id == id)\\n        if (defaultClass) defaultClass = JSON.stringify({\\n            name: defaultClass.class_name[0],\\n            url: defaultClass.class_url[0]\\n        })\\n        else throw new Error('cannot find id: ' + id + ' in classTab: ' + this.sign)\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\n    },\\n    getLastClick() {\\n        return JSON.parse(getVar(this.sign, '{}'))\\n    },\\n    setUrl(url) {\\n        return url.replace(/\\\\$\\\\{([^}]*)\\\\}/g, (_, id) => this.getClass(id).url)\\n    }\\n}\\n$.exports = ClassTab\\n\"},{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"indexLoad\",\"rule\":\"js:\\nlet myCollection_el = [],\\n    pageNum = parseInt(MY_URL.split('#')[1]),\\n    RULE = MY_PARAMS.RULE,\\n    fyAll = RULE.url.includes('fyAll'),\\n    // 加载ClassTab组件\\n    ClassTab = $.require('hiker://page/ClassTab?rule=' + getItem('myCollection')),\\n    tabHeader = []\\n\\nif (RULE.class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: RULE.class_name,\\n    class_url: RULE.class_url\\n})\\nif (RULE.area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: RULE.area_name,\\n    class_url: RULE.area_url\\n})\\nif (RULE.year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: RULE.year_name,\\n    class_url: RULE.year_url\\n})\\nif (RULE.sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: RULE.sort_name,\\n    class_url: RULE.sort_url\\n})\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title })\\nif (pageNum == 1) {\\n    addListener('onClose', 'clearVar(\\\"myCollection-searchMode\\\")')\\n    putVar('myCollection-searchMode', RULE.title)\\n    tabHeader.load(myCollection_el)\\n    if (RULE.search_url) myCollection_el.push({\\n        title: \\\"搜索\\\",\\n        desc: \\\"搜你想要的...\\\",\\n        url: '\\\"hiker://search?s=\\\"+input+\\\"&rule=' + getItem('myCollection') + '\\\"',\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 处理MY_URL和MY_RULE\\nMY_RULE.version = RULE.version\\nMY_RULE.group = RULE.group\\nMY_RULE.title = RULE.title\\nMY_RULE.ua = RULE.ua\\nMY_RULE.col_type = RULE.col_type\\nMY_RULE.detail_col_type = RULE.detail_col_type\\nMY_RULE.find_rule = RULE.find_rule\\nMY_RULE.detail_find_rule = RULE.detail_find_rule\\nMY_RULE.preRule = RULE.preRule\\nMY_RULE.pageList = JSON.parse(RULE.pages || '[]')\\nMY_RULE.pages = JSON.stringify(MY_RULE.pageList)\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\nMY_RULE.params = {}\\n\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nvar { MY_URL, indexHtml } = urlParse(RULE.url, pageNum, (url) => {\\n    url[0] = fyAll ? url[0].replace(/fyAll/g, '$${fyAll}') : url[0].replace(/fy(class|area|year|sort)/g, '$${fy$1}')\\n    url[0] = tabHeader.setUrl(url[0])\\n})\\nMY_RULE.url = MY_URL\\n// 正文解析\\nif (pageNum == 1) eval(MY_RULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    function getUrl() {\\n        return MY_URL\\n    }\\n\\n    function getResCode() {\\n        return indexHtml\\n    }\\n\\n    function setResult(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(el.data)) el = el.data\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\n            let RULE = Object.assign({}, MY_RULE)\\n            v.col_type = v.col_type || MY_RULE.col_type\\n\\n            if (!v.url) {\\n                return v\\n            } else if (v.url.includes('@lazyRule=')) {\\n                v.url = v.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\n                return v\\n            } else if (v.url.includes('@rule=')) {\\n                let [_, url, rule] = v.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n                v.url = url\\n                RULE.detail_find_rule = rule\\n                RULE.detail_col_type = MY_RULE.col_type\\n            } else if (v.url.startsWith('hiker://page/')) {\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\n                    return v\\n                let path = v.url.split('#')[0].match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(?:\\\\?.*)?$/)[1],\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path)\\n                RULE.detail_find_rule = subPage.rule\\n                RULE.detail_col_type = subPage.col_type\\n                RULE.params = v.extra || {}\\n            } else if (!MY_RULE.detail_find_rule) { return v }\\n            v.extra = { url: v.url, RULE: RULE, pageTitle: v.title }\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n\\n    function setHomeResult(a, param1, param2, param3) {\\n        setResult(a, param1, param2, param3)\\n    }\\n\\n    function setSearchResult(a, param1, param2, param3) {\\n        setResult(a, param1, param2, param3)\\n    }\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let findRule = MY_RULE.find_rule.split(';')\\n    parseDomForArray(indexHtml, findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) {}\\n            }),\\n            res = {\\n                title: title,\\n                url: url,\\n                desc: desc,\\n                img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                res.url = res.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title  }\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"详情\",\"path\":\"detailLoad\",\"rule\":\"js:\\nvar myCollection_el = []\\n\\n// 处理MY_URL和MY_RULE\\nlet RULE = MY_PARAMS.RULE\\nMY_RULE.version = RULE.version\\nMY_RULE.group = RULE.group\\nMY_RULE.title = RULE.title\\nMY_RULE.url = MY_URL\\nMY_RULE.ua = RULE.ua\\nMY_RULE.col_type = RULE.detail_col_type\\nMY_RULE.find_rule = RULE.detail_find_rule\\nMY_RULE.preRule = RULE.preRule\\nMY_RULE.pageList = RULE.pageList\\nMY_RULE.pages = RULE.pages\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\nMY_RULE.params = RULE.params\\n// 解析正文\\nif(MY_PARAMS.pageTitle) setPageTitle(MY_PARAMS.pageTitle)\\neval(MY_RULE.preRule)\\nsetLastChapterRule(MY_RULE.last_chapter_rule)\\nMY_PARAMS = MY_RULE.params\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    function setResult(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(el.data)) el = el.data\\n\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\n            let RULE = Object.assign({}, MY_RULE)\\n            v.col_type = v.col_type || MY_RULE.col_type\\n\\n            if (!v.url) {\\n                return v\\n            } else if (v.url.includes('@lazyRule=')) {\\n                v.url = v.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\n                return v\\n            } else if (v.url.includes('@rule=')) {\\n                let [_, url, rule] = v.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n                v.url = url\\n                RULE.detail_find_rule = rule\\n                RULE.detail_col_type = MY_RULE.col_type\\n            } else if (v.url.startsWith('hiker://page/')) {\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\n                    return v\\n                let path = v.url.split('#')[0].match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(?:\\\\?.*)?$/)[1],\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path)\\n                RULE.detail_find_rule = subPage.rule\\n                RULE.detail_col_type = subPage.col_type\\n                RULE.params = v.extra || {}\\n            } else { return v }\\n            v.extra = { url: v.url, RULE: RULE }\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n\\n    function setHomeResult(a, param1, param2, param3) {\\n        setResult(a, param1, param2, param3)\\n    }\\n\\n    function setSearchResult(a, param1, param2, param3) {\\n        setResult(a, param1, param2, param3)\\n    }\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    const { runCode } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\n    let findRule = MY_RULE.find_rule.split(';')\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) {}\\n            }),\\n            res = {\\n                title: title,\\n                url: url,\\n                desc: desc,\\n                img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url && res.url.includes('@lazyRule='))\\n            res.url = res.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"数据载入\",\"path\":\"dataLoad\",\"rule\":\"//真正获取数据的逻辑\\nfunction load() {\\n    let url = 'http://hiker.nokia.press/hikerule/dev/json_list?name=1596889407',\\n        d = []\\n    try {\\n        d = fetch(url)\\n        if (url.startsWith('hiker://page/'))\\n            d = JSON.parse(d).rule\\n        d = JSON.parse(d)\\n    } catch (e) {\\n        d = []\\n    }\\n    return d.filter((v) => { return v.title != MY_RULE.title && v.author != '轻合集生成器' })\\n}\\n//检查间隔，默认一天\\nlet min = 60 * 24 * 1\\n\\nlet data = []\\nlet time = getItem('updatetime', '0')\\ntime = parseInt(time)\\nlet now = new Date().getTime()\\nif (now - time > 1000 * 60 * min) {\\n    log('更新了数据')\\n    setItem('updatetime', '' + now)\\n    data = load()\\n    saveFile('data.json', JSON.stringify(data))\\n} else {\\n    log('没有更新数据')\\n    data = JSON.parse(readFile('data.json'))\\n}\\n$.exports = data\\n\"},{\"col_type\":\"movie_3\",\"name\":\"工具集\",\"path\":\"utility\",\"rule\":\"$.exports = {\\n    runCode: function(rule) {log(rule)\\n        try {\\n            let [input, code] = rule.split('.js:')\\n            return code ? eval(code) : rule\\n        } catch (e) { return rule }\\n    },\\n    urlParse: function(url, pageNum, func) {\\n        url = url.split(';').map((v) => v.replace(/；；/g, ';'))\\n        if (func) func(url)\\n        url[0] = url[0].replace(/fypage(?:@(-?\\\\d+)@)?(?:\\\\*(\\\\d+)@)?/, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\n        url[0] = /^(.*?)(?:\\\\[firstPage=(.*?)\\\\])?$/.exec(url[0])\\n        url[0] = runCode(url[0][2] && pageNum == 1 ? url[0][2] : url[0][1])\\n        let options = { headers: { 'Content-Type': 'text/plain; charst=UTF-8' }, method: url[1] }\\n        // post方法时转换参数\\n        if (/^post$/i.test(options['method'])) {\\n            let [oriUrl, body] = url[0].split('?')\\n            url[0] = oriUrl.replace(/？？/g, '?')\\n            if (body.startsWith('JsonBody=')) body = body.slice(9)\\n            options['body'] = body\\n        }\\n        if (url[2]) options.headers['Content-Type'] = options.headers['Content-Type'].slice(0, 19) + url[2]\\n        if (url[3]) url[3].match(/{(.*)}/)[1].split('&&').forEach((v) => {\\n            let [key, value] = v.split('@')\\n            options.headers[key] = runCode(value)\\n        })\\n        // 添加全局UA\\n        if (!options.headers['User-Agent']) {\\n            if (MY_RULE.ua == 'pc')\\n                options.headers['User-Agent'] = PC_UA\\n            else if (MY_RULE.ua == 'mobile')\\n                options.headers['User-Agent'] = MOBILE_UA\\n        }\\n        return { MY_URL: url[0], indexHtml: fetch(url[0], options) }\\n    }\\n}\\n\"}],\"params\":\"{\\\"RULE\\\":{\\\"area_name\\\":\\\"网游小说&科幻小说&言情小说\\\",\\\"area_url\\\":\\\"5&6&7\\\",\\\"author\\\":\\\"警告：本小程序仅供海阔视界用户学习交流使用。如有导入，请务必在24小时之内删除！若作它用，后果自负！\\\",\\\"class_name\\\":\\\"玄幻小说&仙侠小说&都市小说&历史军事\\\",\\\"class_url\\\":\\\"1&2&3&4\\\",\\\"col_type\\\":\\\"movie_3\\\",\\\"detail_col_type\\\":\\\"text_1\\\",\\\"detail_find_rule\\\":\\\"js:\\\\n$.require(\\\\\\\"hiker://page/chapter\\\\\\\")\\\",\\\"find_rule\\\":\\\".list&&.xbk:has(li);span&&Text;img&&src;*;a&&href.js:input+\\\\\\\"mulu/1/\\\\\\\"\\\",\\\"firstHeader\\\":\\\"class\\\",\\\"group\\\":\\\"⑧小说\\\",\\\"icon\\\":\\\"\\\",\\\"last_chapter_rule\\\":\\\"\\\",\\\"pageList\\\":[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"正文\\\",\\\"path\\\":\\\"content\\\",\\\"rule\\\":\\\"var d = [];\\\\nd.push({\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    title: \\\\\\\"““””<big>\\\\\\\" + parseDomForHtml(getResCode(), \\\\\\\"#header&&.zhong&&Text\\\\\\\") + \\\\\\\"</big>\\\\\\\",\\\\n});\\\\nd.push({\\\\n    title: parseDomForHtml(getResCode(), \\\\\\\"#nr&&Html\\\\\\\"),\\\\n    col_type: 'rich_text',\\\\n    extra: {\\\\n        textSize: 18,\\\\n        click: true\\\\n    }\\\\n});\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"目录解析\\\",\\\"path\\\":\\\"chapter\\\",\\\"rule\\\":\\\"let cfg = {\\\\n    分页列表: \\\\\\\"body&&.showpage&&a:not(:contains(没有更多分页))\\\\\\\",\\\\n    分页链接: \\\\\\\"a&&href\\\\\\\",\\\\n    分页请求头: {\\\\n        \\\\\\\"User-Agent\\\\\\\": MOBILE_UA,\\\\n        \\\\\\\"Content-Type\\\\\\\": \\\\\\\"text/html; charset=GBK\\\\\\\"\\\\n    },\\\\n    一页章节数: 40,\\\\n    章节列表: \\\\\\\"body&&.lb&&li:not(:contains(本页章节列表结束！))\\\\\\\",\\\\n    章节标题: \\\\\\\"a&&Text\\\\\\\",\\\\n    章节链接: \\\\\\\"a&&href\\\\\\\",\\\\n    缓存个数: 15\\\\n}\\\\n\\\\n\\\\nvar code = getResCode()\\\\nvar caches;\\\\n\\\\nfunction getCache() {\\\\n    let c = readFile(\\\\\\\"chapter.json\\\\\\\") || \\\\\\\"[]\\\\\\\";\\\\n    caches = JSON.parse(c)\\\\n    let url = getUrl()\\\\n    log(url)\\\\n    for (let it of caches) {\\\\n        if (it.url == url) {\\\\n            return it;\\\\n        }\\\\n    }\\\\n    return {\\\\n        url: url,\\\\n        page: 0,\\\\n        chapters: []\\\\n    }\\\\n}\\\\n\\\\nfunction saveCache(che) {\\\\n    let c = caches\\\\n    if (c.length > cfg.缓存个数) {\\\\n        c.shift()\\\\n    }\\\\n    let exist = false\\\\n    for (let i = 0; i < c.length; i++) {\\\\n        if (c[i].url == che.url) {\\\\n            c[i] = che;\\\\n            exist = true;\\\\n            break\\\\n        }\\\\n    }\\\\n    if (!exist) {\\\\n        c.push(che)\\\\n    }\\\\n    saveFile(\\\\\\\"chapter.json\\\\\\\", JSON.stringify(c))\\\\n}\\\\n\\\\nlet cache = getCache();\\\\n\\\\nlet mp = pdfa(code, cfg.分页列表)\\\\nlet page = mp.length;\\\\nlog(\\\\\\\"实际页数：\\\\\\\" + page)\\\\nlog(\\\\\\\"缓存页数：\\\\\\\" + cache.page)\\\\nif (page == cache.page) {\\\\n    //已完结，目录全部缓存了\\\\n    setResult(cache.chapters)\\\\n    return\\\\n}\\\\n//解析本地没有的缓存\\\\nlet urls = []\\\\nlet htmls = []\\\\n//log(mp)\\\\nfor (let i = cache.page; i < mp.length; i++) {\\\\n    if (i == 0) {\\\\n        htmls.push(code)\\\\n        continue\\\\n    }\\\\n    let it = mp[i];\\\\n    urls.push({\\\\n        url: pd(it, cfg.分页链接),\\\\n        options: {\\\\n            headers: cfg.分页请求头 || {}\\\\n        }\\\\n    })\\\\n}\\\\n//log(urls)\\\\nlet d = [].concat(cache.chapters)\\\\nhtmls = htmls.concat(batchFetch(urls))\\\\n//log(htmls)\\\\nfor (let it of htmls) {\\\\n    if (it == \\\\\\\"\\\\\\\") {\\\\n        break\\\\n    }\\\\n    let list = pdfa(it, cfg.章节列表)\\\\n    let temp = []\\\\n    for (let ii of list) {\\\\n        temp.push({\\\\n            title: pdfh(ii, cfg.章节标题).split(\\\\\\\" （\\\\\\\")[0].split(\\\\\\\"（\\\\\\\")[0],\\\\n            url: pd(ii, cfg.章节链接) + \\\\\\\"#autoPage##fullTheme#@rule=js:$.require('hiker://page/content')\\\\\\\"\\\\n        })\\\\n    }\\\\n    log(list.length)\\\\n    if (list.length == cfg.一页章节数) {\\\\n        //章节齐全的才放本地缓存\\\\n        cache.page = cache.page + 1\\\\n        cache.chapters = cache.chapters.concat(temp)\\\\n    }\\\\n    d = d.concat(temp)\\\\n}\\\\n\\\\nsaveCache(cache)\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"目录分页\\\",\\\"path\\\":\\\"cp\\\",\\\"rule\\\":\\\"js:\\\\n$.require(\\\\\\\"hiker://page/chapter\\\\\\\")\\\"}],\\\"pages\\\":\\\"[{\\\\\\\"col_type\\\\\\\":\\\\\\\"movie_3\\\\\\\",\\\\\\\"name\\\\\\\":\\\\\\\"正文\\\\\\\",\\\\\\\"path\\\\\\\":\\\\\\\"content\\\\\\\",\\\\\\\"rule\\\\\\\":\\\\\\\"var d = [];\\\\\\\\nd.push({\\\\\\\\n    col_type: \\\\\\\\\\\\\\\"text_center_1\\\\\\\\\\\\\\\",\\\\\\\\n    title: \\\\\\\\\\\\\\\"““””<big>\\\\\\\\\\\\\\\" + parseDomForHtml(getResCode(), \\\\\\\\\\\\\\\"#header&&.zhong&&Text\\\\\\\\\\\\\\\") + \\\\\\\\\\\\\\\"</big>\\\\\\\\\\\\\\\",\\\\\\\\n});\\\\\\\\nd.push({\\\\\\\\n    title: parseDomForHtml(getResCode(), \\\\\\\\\\\\\\\"#nr&&Html\\\\\\\\\\\\\\\"),\\\\\\\\n    col_type: 'rich_text',\\\\\\\\n    extra: {\\\\\\\\n        textSize: 18,\\\\\\\\n        click: true\\\\\\\\n    }\\\\\\\\n});\\\\\\\\nsetResult(d);\\\\\\\"},{\\\\\\\"col_type\\\\\\\":\\\\\\\"movie_3\\\\\\\",\\\\\\\"name\\\\\\\":\\\\\\\"目录解析\\\\\\\",\\\\\\\"path\\\\\\\":\\\\\\\"chapter\\\\\\\",\\\\\\\"rule\\\\\\\":\\\\\\\"let cfg = {\\\\\\\\n    分页列表: \\\\\\\\\\\\\\\"body&&.showpage&&a:not(:contains(没有更多分页))\\\\\\\\\\\\\\\",\\\\\\\\n    分页链接: \\\\\\\\\\\\\\\"a&&href\\\\\\\\\\\\\\\",\\\\\\\\n    分页请求头: {\\\\\\\\n        \\\\\\\\\\\\\\\"User-Agent\\\\\\\\\\\\\\\": MOBILE_UA,\\\\\\\\n        \\\\\\\\\\\\\\\"Content-Type\\\\\\\\\\\\\\\": \\\\\\\\\\\\\\\"text/html; charset=GBK\\\\\\\\\\\\\\\"\\\\\\\\n    },\\\\\\\\n    一页章节数: 40,\\\\\\\\n    章节列表: \\\\\\\\\\\\\\\"body&&.lb&&li:not(:contains(本页章节列表结束！))\\\\\\\\\\\\\\\",\\\\\\\\n    章节标题: \\\\\\\\\\\\\\\"a&&Text\\\\\\\\\\\\\\\",\\\\\\\\n    章节链接: \\\\\\\\\\\\\\\"a&&href\\\\\\\\\\\\\\\",\\\\\\\\n    缓存个数: 15\\\\\\\\n}\\\\\\\\n\\\\\\\\n\\\\\\\\nvar code = getResCode()\\\\\\\\nvar caches;\\\\\\\\n\\\\\\\\nfunction getCache() {\\\\\\\\n    let c = readFile(\\\\\\\\\\\\\\\"chapter.json\\\\\\\\\\\\\\\") || \\\\\\\\\\\\\\\"[]\\\\\\\\\\\\\\\";\\\\\\\\n    caches = JSON.parse(c)\\\\\\\\n    let url = getUrl()\\\\\\\\n    log(url)\\\\\\\\n    for (let it of caches) {\\\\\\\\n        if (it.url == url) {\\\\\\\\n            return it;\\\\\\\\n        }\\\\\\\\n    }\\\\\\\\n    return {\\\\\\\\n        url: url,\\\\\\\\n        page: 0,\\\\\\\\n        chapters: []\\\\\\\\n    }\\\\\\\\n}\\\\\\\\n\\\\\\\\nfunction saveCache(che) {\\\\\\\\n    let c = caches\\\\\\\\n    if (c.length > cfg.缓存个数) {\\\\\\\\n        c.shift()\\\\\\\\n    }\\\\\\\\n    let exist = false\\\\\\\\n    for (let i = 0; i < c.length; i++) {\\\\\\\\n        if (c[i].url == che.url) {\\\\\\\\n            c[i] = che;\\\\\\\\n            exist = true;\\\\\\\\n            break\\\\\\\\n        }\\\\\\\\n    }\\\\\\\\n    if (!exist) {\\\\\\\\n        c.push(che)\\\\\\\\n    }\\\\\\\\n    saveFile(\\\\\\\\\\\\\\\"chapter.json\\\\\\\\\\\\\\\", JSON.stringify(c))\\\\\\\\n}\\\\\\\\n\\\\\\\\nlet cache = getCache();\\\\\\\\n\\\\\\\\nlet mp = pdfa(code, cfg.分页列表)\\\\\\\\nlet page = mp.length;\\\\\\\\nlog(\\\\\\\\\\\\\\\"实际页数：\\\\\\\\\\\\\\\" + page)\\\\\\\\nlog(\\\\\\\\\\\\\\\"缓存页数：\\\\\\\\\\\\\\\" + cache.page)\\\\\\\\nif (page == cache.page) {\\\\\\\\n    //已完结，目录全部缓存了\\\\\\\\n    setResult(cache.chapters)\\\\\\\\n    return\\\\\\\\n}\\\\\\\\n//解析本地没有的缓存\\\\\\\\nlet urls = []\\\\\\\\nlet htmls = []\\\\\\\\n//log(mp)\\\\\\\\nfor (let i = cache.page; i < mp.length; i++) {\\\\\\\\n    if (i == 0) {\\\\\\\\n        htmls.push(code)\\\\\\\\n        continue\\\\\\\\n    }\\\\\\\\n    let it = mp[i];\\\\\\\\n    urls.push({\\\\\\\\n        url: pd(it, cfg.分页链接),\\\\\\\\n        options: {\\\\\\\\n            headers: cfg.分页请求头 || {}\\\\\\\\n        }\\\\\\\\n    })\\\\\\\\n}\\\\\\\\n//log(urls)\\\\\\\\nlet d = [].concat(cache.chapters)\\\\\\\\nhtmls = htmls.concat(batchFetch(urls))\\\\\\\\n//log(htmls)\\\\\\\\nfor (let it of htmls) {\\\\\\\\n    if (it == \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\") {\\\\\\\\n        break\\\\\\\\n    }\\\\\\\\n    let list = pdfa(it, cfg.章节列表)\\\\\\\\n    let temp = []\\\\\\\\n    for (let ii of list) {\\\\\\\\n        temp.push({\\\\\\\\n            title: pdfh(ii, cfg.章节标题).split(\\\\\\\\\\\\\\\" （\\\\\\\\\\\\\\\")[0].split(\\\\\\\\\\\\\\\"（\\\\\\\\\\\\\\\")[0],\\\\\\\\n            url: pd(ii, cfg.章节链接) + \\\\\\\\\\\\\\\"#autoPage##fullTheme#@rule=js:$.require('hiker://page/content')\\\\\\\\\\\\\\\"\\\\\\\\n        })\\\\\\\\n    }\\\\\\\\n    log(list.length)\\\\\\\\n    if (list.length == cfg.一页章节数) {\\\\\\\\n        //章节齐全的才放本地缓存\\\\\\\\n        cache.page = cache.page + 1\\\\\\\\n        cache.chapters = cache.chapters.concat(temp)\\\\\\\\n    }\\\\\\\\n    d = d.concat(temp)\\\\\\\\n}\\\\\\\\n\\\\\\\\nsaveCache(cache)\\\\\\\\nsetResult(d)\\\\\\\"},{\\\\\\\"col_type\\\\\\\":\\\\\\\"text_1\\\\\\\",\\\\\\\"name\\\\\\\":\\\\\\\"目录分页\\\\\\\",\\\\\\\"path\\\\\\\":\\\\\\\"cp\\\\\\\",\\\\\\\"rule\\\\\\\":\\\\\\\"js:\\\\\\\\n$.require(\\\\\\\\\\\\\\\"hiker://page/chapter\\\\\\\\\\\\\\\")\\\\\\\"}]\\\",\\\"preRule\\\":\\\"\\\",\\\"sdetail_col_type\\\":\\\"movie_1\\\",\\\"sdetail_find_rule\\\":\\\"*\\\",\\\"searchFind\\\":\\\"js:\\\\nvar res = {};\\\\r\\\\nvar d = [];\\\\r\\\\ntry {\\\\r\\\\n    var list = parseDomForArray(getResCode(), '.slist&&li');\\\\r\\\\n    for (var j in list) {\\\\r\\\\n        d.push({\\\\r\\\\n            title: parseDomForHtml(list[j], 'a,1&&Text'),\\\\r\\\\n            desc: parseDomForHtml(list[j], 'a,-1&&Text'),\\\\r\\\\n            //pic_url: parseDom(list[j], 'img&&data-original'),       \\\\r\\\\n            url: parseDom(list[j], 'a,1&&href') + \\\\\\\"/mulu/1/\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n    }\\\\r\\\\n} catch (e) {}\\\\r\\\\nres.data = d;\\\\r\\\\nsetHomeResult(res);\\\",\\\"search_url\\\":\\\"https://m.top.la/s.php?submit=&type=articlename&s=**;post;gbk\\\",\\\"sort_name\\\":\\\"\\\",\\\"sort_url\\\":\\\"\\\",\\\"title\\\":\\\"顶点小说🅛\\\",\\\"titleColor\\\":\\\"#0040ff\\\",\\\"ua\\\":\\\"mobile\\\",\\\"url\\\":\\\"https://m.top.la/list/fyAll_fypage.html;get;gbk\\\",\\\"version\\\":54,\\\"year_name\\\":\\\"\\\",\\\"year_url\\\":\\\"\\\"}}\",\"saved\":false,\"title\":\"轻合集.小棉袄\",\"version\":0,\"url\":\"hiker://page/indexLoad?#fypage#noHistory#\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nlet myCollection_el = [],\\n    pageNum = parseInt(MY_URL.split('#')[1]),\\n    RULE = MY_PARAMS.RULE,\\n    fyAll = RULE.url.includes('fyAll'),\\n    // 加载ClassTab组件\\n    ClassTab = $.require('hiker://page/ClassTab?rule=' + getItem('myCollection')),\\n    tabHeader = []\\n\\nif (RULE.class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: RULE.class_name,\\n    class_url: RULE.class_url\\n})\\nif (RULE.area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: RULE.area_name,\\n    class_url: RULE.area_url\\n})\\nif (RULE.year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: RULE.year_name,\\n    class_url: RULE.year_url\\n})\\nif (RULE.sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: RULE.sort_name,\\n    class_url: RULE.sort_url\\n})\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title })\\nif (pageNum == 1) {\\n    addListener('onClose', 'clearVar(\\\"myCollection-searchMode\\\")')\\n    putVar('myCollection-searchMode', RULE.title)\\n    tabHeader.load(myCollection_el)\\n    if (RULE.search_url) myCollection_el.push({\\n        title: \\\"搜索\\\",\\n        desc: \\\"搜你想要的...\\\",\\n        url: '\\\"hiker://search?s=\\\"+input+\\\"&rule=' + getItem('myCollection') + '\\\"',\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 处理MY_URL和MY_RULE\\nMY_RULE.version = RULE.version\\nMY_RULE.group = RULE.group\\nMY_RULE.title = RULE.title\\nMY_RULE.ua = RULE.ua\\nMY_RULE.col_type = RULE.col_type\\nMY_RULE.detail_col_type = RULE.detail_col_type\\nMY_RULE.find_rule = RULE.find_rule\\nMY_RULE.detail_find_rule = RULE.detail_find_rule\\nMY_RULE.preRule = RULE.preRule\\nMY_RULE.pageList = JSON.parse(RULE.pages || '[]')\\nMY_RULE.pages = JSON.stringify(MY_RULE.pageList)\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\nMY_RULE.params = {}\\n\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nvar { MY_URL, indexHtml } = urlParse(RULE.url, pageNum, (url) => {\\n    url[0] = fyAll ? url[0].replace(/fyAll/g, '$${fyAll}') : url[0].replace(/fy(class|area|year|sort)/g, '$${fy$1}')\\n    url[0] = tabHeader.setUrl(url[0])\\n})\\nMY_RULE.url = MY_URL\\n// 正文解析\\nif (pageNum == 1) eval(MY_RULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    function getUrl() {\\n        return MY_URL\\n    }\\n\\n    function getResCode() {\\n        return indexHtml\\n    }\\n\\n    function setResult(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(el.data)) el = el.data\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\n            let RULE = Object.assign({}, MY_RULE)\\n            v.col_type = v.col_type || MY_RULE.col_type\\n\\n            if (!v.url) {\\n                return v\\n            } else if (v.url.includes('@lazyRule=')) {\\n                v.url = v.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\n                return v\\n            } else if (v.url.includes('@rule=')) {\\n                let [_, url, rule] = v.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n                v.url = url\\n                RULE.detail_find_rule = rule\\n                RULE.detail_col_type = MY_RULE.col_type\\n            } else if (v.url.startsWith('hiker://page/')) {\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\n                    return v\\n                let path = v.url.split('#')[0].match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(?:\\\\?.*)?$/)[1],\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path)\\n                RULE.detail_find_rule = subPage.rule\\n                RULE.detail_col_type = subPage.col_type\\n                RULE.params = v.extra || {}\\n            } else if (!MY_RULE.detail_find_rule) { return v }\\n            v.extra = { url: v.url, RULE: RULE, pageTitle: v.title }\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n\\n    function setHomeResult(a, param1, param2, param3) {\\n        setResult(a, param1, param2, param3)\\n    }\\n\\n    function setSearchResult(a, param1, param2, param3) {\\n        setResult(a, param1, param2, param3)\\n    }\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let findRule = MY_RULE.find_rule.split(';')\\n    parseDomForArray(indexHtml, findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) {}\\n            }),\\n            res = {\\n                title: title,\\n                url: url,\\n                desc: desc,\\n                img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                res.url = res.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title  }\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\",\"group\":\"①②轻合集\",\"ua\":\"mobile\",\"preRule\":\"setItem('myCollection', MY_RULE.title)\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"ClassTab\\\",\\\"path\\\":\\\"ClassTab\\\",\\\"rule\\\":\\\"function ClassTab(classArray, params) {\\\\n    Object.assign(this, params)\\\\n    this.arr = classArray.map(v => this.init(v))\\\\n    this.sign = '$' + MY_RULE.title + '_' + (this.name || '') + '_'\\\\n    this.color = this.color || '#12b668'\\\\n    this.boundary = this.boundary || 'blank_block'\\\\n}\\\\nClassTab.prototype = {\\\\n    constructor: ClassTab,\\\\n    load(el) {\\\\n        let folded = getVar('fold_' + this.sign, '')\\\\n        if (this.fold) el.push({\\\\n            title: '““””<span style=\\\\\\\"color:#049eff\\\\\\\">' + (folded ? '▶' : '▼'),\\\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\\\n                putVar('fold_' + sign, { '': 'T', 'T': '' } [folded])\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, this.sign, folded),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n        let arr = folded ? [this.arr[0]] : this.arr\\\\n        arr.forEach((v) => {\\\\n            let { id, class_name, class_url } = v,\\\\n                selected = JSON.stringify(this.getClass(id))\\\\n            class_name.forEach((name, i) => {\\\\n                let url = class_url[i],\\\\n                    now = JSON.stringify({ name: name, url: url })\\\\n                el.push({\\\\n                    title: (selected == now ? '““””<span style=\\\\\\\"color:' + this.color + '\\\\\\\"><b>' : '') + name,\\\\n                    url: $('#noLoading#').lazyRule((sign, id, now) => {\\\\n                        putVar(sign + id, now)\\\\n                        putVar(sign, now)\\\\n                        refreshPage(false)\\\\n                        return 'hiker://empty'\\\\n                    }, this.sign, id, now),\\\\n                    col_type: 'scroll_button'\\\\n                })\\\\n            })\\\\n            el.push({ col_type: this.boundary })\\\\n        })\\\\n    },\\\\n    init(classObject) {\\\\n        if (typeof classObject.class_name == 'string')\\\\n            classObject.class_name = classObject.class_name.split('&')\\\\n        if (typeof classObject.class_url == 'string')\\\\n            classObject.class_url = classObject.class_url.split('&')\\\\n        return classObject\\\\n    },\\\\n    push(classObject) {\\\\n        this.arr.push(this.init(classObject))\\\\n    },\\\\n    getClass(id) {\\\\n        let defaultClass = this.arr.find(item => item.id == id)\\\\n        if (defaultClass) defaultClass = JSON.stringify({\\\\n            name: defaultClass.class_name[0],\\\\n            url: defaultClass.class_url[0]\\\\n        })\\\\n        else throw new Error('cannot find id: ' + id + ' in classTab: ' + this.sign)\\\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\\\n    },\\\\n    getLastClick() {\\\\n        return JSON.parse(getVar(this.sign, '{}'))\\\\n    },\\\\n    setUrl(url) {\\\\n        return url.replace(/\\\\\\\\$\\\\\\\\{([^}]*)\\\\\\\\}/g, (_, id) => this.getClass(id).url)\\\\n    }\\\\n}\\\\n$.exports = ClassTab\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"首页\\\",\\\"path\\\":\\\"indexLoad\\\",\\\"rule\\\":\\\"js:\\\\nlet myCollection_el = [],\\\\n    pageNum = parseInt(MY_URL.split('#')[1]),\\\\n    RULE = MY_PARAMS.RULE,\\\\n    fyAll = RULE.url.includes('fyAll'),\\\\n    // 加载ClassTab组件\\\\n    ClassTab = $.require('hiker://page/ClassTab?rule=' + getItem('myCollection')),\\\\n    tabHeader = []\\\\n\\\\nif (RULE.class_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyclass',\\\\n    class_name: RULE.class_name,\\\\n    class_url: RULE.class_url\\\\n})\\\\nif (RULE.area_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyarea',\\\\n    class_name: RULE.area_name,\\\\n    class_url: RULE.area_url\\\\n})\\\\nif (RULE.year_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyyear',\\\\n    class_name: RULE.year_name,\\\\n    class_url: RULE.year_url\\\\n})\\\\nif (RULE.sort_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fysort',\\\\n    class_name: RULE.sort_name,\\\\n    class_url: RULE.sort_url\\\\n})\\\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title })\\\\nif (pageNum == 1) {\\\\n    addListener('onClose', 'clearVar(\\\\\\\"myCollection-searchMode\\\\\\\")')\\\\n    putVar('myCollection-searchMode', RULE.title)\\\\n    tabHeader.load(myCollection_el)\\\\n    if (RULE.search_url) myCollection_el.push({\\\\n        title: \\\\\\\"搜索\\\\\\\",\\\\n        desc: \\\\\\\"搜你想要的...\\\\\\\",\\\\n        url: '\\\\\\\"hiker://search?s=\\\\\\\"+input+\\\\\\\"&rule=' + getItem('myCollection') + '\\\\\\\"',\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n    })\\\\n}\\\\n// 处理MY_URL和MY_RULE\\\\nMY_RULE.version = RULE.version\\\\nMY_RULE.group = RULE.group\\\\nMY_RULE.title = RULE.title\\\\nMY_RULE.ua = RULE.ua\\\\nMY_RULE.col_type = RULE.col_type\\\\nMY_RULE.detail_col_type = RULE.detail_col_type\\\\nMY_RULE.find_rule = RULE.find_rule\\\\nMY_RULE.detail_find_rule = RULE.detail_find_rule\\\\nMY_RULE.preRule = RULE.preRule\\\\nMY_RULE.pageList = JSON.parse(RULE.pages || '[]')\\\\nMY_RULE.pages = JSON.stringify(MY_RULE.pageList)\\\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\\\nMY_RULE.params = {}\\\\n\\\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\\\nvar { MY_URL, indexHtml } = urlParse(RULE.url, pageNum, (url) => {\\\\n    url[0] = fyAll ? url[0].replace(/fyAll/g, '$${fyAll}') : url[0].replace(/fy(class|area|year|sort)/g, '$${fy$1}')\\\\n    url[0] = tabHeader.setUrl(url[0])\\\\n})\\\\nMY_RULE.url = MY_URL\\\\n// 正文解析\\\\nif (pageNum == 1) eval(MY_RULE.preRule)\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    function getUrl() {\\\\n        return MY_URL\\\\n    }\\\\n\\\\n    function getResCode() {\\\\n        return indexHtml\\\\n    }\\\\n\\\\n    function setResult(el, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n        if (Array.isArray(el.data)) el = el.data\\\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\\\n            let RULE = Object.assign({}, MY_RULE)\\\\n            v.col_type = v.col_type || MY_RULE.col_type\\\\n\\\\n            if (!v.url) {\\\\n                return v\\\\n            } else if (v.url.includes('@lazyRule=')) {\\\\n                v.url = v.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\\\n                return v\\\\n            } else if (v.url.includes('@rule=')) {\\\\n                let [_, url, rule] = v.url.match(/^([\\\\\\\\s\\\\\\\\S]*?)@rule=([\\\\\\\\s\\\\\\\\S]*)$/)\\\\n                v.url = url\\\\n                RULE.detail_find_rule = rule\\\\n                RULE.detail_col_type = MY_RULE.col_type\\\\n            } else if (v.url.startsWith('hiker://page/')) {\\\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\\\n                    return v\\\\n                let path = v.url.split('#')[0].match(/^hiker:\\\\\\\\/\\\\\\\\/page\\\\\\\\/(.+?)(?:\\\\\\\\?.*)?$/)[1],\\\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path)\\\\n                RULE.detail_find_rule = subPage.rule\\\\n                RULE.detail_col_type = subPage.col_type\\\\n                RULE.params = v.extra || {}\\\\n            } else if (!MY_RULE.detail_find_rule) { return v }\\\\n            v.extra = { url: v.url, RULE: RULE, pageTitle: v.title }\\\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\\\n            return v\\\\n        }))\\\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\\\n    }\\\\n\\\\n    function setHomeResult(a, param1, param2, param3) {\\\\n        setResult(a, param1, param2, param3)\\\\n    }\\\\n\\\\n    function setSearchResult(a, param1, param2, param3) {\\\\n        setResult(a, param1, param2, param3)\\\\n    }\\\\n\\\\n    eval(MY_RULE.find_rule.slice(3))\\\\n} else {\\\\n    let findRule = MY_RULE.find_rule.split(';')\\\\n    parseDomForArray(indexHtml, findRule.shift()).forEach((data) => {\\\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\\\n                try {\\\\n                    if (v == '*') return ''\\\\n                    else v = (i == 1 || i == 3) ?\\\\n                        parseDom(data, v) :\\\\n                        parseDomForHtml(data, v)\\\\n                    if (i != 3) v = runCode(v)\\\\n                    return v\\\\n                } catch (e) {}\\\\n            }),\\\\n            res = {\\\\n                title: title,\\\\n                url: url,\\\\n                desc: desc,\\\\n                img: img,\\\\n                col_type: MY_RULE.col_type\\\\n            }\\\\n        if (res.url) {\\\\n            if (res.url.includes('@lazyRule=')) {\\\\n                res.url = res.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title  }\\\\n            }\\\\n        }\\\\n        myCollection_el.push(res)\\\\n    })\\\\n    setResult(myCollection_el)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"详情\\\",\\\"path\\\":\\\"detailLoad\\\",\\\"rule\\\":\\\"js:\\\\nvar myCollection_el = []\\\\n\\\\n// 处理MY_URL和MY_RULE\\\\nlet RULE = MY_PARAMS.RULE\\\\nMY_RULE.version = RULE.version\\\\nMY_RULE.group = RULE.group\\\\nMY_RULE.title = RULE.title\\\\nMY_RULE.url = MY_URL\\\\nMY_RULE.ua = RULE.ua\\\\nMY_RULE.col_type = RULE.detail_col_type\\\\nMY_RULE.find_rule = RULE.detail_find_rule\\\\nMY_RULE.preRule = RULE.preRule\\\\nMY_RULE.pageList = RULE.pageList\\\\nMY_RULE.pages = RULE.pages\\\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\\\nMY_RULE.params = RULE.params\\\\n// 解析正文\\\\nif(MY_PARAMS.pageTitle) setPageTitle(MY_PARAMS.pageTitle)\\\\neval(MY_RULE.preRule)\\\\nsetLastChapterRule(MY_RULE.last_chapter_rule)\\\\nMY_PARAMS = MY_RULE.params\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    function setResult(el, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n        if (Array.isArray(el.data)) el = el.data\\\\n\\\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\\\n            let RULE = Object.assign({}, MY_RULE)\\\\n            v.col_type = v.col_type || MY_RULE.col_type\\\\n\\\\n            if (!v.url) {\\\\n                return v\\\\n            } else if (v.url.includes('@lazyRule=')) {\\\\n                v.url = v.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\\\n                return v\\\\n            } else if (v.url.includes('@rule=')) {\\\\n                let [_, url, rule] = v.url.match(/^([\\\\\\\\s\\\\\\\\S]*?)@rule=([\\\\\\\\s\\\\\\\\S]*)$/)\\\\n                v.url = url\\\\n                RULE.detail_find_rule = rule\\\\n                RULE.detail_col_type = MY_RULE.col_type\\\\n            } else if (v.url.startsWith('hiker://page/')) {\\\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\\\n                    return v\\\\n                let path = v.url.split('#')[0].match(/^hiker:\\\\\\\\/\\\\\\\\/page\\\\\\\\/(.+?)(?:\\\\\\\\?.*)?$/)[1],\\\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path)\\\\n                RULE.detail_find_rule = subPage.rule\\\\n                RULE.detail_col_type = subPage.col_type\\\\n                RULE.params = v.extra || {}\\\\n            } else { return v }\\\\n            v.extra = { url: v.url, RULE: RULE }\\\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\\\n            return v\\\\n        }))\\\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\\\n    }\\\\n\\\\n    function setHomeResult(a, param1, param2, param3) {\\\\n        setResult(a, param1, param2, param3)\\\\n    }\\\\n\\\\n    function setSearchResult(a, param1, param2, param3) {\\\\n        setResult(a, param1, param2, param3)\\\\n    }\\\\n\\\\n    eval(MY_RULE.find_rule.slice(3))\\\\n} else {\\\\n    const { runCode } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\\\n    let findRule = MY_RULE.find_rule.split(';')\\\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\\\n                try {\\\\n                    if (v == '*') return ''\\\\n                    else v = (i == 1 || i == 3) ?\\\\n                        parseDom(data, v) :\\\\n                        parseDomForHtml(data, v)\\\\n                    if (i != 3) v = runCode(v)\\\\n                    return v\\\\n                } catch (e) {}\\\\n            }),\\\\n            res = {\\\\n                title: title,\\\\n                url: url,\\\\n                desc: desc,\\\\n                img: img,\\\\n                col_type: MY_RULE.col_type\\\\n            }\\\\n        if (res.url && res.url.includes('@lazyRule='))\\\\n            res.url = res.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ title: MY_RULE.title, pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');')\\\\n        myCollection_el.push(res)\\\\n    })\\\\n    setResult(myCollection_el)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据载入\\\",\\\"path\\\":\\\"dataLoad\\\",\\\"rule\\\":\\\"//真正获取数据的逻辑\\\\nfunction load() {\\\\n    let url = 'http://hiker.nokia.press/hikerule/dev/json_list?name=1596889407',\\\\n        d = []\\\\n    try {\\\\n        d = fetch(url)\\\\n        if (url.startsWith('hiker://page/'))\\\\n            d = JSON.parse(d).rule\\\\n        d = JSON.parse(d)\\\\n    } catch (e) {\\\\n        d = []\\\\n    }\\\\n    return d.filter((v) => { return v.title != MY_RULE.title && v.author != '轻合集生成器' })\\\\n}\\\\n//检查间隔，默认一天\\\\nlet min = 60 * 24 * 1\\\\n\\\\nlet data = []\\\\nlet time = getItem('updatetime', '0')\\\\ntime = parseInt(time)\\\\nlet now = new Date().getTime()\\\\nif (now - time > 1000 * 60 * min) {\\\\n    log('更新了数据')\\\\n    setItem('updatetime', '' + now)\\\\n    data = load()\\\\n    saveFile('data.json', JSON.stringify(data))\\\\n} else {\\\\n    log('没有更新数据')\\\\n    data = JSON.parse(readFile('data.json'))\\\\n}\\\\n$.exports = data\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"工具集\\\",\\\"path\\\":\\\"utility\\\",\\\"rule\\\":\\\"$.exports = {\\\\n    runCode: function(rule) {log(rule)\\\\n        try {\\\\n            let [input, code] = rule.split('.js:')\\\\n            return code ? eval(code) : rule\\\\n        } catch (e) { return rule }\\\\n    },\\\\n    urlParse: function(url, pageNum, func) {\\\\n        url = url.split(';').map((v) => v.replace(/；；/g, ';'))\\\\n        if (func) func(url)\\\\n        url[0] = url[0].replace(/fypage(?:@(-?\\\\\\\\d+)@)?(?:\\\\\\\\*(\\\\\\\\d+)@)?/, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\\\n        url[0] = /^(.*?)(?:\\\\\\\\[firstPage=(.*?)\\\\\\\\])?$/.exec(url[0])\\\\n        url[0] = runCode(url[0][2] && pageNum == 1 ? url[0][2] : url[0][1])\\\\n        let options = { headers: { 'Content-Type': 'text/plain; charst=UTF-8' }, method: url[1] }\\\\n        // post方法时转换参数\\\\n        if (/^post$/i.test(options['method'])) {\\\\n            let [oriUrl, body] = url[0].split('?')\\\\n            url[0] = oriUrl.replace(/？？/g, '?')\\\\n            if (body.startsWith('JsonBody=')) body = body.slice(9)\\\\n            options['body'] = body\\\\n        }\\\\n        if (url[2]) options.headers['Content-Type'] = options.headers['Content-Type'].slice(0, 19) + url[2]\\\\n        if (url[3]) url[3].match(/{(.*)}/)[1].split('&&').forEach((v) => {\\\\n            let [key, value] = v.split('@')\\\\n            options.headers[key] = runCode(value)\\\\n        })\\\\n        // 添加全局UA\\\\n        if (!options.headers['User-Agent']) {\\\\n            if (MY_RULE.ua == 'pc')\\\\n                options.headers['User-Agent'] = PC_UA\\\\n            else if (MY_RULE.ua == 'mobile')\\\\n                options.headers['User-Agent'] = MOBILE_UA\\\\n        }\\\\n        return { MY_URL: url[0], indexHtml: fetch(url[0], options) }\\\\n    }\\\\n}\\\\n\\\"}]\"}","title":"顶点小说🅛"}