邀您一起看：漫蛙

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥漫蛙@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"var {\\n    QING_TITLE, title, url,\\n    class_name, class_url,\\n    area_name, area_url,\\n    year_name, year_url,\\n    sort_name, sort_url\\n} = $.importParam\\nconst ClassTab = function(classArray, params) {\\n    Object.assign(this, params)\\n    this.arr = classArray.map(v => this.init(v))\\n    this.sign = '$' + QING_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 = this.fold && getVar('$fold_' + this.sign, '')\\n        if (this.arr.length > 1 && this.fold) el.push({\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\n                putVar('$fold_' + sign, folded ? '' : 'T')\\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 ? '““””' + name.fontcolor(this.color).bold() : name,\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\n                        putVar(sign + id, 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('&').map((v) => v.trim())\\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        defaultClass = JSON.stringify(defaultClass ? {\\n            name: defaultClass.class_name[0],\\n            url: defaultClass.class_url[0]\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\n    },\\n    setUrl(url) {\\n        return url.replace(/\\\\$\\\\{([^}]*)\\\\}/g, (_, id) => this.getClass(id).url)\\n    }\\n}\\n// 生成头部分类\\nlet fyAll = url.includes('fyAll'),\\n    tabHeader = []\\nif (class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: class_name,\\n    class_url: class_url\\n})\\nif (area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: area_name,\\n    class_url: area_url\\n})\\nif (year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: year_name,\\n    class_url: year_url\\n})\\nif (sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: sort_name,\\n    class_url: sort_url\\n})\\n$.exports = {\\n    fyAll: fyAll,\\n    tabHeader: new ClassTab(tabHeader, { name: title, fold: readFile('tabFold'), })\\n}\\n\"},{\"col_type\":\"icon_2_round\",\"name\":\"设置\",\"path\":\"Config\",\"rule\":\"js:\\naddListener('onClose', 'clearMyVar(\\\"sortFlag\\\");refreshPage()')\\nsetPageTitle('⚙ 阅漫君设置 ⚙')\\nconst QING_TITLE = getMyVar('myCollection'),\\n    url = getMyVar('remoteUrl')\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE, true),\\n    el = [{\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，没事别点，可每月点一次更新）',\\n        url: $(\\\"清除缓存，立即更新\\\").confirm((url) => {\\n            //远程依赖索引文件代理地址列表\\n            let requirelist = ['https://ghproxy.cc/https://raw.githubusercontent.com/QQ1993HUANG/A/main/阅漫君.json']\\n            for (let i = 0; i < requirelist.length; i++) {\\n                try { //远程依赖索引\\n                    let res = request(requirelist[i] + 'QQ1993HUANG/A/main', {\\n                        withStatusCode: true\\n                    })\\n                    if (JSON.parse(res).statusCode == 200) {\\n                        if (fileExist(url)) {\\n                            deleteFile(url)\\n                            requireDownload(requirelist[i] + 'QQ1993HUANG/A/main',url)\\n                            break\\n                        } else {\\n                            requireDownload(requirelist[i] + 'QQ1993HUANG/A/main',url)\\n                            break\\n                        }\\n                    }\\n                } catch (e) {}\\n            }\\n            refreshPage(true)\\n            back(false)\\n            return 'toast://已更新'\\n        }, url),\\n        img: 'hiker://images/icon4',\\n        col_type: 'avatar'\\n    }],\\n    updateInterval = readFile('updateInterval') || '1',\\n    newWindow = readFile('newWindow'),\\n    tabFold = readFile('tabFold'),\\n    disableCustom = readFile('disableCustom'),\\n    editMode = disableCustom ? '导入海阔' : getMyVar('editMode', '启用/禁用')\\n\\nel.push({\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\n本地文件链接无效').input(() => {\\n        input = parseInt(input)\\n        if (Number.isNaN(input)) input = 1\\n        else if (input < 1) input = 0\\n        saveFile('updateInterval', input.toString())\\n        refreshPage()\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  🖥 独立首页: ' + (newWindow ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((newWindow) => {\\n        saveFile('newWindow', newWindow ? '' : 'T')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, newWindow),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\n        saveFile('tabFold', tabFold ? '' : 'T')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, tabFold),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💼 备份恢复  ',\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\n        let url = getMyVar('remoteUrl')\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\n        else if (url.startsWith('hiker://page/')) url = 'hiker://empty'\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\n                let rules = request(url),\\n                    customData = readFile('customData')\\n                writeFile(input, JSON.stringify({\\n                    updateInterval: updateInterval,\\n                    newWindow: newWindow,\\n                    tabFold: tabFold,\\n                    disableCustom: disableCustom,\\n                    customData: customData,\\n                    rules: rules\\n                }))\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\n            saveFile('updateInterval', updateInterval)\\n            saveFile('newWindow', newWindow)\\n            saveFile('tabFold', tabFold)\\n            saveFile('disableCustom', disableCustom)\\n            saveFile('customData', customData)\\n            if (rules) writeFile(url, rules)\\n            refreshPage()\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\n        }, url)\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '““””<font color=\\\"#666666\\\"><small>特别鸣谢，小程序提供者：团子/墙佬/道长/    小程序维护：小米粥\\\\n'\\n        /*data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\n        .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、')*/,\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\nel.push({\\n    title: \\\"更新&反馈\\\",\\n    url: \\\"hiker://page/Up#noRefresh##noRecordHistory##noHistory#\\\",\\n    extra: {\\n        version: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\"\\n    },\\n    col_type: \\\"text_center_1\\\"\\n});\\nel.push({ col_type: 'line' }, {\\n    title: '““””' + '📝'.small() + '&nbsp 阅漫君自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据', '编辑JSON'], 1).select(() => {\\n        switch (input.slice(0, 2)) {\\n            case '清除':\\n                deleteFile('customData')\\n                break\\n            case '启用':\\n                saveFile('disableCustom', '')\\n                break\\n            case '禁用':\\n                saveFile('disableCustom', 'T')\\n                input += '\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\n                break\\n            case '编辑':\\n                let url = getMyVar('remoteUrl')\\n                if (!url.startsWith('hiker://files/') && !url.startsWith('file://'))\\n                    url = 'hiker://files/libs/' + md5(url) + '.js'\\n                return  'hiker://page/interface#noRefresh##noHistory##noRecordHistory#?rule=JSON编辑器&Json='+base64Encode(url)\\n        }\\n        refreshPage(false)\\n        return 'toast://已' + input\\n    }),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});/*\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\n    el.push({\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putMyVar('editMode', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'scroll_button'\\n    })\\n});\\nif (editMode == '导入海阔') el.push({\\n    title: '全部导入',\\n    url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\n    let d = { title: v.title, img: data[i].icon }\\n    switch (editMode) {\\n        case '启用/禁用':\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                rules[i].visible = !rules[i].visible\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '重新排序':\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\n            if (sortFlag == -1)\\n                d.url = $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('sortFlag', i.toString())\\n                    refreshPage(false)\\n                    return 'toast://选择要移动到的位置'\\n                }, i)\\n            else\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\n                    saveFile('customData', JSON.stringify(rules))\\n                    putMyVar('sortFlag', '-1')\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, sortFlag, i)\\n            break\\n        case '更改图标':\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                if (input)\\n                    rules[i].icon = input\\n                else\\n                    delete rules[i].icon\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '导入海阔':\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let data = $.require('hiker://page/dataLoad?rule=' + getMyVar('myCollection'), true)\\n                return 'rule://' + base64Encode(JSON.stringify(data[i]))\\n            }, i)\\n            break\\n    }\\n    el.push(d)\\n})*/\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\n    el.push({\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putMyVar('editMode', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'scroll_button'\\n    })\\n});\\nif(editMode === '导入海阔') {\\n    el.push({\\n        title:'搜索',\\n        desc:'输入小程序标题|地址进行搜索...',\\n        url:$.toString(()=>{\\n            refreshPage(false);\\n        }),\\n        col_type:'input',\\n        extra: {\\n            onChange: \\\"putMyVar('importSearchKey',input)\\\",\\n            titleVisible: true,\\n            defaultValue:getMyVar('importSearchKey','')\\n        },\\n    });\\n    el.push({\\n        title: '全部导入(非搜索过滤后结果)',\\n        url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\n        col_type: 'text_center_1',\\n        extra: {lineVisible: false}\\n    });\\n}\\nvar datas = (disableCustom ? data : JSON.parse(readFile('customData') || '[]'));\\nlet sk = getMyVar('importSearchKey','');\\nif(editMode === '导入海阔'&&sk) {\\n    datas = datas.filter(it=>it.title.includes(sk)||(it.url&&it.url.includes(sk)));\\n    data = data.filter(it=>it.title.includes(sk)||(it.url&&it.url.includes(sk)));\\n}\\ndatas.forEach((v, i) => {\\n    let d = { title: v.title, img: data[i].icon }\\n    switch (editMode) {\\n        case '启用/禁用':\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                rules[i].visible = !rules[i].visible\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '重新排序':\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\n            if (sortFlag == -1)\\n                d.url = $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('sortFlag', i.toString())\\n                    refreshPage(false)\\n                    return 'toast://选择要移动到的位置'\\n                }, i)\\n            else\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\n                    saveFile('customData', JSON.stringify(rules))\\n                    putMyVar('sortFlag', '-1')\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, sortFlag, i)\\n            break\\n        case '更改图标':\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                if (input)\\n                    rules[i].icon = input\\n                else\\n                    delete rules[i].icon\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '导入海阔':\\n            d.url = 'rule://' + base64Encode(JSON.stringify(data[i]));\\n            break\\n    }\\n    el.push(d)\\n})\\nsetResult(el)\"},{\"col_type\":\"movie_3\",\"name\":\"页面载入\",\"path\":\"frameLoad\",\"rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nvar myColl_el = []\\neval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(oriRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n} else if (MY_PAGE == 1) {\\n    tabHeader.load(myColl_el)\\n    if (RULE.search_url) myColl_el.push({\\n        title: \\\"搜索\\\",\\n        desc: \\\"这是阅漫君的搜索哦~~\\\",\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        extra: {\\n            rules: $.toString((QING_TITLE, title) => {\\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\\n                rules = [rules.find((v) => v.title == title)]\\n                return JSON.stringify(rules)\\n            }, QING_TITLE, RULE.title),\\n            defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"\\n        },\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 正文解析\\nvar {\\n    paramHandle,\\n    runPreRule,\\n    genExUrl,\\n    hijackLazyRule\\n} = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\nrunPreRule(oriRULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    let { hijackEl } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n    setResult = function(param0, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(param0.data)) param0 = param0.data\\n        Array.prototype.push.apply(myColl_el, param0.map(hijackEl))\\n        method_setResult.invoke(javaContext, myColl_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let { runCode } = $.require('hiker://page/funcTools?rule=' + QING_TITLE),\\n        [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.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) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(Object.assign(genMyRule(), { detail_find_rule: detailFindRule }))),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(genMyRule())),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myColl_el.push(res)\\n    })\\n    setResult(myColl_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"数据载入\",\"path\":\"dataLoad\",\"rule\":\"let showAll = $.importParam,\\n    url = getMyVar('remoteUrl'),\\n    data = []\\nif (url.startsWith('hiker://') || url.startsWith('file://')) {\\n    // 如果为本地文件则不进行缓存\\n    try {\\n        let oriData = fetch(url)\\n        if (url.startsWith('hiker://page/'))\\n            oriData = JSON.parse(oriData).rule\\n        data = JSON.parse(oriData)\\n    } catch (e) {}\\n} else {\\n    // 获取远程数据，检查间隔默认一天\\n    let interval = parseInt(readFile('updateInterval') || '1'),\\n        oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\n        remoteData = []\\n    if (interval == 0) interval = -1\\n    try { remoteData = JSON.parse(fetchCache(url, 24 * interval, { timeout: 50000 })) } catch (e) {}\\n    if (!Array.isArray(remoteData)) remoteData = []\\n    if (remoteData.length < 3) {\\n        log('未获取到数据')\\n        if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData)\\n        data = JSON.parse(oldData || '[]')\\n    } else {\\n        log('已获取到数据')\\n        data = remoteData\\n    }\\n}\\ndata = data.filter((v) => v.title != getMyVar('myCollection') && !(v.author || '').includes('阅漫君生成器'))\\nif (readFile('disableCustom')) $.exports = data\\nelse { // 写入自定义数据\\n    let customData = JSON.parse(readFile('customData') || '[]'),\\n        rewriteData = []\\n    customData = customData.reduce((self, v) => {\\n        let index = data.findIndex((vv) => v.title == vv.title)\\n        if (index >= 0) {\\n            self.push(v)\\n            let rule = data.splice(index, 1)[0]\\n            if (showAll || v.visible)\\n                rewriteData.push(Object.assign(rule, v))\\n        }\\n        return self\\n    }, [])\\n    data.forEach((v) => customData.push({ title: v.title, visible: true }))\\n    saveFile('customData', JSON.stringify(customData))\\n    $.exports = rewriteData.concat(data)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"链接处理*\",\"path\":\"urlParse\",\"rule\":\"// 首页链接替换分类\\nfunction indexUrl(param) {\\n    function runCode(rule) {\\n        try {\\n            let [input, code] = rule.split('.js:')\\n            return code ? eval(code) : rule\\n        } catch (e) { return rule }\\n    }\\n    let { RULE, pageNum, QING_TITLE } = JSON.parse(param.split('###')[1])\\n    RULE = JSON.parse(base64Decode(RULE))\\n    pageNum = parseInt(pageNum)\\n    let url = RULE.url\\n\\n    eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\n    url = url.replace(/fypage(?:@(-?\\\\d+)@)?(?:\\\\*(\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\n    url = /^([\\\\s\\\\S]*?)(?:\\\\[firstPage=([\\\\s\\\\S]*?)\\\\])?(?:(\\\\.js:[\\\\s\\\\S]*?))?$/.exec(url)\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\n    return runCode(url[1])\\n}\\nfunction paramHandle(urlParam, ua, urlTmp) {\\n    let charset, paramTmp\\n    try { // 链接的编码、UA和Referer应该是首先继承首页链接\\n        [, , charset, paramTmp] = urlTmp.split(';')\\n        paramTmp = paramTmp.match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { paramTmp = [] }\\n    let UserAgent = paramTmp.find((v) => v.startsWith('User-Agent@')),\\n        Referer = paramTmp.find((v) => v.startsWith('Referer@'))\\n    urlParam[0] = urlParam[0] || 'GET'\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\n    try {\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { urlParam[2] = [] }\\n    // 添加全局UA和上级Referer\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\n        if (UserAgent) urlParam[2].push(UserAgent)\\n        else if (ua == 'pc')\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n        else if (ua == 'mobile')\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n    }\\n    if (Referer && !urlParam[2].some((v) => v.startsWith('Referer@')))\\n        urlParam[2].push(Referer)\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\n    return urlParam.join(';')\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级[一]*\",\"path\":\"ejtool\",\"rule\":\"function cover(标题, 作者, 分类, 状态, 章节, 更新, 简介,封面图片,true_url, hasLine) {\\r\\nvar 标题, 作者, 分类, 状态, 章节, 更新, 简介,封面图片,true_url, hasLine;\\r\\n\\ttry {\\r\\n\\t\\td.push({\\r\\n\\t\\t\\ttitle: '‘‘’’<small><font color=\\\"#FA7298\\\">'+作者.slice(0,15)+\\\"&nbsp;\\\"+状态+'</font></small>'+'‘‘’’<small><font color=\\\"#B15BFF\\\">'+\\\"\\\\n\\\"+分类+'</font></small>'+'‘‘’’<small><font color=\\\"#FF359A\\\">'+\\\"\\\\n\\\"+章节+\\\"&nbsp;\\\"+更新+'</font></small>',\\r\\n\\t\\t\\tdesc:'‘‘’’<small>' +简介+ '</small>',\\r\\n\\t\\t\\tpic_url:  封面图片,\\r\\n\\t\\t\\turl: true_url,\\r\\n\\t\\t\\tcol_type: 'movie_1_vertical_pic_blur'\\r\\n\\t\\t});\\n\\t\\td.push({\\r\\n\\t\\t\\tcol_type: 'line_blank',\\r\\n\\t\\t});\\n\\t\\td.push({\\r\\n\\t\\t\\tcol_type: 'line',\\r\\n\\t\\t});\\r\\n\\t\\tif (hasLine) {\\r\\n\\t\\t\\titem.extra = {\\r\\n\\t\\t\\t\\tlineVisible: false\\r\\n\\t\\t\\t}\\r\\n\\t\\t}\\r\\n\\t\\td.push(item);\\r\\n\\t} catch (e) {}\\r\\n}\\r\\nfunction chapter(title,pic_url,chapterList, chapterTitle, chapterUrl, defaultOrder, hasLine,downloadlazy) {\\r\\n\\tvar list = chapterList;\\r\\n\\tvar original = [{\\r\\n\\t\\turl: MY_URL,\\r\\n\\t\\torder: defaultOrder\\r\\n\\t}];\\r\\n\\t!fileExist('hiker://files/rules/comic/comicLogFile.js') ? (writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(original))) : 0;\\r\\n\\tvar log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));\\r\\n\\tfor (var i in log) {\\r\\n\\t\\tif (log[i].url == MY_URL) {\\r\\n\\t\\t\\tvar now = i;\\r\\n\\t\\t\\tvar order = log[i].order;\\r\\n\\t\\t\\tbreak;\\r\\n\\t\\t} else {\\r\\n\\t\\t\\tvar now = '';\\r\\n\\t\\t\\tvar order = defaultOrder;\\r\\n\\t\\t}\\r\\n\\t}\\r\\n\\tlet orderItem = {\\r\\n\\t\\ttitle: \\\"““””\\\" + '<strong><font color=\\\"#098AC1\\\">' + '章节排序⇅' + '</font></strong>',\\r\\n\\t\\turl: MY_URL + `@lazyRule=.js:var log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));var now='` + now + `';if(now!=''){var now=parseInt(now);var order=log[now].order}else{var now=parseInt(log.length);var order=` + defaultOrder + `;log.push({url:input,order:order});}if(log[now].order){log[now].order=0;}else{log[now].order=1;};writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(log));refreshPage();'hiker://empty'`,\\r\\n\\t\\tcol_type: 'text_2'\\r\\n\\t}\\r\\n\\tif (hasLine) {\\r\\n\\t\\torderItem.title = \\\"““””\\\" + '<strong><font color=\\\"#098AC1\\\">' + '集数排序⇅' + '</font></strong>';\\r\\n\\t\\torderItem.col_type = \\\"text_2\\\"\\r\\n\\t}\\r\\n\\tlet chapterLists = list.map((item)=>({\\r\\n\\t\\ttitle: pdfh(item,\\\"a&&Text\\\"),\\r\\n\\t\\turl: pd(item,\\\"a&&href\\\"),\\r\\n\\t}));\\r\\nd.push({\\r\\n\\ttitle: '‘‘’’<strong><font color= \\\"#098AC1\\\">' + \\\"下载漫画\\\" + '</front></strong>',\\r\\n\\turl: \\\"hiker://page/download.view#noHistory##noRecordHistory##noRefresh#?rule=本地资源管理\\\",\\r\\n\\tcol_type: \\\"text_2\\\",\\r\\n\\textra: {\\r\\n\\t\\tchapterList: chapterLists,\\r\\n\\t\\tinfo:{\\r\\n\\t\\t\\tbookName: title,\\r\\n\\t\\t\\truleName: MY_RULE.title,\\r\\n\\t\\t\\tbookTopPic: pic_url,\\r\\n\\t\\t\\tparseCode: downloadlazy\\r\\n\\t\\t},\\r\\n\\t\\tdefaultView:\\\"1\\\"\\r\\n\\t}\\r\\n});\\r\\n\\td.push({\\r\\n\\t\\ttitle: '‘‘’’<strong><font color= \\\"#098AC1\\\">' + \\\"本地书架\\\" + '</front></strong>',\\r\\n\\t\\turl: \\\"hiker://page/Main.view?rule=本地资源管理\\\",\\r\\n\\t\\tcol_type: \\\"text_2\\\",\\r\\n\\t});  \\r\\n\\td.push(orderItem);\\r\\n\\td.push({col_type: 'line'});\\t\\r\\n\\tvar list = order ? list : list.reverse();\\n\\tif(!list||list==\\\"\\\"){\\r\\n\\t\\td.push({\\r\\n\\t\\t\\ttitle: '此漫画已下架!!',\\r\\n\\t\\t\\tcol_type: 'text_center_1',\\r\\n\\t\\t});\\r\\n\\t}\\r\\n\\tfor (var i in list) {\\r\\n\\t\\ttry {\\r\\n\\t\\t\\td.push({\\r\\n\\t\\t\\t\\ttitle: pdfh(list[i], chapterTitle),\\r\\n\\t\\t\\t\\turl: pd(list[i], chapterUrl) + lazy,\\r\\n\\t\\t\\t\\tcol_type: 'text_2',\\r\\n\\t\\t\\t});\\r\\n\\t\\t}catch (e) {}\\r\\n\\t}\\r\\n}\\r\\n\\r\\nfunction line(lineList, lineTitleRule, varKey) {\\r\\n\\tlet list = lineList\\r\\n\\tvarKey = varKey == null ? (MY_RULE.url + '#line-index'): varKey;\\r\\n\\taddListener('onClose', $.toString((keyList) => {\\r\\n\\t\\tfor (let i in keyList) {clearVar(keyList[i])}\\r\\n\\t}, [varKey, MY_RULE.title + '#line-title']))\\r\\n\\tlet line0Title = '';\\r\\n\\ttry {\\r\\n\\t\\tline0Title = pdfh(list[0], lineTitleRule).replace(\\\"章节列表：\\\",\\\"\\\");\\r\\n\\t} catch (e) {}\\r\\n\\tlog(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')))\\r\\n\\tfor (let i in list) {\\r\\n\\t\\ttry {\\r\\n\\t\\t\\tlet lineTitle = pdfh(list[i], lineTitleRule).replace(\\\"章节列表：\\\",\\\"\\\");\\r\\n\\t\\t\\td.push({\\r\\n\\t\\t\\t\\ttitle: getMyVar((MY_RULE.title + '#line-title'), line0Title) === lineTitle ? \\\"切换:‘‘\\\" + lineTitle+\\\"\\\":lineTitle+\\\"‘‘:切换\\\",\\r\\n\\t\\t\\t\\turl: $().lazyRule((varKey, lineIndex, lineTitle) => {\\r\\n\\t\\t\\t\\t\\tputMyVar(varKey, lineIndex.toString());\\r\\n\\t\\t\\t\\t\\tputMyVar((MY_RULE.title + '#line-title'), lineTitle);\\r\\n\\t\\t\\t\\t\\tlog(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')));\\r\\n\\t\\t\\t\\t\\trefreshPage();\\r\\n\\t\\t\\t\\t\\treturn \\\"toast://已切换至\\\" + lineTitle;\\r\\n\\t\\t\\t\\t}, varKey, i, lineTitle),\\r\\n\\t\\t\\t\\tcol_type: 'text_2',\\r\\n\\t\\t\\t});\\r\\n\\t\\t} catch (e) {}\\r\\n\\t}\\r\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级[二]*\",\"path\":\"comicFunctionFile.js\",\"rule\":\"function cover(coverTitle, coverTitle1, coverTitle2, coverTitle3, coverDesc, coverPic, coverUrl, hasLine) {\\n    try {\\n        const Color = \\\"#19B89D\\\";\\n        var des_desc = pdfh(html, coverDesc).replace('简　　介：', '').replace('漫画简介：', '');\\n        d.push({\\n            title: '‘‘’’<><font color=\\\"#FA7298\\\">' + pdfh(html, coverTitle) + '\\\\n' + '‘‘’’<><font color=\\\"#734338\\\">' + pdfh(html, coverTitle1) + '\\\\n',\\n            desc: '‘‘’’<><font color=\\\"#954A45\\\">' + pdfh(html, coverTitle2) + '\\\\n' + '‘‘’’<><font color=\\\"#954A45\\\">' + pdfh(html, coverTitle3),\\n            pic_url: pd(html, coverPic)||coverPic,\\n            url: 'hiker://search?s='+MY_PARAMS.ytitle+'&rule=阅漫君',\\n            col_type: 'movie_1_vertical_pic_blur'\\n        });\\n        d.push({\\n            col_type: 'line'\\n        });\\n        //var jj = getMyVar(\\\"jjs\\\", \\\"收起\\\");\\n        //var jjurl = 'hiker://empty@lazyRule=.js:getMyVar(\\\"jjs\\\") == \\\"收起\\\"?putMyVar(\\\"jjs\\\",\\\"展开\\\"):putMyVar(\\\"jjs\\\",\\\"收起\\\");\\\"hiker://empty\\\"';\\n        d.push({\\n            title: '简介 <small><small><span style=\\\"color:#19B89D\\\">展开></span></small></small>',\\n            img: \\\"https://lanmeiguojiang.com/tubiao/more/197.png\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule((jjid, decid, des_desc) => {\\n                if (getMyVar(\\\"jjs\\\", \\\"收起\\\") == \\\"收起\\\") {\\n                    putMyVar(\\\"jjs\\\", \\\"展开\\\");\\n\\n                    updateItem({\\n                        extra: {\\n                            id: jjid\\n                        },\\n                        title: '简介 <small><small><span style=\\\"color:#19B89D\\\">收起></span></small></small>'\\n                    })\\n\\n                    updateItem({\\n                        extra: {\\n                            textSize: 14,\\n                            lineSpacing: 3,\\n                            id: decid\\n                        },\\n                        title: '<span style=\\\"color:#808080\\\">' + des_desc + '...</span>'\\n                    })\\n                    return \\\"hiker://empty\\\"\\n                } else {\\n                    putMyVar(\\\"jjs\\\", \\\"收起\\\");\\n\\n                    updateItem({\\n                        extra: {\\n                            id: jjid\\n                        },\\n                        title: '简介 <small><small><span style=\\\"color:#19B89D\\\">展开></span></small></small>'\\n                    })\\n\\n                    updateItem({\\n                        extra: {\\n                            textSize: 14,\\n                            lineSpacing: 3,\\n                            id: decid\\n                        },\\n                        title: '<span style=\\\"color:#808080\\\">' + des_desc.substr(0, 30) + '...</span>'\\n                    })\\n                    return \\\"hiker://empty\\\"\\n                }\\n\\n            }, MY_RULE + \\\"_jjid\\\", MY_RULE + \\\"_decid\\\", des_desc),\\n            col_type: \\\"avatar\\\",\\n            extra: {\\n                id: MY_RULE + \\\"_jjid\\\"\\n            }\\n        });\\n\\n        d.push({\\n            title: '<span style=\\\"color:#808080\\\">' + des_desc.substr(0, 30) + '...</span>',\\n            col_type: \\\"rich_text\\\",\\n            extra: {\\n                textSize: 14,\\n                lineSpacing: 3,\\n                id: MY_RULE + \\\"_decid\\\"\\n            }\\n        });\\n        d.push({\\n            col_type: 'line'\\n        })\\n        d.push({\\n            col_type: 'line'\\n        })\\n    } catch (e) {}\\n}\\n\\nfunction down(Title, chapterPic, list, chapterTitle, chapterLine, downloadlazy) {\\n    try {\\n        let doList = list.map((item) => ({\\n            title: pdfh(item, chapterTitle),\\n            url: pd(item, chapterLine),\\n        }));\\n        d.push({\\n            title: '““””<b><span style=\\\"color: #1aad19\\\">下载漫画🔹</span></b>',\\n            url: \\\"hiker://page/download.view#noRecordHistory##noRefresh#?rule=本地资源管理\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                chapterList: doList,\\n                info: {\\n                    bookName: pdfh(html, Title),\\n                    ruleName: MY_RULE.title,\\n                    bookTopPic: pd(html, chapterPic),\\n                    parseCode: downloadlazy\\n                },\\n                defaultView: \\\"1\\\"\\n            }\\n        });\\n        d.push({\\n            col_type: 'line'\\n        });\\n    } catch (e) {}\\n}\\n\\nfunction chapter(chapterList, chapterTitle, chapterUrl, defaultOrder, hasLine) {\\n    var list = chapterList;\\n    var original = [{\\n        url: MY_URL,\\n        order: defaultOrder\\n    }];\\n    !fileExist('hiker://files/rules/comic/comicLogFile.js') ? (writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(original))) : 0;\\n    var log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));\\n    for (var i in log) {\\n        if (log[i].url == MY_URL) {\\n            var now = i;\\n            var order = log[i].order;\\n            break;\\n        } else {\\n            var now = '';\\n            var order = defaultOrder;\\n        }\\n    }\\n    let orderItem = {\\n        title: \\\"““””\\\" + '<font color=\\\"#f37335\\\">' + '章节排序⇅' + '</font>',\\n        url: MY_URL + `@lazyRule=.js:var log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));var now='` + now + `';if(now!=''){var now=parseInt(now);var order=log[now].order}else{var now=parseInt(log.length);var order=` + defaultOrder + `;log.push({url:input,order:order});}if(log[now].order){log[now].order=0;}else{log[now].order=1;};writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(log));refreshPage();'hiker://empty'`,\\n        col_type: 'text_center_1'\\n    }\\n    if (hasLine) {\\n        orderItem.title = \\\"““””\\\" + '<font color=\\\"#f37335\\\">' + '集数排序⇅' + '</font>';\\n        orderItem.col_type = \\\"text_center_1\\\"\\n    }\\n    d.push(orderItem);\\n    d.push({\\n        col_type: 'line'\\n    });\\n\\n    var list = order ? list : list.reverse();\\n    for (let i in list) {\\n        try {\\n            d.push({\\n                title: '““””<small>' + pdfh(list[i], chapterTitle) + '</small>',\\n                url: pd(list[i], chapterUrl) + lazy,\\n                col_type: 'text_2',\\n            });\\n        } catch (e) {}\\n    }\\n}\\n\\nfunction line(lineList, lineTitleRule, varKey) {\\n    let list = lineList\\n    varKey = varKey == null ? (MY_RULE.url + '#line-index') : varKey;\\n    addListener('onClose', $.toString((keyList) => {\\n        for (let i in keyList) {\\n            clearVar(keyList[i])\\n        }\\n\\n    }, [varKey, MY_RULE.title + '#line-title']))\\n    let line0Title = ''\\n    try {\\n        line0Title = pdfh(list[0], lineTitleRule);\\n    } catch (e) {}\\n    log(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')))\\n    for (let i in list) {\\n        try {\\n            let lineTitle = pdfh(list[i], lineTitleRule);\\n            d.push({\\n                title: getMyVar((MY_RULE.title + '#line-title'), line0Title) === lineTitle ? \\\"切换:‘‘\\\" + lineTitle + \\\"\\\" : lineTitle + \\\"‘‘:切换\\\",\\n                url: $().lazyRule((varKey, lineIndex, lineTitle) => {\\n                    putMyVar(varKey, lineIndex.toString())\\n                    // log(MY_RULE.url)\\n                    putMyVar((MY_RULE.title + '#line-title'), lineTitle)\\n                    log(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')))\\n                    refreshPage()\\n                    return \\\"toast://已切换至\\\" + lineTitle\\n                }, varKey, i, lineTitle),\\n                col_type: 'flex_button'\\n            });\\n        } catch (e) {}\\n    }\\n    d.push({\\n                col_type: 'line'\\n            });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"动态[二]*\",\"path\":\"dtfl\",\"rule\":\"const empty = \\\"hiker://empty\\\"\\n\\nif (typeof(拼接分类) != 'undefined' && 拼接分类 != '') {\\n    var categories = pdfa(html, 大类定位).concat(pdfa(html, 拼接分类))\\n} else {\\n    var categories = pdfa(html, 大类定位)\\n}\\n\\nlet init_cate = []\\n\\nfor (let i = 0; i < 20; i++) {\\n    init_cate.push(\\\"0\\\")\\n}\\n\\nconst fold = getMyVar(MY_RULE.group, \\\"0\\\")\\nconst cate_temp_json = getMyVar(MY_RULE.title, JSON.stringify(init_cate))\\nconst cate_temp = JSON.parse(cate_temp_json)\\n\\nif (parseInt(page) === 1) {\\n    d.push({\\n        title: fold === '1' ? '““””<b>' + '∨'.fontcolor(\\\"#FF0000\\\") + '</b>' : '““””<b>' + '∧'.fontcolor(\\\"#1aad19\\\") + '</b>',\\n        url: $().lazyRule((fold) => {\\n            putMyVar(MY_RULE.group, fold === '1' ? '0' : '1');\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, fold),\\n        col_type: 'scroll_button',\\n    })\\n    categories.forEach((category, index) => {\\n        let sub_categories = pdfa(category, 小类定位);\\n        if (index === 0) {\\n            sub_categories.forEach((item, key) => {\\n                let title = pdfh(item, 分类标题)\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\")\\n                }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\n                        let new_cate = []\\n                        params.cate_temp.forEach((cate, index) => {\\n                            new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\")\\n                        })\\n                        putMyVar(MY_RULE.title, JSON.stringify(new_cate))\\n                        putMyVar(MY_RULE.url, input)\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        key: key,\\n                        page: page,\\n                    }),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        } else if (fold === '1') {\\n            sub_categories.forEach((item, key) => {\\n                let title = pdfh(item, 分类标题)\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\")\\n                }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\n                        params.cate_temp[params.index] = params.key.toString()\\n\\n                        putMyVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\n                        putMyVar(MY_RULE.url, input)\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        index: index,\\n                        key: key,\\n                        page: page,\\n                    }),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        }\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"动态[一]*\",\"path\":\"categories-header\",\"rule\":\"/**\\n * 本地网页插件链接 hiker://files/rules/js/categories-header.js\\n * 子页面链接 hiker://page/categories-header\\n * 道长仓库链接 http://hiker.nokia.press/hikerule/rulelist.json?id=2705\\n * 码云 Gitee 链接 https://gitee.com/reborn0/HikerRules/raw/master/plugins/categories-header.js\\n */\\n/**\\n * Object.assign 用法参考链接\\n *\\n * 1.https://www.daimajiaoliu.com/daima/47139a9e7100407\\n * 2.https://segmentfault.com/a/1190000011778875\\n * 3.https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\\n */\\n// 利用 Symbol 实现私有变量和私有方法，外界不可访问（参考链接2）\\nconst symbolMap = {\\n    // checkParams: Symbol('checkParams'),\\n    mLayout: Symbol('mLayout'),\\n    true_url: Symbol('true_url'),\\n    mPage: Symbol('mPage'),\\n    src: Symbol('src'),\\n    ruleObjList: Symbol('ruleObjList'),\\n    mFold: Symbol('mFold'),\\n    mFoldInnerEnable: Symbol('mFoldInnerEnable'),\\n    mFoldIndex: Symbol('mFoldIndex'),\\n    mFoldLayout: Symbol('mFoldLayout'),\\n    mColor: Symbol('mColor'),\\n    mTag: Symbol('mTag'),\\n}\\n\\nfunction CategoriesHeader(color) {\\n    // 'use strict';\\n    // ...\\n    // this[symbolMap.listRule] = []\\n    // this[symbolMap.subListRule] = []\\n    this[symbolMap.mColor] = color || \\\"#FA7298\\\";\\n    this[symbolMap.ruleObjList] = []\\n    this.VARMAP = {\\n        CATEGORY: \\\"header.category\\\",\\n        URL: \\\"header.url\\\",\\n        FOLD: \\\"header.fold\\\",\\n    }\\n    this[symbolMap.mFoldLayout] = {\\n        injectIndex: 1\\n    }\\n    this[symbolMap.mFoldIndex] = 1\\n}\\n\\nObject.assign(CategoriesHeader.prototype, {\\n    // Override 构造方法，相当于 function.prototype.constructor = (...) => {...}，new function() 的时候会自动执行\\n    constructor: CategoriesHeader,\\n    // 定义私有方法\\n    VERSION: 202111301900,\\n    checkParams() {\\n        if (!this[symbolMap.mLayout]) {\\n            throw new Error(\\\"请调用 layout(d) 传入当前界面\\\")\\n        }\\n        if (!this[symbolMap.true_url]) {\\n            throw new Error(\\\"请调用 trueUrl(url) 传入当前分类的链接\\\")\\n        }\\n        if (!this[symbolMap.mPage]) {\\n            throw new Error(\\\"请调用 page(mPage) 传入当前页数\\\")\\n        }\\n        if (this[symbolMap.ruleObjList].length < 1) {\\n            throw new Error(\\\"请调用相关方法传入定位规则\\\")\\n        }\\n        if (!this[symbolMap.mFold]) {\\n            this[symbolMap.mFold] = '0'\\n        }\\n    },\\n    layout(mLayout) {\\n        this[symbolMap.mLayout] = mLayout\\n        return this\\n    },\\n    trueUrl(url) {\\n        this[symbolMap.true_url] = url\\n        return this\\n    },\\n    page(mPage) {\\n        if (typeof (mPage) === 'string') {\\n            mPage = parseInt(mPage)\\n        }\\n        this[symbolMap.mPage] = mPage\\n        return this\\n    },\\n    html(mSrc) {\\n        this[symbolMap.src] = mSrc\\n        return this\\n    },\\n    list(rule) {\\n        if (this[symbolMap.ruleObjList].length > 0) {\\n            throw new Error(\\\"list(rule) add(ruleObj) 只能二选一！\\\")\\n        }\\n        this[symbolMap.ruleObjList] = [{}]\\n        this[symbolMap.ruleObjList][0].listRule = rule\\n        this[symbolMap.ruleObjList][0]['一级分类'] = rule\\n        return this\\n    },\\n    subList(rule) {\\n        if (this[symbolMap.ruleObjList].length > 1) {\\n            throw new Error(\\\"subList(rule) add(ruleObj) 只能二选一！\\\")\\n        }\\n        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {\\n            throw new Error(\\\"请先调用 list(rule) 或 一级分类(rule) 定位一级分类\\\")\\n        }\\n        this[symbolMap.ruleObjList][0].subListRule = rule\\n        this[symbolMap.ruleObjList][0]['子分类'] = rule\\n        return this\\n    },\\n    title(rule) {\\n        if (this[symbolMap.ruleObjList].length > 1) {\\n            throw new Error(\\\"title(rule) add(ruleObj) 只能二选一！\\\")\\n        }\\n        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {\\n            throw new Error(\\\"请先调用 list(rule) 或 一级分类(rule) 定位一级分类\\\")\\n        }\\n        this[symbolMap.ruleObjList][0].titleRule = rule\\n        this[symbolMap.ruleObjList][0]['分类标题'] = this[symbolMap.ruleObjList][0].titleRule\\n        return this\\n    },\\n    url(rule) {\\n        if (this[symbolMap.ruleObjList].length > 1) {\\n            throw new Error(\\\"url(rule) add(ruleObj) 只能二选一！\\\")\\n        }\\n        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {\\n            throw new Error(\\\"请先调用 list(rule) 或 一级分类(rule) 定位一级分类\\\")\\n        }\\n        this[symbolMap.ruleObjList][0].urlRule = rule\\n        this[symbolMap.ruleObjList][0]['分类链接'] = this[symbolMap.ruleObjList][0].urlRule\\n        return this\\n    },\\n    /**\\n     * 是否开启折叠功能\\n     *\\n     * @param enabled true 表示开启，false 表示禁用\\n     * @returns {CategoriesHeader}\\n     */\\n    foldInner(enabled) {\\n        if (!(typeof (enabled) === 'boolean')) {\\n            throw new Error(\\\"请传入 true 或 false 表示开启或关闭折叠功能！\\\")\\n        }\\n        this[symbolMap.mFoldInnerEnable] = enabled\\n        return this\\n    },\\n    /**\\n     * 从第 index 行开始折叠\\n     *\\n     * @param index 开始折叠的行数\\n     * @returns {CategoriesHeader}\\n     */\\n    foldIndex(index) {\\n        if (!(typeof (index) === 'number')) {\\n            throw new Error(\\\"开始折叠行请传入数字！\\\")\\n        }\\n        if (index < 1) {\\n            throw new Error(\\\"开始折叠行请传入大于 0 的整数！\\\")\\n        }\\n        this[symbolMap.mFoldIndex] = index || 1;\\n        return this\\n    },\\n    /**\\n     * 折叠按钮的界面\\n     *\\n     * @param layout 与 d.push 结构一致，\\n     *        例：{ title:\\\"标题1\\\", url:\\\"xxx\\\", col_type:\\\"scroll_button\\\" };\\n     *        参数采用可选覆盖模式，不写的参数则使用默认;\\n     *        比如传入 { col_type:\\\"text_1\\\" }，那最终结果就是 { title:\\\"标题1\\\", url:\\\"xxx\\\", col_type:\\\"text_1\\\" }\\n     * @returns {CategoriesHeader}\\n     */\\n    foldLayout(layout) {\\n        if (typeof layout === 'object') {\\n            let keys = Object.keys(layout)\\n            let injectIndex = layout.injectIndex || layout['折叠按钮插入行']\\n            if (layout.title || layout.url || layout.col_type || injectIndex) {\\n                for (let i = 0; i < keys.length; i++) {\\n                    const key = keys[i]\\n                    this[symbolMap.mFoldLayout][key] = layout[key];\\n                }\\n            } else {\\n                throw new Error(\\\"请传入正确的折叠界面元素！\\\")\\n            }\\n            // injectIndex 折叠按钮插入第 injectIndex 行\\n            if (injectIndex) {\\n                if (!(typeof (injectIndex) === 'number')) {\\n                    throw new Error(\\\"折叠按钮插入行请传入数字！\\\")\\n                }\\n                if (injectIndex < 1) {\\n                    throw new Error(\\\"折叠按钮插入行请传入大于 0 的整数！\\\")\\n                }\\n                if (injectIndex > this[symbolMap.mFoldIndex]) {\\n                    throw new Error(\\\"折叠按钮插入行不得大于显示折叠行数！请调用 .foldIndex(index) 或 .第几行开始折叠(index) 传入正确的显示折叠行数\\\")\\n                }\\n                this[symbolMap.mFoldLayout].injectIndex = injectIndex || 1;\\n            }\\n        } else {\\n            throw new Error(\\\"请传入正确的折叠界面元素！\\\")\\n        }\\n        return this;\\n    },\\n    // 当前是否折叠\\n    fold(isFold) {\\n        if (typeof (isFold) === 'string') {\\n            isFold = isFold === '1'\\n        }\\n        if (isFold) {\\n            this[symbolMap.mFold] = '1';\\n        } else {\\n            this[symbolMap.mFold] = '0';\\n        }\\n        return this\\n    },\\n    color(mColor) {\\n        this[symbolMap.mColor] = mColor\\n        return this\\n    },\\n    tag(mTag) {\\n        this[symbolMap.mTag] = mTag\\n        return this\\n    },\\n    add(ruleObj) {\\n        // log($.stringify(ruleObj))\\n        if (ruleObj.constructor === Array) {\\n            this[symbolMap.ruleObjList] = this[symbolMap.ruleObjList].concat(ruleObj)\\n        } else {\\n            this[symbolMap.ruleObjList].push(ruleObj)\\n        }\\n        return this;\\n    },\\n    evalJSRule(item, jsRule) {\\n        let rule = jsRule.replace(\\\"@js:\\\", \\\"\\\")\\n        rule = rule.trim()\\n        // log($.stringify(rule))\\n        let input = item\\n        if (rule.startsWith(\\\"(\\\")) {\\n            eval('result = ' + rule)\\n        } else {\\n            /**\\n             * 还原成 $.toString(...) 的最终结果，达到最终处理方式跟上面的 if 一致的目的\\n             */\\n            eval('result = ' + '(() => {' + rule + '})()')\\n        }\\n        return (result || '')\\n    },\\n    getTitle(src, category) {\\n        let title = ''\\n        let titleRule = category.titleRule || 'a&&Text'\\n        if (titleRule.startsWith(\\\"@js:\\\")) {\\n            title = this.evalJSRule(src, titleRule)\\n        } else {\\n            title = parseDomForHtml(src, titleRule)\\n        }\\n        return title || \\\"\\\";\\n    },\\n    getUrl(src, category) {\\n        let url = ''\\n        let urlRule = category.urlRule || 'a&&href'\\n        if (typeof urlRule === 'object') {\\n            let mUrlRule = urlRule.rule || urlRule['解析规则'] || 'a&&href';\\n            if (mUrlRule.startsWith(\\\"@js:\\\")) {\\n                url = this.evalJSRule(src, mUrlRule);\\n            } else {\\n                let parse = parseDom;\\n                if (urlRule.parseOption) {\\n                    switch (urlRule.parseOption) {\\n                        case \\\"parseDom\\\":\\n                        case \\\"pd\\\":\\n                            parse = parseDom;\\n                            break;\\n                        case \\\"parseDomForHtml\\\":\\n                        case \\\"pdfh\\\":\\n                            parse = parseDomForHtml;\\n                            break;\\n                        default:\\n                            parse = parseDom;\\n                    }\\n                } else if (urlRule[\\\"解析方法\\\"]) {\\n                    switch (urlRule[\\\"解析方法\\\"]) {\\n                        case \\\"parseDom\\\":\\n                        case \\\"pd\\\":\\n                            parse = parseDom;\\n                            break;\\n                        case \\\"parseDomForHtml\\\":\\n                        case \\\"pdfh\\\":\\n                            parse = parseDomForHtml;\\n                            break;\\n                        default:\\n                            parse = parseDom;\\n                    }\\n                }\\n                url = parse(src, mUrlRule);\\n            }\\n            if (urlRule.dealUrl) {\\n                url = urlRule.dealUrl(url)\\n            } else if (urlRule['二次处理']) {\\n                url = urlRule['二次处理'](url)\\n            }\\n        } else {\\n            if (urlRule.startsWith(\\\"@js:\\\")) {\\n                url = this.evalJSRule(src, urlRule);\\n            } else {\\n                url = parseDom(src, urlRule);\\n            }\\n        }\\n        return url || \\\"\\\";\\n    },\\n    build() {\\n        // 检测是否传入需要的参数\\n        this.checkParams()\\n        // 每一个分类的唯一标识\\n        let mTag = this[symbolMap.mTag] || \\\"\\\"\\n        //翻页 需要根据实际替换\\n        const html = this[symbolMap.src] || request(this[symbolMap.true_url])\\n        const empty = \\\"hiker://empty\\\"\\n        //获取列表\\n        const categories = []\\n        this[symbolMap.ruleObjList].map(ruleObj => {\\n            let list = []\\n            let listRule = ruleObj.listRule || ruleObj[\\\"一级分类\\\"]\\n            if (listRule.startsWith(\\\"@js:\\\")) {\\n                // log($.stringify(listRule))\\n                list = this.evalJSRule(html, listRule)\\n            } else {\\n                list = parseDomForArray(html, listRule)\\n            }\\n            // log(list)\\n            list.map(category => {\\n                categories.push({\\n                    list: category,\\n                    subListRule: ruleObj.subListRule || ruleObj[\\\"子分类\\\"],\\n                    titleRule: ruleObj.titleRule || ruleObj[\\\"分类标题\\\"],\\n                    urlRule: ruleObj.urlRule || ruleObj[\\\"分类链接\\\"],\\n                });\\n            })\\n        })\\n\\n        // log($.stringify(categories))\\n\\n        let init_cate = []\\n        for (let i = 0; i < 20; i++) {\\n            init_cate.push(\\\"0\\\")\\n        }\\n\\n        const cate_temp_json = getMyVar(mTag + this.VARMAP.CATEGORY, JSON.stringify(init_cate))\\n        const cate_temp = JSON.parse(cate_temp_json)\\n\\n        if (this[symbolMap.mPage] === 1) {\\n\\n            categories.forEach((category, index) => {\\n\\n                // 折叠 UI\\n                if (this[symbolMap.mFoldInnerEnable] && this[symbolMap.mFoldLayout].injectIndex === (index+1)) {\\n                    let foldLayout = {\\n                        title: this[symbolMap.mFoldLayout].title || (this[symbolMap.mFold] === '1' ? '““””<b><span style=\\\"color: #FF0000\\\">∨</span></b>' : '““””<b><span style=\\\"color: #1aad19\\\">∧</span></b>'),\\n                        url: this[symbolMap.mFoldLayout].url || $(\\\"hiker://empty#noHistory#\\\").lazyRule((params) => {\\n                            putMyVar(params.mTag + params.VARMAP.FOLD, getMyVar(params.mTag + params.VARMAP.FOLD, params.isFold) === '1' ? '0' : '1')\\n                            refreshPage(false);\\n                            return \\\"hiker://empty\\\"\\n                        }, {\\n                            mTag: mTag,\\n                            isFold: this[symbolMap.mFold],\\n                            VARMAP: this.VARMAP\\n                        }),\\n                        col_type: this[symbolMap.mFoldLayout].col_type || \\\"scroll_button\\\",\\n                    }\\n                    this[symbolMap.mLayout].push(foldLayout)\\n                }\\n\\n                //具体列表下的分类\\n                let sub_categories = [];\\n                if (category.subListRule.startsWith(\\\"@js:\\\")) {\\n                    sub_categories = this.evalJSRule(category.list, category.subListRule)\\n                } else {\\n                    sub_categories = parseDomForArray(category.list, category.subListRule);\\n                }\\n                if (index < (this[symbolMap.mFoldIndex] || 1)) {\\n                    sub_categories.forEach((item, key) => {\\n                        let title = this.getTitle(item, category)\\n                        let url = this.getUrl(item, category)\\n\\n                        this[symbolMap.mLayout].push({\\n                            title: key.toString() === cate_temp[index] ? '““””<b><font color=' + this[symbolMap.mColor] + '>' + title + ' </font></b>' : title,\\n                            url: $(url).lazyRule((params) => {\\n                                let new_cate = []\\n                                if (params.index === 0) {\\n                                    params.cate_temp.forEach((cate, index) => {\\n                                        new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\")\\n                                    });\\n                                } else {\\n                                    params.cate_temp[params.index] = params.key.toString()\\n                                }\\n                                putMyVar(params.tag + params.VARMAP.CATEGORY, JSON.stringify(params.index === 0 ? new_cate : params.cate_temp))\\n                                putMyVar(params.tag + params.VARMAP.URL, input)\\n                                refreshPage(true)\\n                                return \\\"hiker://empty\\\"\\n                            }, {\\n                                cate_temp: cate_temp,\\n                                index: index,\\n                                VARMAP: this.VARMAP,\\n                                tag: mTag,\\n                                key: key,\\n                                page: this[symbolMap.mPage],\\n                            }),\\n                            col_type: 'scroll_button',\\n                        })\\n                    })\\n                    this[symbolMap.mLayout].push({\\n                        col_type: \\\"blank_block\\\"\\n                    });\\n                } else if (this[symbolMap.mFold] === '0') {\\n                    sub_categories.forEach((item, key) => {\\n                        let title = this.getTitle(item, category)\\n                        let url = this.getUrl(item, category)\\n\\n                        this[symbolMap.mLayout].push({\\n                            title: key.toString() === cate_temp[index] ? '““””<b><font color=' + this[symbolMap.mColor] + '>' + title + ' </font></b>' : title,\\n                            url: $(url).lazyRule((params) => {\\n                                params.cate_temp[params.index] = params.key.toString()\\n\\n                                putMyVar(params.tag + params.VARMAP.CATEGORY, JSON.stringify(params.cate_temp))\\n                                putMyVar(params.tag + params.VARMAP.URL, input)\\n                                refreshPage(true)\\n                                return \\\"hiker://empty\\\"\\n                            }, {\\n                                cate_temp: cate_temp,\\n                                index: index,\\n                                VARMAP: this.VARMAP,\\n                                tag: mTag,\\n                                key: key,\\n                                page: this[symbolMap.mPage],\\n                            }),\\n                            col_type: 'scroll_button',\\n                        })\\n                    })\\n                    this[symbolMap.mLayout].push({\\n                        col_type: \\\"blank_block\\\"\\n                    });\\n                }\\n            });\\n        }\\n    },\\n\\n    界面(layout) {\\n        return this.layout(layout)\\n    },\\n    分类链接(trueUrl) {\\n        return this.trueUrl(trueUrl);\\n    },\\n    页码(page) {\\n        return this.page(page);\\n    },\\n    源码(html) {\\n        return this.html(html);\\n    },\\n    定位一级分类(list) {\\n        return this.list(list);\\n    },\\n    定位子分类(subList) {\\n        return this.subList(subList);\\n    },\\n    定位分类标题(title) {\\n        return this.title(title);\\n    },\\n    定位分类链接(url) {\\n        return this.url(url);\\n    },\\n    开启内置折叠功能() {\\n        return this.foldInner(true);\\n    },\\n    关闭内置折叠功能() {\\n        return this.foldInner(false);\\n    },\\n    第几行开始折叠(index) {\\n        return this.foldIndex(index);\\n    },\\n    折叠按钮样式(layout) {\\n        return this.foldLayout(layout)\\n    },\\n    折叠(fold) {\\n        return this.fold(fold);\\n    },\\n    选中的分类颜色(color) {\\n        return this.color(color);\\n    },\\n    唯一标识(mTag) {\\n        return this.tag(mTag)\\n    },\\n    添加分类定位(ruleObj) {\\n        return this.add(ruleObj);\\n    },\\n    开始打造分类() {\\n        return this.build();\\n    },\\n\\n})\\n$.exports = new CategoriesHeader();\\n$.exports\"},{\"col_type\":\"movie_3\",\"name\":\"链接处理[二]*\",\"path\":\"url-processor\",\"rule\":\"/**\\n * 本地网页插件链接 hiker://files/rules/js/UrlProcessor.js\\n * 子页面链接 hiker://page/url-processor\\n * 道长仓库链接 http://hiker.nokia.press/hikerule/rulelist.json?id=2849\\n * 码云 Gitee 链接 https://gitee.com/reborn0/HikerRules/raw/master/plugins/UrlProcessor.js\\n */\\nfunction UrlProcessor() {\\n    this.params = {}\\n    this.regexMap = [\\n        {\\n            reg: '(vodtype|videot)\\\\\\\\/\\\\\\\\w+',\\n            exec: () => {\\n                return this.params.url\\n                    .replace(/-\\\\d+.html/, '-' + this.params.page + '.html')\\n                    .replace(/((vodtype|videot)\\\\/\\\\w+).html/, '$1-' + this.params.page + '.html')\\n            }\\n        },\\n        {\\n            reg: '\\\\\\\\/?[\\\\\\\\w\\\\\\\\d]+-.*?-.*?-.*?-.*?-.*?-.*?-.*?-\\\\\\\\d*---\\\\\\\\d*.html',\\n            exec: () => {\\n                return this.params.url\\n                    .replace(/\\\\d*(---.html)/, this.params.page + '$1')\\n                    .replace(/(---\\\\d+.html)/, this.params.page + '$1'); // 拼接页码\\n            }\\n        },\\n        {\\n            reg: '((\\\\\\\\/vod\\\\\\\\/show)?(\\\\\\\\/area\\\\\\\\/[\\\\\\\\w\\\\\\\\d%]+)?(\\\\\\\\/by\\\\\\\\/[\\\\\\\\w\\\\\\\\d%]+)?(\\\\\\\\/id\\\\\\\\/\\\\\\\\d+)?(\\\\\\\\/letter\\\\\\\\/[\\\\\\\\w\\\\\\\\d%]+)?)(\\\\\\\\/page\\\\\\\\/\\\\\\\\d+)?(\\\\\\\\/year\\\\\\\\/\\\\\\\\d+)?\\\\\\\\.html',\\n            exec: () => {\\n                let regExp = /((\\\\/vod\\\\/show)?(\\\\/area\\\\/[\\\\w\\\\d%]+)?(\\\\/by\\\\/[\\\\w\\\\d%]+)?(\\\\/id\\\\/\\\\d+)?(\\\\/letter\\\\/[\\\\w\\\\d%]+)?)(\\\\/page\\\\/\\\\d+)?(\\\\/year\\\\/\\\\d+)?\\\\.html/\\n                return this.params.url\\n                    .replace(regExp, '$1' + (\\\"/page/\\\" + this.params.page) + '$8' + \\\".html\\\")\\n            }\\n        }\\n    ]\\n}\\n\\nObject.assign(UrlProcessor.prototype, {\\n    constructor: UrlProcessor,\\n    checkParams() {\\n        if (!this.params.url) {\\n            throw new Error(\\\"请先调用 .baseUrl(url) 传入链接进行初始化!\\\")\\n        }\\n        if (!this.params.page) {\\n            throw new Error(\\\"请先调用 .page(page) 传入页码进行初始化!\\\")\\n        }\\n    },\\n    baseUrl(url){\\n        this.params.url = url\\n        return this\\n    },\\n    page(page){\\n        this.params.page = page\\n        return this\\n    },\\n    addExtra(regExp) {\\n        if (regExp.constructor === Array) {\\n            this.regexMap = this.regexMap.concat(regExp)\\n        } else {\\n            this.regexMap.push(regExp)\\n        }\\n        return this;\\n    },\\n    debug() {\\n        this.params.debug = true\\n        return this;\\n    },\\n    exec() {\\n        this.checkParams()\\n        let true_url = ''\\n        for (let i = 0; i < this.regexMap.length; i++) {\\n            let regObj = this.regexMap[i];\\n            let urlExp = regObj.reg;\\n            if (typeof urlExp === 'string') {\\n                urlExp = new RegExp(urlExp)\\n            }\\n            if (urlExp.test(this.params.url)) {\\n                if (this.params.debug) {\\n                    log(urlExp.toString())\\n                }\\n                true_url = regObj.exec();\\n                break;\\n            }\\n        }\\n        if (true_url) {\\n            return true_url;\\n        } else {\\n            return this.params.url\\n        }\\n    },\\n    获取处理结果() {\\n        return this.exec()\\n    },\\n    链接(url) {\\n        return this.baseUrl(url)\\n    },\\n    页码(page) {\\n        return this.page(page)\\n    },\\n    插入新处理规则(regExp) {\\n        return this.addExtra(regExp)\\n    },\\n    调试模式() {\\n        return this.debug();\\n    }\\n})\\n$.exports=new UrlProcessor()\\n$.exports\\n\"},{\"col_type\":\"movie_3\",\"name\":\"一级*\",\"path\":\"yjtool\",\"rule\":\"function convert1(str) {\\n    let c = str.split(\\\";\\\")\\n    return {\\n        列表: c[0],\\n        标题: c[1],\\n        图片: c[2],\\n        描述: c[3],\\n        链接: c[4]\\n    }\\n}\\n\\nfunction merge(source, target) {\\n    let keys = Object.keys(source)\\n    for (let i in keys) {\\n        target[keys[i]] = source[keys[i]]\\n    }\\n}\\n\\nfunction 一级(obj) {\\n    var d = [];\\n    if ($.type(obj) == \\\"string\\\") {\\n        obj = convert1(obj)\\n    }\\n    if (obj.规则) {\\n        let c = convert1(obj.规则)\\n        merge(c, obj)\\n    }\\n    let arr = pdfa(getResCode(), obj.列表);\\n       if (obj.列表处理 != null) {\\n            arr = obj.链接处理(arr)\\n        }\\n    for (let it of arr) {\\n        let url = pd(it, obj.链接)\\n        if (obj.链接处理 != null) {\\n            url = obj.链接处理(url)\\n        }\\n        let title = pdfh(it, obj.标题)\\n        if (obj.标题处理 != null) {\\n            title = obj.标题处理(title)\\n        }\\n        let pic = pd(it, obj.图片)\\n        if (obj.图片处理 != null) {\\n            pic = obj.图片处理(pic)\\n        }\\n        d.push({\\n            title: obj.标题 ? pdfh(it, obj.标题) : \\\"\\\",\\n            url: url+'#autoCache#',\\n            col_type: \\\"\\\",\\n            desc: obj.描述 ? pdfh(it, obj.描述) : \\\"\\\",\\n            pic_url: pic,\\n            extra: {\\n                ytitle: title,\\n                ypic: pic,\\n                yurl: url.replace('hiker://empty##','')\\n            }\\n        });\\n\\n    }\\n    setResult(d);\\n}\\nvar tool = {\\n    一级: 一级\\n}\\n$.exports = tool\"},{\"col_type\":\"movie_3\",\"name\":\"一级[二]*\",\"path\":\"yiji\",\"rule\":\"function 一级() {};\\r\\nObject.assign(一级.prototype, {\\r\\n\\tconstructor: 一级,\\r\\n\\ttest() {},\\r\\n\\t获取源码(url, header) {return fetch(true_url, {headers: header || {'User-Agent': PC_UA}}) },// 默认统一使用MOBILE_UA\\r\\n\\t搜索框架(page) {\\r\\n\\t\\tif (page == '1') {\\n/*\\r\\n\\t\\t\\td.push({\\r\\n\\t\\t\\t\\ttitle: \\\"搜索本规则\\\",\\r\\n\\t\\t\\t\\turl: \\\"'hiker://search?rule=\\\" + MY_RULE.title + \\\"&s='+input\\\",\\r\\n\\t\\t\\t\\tdesc: \\\" \\\",\\r\\n\\t\\t\\t\\tcol_type: \\\"input\\\"\\r\\n\\t\\t\\t});\\n*/\\r\\n\\t\\t}\\r\\n\\t},\\r\\n\\t获取链接(page, regex) {\\r\\n\\t\\tlet true_url = getMyVar('header.url', MY_URL);\\r\\n\\t\\t//let 链接处理工具 = requireCache(config.链接处理工具依赖)\\r\\n\\t\\t//let 链接处理工具 = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2849')\\r\\n\\t\\t//let 链接处理工具 = $.require('hiker://page/url-processor')\\r\\n\\t\\tlet 链接处理工具 = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2849')\\r\\n\\t\\ttrue_url = 链接处理工具\\r\\n\\t\\t\\t.链接(true_url)\\r\\n\\t\\t\\t.页码(page)\\r\\n\\t\\t\\t.插入新处理规则(regex || [])\\r\\n\\t\\t\\t.获取处理结果();\\r\\n\\t\\treturn true_url;\\r\\n\\t},\\r\\n\\t打造分类(ruleList) {\\r\\n\\t\\t//  let htmlCategories = requireCache(config.动态分类依赖)\\r\\n\\t\\t//let htmlCategories = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2705')\\r\\n\\t\\tif (!ruleList) {\\r\\n\\t\\t\\tlet 分类定位 = [{\\r\\n\\t\\t\\t\\t\\t一级分类: 一级定位A,\\r\\n\\t\\t\\t\\t\\t子分类: 统一定位B || 一级定位B,\\r\\n\\t\\t\\t\\t\\t分类链接: {二次处理(url) {try {return 一级处理C(url)} catch (e) {return url}}}\\r\\n\\t\\t\\t}]\\r\\n\\t\\t\\tif (二级定位A && (统一定位B || 二级定位B)) {\\r\\n\\t\\t\\t\\t分类定位.push({\\r\\n\\t\\t\\t\\t\\t\\t一级分类: 二级定位A,\\r\\n\\t\\t\\t\\t\\t\\t子分类: 统一定位B || 二级定位B,\\r\\n\\t\\t\\t\\t\\t\\t分类链接: {二次处理(url) {try {return 二级处理C(url)} catch (e) {return url}}}\\r\\n\\t\\t\\t\\t})\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\tif (三级定位A && (统一定位B || 三级定位B)) {\\r\\n\\t\\t\\t\\t分类定位.push({\\r\\n\\t\\t\\t\\t\\t\\t一级分类: 三级定位A,\\r\\n\\t\\t\\t\\t\\t\\t子分类: 统一定位B || 三级定位B,\\r\\n\\t\\t\\t\\t\\t\\t分类链接: {二次处理(url) {try {return 三级处理C(url)} catch (e) {return url}}}\\r\\n\\t\\t\\t\\t})\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\tif (四级定位A && (统一定位B || 四级定位B)) {\\r\\n\\t\\t\\t\\t分类定位.push({\\r\\n\\t\\t\\t\\t\\t\\t一级分类: 四级定位A,\\r\\n\\t\\t\\t\\t\\t\\t子分类: 统一定位B || 四级定位B,\\r\\n\\t\\t\\t\\t\\t\\t分类链接: {二次处理(url) {try {return 四级处理C(url)} catch (e) {return url}}}\\r\\n\\t\\t\\t\\t})\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\truleList = 分类定位;\\r\\n\\t\\t}\\r\\n\\t\\t// '0' 为默认不折叠，'1' 为默认折叠\\r\\n\\t\\tconst 当前折叠状态 = getMyVar('header.fold', '0')\\r\\n\\t\\t// 引入动态分类依赖\\r\\n\\t\\tlet htmlCategories = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2705')\\r\\n\\t\\tvar getRangeColors = function() {\\r\\n\\t\\t\\treturn '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\r\\n\\t\\t} // 随机选中的分类颜色\\r\\n\\t\\tvar colour;\\r\\n\\t\\tif (分类颜色 !== '') {\\r\\n\\t\\t\\tcolour = 分类颜色\\r\\n\\t\\t} else {\\r\\n\\t\\t\\tcolour = getRangeColors()\\r\\n\\t\\t}\\r\\n\\t\\thtmlCategories.界面(d)\\r\\n\\t\\t\\t//.分类链接(true_url)\\r\\n\\t\\t\\t.源码(html)\\r\\n\\t\\t\\t.页码(page)\\r\\n\\t\\t\\t.添加分类定位(ruleList)\\r\\n\\t\\t\\t.开启内置折叠功能() // 必须\\r\\n\\t\\t\\t.折叠(当前折叠状态) // 必须\\r\\n\\t\\t\\t.折叠按钮样式({\\r\\n\\t\\t\\t\\ttitle: 当前折叠状态 == \\\"1\\\" ? \\\"““””<big><b><font color='#5959AB'>\\\" + 动态缩小 + \\\"</font></b></big>\\\" : \\\"““””<big><b><font color='#F75D59'>\\\" + 动态扩展 + \\\"</font></b></big>\\\"\\r\\n\\t\\t\\t}) // 可选\\r\\n\\t\\t\\t// .第几行开始折叠(2) // 可选\\r\\n\\t\\t\\t// .折叠按钮样式({ 折叠按钮插入行: 2 })  // 可选，但必须先调用 .第几行开始折叠(index)，然后再传入 { 折叠按钮插入行: index }\\r\\n\\t\\t\\t.选中的分类颜色(colour)\\r\\n\\t\\t\\t.开始打造分类();\\r\\n\\t},\\r\\n\\r\\n\\t生成片单(d,html) {\\r\\n\\r\\n\\t\\tvar 列表\\r\\n\\t\\tvar 标题\\r\\n\\t\\tvar 描述\\r\\n\\t\\tvar 图片\\r\\n\\t\\tvar 链接\\r\\n\\r\\n\\t\\tif (框架类型 === 'myui-vodlist') {\\r\\n\\t\\t\\t列表 = '.myui-vodlist&&li';\\r\\n\\t\\t\\t标题 = 'h4&&Text';\\r\\n\\t\\t\\t描述 = '.pic-tag||.pic-text&&Text';\\r\\n\\t\\t\\t图片 = '.lazyload&&data-original';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t\\t//log('框架类型·myui-vodlist')\\r\\n\\t\\t} else if (框架类型 === '#data_list') {\\r\\n\\t\\t\\t列表 = '#data_list&&li';\\r\\n\\t\\t\\t标题 = 'a&&title';\\r\\n\\t\\t\\t描述 = 'em&&Text';\\r\\n\\t\\t\\t图片 = 'img&&data-srcl';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t\\t//log('框架类型·data_list')\\r\\n\\t\\t} else if (框架类型 === 'fed-list-title') {\\r\\n\\t\\t\\t列表 = '.fed-list-info&&li';\\r\\n\\t\\t\\t标题 = '.fed-list-title&&Text';\\r\\n\\t\\t\\t描述 = '.fed-text-center&&Text';\\r\\n\\t\\t\\t图片 = 'a&&data-original';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t\\t//log('框架类型·.fed-list-info')\\r\\n\\t\\t} else if (框架类型 === 'item') {\\r\\n\\t\\t\\t列表 = 'body&&.item';\\r\\n\\t\\t\\t标题 = 'img&&alt';\\r\\n\\t\\t\\t描述 = 'p&&Text';\\r\\n\\t\\t\\t图片 = 'img&&srcl';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t} else if (框架类型 === 'module-items') {\\r\\n\\t\\t\\t列表 = '.module-items&&.module-item';\\r\\n\\t\\t\\t标题 = 'a&&title';\\r\\n\\t\\t\\t描述 = '.module-item-text&&Text';\\r\\n\\t\\t\\t图片 = 'img||.lazy&&data-src';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t} else if (框架类型 === 'pack-ykpack') {\\r\\n\\t\\t\\t列表 = 'body&&.pack-ykpack';\\r\\n\\t\\t\\t标题 = 'a&&title';\\r\\n\\t\\t\\t描述 = 'span,-1&&Text';\\r\\n\\t\\t\\t图片 = '.eclazy&&data-original';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t} else if (框架类型 === 'stui-vodlist') {\\r\\n\\t\\t\\t列表 = '.stui-vodlist&&li';\\r\\n\\t\\t\\t标题 = 'a&&title';\\r\\n\\t\\t\\t描述 = '.pic-text&&Text';\\r\\n\\t\\t\\t图片 = '.lazyload||a&&data-original';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t} else if (框架类型 === 'vodlist') {\\r\\n\\t\\t\\t列表 = '.vodlist&&li';\\r\\n\\t\\t\\t标题 = 'a&&title';\\r\\n\\t\\t\\t描述 = 'a&&Text';\\r\\n\\t\\t\\t图片 = '.lazyload&&data-original';\\r\\n\\t\\t\\t链接 = 'a&&href';\\r\\n\\t\\t} else if (框架类型 === '测试') {\\r\\n\\t\\t\\t列表 = 'body&&a';\\r\\n\\t\\t\\t标题 = 'body&&a';\\r\\n\\t\\t\\t描述 = 'body&&a';\\r\\n\\t\\t\\t图片 = 'body&&a';\\r\\n\\t\\t\\t链接 = 'body&&a';\\r\\n\\t\\t} else if (框架类型 === '') {\\r\\n\\t\\t\\t列表 = 框架列表;\\r\\n\\t\\t\\t标题 = 框架标题;\\r\\n\\t\\t\\t描述 = 框架描述;\\r\\n\\t\\t\\t图片 = 框架图片;\\r\\n\\t\\t\\t链接 = 框架链接;\\r\\n\\t\\t}\\r\\n\\t\\tlet list = pdfa(html, 列表);\\r\\n\\t\\tfor (let k in list) {\\r\\n\\t\\t\\td.push({\\r\\n\\t\\t\\t\\ttitle: pdfh(list[k], 标题),\\r\\n\\t\\t\\t\\tdesc: pdfh(list[k], 描述),\\r\\n\\t\\t\\t\\timg: pd(list[k], 图片) + '@Referer=',\\r\\n\\t\\t\\t\\turl: pd(list[k], 链接)+\\\"#immersiveTheme##autoCache#\\\",\\r\\n\\t\\t\\t});\\r\\n\\t\\t}\\r\\n\\t\\td.push({\\r\\n\\t\\t\\tcol_type: 'big_big_blank_block',\\r\\n\\t\\t});\\r\\n\\t}\\r\\n})\\r\\n\\r\\n$.exports = new 一级();\\r\\n$.exports\"},{\"col_type\":\"movie_3\",\"name\":\"函数组件*\",\"path\":\"qs\",\"rule\":\"function 优化路线章节数据(多路线否, 源数据, 路线列表, 路线名, 选集总列表, 选集列表, 集名, 集url, 前缀, 标题, 图片) {\\n\\n    //当多路线否 选集总列表为空\\n    //最终返回 [{title: '路线名',list: [{title:'选集名',url:'选集url',...}],sjss:'下载资料'},....]\\n    //选集列表 第一项是css选择器，之后可以用$分割添加要删除章节名\\n\\n\\n    var 章节json = [];\\n    var 单路线章节 = '章节列表'\\n\\n    var 列表名 = [];\\n    if (!多路线否) {\\n\\n        列表名.push(单路线章节)\\n\\n    } else {\\n\\n        pdfa(源数据, 路线列表).forEach(function(data) {\\n            列表名.push(pdfh(data, 路线名))\\n        });\\n\\n    }\\n\\n    var 集数组 = [];\\n\\n\\nvar 排除章节 = [];\\nif(选集列表.includes('$')){\\n排除章节 = 选集列表.split('$')\\n选集列表 = 排除章节.shift()\\n}\\n\\n    if (!多路线否) {\\n        集数组.push(pdfa(源数据, 选集列表))\\n    } else {\\n        pdfa(源数据, 选集总列表).forEach(function(data) {\\n            集数组.push(pdfa(data, 选集列表))\\n        });\\n    }\\n\\n\\n    for (let i in 集数组) {\\n\\n        var doList = [];\\n\\n排除章节.forEach(function(data) {\\n    var 标识id = 集数组[i].findIndex(返回 => 返回.indexOf(data) != -1);\\n    if (标识id != -1) {\\n      集数组[i].splice(标识id, 1)\\n    };\\n  });\\n\\n        for (let it of 集数组[i]) {\\n            var doListurl = pdfh(it, 集url)\\n            doListurl = doListurl.includes(\\\"http\\\") ? doListurl : 前缀 + doListurl\\n            doList.push({\\n                title: '““””<small>' + pdfh(it, 集名) + '</small>',\\n                url: doListurl\\n            })\\n        }\\n\\n        var bookName = !多路线否 ? 标题 : 标题 + '-' + 列表名[i]\\n\\n        章节json.push({\\n            title: 列表名[i],\\n            list: doList,\\n            sjss: {\\n                chapterList: doList,\\n                info: {\\n                    bookName: bookName, //漫画名称,\\n                    ruleName: MY_RULE.title,\\n                    bookTopPic: 图片,\\n                    parseCode: downloadlazy,\\n                },\\n                defaultView: \\\"1\\\"\\n            }\\n        })\\n    }\\n    return 章节json\\n}\\n\\n\\nfunction 添加头部列表(d, 标题, 图片, 描述, 作者, 时间, 分类,页URL) {\\n\\n    标题 = !标题 ? '' : 标题 + '\\\\n'\\n    图片 = !图片 ? '' : 图片\\n    描述 = !描述 ? '' : 描述.replace(\\\"更新至：\\\", '')\\n\\n    作者 = !作者 ? '' : '\\\\n' + 作者\\n    时间 = !时间 ? '' : '\\\\n' + 时间\\n    分类 = !分类 ? '' : '\\\\n' + 分类\\n\\n\\n    var 头部title = ['‘‘’’<b>','</b> <small><font color=#FA7298>','</font>','</small>']\\n    var 头部desc = ['‘‘’’<font color=#f8ecc9>','</font>']\\n\\n\\n\\n    头部title = 头部title[0]+标题+头部title[1]+描述+头部title[2]+作者+头部title[3]\\n\\n    头部desc = 头部desc[0]+时间+分类+头部desc[1]\\n\\n    d.push({\\n        title: 头部title,\\n        desc: 头部desc,\\n        pic_url: 图片,\\n        url: 'hiker://search?s='+getParam('Name')+'&rule=阅漫君',\\n        col_type: 'movie_1_vertical_pic_blur'\\n    });\\n\\n}\\n\\n\\nfunction 添加简介(d, 数据源, 页URL, 图片) {\\n    //获取数据\\n    var 简介内容 = 数据源\\n    简介内容 = 简介内容.replace(\\\"简介：\\\", \\\"\\\").replace(\\\"介绍:\\\", \\\"\\\").replace(\\\"漫画\\\", \\\"\\\").replace(\\\"……\\\", \\\"\\\").replace(\\\"简介\\\", \\\"\\\")\\n\\n    var 简介内容收;\\n    if (简介内容.length > 45) {\\n        简介内容收 = 简介内容.substr(0, 45) + '...'\\n    } else {\\n        简介内容收 = 简介内容 + '...'\\n    }\\n\\n    //图标获取\\n    if (!图片) {\\n        图片 = 'https://lanmeiguojiang.com/tubiao/q/107.png'\\n    }\\n\\n    //页URL 获取\\n    if (!页URL) {\\n        页URL = MY_RULE.title\\n    }\\n\\n    //标题与简介样式\\n    var mztext = \\\"&nbsp;&nbsp;&nbsp;&nbsp;<small>简介</small><br>\\\"\\n    var bttitle = '<font color=\\\"#098AC1\\\">漫画简介  </font><small><small><font color=\\\"#f47983\\\">简介收></font></small></small>'\\n\\n    //展开与收缩操作\\n    var jj = getMyVar(页URL + \\\"简介收\\\", \\\"已收起\\\");\\n    var jjurl = $(\\\"#noLoading#\\\").lazyRule((简介内容, 简介内容收, 收, 收内容, 当前URL) => {\\n        var jsbl = 当前URL + \\\"简介收\\\";\\n        var jj = getMyVar(当前URL + \\\"简介收\\\", \\\"已收起\\\");\\n        jj = jj == \\\"已收起\\\" ? \\\"展开\\\" : \\\"已收起\\\";\\n        putMyVar(jsbl, jj)\\n        updateItem({\\n            extra: {\\n                id: 当前URL + \\\"_bt\\\"\\n            },\\n            title: 收.replace(\\\"简介收\\\", jj)\\n        })\\n\\n        updateItem({\\n            extra: {\\n                id: 当前URL + \\\"_mz\\\"\\n            },\\n            title: jj == \\\"已收起\\\" ? 收内容.replace(\\\"简介\\\", 简介内容收) : 收内容.replace(\\\"简介\\\", 简介内容)\\n        })\\n        return \\\"hiker://empty\\\"\\n    }, 简介内容, 简介内容收, bttitle, mztext, 页URL)\\n\\n\\n    //标题\\n    d.push({\\n        title: bttitle.replace(\\\"简介收\\\", jj),\\n        url: jjurl,\\n        col_type: \\\"avatar\\\",\\n        pic_url: 图片,\\n        extra: {\\n            id: 页URL + \\\"_bt\\\"\\n        }\\n    });\\n\\n    //简介\\n    d.push({\\n        title: jj == \\\"已收起\\\" ? mztext.replace(\\\"简介\\\", 简介内容收) : mztext.replace(\\\"简介\\\", 简介内容),\\n        col_type: \\\"rich_text\\\",\\n        extra: {\\n            id: 页URL + \\\"_mz\\\"\\n        }\\n    });\\n\\n}\\n\\nfunction 添加列表章节(d, 标题数据, 列表数据, 解析代码, 页URL, 图片) {\\n\\n\\n    //d与外界d，为同内存地址，不用返回\\n    //标题数据  即标题名字\\n    //列表数据必须是JSON  格式是[{title:'',url:'',},.....]  且url必须有前缀\\n\\n    //图标获取\\n    if (!图片) {\\n        图片 = 'https://lanmeiguojiang.com/tubiao/q/18.png'\\n    }\\n\\n    //页URL 获取\\n    if (!页URL) {\\n        页URL = MY_RULE.title\\n    }\\n\\n    //标题名\\n    var 标题名 = '<b>路线</b>  <small><small><font color=#f9906f>排序 ></font></small></small>'\\n\\n\\n    var 排序 = getMyVar(页URL + \\\"章节排序\\\", \\\"正序\\\");\\n    var 提示 = 排序 == '倒序' ? '正序' : '倒序';\\n\\n    var 排序url = $(\\\"#noLoading#\\\").lazyRule((标题名, 标题数据, 列表数据, 解析代码, 页URL) => {\\n        var 排序 = getMyVar(页URL + \\\"章节排序\\\", \\\"正序\\\");\\n        var 提示 = 排序 == '倒序' ? '正序' : '倒序';\\n        updateItem({\\n            extra: {\\n                id: 页URL + \\\"_排序\\\"\\n            },\\n            title: 标题名.replace('路线', 标题数据).replace('排序', 提示)\\n        })\\n\\n\\n        if (提示 == '倒序') {\\n            列表数据.reverse()\\n        }\\n        列表数据.forEach(function(data, ssid) {\\n            updateItem({\\n                title: data.title,\\n                url: data.url + 解析代码,\\n                extra: {\\n                    id: 页URL + \\\"_选集\\\" + ssid\\n                }\\n            });\\n        });\\n\\n\\n        putMyVar(页URL + \\\"章节排序\\\", 提示)\\n        return \\\"hiker://empty\\\"\\n    }, 标题名, 标题数据, 列表数据, 解析代码, 页URL)\\n\\n    d.push({\\n        title: 标题名.replace('路线', 标题数据).replace('排序', 排序),\\n        pic_url: 图片,\\n        url: 排序url,\\n        col_type: \\\"avatar\\\",\\n        extra: {\\n            id: 页URL + \\\"_排序\\\"\\n        }\\n    });\\n\\n    if (排序 == '倒序') {\\n        列表数据.reverse()\\n    }\\n\\n    列表数据.forEach(function(data, id) {\\n        d.push({\\n            title: data.title,\\n            url: data.url + 解析代码,\\n            col_type: \\\"text_2\\\",\\n            extra: {\\n                id: 页URL + \\\"_选集\\\" + id\\n            }\\n        });\\n    });\\n\\n}\\n\\n/*\\nfunction 添加防止网页(项url, UA) {\\n\\n    //上级跳转到当前页的链接必须是hiker://empty；不然一刷新还是会重复加载\\n    //UA ''或false或'手机' 默认是手机端 ; 电脑 'PC'\\n\\n    var 刷新重复 = MY_RULE.title + \\\"网页源码\\\"\\n    var pc链接 = 项url.replace(\\\"m.\\\", \\\"www.\\\")\\n    var 手机链接 = 项url.replace(\\\"www.\\\", \\\"m.\\\")\\n\\n    var code;\\n    if (getMyVar(刷新重复, \\\"false\\\") == \\\"false\\\") {\\n\\n        code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\n        putMyVar(刷新重复, getParam('url') + \\\"￥&￥\\\" + code)\\n\\n    } else {\\n\\n        var pm = getMyVar(刷新重复).split(\\\"￥&￥\\\")\\n        if (pm[0] == getParam('url')) {\\n            code = pm[1]\\n        } else {\\n            code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\n            putMyVar(刷新重复, getParam('url') + \\\"￥&￥\\\" + code)\\n        }\\n    }\\n    return code\\n}\\n*/\\n\\nfunction 添加选择路线(d, 路线数据, 页URL, 多路线否) {\\n\\n    //路线数据 格式[{title:'路线名'},....]\\n    //多路线否  false 则不启用选择路线；true 则启用\\n\\n    var 选择列表 = getItem(页URL + \\\"选择列表\\\", \\\"0\\\")\\n\\n    if (多路线否) {\\n\\n        var 路线选中 = '‘‘’’<font color=#098AC1>选中</font>'\\n\\n\\n        d.push({\\n            title: '‘‘’’📖<font color=\\\"#FA7298\\\"> 图源列表</font> ：',\\n            url: \\\"toast://点我干啥呢\\\",\\n            col_type: 'flex_button'\\n        });\\n\\n\\n        路线数据.forEach(function(data, id) {\\n\\n            var jjurl = $(\\\"#noLoading#\\\").lazyRule((页URL,id) => {\\n                setItem(页URL + '选择列表',id+'');\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\";\\n            },页URL,id);\\n\\n            var 标题名 = id == 选择列表 ? 路线选中.replace('选中', data.title) : data.title;\\n            d.push({\\n                title: 标题名,\\n                url: jjurl,\\n                col_type: 'flex_button',\\n                extra: {\\n                    id: 页URL + \\\"_路线\\\" + id\\n                }\\n            });\\n        });\\n\\n    }\\n    return 选择列表\\n}\\n\\n\\nfunction 添加选择下载(d, 路线数据, 多路线否) {\\n    d.push({\\n    title: '‘‘’’🗳<font color=\\\"#f47983\\\"> 书架</font> ',\\n    url: \\\"hiker://page/Bookrack.view?rule=本地资源管理&ruleName=\\\"+MY_RULE.title,\\n    col_type: 'scroll_button'\\n});\\n\\n    //路线数据 格式[{title:'路线名',sjss:'下载资料信息'},....]\\n    //多路线否  false 则只有①个下载 标题为 点击下载；true 则多个下载\\n\\nif(多路线否){\\n\\nd.push({\\n        title: '‘‘’’📥<font color=\\\"#f47983\\\"> 下载</font> ：',\\n        url: \\\"toast://点我干啥呢\\\",\\n        col_type: 'scroll_button'\\n    });\\n\\n}\\n\\n    路线数据.forEach(function(data, id) {\\n\\n        d.push({\\n            title: data.title.includes('章节列表') ? '点击下载' : data.title,\\n            url: 'hiker://page/download.view#noRecordHistory##noRefresh##noHistory#?rule=本地资源管理',\\n            col_type: 'scroll_button',\\n            extra: data.sjss\\n        });\\n    });\\n\\n    if (多路线否) {\\n        d.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n    }\\n\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"CSS选择器模版*\",\"path\":\"ejwb.js\",\"rule\":\"function 一级(列表, 标题, 图片, 集数, 链接, 访问头) {\\n    访问头 = !访问头 ? '' : 访问头\\n    var d = [];\\n    var code = getCode()\\n    pdfa(code, 列表).forEach(function(data) {\\n        d.push({\\n            title: pdfh(data, 标题),\\n            desc: pdfh(data, 集数),\\n            pic_url: pd(data, 图片)||图片 + \\\"@Referer=\\\" + 访问头,\\n            url: 'hiker://empty#immersiveTheme##autoCache#',\\n            col_type: \\\"movie_3\\\",\\nextra: {\\n            name: pdfh(data, 标题),\\n            url: pd(data, 链接),\\n            qz: MY_HOME\\n        }\\n        });\\n    });\\n    setResult(d);\\n}\\n\\n\\n\\nfunction 搜索(列表, 标题, 链接, 描述, 详情, 图片, 访问头) {\\n    var d = [];\\n    访问头 = !访问头 ? '' : 访问头\\n    pdfa(getResCode(), 列表).forEach(function(data) {\\n        d.push({\\n            title: pdfh(data, 标题),\\n            desc: pdfh(data, 描述),\\n            pic_url: pd(data, 图片) + \\\"@Referer=\\\" + 访问头,\\n            url: 'hiker://empty#immersiveTheme##autoCache#',\\n            content: pdfh(data, 详情),\\n\\nextra: {\\n            name: pdfh(data, 标题),\\n            url: pd(data, 链接),\\n            qz: MY_HOME\\n        }\\n        });\\n    });\\n    setResult(d);\\n}\\n\\n\\n\\n\\nfunction 最新(选择器, UA) {\\n    if (UA == \\\"PC\\\") {\\n        var code = fetch(getParam('url').replace(\\\"m.\\\", \\\"www.\\\"));\\n    } else {\\n        var code = request(getParam('url').replace(\\\"www.\\\", \\\"m.\\\"));\\n    }\\n    setResult(pdfh(code, 选择器))\\n}\\n\\n\\n\\neval(JSON.parse(request(\\\"hiker://page/qs?rule=阅漫君\\\")).rule)\\n\\nfunction 二级(头部列表, 标题, 图片, 描述, 访问头, 作者, 时间, 分类, 简介, 多路线否, 路线列表, 路线名, 选集总列表, 选集列表, 集名, 集url, downloadlazy,当前URL,当前页名,前缀,UA,防重载否) {\\n    var d = [];\\n\\n//头部列表  则默认使用 code 来作为头部列表数据\\n//多路线否  true 则使用多路线；false 则使用章路线\\n//UA  不填则使用手机端  'PC'则手机端\\n\\nif (当前页名) {\\n    setPageTitle(当前页名)\\n}\\n\\nif(防重载否){\\n//网页内容+防止重拉\\n    var code = 添加防止网页(当前URL, UA)\\n}else{\\n    var code = getCode()\\n}\\n    \\n\\n    //头部列表数据\\n    var 头部 = !头部列表 ? code : pdfa(code, 头部列表)[0];\\n    标题 = pdfh(头部, 标题)\\n    图片 = pdfh(头部, 图片)||图片\\n    if (图片) {\\n        图片 = 图片.includes('http') ? 图片 : 前缀 + 图片\\n        if (!访问头) {} else if (访问头.substr(0, 1) == '@') {\\n            图片 = 图片 + 访问头\\n        } else {\\n            图片 = 图片 + \\\"@Referer=\\\" + 访问头\\n        }\\n    }\\n    \\n\\n描述 = 描述.includes('$') ? 描述.split('$')[1] + pdfh(头部, 描述.split('$')[0]) : pdfh(头部, 描述)\\n\\n作者 = 作者.includes('$') ? 作者.split('$')[1] + pdfh(头部, 作者.split('$')[0]) : pdfh(头部, 作者)\\n    \\n时间 = 时间.includes('$') ? 时间.split('$')[1] + pdfh(头部, 时间.split('$')[0]) : pdfh(头部, 时间)\\n\\n分类 = 分类.includes('$') ? 分类.split('$')[1] + pdfh(头部, 分类.split('$')[0]) : pdfh(头部, 分类)\\n\\n    \\n    //头部列表\\n    添加头部列表(d, 标题, 图片, 描述, 作者, 时间, 分类,当前URL)\\n    \\n    //路线名与选集数据\\n    var 章节json = 优化路线章节数据(多路线否, code, 路线列表,路线名,选集总列表,选集列表,集名,集url,前缀,当前页名,图片)\\n\\n    //简介\\n    添加简介(d, pdfh(code, 简介), 当前URL, '')\\n\\n   //当没有章节内容，就不显示\\n    if (章节json.length > 0) {\\n\\n        //路线选择\\n        var 选择列表 = 添加选择路线(d, 章节json, 当前URL, 多路线否)\\n\\n        //选择下载\\n        添加选择下载(d, 章节json,多路线否)\\n\\n        //排序与选集\\n        添加列表章节(d, 章节json[选择列表].title, 章节json[选择列表].list, lazy, 当前URL, '')\\n\\n        d.push({\\n            col_type: \\\"long_text\\\"\\n        });\\n    }\\n    setResult(d)\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级列表*\",\"path\":\"ejlb\",\"rule\":\"var tabs = []\\nvar lists = []\\nvar arts = pdfa(html, 线路);\\narts.forEach((data, id) => {\\n    tabs.push(pdfh(data, 线路名))\\n})\\nvar conts = pdfa(html, 选集);\\nconts.forEach((data, id) => {\\n    lists.push(pdfa(data, 选集列表))\\n})\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\"lists\\\");\\n}));\\nstorage0.putMyVar(\\\"lists\\\", lists);\\nvar list = lists[getMyVar(MY_URL, '0')];\\nvar 排序 = getMyVar(MY_URL + \\\"章节排序\\\", '#1aad19\\\">正序');\\nvar 提示 = 排序 == '#FF0000\\\">倒序' ? '#1aad19\\\">正序' : '#FF0000\\\">倒序';\\nvar 排序名 = '““””<b><span style=\\\"color:排序</span></b>'\\n\\nd.push({\\n    title: '““””<b><span style=\\\"color: ' + 排序 + '</span></b>',\\n    url: $(\\\"#noLoading#\\\").lazyRule((排序名, lazy) => {\\n        var lists = storage0.getMyVar(\\\"lists\\\");\\n        var 章节 = lists[getMyVar(MY_URL, '0')];\\n        var 排序 = getMyVar(MY_URL + \\\"章节排序\\\", '#1aad19\\\">正序');\\n        var 提示 = 排序 == '#FF0000\\\">倒序' ? '#1aad19\\\">正序' : '#FF0000\\\">倒序';\\n        updateItem({\\n            extra: {\\n                id: MY_URL + \\\"_排序\\\"\\n            },\\n            title: 排序名.replace('排序', 提示)\\n        })\\n        if (排序 == '#1aad19\\\">正序') {\\n            章节.reverse()\\n        }\\n        let cp = 章节.map((data, ssid) => {\\n            return {\\n                title: pdfh(data, 'a&&Text'),\\n                url: pd(data, 'a&&href') + lazy,\\n                col_type: 'text_2',\\n                extra: {\\n                    cls: MY_URL + \\\"_选集\\\"\\n                }\\n            };\\n        });\\n        deleteItemByCls(MY_URL + \\\"_选集\\\");\\n        addItemBefore(MY_URL + \\\"footer\\\", cp);\\n        putMyVar(MY_URL + \\\"章节排序\\\", 提示)\\n        return \\\"hiker://empty\\\"\\n    }, 排序名, lazy),\\n    col_type: 'text_center_1',\\n    extra: {\\n        id: MY_URL + \\\"_排序\\\"\\n    }\\n})\\ntabs.forEach((data, id) => {\\n    d.push({\\n        title: getMyVar(MY_URL, '0') == id ? '““' + data + '””' : data,\\n        url: $(\\\"#noLoading#\\\").lazyRule((线路, lazy, id) => {\\n            var lists = storage0.getMyVar(\\\"lists\\\");\\n            var 排序 = getMyVar(MY_URL + \\\"章节排序\\\", '#1aad19\\\">正序');\\n            var 提示 = 排序 == '#FF0000\\\">倒序' ? '#1aad19\\\">正序' : '#FF0000\\\">倒序';\\n\\n            线路.forEach((data, xlid) => {\\n                updateItem({\\n                    title: id == xlid ? '““' + data + '””' : data,\\n                    extra: {\\n                        id: MY_URL + \\\"_线路\\\" + xlid\\n                    }\\n                });\\n            })\\n            putMyVar(MY_URL, id)\\n            var 章节 = lists[getMyVar(MY_URL, '0')];\\n            if (排序 == '#FF0000\\\">倒序') {\\n                章节.reverse()\\n            }\\n            let cp = 章节.map((data, ssid) => {\\n                return {\\n                    title: pdfh(data, 'a&&Text'),\\n                    url: pd(data, 'a&&href') + lazy,\\n                    col_type: 'text_2',\\n                    extra: {\\n                        cls: MY_URL + \\\"_选集\\\"\\n                    }\\n                };\\n            });\\n            deleteItemByCls(MY_URL + \\\"_选集\\\");\\n            addItemBefore(MY_URL + \\\"footer\\\", cp);\\n            return \\\"hiker://empty\\\"\\n        }, tabs, lazy, id),\\n        col_type: 'text_center_1',\\n        extra: {\\n            id: MY_URL + \\\"_线路\\\" + id\\n        }\\n    });\\n})\\n\\nif (排序 == '#FF0000\\\">倒序') {\\n    list.reverse()\\n}\\nlist.forEach((data, id) => {\\n    d.push({\\n        title: pdfh(data, 'a&&Text'),\\n        url: pd(data, 'a&&href') + lazy,\\n        col_type: 'text_2',\\n        extra: {\\n            cls: MY_URL + \\\"_选集\\\"\\n        }\\n    });\\n})\\nlet newstip = list.length;\\nif (newstip) {\\n    setLastChapterRule('js:' + $.toString((newstip) => {\\n        setResult('更新至: 第' + newstip + \\\"集\\\");\\n    }, newstip));\\n}\\n\\nd.push({\\n    col_type: \\\"big_blank_block\\\",\\n    extra: {\\n        id: MY_URL + \\\"footer\\\"\\n    }\\n});\"},{\"col_type\":\"movie_3\",\"name\":\"环境劫持\",\"path\":\"hijackEnv\",\"rule\":\"var { RULE, isIndex, pageTitle } = MY_PARAMS\\nRULE = JSON.parse(base64Decode(RULE))\\nvar oriRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE).find((v) => v.title == RULE.title)\\nif (isIndex) {\\n    RULE = oriRULE\\n    var { tabHeader, fyAll } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, RULE))\\n    // 处理MY_RULE\\n    MY_RULE.class_url = tabHeader.getClass(fyAll ? 'fyAll' : 'fyclass').url\\n    MY_RULE.area_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyarea').url\\n    MY_RULE.year_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyyear').url\\n    MY_RULE.sort_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fysort').url\\n    MY_RULE.url = RULE.url\\n    MY_RULE.col_type = RULE.col_type\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.find_rule\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\n    MY_RULE.params = {}\\n} else {\\n    RULE.pages = oriRULE.pages\\n    // 处理MY_RULE\\n    MY_RULE.url = MY_PARAMS.url\\n    MY_RULE.col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.detail_find_rule\\n    MY_RULE.params = RULE.params\\n}\\nMY_RULE.pages = RULE.pages\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\nMY_RULE.title = RULE.title\\nMY_RULE.ua = RULE.ua\\nlog(MY_RULE.url)\\n// 载入函数工具\\nvar { genMyRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE, {\\n    QING_TITLE: QING_TITLE,\\n    MY_RULE: MY_RULE,\\n    isIndex: isIndex\\n})\\n// 防止require多次运行\\nconst myColl_required = {}\\nrequire = function(param0, param1, param2, param3, param4) {\\n    if (myColl_required[param0]) return\\n    myColl_required[param0] = true\\n    param2 = param2 != null ? param2 : 0\\n    param3 = MY_TICKET\\n    param4 = eval\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\n}\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\n    if (myColl_required[param0]) return\\n    myColl_required[param0] = true\\n    param3 = param3 != null ? param3 : 0\\n    param4 = MY_TICKET\\n    param5 = eval\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\n}\\nrc = requireCache\\n// 最新章节规则环境劫持\\nsetLastChapterRule = function(param0) {\\n    if (param0.startsWith(\\\"js:\\\")) {\\n        param0 = 'js:' + $.toString((QING_TITLE, MY_PARAMS) => {\\n            eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n            var { runPreRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n            runPreRule(oriRULE.preRule)\\n        }, QING_TITLE, { url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex }) + ';' + param0.slice(3)\\n    }\\n    method_setLastChapterRule.invoke(javaContext, param0)\\n}\\n// 动态新增函数劫持\\naddItemAfter = function(param0, param1) {\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\n    else param1 = hijackEl(param1)\\n    method_addItemAfter.invoke(javaContext, param0, param1)\\n}\\naddItemBefore = function(param0, param1) {\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\n    else param1 = hijackEl(param1)\\n    method_addItemBefore.invoke(javaContext, param0, param1)\\n}\\n//@菜团 环境劫持劫持哪里加个这个-L佬\\nrequest = function(param0, param1, param2) {\\n    if (param0.includes(\\\"hiker://page/\\\")) {\\n        let rule = (param0.split(/\\\\?.*rule=/)[1] || \\\"\\\").split(\\\"&\\\")[0];\\n        let pageUrl = param0.split(\\\"hiker://page/\\\")[1].split(\\\"?\\\")[0];\\n        if (rule !== QING_TITLE) {\\n            let ruleCode;\\n            if (!rule || rule === RULE.title) {\\n                ruleCode = (RULE.pageList || (RULE.pageList = JSON.parse(RULE.pages))).find(v => v.path === pageUrl);\\n            }\\n            if(ruleCode){\\n                return JSON.stringify(ruleCode);\\n            }else{\\n                return \\\"\\\";\\n            }\\n        }\\n    }\\n    param2 = MY_RULE;\\n    var retStr = method_request.invoke(javaContext, param0, param1, param2);\\n    try {\\n        if (retStr instanceof java.io.InputStream) {\\n            return retStr;\\n        }\\n    } catch (e) {}\\n    return retStr == null ? retStr : retStr + \\\"\\\";\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"函数工具\",\"path\":\"funcTools\",\"rule\":\"let { QING_TITLE, MY_RULE, isIndex } = $.importParam\\nif (!MY_RULE) MY_RULE = {}\\n\\nfunction runCode(rule) {\\n    try {\\n        let [input, code] = rule.split('.js:')\\n        return code ? eval(code) : rule\\n    } catch (e) { return rule }\\n}\\n// 首页链接替换分类\\nfunction indexUrl(param) {\\n    MY_RULE = JSON.parse(base64Decode(MY_RULE))\\n    let pageNum = parseInt(param.split('###')[1]),\\n        url = MY_RULE.url,\\n        { fyAll, tabHeader } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, MY_RULE))\\n\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\n    url = url.replace(/fypage(?:@(-?\\\\d+)@)?(?:\\\\*(\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\n    url = /^([\\\\s\\\\S]*?)(?:\\\\[firstPage=([\\\\s\\\\S]*?)\\\\])?(?:(\\\\.js:[\\\\s\\\\S]*?))?$/.exec(url)\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\n    return runCode(url[1])\\n}\\n\\nfunction paramHandle(urlParam, ua, urlTmp) {\\n    let charset, paramTmp\\n    try { // 链接的编码、UA和Referer应该是首先继承首页链接\\n        [, , charset, paramTmp] = urlTmp.split(';')\\n        paramTmp = paramTmp.match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { paramTmp = [] }\\n    let UserAgent = paramTmp.find((v) => v.startsWith('User-Agent@')),\\n        Referer = paramTmp.find((v) => v.startsWith('Referer@'))\\n    urlParam[0] = urlParam[0] || 'GET'\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\n    try {\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { urlParam[2] = [] }\\n    // 添加全局UA和上级Referer\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\n        if (UserAgent) urlParam[2].push(UserAgent)\\n        else if (ua == 'pc')\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n        else if (ua == 'mobile')\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n    }\\n    if (Referer && !urlParam[2].some((v) => v.startsWith('Referer@')))\\n        urlParam[2].push(Referer)\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\n    return urlParam.join(';')\\n}\\n// 预处理并初始化config\\nfunction runPreRule(rule) {\\n    if ((typeof MY_PAGE != 'undefined' &&  MY_PAGE == 1) &&\\n         (isIndex || !getMyVar('$preRule_' + MY_RULE.title))) {\\n        eval(rule)\\n        putMyVar('$preRule_' + MY_RULE.title, 'T')\\n    }\\n    let _cfg = getMyVar('initConfig', '{}')\\n    if (_cfg && _cfg.length > 0) {\\n        config = JSON.parse(_cfg)\\n    }\\n}\\n// 正文解析通用变量\\nfunction genMyRule() {\\n    let RULE = Object.assign({}, MY_RULE)\\n    delete RULE.last_chapter_rule\\n    delete RULE.preRule\\n    delete RULE.pageList\\n    delete RULE.pages\\n    return RULE\\n}\\n\\nfunction genExUrl(url) {\\n    url = url.split(';')\\n    return url.shift() + ';' + paramHandle(url, MY_RULE.ua, MY_RULE.url)\\n}\\n\\nhijackLazyRule = $.toString((QING_TITLE, MY_PARAMS) => {\\n    if (!MY_RULE) MY_RULE = {}\\n    MY_PARAMS = JSON.parse(base64Decode(MY_PARAMS))\\n    eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n    var {\\n        paramHandle,\\n        genExUrl,\\n        hijackLazyRule,\\n        hijackEl\\n    } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n}, QING_TITLE, base64Encode(JSON.stringify({ url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex })))\\n\\nfunction hijackEl(el) {\\n    if(!el || typeof el != 'object') return\\n    if (!el.extra) el.extra = {}\\n    el.col_type = el.col_type || MY_RULE.col_type\\n    let NOW_RULE = Object.assign(genMyRule(), { params: el.extra })\\n\\n    if (typeof el.url != 'string' ||\\n        ['x5_webview_single', 'input'].some((v) => el.col_type == v) ||\\n        ['海阔视界', 'javascript:'].some((v) => el.url.startsWith(v)) ||\\n        ['rule', 'pics', 'toast', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'x5Rule', 'webRule',\\n            'download', 'share', 'fileSelect', 'video'].some((v) => el.url.startsWith(v + '://'))) {\\n        return el\\n    } else if (el.url.startsWith('input://')) {\\n        let para = JSON.parse(el.url.slice(8))\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\n        el.url = 'input://' + JSON.stringify(para)\\n        return el\\n    } else if (el.url.startsWith('confirm://')) {\\n        let reIndex = el.url.indexOf('.js:')\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\n        return el\\n    } else if (el.url.startsWith('select://')) {\\n        let para = JSON.parse(el.url.slice(9))\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\n        el.url = 'select://' + JSON.stringify(para)\\n        return el\\n    } else if (el.url.includes('@rule=')) {\\n        let [_, url, rule] = el.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n        el.url = url\\n        NOW_RULE.detail_find_rule = rule\\n        NOW_RULE.detail_col_type = MY_RULE.col_type\\n    } else if (el.url.startsWith('hiker://page/')) {\\n        if (el.url.includes('rule=') || el.extra.rule)\\n            return el\\n        let [_, path, flag, params] = el.url.match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(#.*?)?(?:\\\\?(.*))?$/),\\n            subPage = MY_RULE.pageList.find((v) => v.path == path),\\n            subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\n        el.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (el.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\n        NOW_RULE.detail_find_rule = subPage.rule\\n        NOW_RULE.detail_col_type = subPage.col_type\\n    } else if (el.url.includes('@lazyRule=')) {\\n        let reIndex = el.url.indexOf('.js:')\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\n        return el\\n    } else if (isIndex) {\\n        if (!MY_RULE.detail_find_rule || /hiker:\\\\/\\\\/(?!empty.+$)/.test(el.url)) return el\\n    } else {\\n        return el\\n    }\\n    el.extra = Object.assign({}, el.extra, {\\n        url: genExUrl(el.url),\\n        RULE: base64Encode(JSON.stringify(NOW_RULE)),\\n        pageTitle: isIndex && el.title\\n    })\\n    el.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n    return el\\n}\\n$.exports = {\\n    runCode: runCode,\\n    indexUrl: indexUrl,\\n    paramHandle: paramHandle,\\n    runPreRule: runPreRule,\\n    genMyRule: genMyRule,\\n    genExUrl: genExUrl,\\n    hijackLazyRule: hijackLazyRule,\\n    hijackEl: hijackEl\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"漫画解析*\",\"path\":\"js\",\"rule\":\"function 爱米推类(input) {\\n\\ttry{\\n        var url = input\\n        .replace('m.'||'mh.'||'wap.', 'www.')\\n        .replace('ikr.', 'icekr.');\\n        var html = request(url, {\\n    headers: {\\n        'User-Agent': PC_UA,\\n        'Referer': url\\n    }\\n})\\n    eval(pdfh(pdfa(html, 'body&&script:not([src]):not([type])')[0], 'script&&Html'));\\n    var pics = [];\\n    if (chapterImages.length > 0) {\\n        var host = request(input).match(/img src=\\\"(.*?)\\\\/image/)[1];\\n        chapterImages.forEach(img => {\\n            if (img.indexOf(\\\"http\\\") > -1) {\\n            pics.push(img + '@Referer=' + url)\\n            } else {\\n            pics.push(host + img + '@Referer=' + url)\\n            }\\n        })\\n    } else {\\n        var html = request(input);\\n        var pics = [];\\n        if(/k_total/.test(html)){\\n            var Page = pdfh(html, '#k_total&&Text');\\n            if(Page.length > 0){\\n                var host = html.match(/mip-img src=\\\"(.*?)image/)[1];\\n            for (var i = 0; i < Page; i++) {\\n        pics.push(host + 'image/view/' + input.match(/\\\\d+/)[0] + '/' + i + '.webp'+ '@Referer=')\\n            }\\n    } else {\\n        var res1 = {};\\n        var d1 = [];\\n        var jsHtml = fetch(input, {\\n            headers: {\\n                \\\"content-type\\\": \\\"UTF-8\\\",\\n                \\\"User-Agent\\\": \\\"Mobile\\\"\\n            },\\n            method: \\\"GET\\\"\\n        });\\n        var pics = [];\\n        for (var k = 1;; k++) {\\n            try {\\n                var jsHtml = fetch(input.split(\\\".html\\\")[0] + \\\"-\\\" + k + \\\".html\\\", {\\n                    headers: {\\n                        \\\"content-type\\\": \\\"UTF-8\\\",\\n                        \\\"User-Agent\\\": \\\"Mobile\\\"\\n                    },\\n                    method: \\\"GET\\\"\\n                });\\n                let page = pdfh(jsHtml, \\\"\\\");\\n                if (page && page.includes(\\\"/\\\")) {\\n                    page = parseInt(page.split(\\\"/\\\")[1]);\\n                    var jsUrl = parseDomForHtml(jsHtml, \\\".erPag&&mip-img||img&&src\\\")+ '@Referer=';\\n                    if (jsUrl.indexOf(\\\"png\\\") > -1) {\\n                        break\\n                    }\\n                    let urls = [];\\n                    for (let i = 2; i <= page; i++) {\\n                        urls.push({\\n                            url: input.split(\\\".html\\\")[0] + \\\"-\\\" + i + \\\".html\\\",\\n                            options: {\\n                                headers: {\\n                                    \\\"content-type\\\": \\\"UTF-8\\\",\\n                                    \\\"User-Agent\\\": \\\"Mobile\\\"\\n                                },\\n                                method: \\\"GET\\\"\\n                            }\\n                        })\\n                    }\\n                    let htmls = bf(urls);\\n                    for (let i = 0; i < htmls.length; i++) {\\n                        var jsUrl = parseDomForHtml(htmls[i], \\\".erPag&&mip-img||img&&src\\\")+ '@Referer=';\\n                        if (jsUrl.indexOf(\\\"png\\\") > -1) {\\n                            break\\n                        }\\n                    }\\n                    pics.push(jsUrl);\\n                }\\n                var jsUrl = parseDomForHtml(jsHtml, \\\".erPag&&mip-img||img&&src\\\")+ '@Referer=';\\n                if (jsUrl.indexOf(\\\"png\\\") > -1) {\\n                    break\\n                } else {\\n                    pics.push(jsUrl);\\n                }\\n            } catch (e) {\\n                break\\n            }\\n        }\\n    }\\n        } else {\\n            var list = pdfa(html, 'body&&.scroll-item||.image-content||#scroll-image');\\n        var first = pdfa(html, 'body&&#image');\\n        list = first.concat(list);\\n        list.forEach(img => {\\n            pics.push(pdfh(img, 'img&&data-src||src') + '@Referer=' + input)\\n        })\\n        }\\n    }\\n    } catch(e) {\\n        var html = request(input);\\n        var pics = [];\\n        var list = pdfa(html, 'body&&.scroll-item||.image-content||#scroll-image');\\n        var first = pdfa(html, 'body&&#image');\\n        list = first.concat(list);\\n        list.forEach(img => {\\n            pics.push(pdfh(img, 'img&&data-src||src') + '@Referer=' + input)\\n        })\\n    }\\n    return \\\"pics://\\\" + pics.join(\\\"&&\\\")\\n}\\n$.exports.jx=爱米推类;\\n\\nfunction 包子(input) {\\n    var id = true;\\n    var code = request(input)\\n    var pics = [];\\n    var to_Repeat = false;\\n\\n\\n    while (id) {\\n        pdfa(code, \\\".chapter-main&&amp-img\\\")\\n            .forEach(data => pics.push(pdfh(data, \\\"amp-img&&src\\\") + '@Referer=https://www.webmota.com/'));\\n        var next_Page = pdfh(code, \\\".next_chapter,-1&&Html\\\")\\n        if (next_Page.includes('下一页')) {\\n            code = request(pdfh(next_Page, \\\"a&&href\\\"))\\n            to_Repeat = true;\\n        } else {\\n            id = false;\\n        }\\n    }\\n\\n    //去除重复图片\\n    if (to_Repeat) {\\n        for (let i = 0; i < pics.length; i++) {\\n            while (pics.indexOf(pics[i], i + 1) != -1) {\\n                pics.splice(pics.indexOf(pics[i], i + 1), 1)\\n            }\\n        }\\n    }\\n\\n    return \\\"pics://\\\" + pics.join(\\\"&&\\\");\\n}\\n$.exports.bz=包子;\\n\\nfunction 古风(input) {\\n\\tvar html = fetchPC(input);\\n\\teval(pdfh(pdfa(html, 'body&&script:not([src]):not([type])')[0], 'script&&Html'));\\n\\tvar pics = [];\\n\\tfor (var i in chapterImages) {\\n\\t\\tpics.push('https://res.xiaoqinre.com/' + chapterPath + chapterImages[i] + '@Referer=https://www.123gf.com')\\n\\t\\t}\\n\\treturn \\\"pics://\\\" + pics.join(\\\"&&\\\")\\n}\\n$.exports.GF=古风;\\n\\nfunction 爱米(input) {\\n        var html = request(input);\\n        var pics = [];\\n        var list = pdfa(html, 'body&&.scroll-item||.image-content||#scroll-image');\\n        var first = pdfa(html, 'body&&#image');\\n        list = first.concat(list);\\n        list.forEach(img => {\\n            pics.push(pdfh(img, 'img&&data-src||src') + '@Referer=' + input)\\n        })\\n        return \\\"pics://\\\" + pics.join(\\\"&&\\\")\\n}\\n$.exports.IM=爱米;\"},{\"col_type\":\"movie_3\",\"name\":\"云口令*\",\"path\":\"import\",\"rule\":\"writeFile('hiker://files//rules/Tz/JM',fetch(input))\\n'toast://已从云口令获取阅漫君源'\"},{\"col_type\":\"movie_3\",\"name\":\"更新详情*\",\"path\":\"Up\",\"rule\":\"js:\\nvar res = {};\\nvar items = [];\\nvar img = 'https://bing.img.run/1366x768.php';\\nitems.push({\\n    img: img,\\n    url: img + \\\"#.jpg\\\",\\n    desc: '0',\\n    col_type: 'card_pic_1'\\n});\\n\\nitems.push({\\n    title: \\\"““””<h4>【阅漫君反馈收集】</h4>\\\" + '<span style=\\\"color: grey\\\">小小</span>',\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://page/manageRule#noHistory##noRecordHistory#?rule=道长仓库Pro\\\",\\n    extra: {\\n        lver: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\",\\n        id: \\\"6975\\\"\\n    }\\n});\\n\\nif (getItem(\\\"read_policy\\\") !== \\\"1\\\") {\\n    items.push({\\n        title: '““””<small><font color=#871f78>本规则数据来源于网络，如您喜欢，请支持官方</font></small>',\\n        desc: '““””<small><font color=#f20c00>本规则仅限免费学习交流使用，请于导入后24小时内删除，任何组织或个人不得以任何方式方法传播或售卖此规则的整体或部分！</font></small>',\\n        url: $('#noHistory#').lazyRule(() => {\\n            setItem(\\\"read_policy\\\", \\\"1\\\")\\n            refreshPage(false)\\n            return \\\"toast://你已同意该协议\\\"\\n        }),\\n        col_type: 'text_center_1'\\n    })\\n}\\n\\nitems.push({\\n    title: '““””<b>使用说明</b>',\\n    url: \\\"切换分组搜索即可\\\",\\n    col_type: \\\"text_2\\\"\\n});\\n\\nlet newVersion;\\nlet myVersion = MY_PARAMS.version;\\ntry {\\n    newVersion = JSON.parse(fetchPC(\\\"http://hiker.nokia.press/hikerule/dev/getbyid?id=6975\\\", {\\n        timeout: 1000\\n    })).result.ver;\\n} catch (e) {\\n    toast(\\\"道长仓库抽风了，本次未检测到新版信息\\\");\\n    newVersion = myVersion;\\n}\\nlet isUpdate = Number(newVersion) > Number(myVersion);\\nlet isVer = Number(newVersion) === Number(myVersion);\\nif (isUpdate) {\\n    log('有新版本:' + newVersion + ',当前:' + myVersion);\\n}\\nitems.push({\\n    title: isUpdate ? \\\"🆙新版本\\\" : \\\"规则发布页&反馈\\\",\\n    url: isUpdate ? \\\"rule://5rW36ZiU6KeG55WM6aaW6aG16aKR6YGT6KeE5YiZ44CQ6IGa5ryr8J+UruOAke+/pWhvbWVfcnVsZV91cmzvv6VodHRwOi8vaGlrZXIubm9raWEucHJlc3MvaGlrZXJ1bGUvcnVsZWxpc3QuanNvbj9pZD0yODQ3\\\" : \\\"hiker://page/manageRule#noHistory##noRecordHistory#?rule=道长仓库Pro\\\",\\n    col_type: \\\"text_2\\\",\\n    extra: {\\n        lver: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\",\\n        id: \\\"6975\\\"\\n    }\\n});\\nconst Color = \\\"#19B89D\\\";\\nvar des_desc = \\n'<h1 style=\\\"text-align: center;\\\">🐾更新[202412.3]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①剔除失效源，漫蛙/包子修复</br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[1105]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更换远程仓库，优化加载速度 并增加更新长按规则名 清除缓存即可</br>②修复漫蛙图源加载不出来<br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[231213]</h1>' +\\n    '<<blockquote><font color=\\\"<br>剔除无用源，修复部分源报错</br></<blockquote>'\\n\\nitems.push({\\n    title: '更新详情 <small><small><span style=\\\"color:#19B89D\\\">展开></span></small></small>',\\n    img: \\\"https://lanmeiguojiang.com/tubiao/more/197.png\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((jjid, decid, des_desc) => {\\n        if (getMyVar(\\\"jjs\\\", \\\"收起\\\") == \\\"收起\\\") {\\n            putMyVar(\\\"jjs\\\", \\\"展开\\\");\\n\\n            updateItem({\\n                extra: {\\n                    id: jjid\\n                },\\n                title: '更新详情 <small><small><span style=\\\"color:#19B89D\\\">收起></span></small></small>'\\n            })\\n\\n            updateItem({\\n                extra: {\\n                    textSize: 14,\\n                    lineSpacing: 3,\\n                    id: decid\\n                },\\n                title: '<span style=\\\"color:#808080\\\">' + des_desc + '</span>'\\n            })\\n            return \\\"hiker://empty\\\"\\n        } else {\\n            putMyVar(\\\"jjs\\\", \\\"收起\\\");\\n\\n            updateItem({\\n                extra: {\\n                    id: jjid\\n                },\\n                title: '更新详情<small><small><span style=\\\"color:#19B89D\\\">展开></span></small></small>'\\n            })\\n\\n            updateItem({\\n                extra: {\\n                    textSize: 14,\\n                    lineSpacing: 3,\\n                    id: decid\\n                },\\n                title: '<span style=\\\"color:#808080\\\">' + des_desc.substr(0, 150)\\n            })\\n            return \\\"hiker://empty\\\"\\n        }\\n\\n    }, MY_RULE + \\\"_jjid\\\", MY_RULE + \\\"_decid\\\", des_desc),\\n    col_type: \\\"avatar\\\",\\n    extra: {\\n        id: MY_RULE + \\\"_jjid\\\"\\n    }\\n});\\n\\nitems.push({\\n    title: '<span style=\\\"color:#808080\\\">' + des_desc.substr(0, 150),\\n    col_type: \\\"rich_text\\\",\\n    extra: {\\n        textSize: 14,\\n        lineSpacing: 3,\\n        id: MY_RULE + \\\"_decid\\\"\\n    }\\n});\\n\\nres.data = items;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"使用帮助*\",\"path\":\"Help\",\"rule\":\"js:\\nvar res = {};\\nvar items = [];\\n\\nitems.push({\\n    title:'二级页面标题双击优化，在顶部则双击到底部，否则双击回顶部',\\n    col_type: 'rich_text'\\n});\\n\\nitems.push({\\n    img: 'https://s1.ax1x.com/2022/11/04/xLhgoR.jpg',\\n    desc: '0',\\n    col_type: 'pic_1_full'\\n});\\n\\nitems.push({\\n    img: 'https://s1.ax1x.com/2022/11/04/xLhcw9.jpg',\\n    desc: '0',\\n    col_type: 'pic_1_full'\\n});\\n\\nres.data = items;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"搜索*\",\"path\":\"search\",\"rule\":\"function convert1(str) {\\n    let c = str.split(\\\";\\\")\\n    return {\\n        列表: c[0],\\n        标题: c[1],\\n        链接: c[2],\\n        描述: c[3],\\n        详情: c[4],\\n        图片: c[5]\\n    }\\n}\\n\\nfunction merge(source, target) {\\n    let keys = Object.keys(source)\\n    for (let i in keys) {\\n        target[keys[i]] = source[keys[i]]\\n    }\\n}\\n\\nfunction 搜索(obj) {\\n    var d = [];\\n    if ($.type(obj) == \\\"string\\\") {\\n        obj = convert1(obj)\\n    }\\n    if (obj.规则) {\\n        let c = convert1(obj.规则)\\n        merge(c, obj)\\n    }\\n    let arr = pdfa(getResCode(), obj.列表);\\n       if (obj.列表处理 != null) {\\n            arr = obj.链接处理(arr)\\n        }\\n    for (let it of arr) {\\n        let url = pd(it, obj.链接)\\n        if (obj.链接处理 != null) {\\n            url = obj.链接处理(url)\\n        }\\n        let title = pdfh(it, obj.标题)\\n        if (obj.标题处理 != null) {\\n            title = obj.标题处理(title)\\n        }\\n        let pic = pd(it, obj.图片)\\n        if (obj.图片处理 != null) {\\n            pic = obj.图片处理(pic)\\n        }\\n        d.push({\\n            title: obj.标题 ? pdfh(it, obj.标题) : \\\"\\\",\\n            url: url+'#autoCache#',\\n            col_type: \\\"\\\",\\n            desc: obj.描述 ? pdfh(it, obj.描述) : \\\"\\\",\\n            content: obj.详情 ? pdfh(it, obj.详情) : \\\"\\\",\\n            pic_url: pic,\\n            extra: {\\n                ytitle: title,\\n                ypic: pic,\\n                yurl: url.replace('hiker://empty##','')\\n            }\\n        });\\n\\n    }\\n    setResult(d);\\n}\\nvar tool = {\\n    搜索: 搜索\\n}\\n$.exports = tool\"},{\"col_type\":\"movie_3\",\"name\":\"DES*\",\"path\":\"des\",\"rule\":\"var javaImport = new JavaImporter();\\njavaImport.importPackage(\\n    Packages.java.lang,\\n    Packages.java.security,\\n    Packages.java.util,\\n    Packages.java.io,\\n    Packages.java.text,\\n    Packages.javax.crypto,\\n    Packages.javax.crypto.spec\\n);\\nwith(javaImport) {\\n   function De(str) {\\n        var generateSecret = SecretKeyFactory.getInstance(\\\"desede\\\").generateSecret(new DESedeKeySpec(String('OW84U8Eerdb99rtsTXWSILDO').getBytes()));\\n        var instance = Cipher.getInstance(\\\"desede/CBC/PKCS5Padding\\\");\\n        instance.init(2, generateSecret, new IvParameterSpec(String('SK8bncVu').getBytes()));\\n        return String(instance.doFinal(_base64.decode(str, 2)));        \\n    }\\n}\\n\\n/*\\neval(getCryptoJS())\\nvar key = CryptoJS.enc.Utf8.parse('OW84U8Eerdb99rtsTXWSILDO')\\nvar iv = CryptoJS.enc.Utf8.parse('SK8bncVu')\\n\\nfunction De(data, encoding) {\\n    var decrypted = CryptoJS.TripleDES.decrypt(data, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7\\n    });\\n    if (!encoding) {\\n        return decrypted.toString(CryptoJS.enc.Utf8);\\n    }\\n    return decrypted.toString(CryptoJS.enc.Base64);\\n};\\n*/\"},{\"col_type\":\"movie_3\",\"name\":\"解密\",\"path\":\"image\",\"rule\":\"$.exports.imageDecrypt = function() {\\n        var javaImport = new JavaImporter();\\n        javaImport.importPackage(\\n            Packages.com.example.hikerview.utils,\\n            Packages.java.lang,\\n            Packages.java.security,\\n            Packages.java.util,\\n            Packages.java.io,\\n            Packages.java.text,\\n            Packages.javax.crypto,\\n            Packages.javax.crypto.spec\\n        );\\n        with(javaImport) {\\n            let bytes = FileUtil.toBytes(input);\\n            function decryptData(bArr) {\\n                var cipher = Cipher.getInstance(\\\"AES/CBC/PKCS7Padding\\\");\\n                cipher.init(2, new SecretKeySpec(String('my2ecret782ecret').getBytes(), 'AES'), new IvParameterSpec(String('my2ecret782ecret').getBytes()));\\n                return cipher.doFinal(bArr);\\n            }\\n            bytes = decryptData(bytes);\\n            return FileUtil.toInputStream(bytes);\\n        }\\n    }\"}],\"params\":\"{\\\"RULE\\\":\\\"eyJ0aXRsZSI6Iua8q+ibmSJ9\\\",\\\"isIndex\\\":true,\\\"url\\\":\\\"hiker://empty/#noHistory##noRecordHistory####fypage.js:let { runCode, indexUrl } = $.require(\\\\\\\"hiker://page/funcTools？？rule=阅漫君\\\\\\\", {\\\\\\\"MY_RULE\\\\\\\":\\\\\\\"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\\\\\\\",\\\\\\\"QING_TITLE\\\\\\\":\\\\\\\"阅漫君\\\\\\\"})；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 12；； NTH-AN00 Build/HONORNTH-AN00；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.105 Mobile Safari/537.36}\\\"}\",\"saved\":false,\"title\":\"阅漫君\",\"version\":0,\"url\":\"hiker://empty/#noHistory##noRecordHistory####fypage.js:let { runCode, indexUrl } = $.require(\\\"hiker://page/funcTools？？rule=阅漫君\\\", {\\\"MY_RULE\\\":\\\"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\\\",\\\"QING_TITLE\\\":\\\"阅漫君\\\"})；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 12；； NTH-AN00 Build/HONORNTH-AN00；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.105 Mobile Safari/537.36}\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nvar myColl_el = []\\neval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(oriRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n} else if (MY_PAGE == 1) {\\n    tabHeader.load(myColl_el)\\n    if (RULE.search_url) myColl_el.push({\\n        title: \\\"搜索\\\",\\n        desc: \\\"这是阅漫君的搜索哦~~\\\",\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        extra: {\\n            rules: $.toString((QING_TITLE, title) => {\\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\\n                rules = [rules.find((v) => v.title == title)]\\n                return JSON.stringify(rules)\\n            }, QING_TITLE, RULE.title),\\n            defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"\\n        },\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 正文解析\\nvar {\\n    paramHandle,\\n    runPreRule,\\n    genExUrl,\\n    hijackLazyRule\\n} = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\nrunPreRule(oriRULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    let { hijackEl } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n    setResult = function(param0, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(param0.data)) param0 = param0.data\\n        Array.prototype.push.apply(myColl_el, param0.map(hijackEl))\\n        method_setResult.invoke(javaContext, myColl_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let { runCode } = $.require('hiker://page/funcTools?rule=' + QING_TITLE),\\n        [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.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) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(Object.assign(genMyRule(), { detail_find_rule: detailFindRule }))),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(genMyRule())),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myColl_el.push(res)\\n    })\\n    setResult(myColl_el)\\n}\\n\",\"group\":\"①轻合集\",\"ua\":\"mobile\",\"preRule\":\"putMyVar('myCollection', MY_RULE.title)\\nputMyVar('remoteUrl', 'https://ghproxy.cc/https://raw.githubusercontent.com/QQ1993HUANG/A/refs/heads/main/阅漫君.json')\\n// \\n/*\\n*/\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"ClassTab\\\",\\\"path\\\":\\\"ClassTab\\\",\\\"rule\\\":\\\"var {\\\\n    QING_TITLE, title, url,\\\\n    class_name, class_url,\\\\n    area_name, area_url,\\\\n    year_name, year_url,\\\\n    sort_name, sort_url\\\\n} = $.importParam\\\\nconst ClassTab = function(classArray, params) {\\\\n    Object.assign(this, params)\\\\n    this.arr = classArray.map(v => this.init(v))\\\\n    this.sign = '$' + QING_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 = this.fold && getVar('$fold_' + this.sign, '')\\\\n        if (this.arr.length > 1 && this.fold) el.push({\\\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\\\n                putVar('$fold_' + sign, folded ? '' : 'T')\\\\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 ? '““””' + name.fontcolor(this.color).bold() : name,\\\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\\\n                        putVar(sign + id, 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('&').map((v) => v.trim())\\\\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        defaultClass = JSON.stringify(defaultClass ? {\\\\n            name: defaultClass.class_name[0],\\\\n            url: defaultClass.class_url[0]\\\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\\\n    },\\\\n    setUrl(url) {\\\\n        return url.replace(/\\\\\\\\$\\\\\\\\{([^}]*)\\\\\\\\}/g, (_, id) => this.getClass(id).url)\\\\n    }\\\\n}\\\\n// 生成头部分类\\\\nlet fyAll = url.includes('fyAll'),\\\\n    tabHeader = []\\\\nif (class_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyclass',\\\\n    class_name: class_name,\\\\n    class_url: class_url\\\\n})\\\\nif (area_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyarea',\\\\n    class_name: area_name,\\\\n    class_url: area_url\\\\n})\\\\nif (year_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyyear',\\\\n    class_name: year_name,\\\\n    class_url: year_url\\\\n})\\\\nif (sort_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fysort',\\\\n    class_name: sort_name,\\\\n    class_url: sort_url\\\\n})\\\\n$.exports = {\\\\n    fyAll: fyAll,\\\\n    tabHeader: new ClassTab(tabHeader, { name: title, fold: readFile('tabFold'), })\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"icon_2_round\\\",\\\"name\\\":\\\"设置\\\",\\\"path\\\":\\\"Config\\\",\\\"rule\\\":\\\"js:\\\\naddListener('onClose', 'clearMyVar(\\\\\\\"sortFlag\\\\\\\");refreshPage()')\\\\nsetPageTitle('⚙ 阅漫君设置 ⚙')\\\\nconst QING_TITLE = getMyVar('myCollection'),\\\\n    url = getMyVar('remoteUrl')\\\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE, true),\\\\n    el = [{\\\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，没事别点，可每月点一次更新）',\\\\n        url: $(\\\\\\\"清除缓存，立即更新\\\\\\\").confirm((url) => {\\\\n            //远程依赖索引文件代理地址列表\\\\n            let requirelist = ['https://ghproxy.cc/https://raw.githubusercontent.com/QQ1993HUANG/A/main/阅漫君.json']\\\\n            for (let i = 0; i < requirelist.length; i++) {\\\\n                try { //远程依赖索引\\\\n                    let res = request(requirelist[i] + 'QQ1993HUANG/A/main', {\\\\n                        withStatusCode: true\\\\n                    })\\\\n                    if (JSON.parse(res).statusCode == 200) {\\\\n                        if (fileExist(url)) {\\\\n                            deleteFile(url)\\\\n                            requireDownload(requirelist[i] + 'QQ1993HUANG/A/main',url)\\\\n                            break\\\\n                        } else {\\\\n                            requireDownload(requirelist[i] + 'QQ1993HUANG/A/main',url)\\\\n                            break\\\\n                        }\\\\n                    }\\\\n                } catch (e) {}\\\\n            }\\\\n            refreshPage(true)\\\\n            back(false)\\\\n            return 'toast://已更新'\\\\n        }, url),\\\\n        img: 'hiker://images/icon4',\\\\n        col_type: 'avatar'\\\\n    }],\\\\n    updateInterval = readFile('updateInterval') || '1',\\\\n    newWindow = readFile('newWindow'),\\\\n    tabFold = readFile('tabFold'),\\\\n    disableCustom = readFile('disableCustom'),\\\\n    editMode = disableCustom ? '导入海阔' : getMyVar('editMode', '启用/禁用')\\\\n\\\\nel.push({\\\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\\\\\n本地文件链接无效').input(() => {\\\\n        input = parseInt(input)\\\\n        if (Number.isNaN(input)) input = 1\\\\n        else if (input < 1) input = 0\\\\n        saveFile('updateInterval', input.toString())\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  🖥 独立首页: ' + (newWindow ? '是' : '否') + '  ',\\\\n    url: $('#noLoading#').lazyRule((newWindow) => {\\\\n        saveFile('newWindow', newWindow ? '' : 'T')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }, newWindow),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\\\n        saveFile('tabFold', tabFold ? '' : 'T')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }, tabFold),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  💼 备份恢复  ',\\\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n        let url = getMyVar('remoteUrl')\\\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\\\n        else if (url.startsWith('hiker://page/')) url = 'hiker://empty'\\\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n                let rules = request(url),\\\\n                    customData = readFile('customData')\\\\n                writeFile(input, JSON.stringify({\\\\n                    updateInterval: updateInterval,\\\\n                    newWindow: newWindow,\\\\n                    tabFold: tabFold,\\\\n                    disableCustom: disableCustom,\\\\n                    customData: customData,\\\\n                    rules: rules\\\\n                }))\\\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\\\n            saveFile('updateInterval', updateInterval)\\\\n            saveFile('newWindow', newWindow)\\\\n            saveFile('tabFold', tabFold)\\\\n            saveFile('disableCustom', disableCustom)\\\\n            saveFile('customData', customData)\\\\n            if (rules) writeFile(url, rules)\\\\n            refreshPage()\\\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\\\n        }, url)\\\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '““””<font color=\\\\\\\"#666666\\\\\\\"><small>特别鸣谢，小程序提供者：团子/墙佬/道长/    小程序维护：小米粥\\\\\\\\n'\\\\n        /*data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\\\n        .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、')*/,\\\\n    url: 'hiker://empty',\\\\n    col_type: 'text_center_1'\\\\n})\\\\nel.push({\\\\n    title: \\\\\\\"更新&反馈\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/Up#noRefresh##noRecordHistory##noHistory#\\\\\\\",\\\\n    extra: {\\\\n        version: MY_PARAMS.version || \\\\\\\"获取版本失败，自行查看\\\\\\\"\\\\n    },\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n});\\\\nel.push({ col_type: 'line' }, {\\\\n    title: '““””' + '📝'.small() + '&nbsp 阅漫君自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据', '编辑JSON'], 1).select(() => {\\\\n        switch (input.slice(0, 2)) {\\\\n            case '清除':\\\\n                deleteFile('customData')\\\\n                break\\\\n            case '启用':\\\\n                saveFile('disableCustom', '')\\\\n                break\\\\n            case '禁用':\\\\n                saveFile('disableCustom', 'T')\\\\n                input += '\\\\\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\\\n                break\\\\n            case '编辑':\\\\n                let url = getMyVar('remoteUrl')\\\\n                if (!url.startsWith('hiker://files/') && !url.startsWith('file://'))\\\\n                    url = 'hiker://files/libs/' + md5(url) + '.js'\\\\n                return  'hiker://page/interface#noRefresh##noHistory##noRecordHistory#?rule=JSON编辑器&Json='+base64Encode(url)\\\\n        }\\\\n        refreshPage(false)\\\\n        return 'toast://已' + input\\\\n    }),\\\\n    col_type: 'text_center_1',\\\\n    extra: { lineVisible: false }\\\\n});/*\\\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\\\n    el.push({\\\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\\\n            putMyVar('editMode', v)\\\\n            refreshPage(false)\\\\n            return 'hiker://empty'\\\\n        }, v),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n});\\\\nif (editMode == '导入海阔') el.push({\\\\n    title: '全部导入',\\\\n    url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\\\n    col_type: 'text_center_1',\\\\n    extra: { lineVisible: false }\\\\n});\\\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\\\n    let d = { title: v.title, img: data[i].icon }\\\\n    switch (editMode) {\\\\n        case '启用/禁用':\\\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\\\n            d.url = $('#noLoading#').lazyRule((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                rules[i].visible = !rules[i].visible\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '重新排序':\\\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\\\n            if (sortFlag == -1)\\\\n                d.url = $('#noLoading#').lazyRule((i) => {\\\\n                    putMyVar('sortFlag', i.toString())\\\\n                    refreshPage(false)\\\\n                    return 'toast://选择要移动到的位置'\\\\n                }, i)\\\\n            else\\\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\\\n                    saveFile('customData', JSON.stringify(rules))\\\\n                    putMyVar('sortFlag', '-1')\\\\n                    refreshPage(false)\\\\n                    return 'hiker://empty'\\\\n                }, sortFlag, i)\\\\n            break\\\\n        case '更改图标':\\\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                if (input)\\\\n                    rules[i].icon = input\\\\n                else\\\\n                    delete rules[i].icon\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '导入海阔':\\\\n            d.url = $('#noLoading#').lazyRule((i) => {\\\\n                let data = $.require('hiker://page/dataLoad?rule=' + getMyVar('myCollection'), true)\\\\n                return 'rule://' + base64Encode(JSON.stringify(data[i]))\\\\n            }, i)\\\\n            break\\\\n    }\\\\n    el.push(d)\\\\n})*/\\\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\\\n    el.push({\\\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\\\n            putMyVar('editMode', v)\\\\n            refreshPage(false)\\\\n            return 'hiker://empty'\\\\n        }, v),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n});\\\\nif(editMode === '导入海阔') {\\\\n    el.push({\\\\n        title:'搜索',\\\\n        desc:'输入小程序标题|地址进行搜索...',\\\\n        url:$.toString(()=>{\\\\n            refreshPage(false);\\\\n        }),\\\\n        col_type:'input',\\\\n        extra: {\\\\n            onChange: \\\\\\\"putMyVar('importSearchKey',input)\\\\\\\",\\\\n            titleVisible: true,\\\\n            defaultValue:getMyVar('importSearchKey','')\\\\n        },\\\\n    });\\\\n    el.push({\\\\n        title: '全部导入(非搜索过滤后结果)',\\\\n        url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\\\n        col_type: 'text_center_1',\\\\n        extra: {lineVisible: false}\\\\n    });\\\\n}\\\\nvar datas = (disableCustom ? data : JSON.parse(readFile('customData') || '[]'));\\\\nlet sk = getMyVar('importSearchKey','');\\\\nif(editMode === '导入海阔'&&sk) {\\\\n    datas = datas.filter(it=>it.title.includes(sk)||(it.url&&it.url.includes(sk)));\\\\n    data = data.filter(it=>it.title.includes(sk)||(it.url&&it.url.includes(sk)));\\\\n}\\\\ndatas.forEach((v, i) => {\\\\n    let d = { title: v.title, img: data[i].icon }\\\\n    switch (editMode) {\\\\n        case '启用/禁用':\\\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\\\n            d.url = $('#noLoading#').lazyRule((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                rules[i].visible = !rules[i].visible\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '重新排序':\\\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\\\n            if (sortFlag == -1)\\\\n                d.url = $('#noLoading#').lazyRule((i) => {\\\\n                    putMyVar('sortFlag', i.toString())\\\\n                    refreshPage(false)\\\\n                    return 'toast://选择要移动到的位置'\\\\n                }, i)\\\\n            else\\\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\\\n                    saveFile('customData', JSON.stringify(rules))\\\\n                    putMyVar('sortFlag', '-1')\\\\n                    refreshPage(false)\\\\n                    return 'hiker://empty'\\\\n                }, sortFlag, i)\\\\n            break\\\\n        case '更改图标':\\\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                if (input)\\\\n                    rules[i].icon = input\\\\n                else\\\\n                    delete rules[i].icon\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '导入海阔':\\\\n            d.url = 'rule://' + base64Encode(JSON.stringify(data[i]));\\\\n            break\\\\n    }\\\\n    el.push(d)\\\\n})\\\\nsetResult(el)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面载入\\\",\\\"path\\\":\\\"frameLoad\\\",\\\"rule\\\":\\\"js:\\\\nconst QING_TITLE = getMyVar('myCollection')\\\\nvar myColl_el = []\\\\neval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\\\n\\\\nif (!isIndex) {\\\\n    if (pageTitle) setPageTitle(pageTitle)\\\\n    setLastChapterRule(oriRULE.last_chapter_rule)\\\\n    MY_PARAMS = MY_RULE.params\\\\n} else if (MY_PAGE == 1) {\\\\n    tabHeader.load(myColl_el)\\\\n    if (RULE.search_url) myColl_el.push({\\\\n        title: \\\\\\\"搜索\\\\\\\",\\\\n        desc: \\\\\\\"这是阅漫君的搜索哦~~\\\\\\\",\\\\n        url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n        extra: {\\\\n            rules: $.toString((QING_TITLE, title) => {\\\\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\\\\n                rules = [rules.find((v) => v.title == title)]\\\\n                return JSON.stringify(rules)\\\\n            }, QING_TITLE, RULE.title),\\\\n            defaultValue: getMyVar('searchKey', ''),\\\\n            onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n        },\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n    })\\\\n}\\\\n// 正文解析\\\\nvar {\\\\n    paramHandle,\\\\n    runPreRule,\\\\n    genExUrl,\\\\n    hijackLazyRule\\\\n} = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\nrunPreRule(oriRULE.preRule)\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    let { hijackEl } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\n    setResult = function(param0, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n        if (Array.isArray(param0.data)) param0 = param0.data\\\\n        Array.prototype.push.apply(myColl_el, param0.map(hijackEl))\\\\n        method_setResult.invoke(javaContext, myColl_el, param1, param2, param3)\\\\n    }\\\\n    setHomeResult = setResult\\\\n    setSearchResult = setResult\\\\n\\\\n    eval(MY_RULE.find_rule.slice(3))\\\\n} else {\\\\n    let { runCode } = $.require('hiker://page/funcTools?rule=' + QING_TITLE),\\\\n        [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\\\\\s\\\\\\\\S]*?)(?:==>([\\\\\\\\s\\\\\\\\S]*))?$/)\\\\n    findRule = findRule.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) { return '' }\\\\n            }),\\\\n            res = {\\\\n                title: title, url: url,\\\\n                desc: desc, img: img,\\\\n                col_type: MY_RULE.col_type\\\\n            }\\\\n        if (res.url) {\\\\n            if (res.url.includes('@lazyRule=')) {\\\\n                let reIndex = res.url.indexOf('.js:')\\\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + res.url.slice(reIndex + 4)\\\\n            } else  if (detailFindRule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: base64Encode(JSON.stringify(Object.assign(genMyRule(), { detail_find_rule: detailFindRule }))),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: base64Encode(JSON.stringify(genMyRule())),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            }\\\\n        }\\\\n        myColl_el.push(res)\\\\n    })\\\\n    setResult(myColl_el)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据载入\\\",\\\"path\\\":\\\"dataLoad\\\",\\\"rule\\\":\\\"let showAll = $.importParam,\\\\n    url = getMyVar('remoteUrl'),\\\\n    data = []\\\\nif (url.startsWith('hiker://') || url.startsWith('file://')) {\\\\n    // 如果为本地文件则不进行缓存\\\\n    try {\\\\n        let oriData = fetch(url)\\\\n        if (url.startsWith('hiker://page/'))\\\\n            oriData = JSON.parse(oriData).rule\\\\n        data = JSON.parse(oriData)\\\\n    } catch (e) {}\\\\n} else {\\\\n    // 获取远程数据，检查间隔默认一天\\\\n    let interval = parseInt(readFile('updateInterval') || '1'),\\\\n        oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\\\n        remoteData = []\\\\n    if (interval == 0) interval = -1\\\\n    try { remoteData = JSON.parse(fetchCache(url, 24 * interval, { timeout: 50000 })) } catch (e) {}\\\\n    if (!Array.isArray(remoteData)) remoteData = []\\\\n    if (remoteData.length < 3) {\\\\n        log('未获取到数据')\\\\n        if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData)\\\\n        data = JSON.parse(oldData || '[]')\\\\n    } else {\\\\n        log('已获取到数据')\\\\n        data = remoteData\\\\n    }\\\\n}\\\\ndata = data.filter((v) => v.title != getMyVar('myCollection') && !(v.author || '').includes('阅漫君生成器'))\\\\nif (readFile('disableCustom')) $.exports = data\\\\nelse { // 写入自定义数据\\\\n    let customData = JSON.parse(readFile('customData') || '[]'),\\\\n        rewriteData = []\\\\n    customData = customData.reduce((self, v) => {\\\\n        let index = data.findIndex((vv) => v.title == vv.title)\\\\n        if (index >= 0) {\\\\n            self.push(v)\\\\n            let rule = data.splice(index, 1)[0]\\\\n            if (showAll || v.visible)\\\\n                rewriteData.push(Object.assign(rule, v))\\\\n        }\\\\n        return self\\\\n    }, [])\\\\n    data.forEach((v) => customData.push({ title: v.title, visible: true }))\\\\n    saveFile('customData', JSON.stringify(customData))\\\\n    $.exports = rewriteData.concat(data)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"链接处理*\\\",\\\"path\\\":\\\"urlParse\\\",\\\"rule\\\":\\\"// 首页链接替换分类\\\\nfunction indexUrl(param) {\\\\n    function runCode(rule) {\\\\n        try {\\\\n            let [input, code] = rule.split('.js:')\\\\n            return code ? eval(code) : rule\\\\n        } catch (e) { return rule }\\\\n    }\\\\n    let { RULE, pageNum, QING_TITLE } = JSON.parse(param.split('###')[1])\\\\n    RULE = JSON.parse(base64Decode(RULE))\\\\n    pageNum = parseInt(pageNum)\\\\n    let url = RULE.url\\\\n\\\\n    eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\\\n    url = url.replace(/fypage(?:@(-?\\\\\\\\d+)@)?(?:\\\\\\\\*(\\\\\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\\\n    url = /^([\\\\\\\\s\\\\\\\\S]*?)(?:\\\\\\\\[firstPage=([\\\\\\\\s\\\\\\\\S]*?)\\\\\\\\])?(?:(\\\\\\\\.js:[\\\\\\\\s\\\\\\\\S]*?))?$/.exec(url)\\\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\\\n    return runCode(url[1])\\\\n}\\\\nfunction paramHandle(urlParam, ua, urlTmp) {\\\\n    let charset, paramTmp\\\\n    try { // 链接的编码、UA和Referer应该是首先继承首页链接\\\\n        [, , charset, paramTmp] = urlTmp.split(';')\\\\n        paramTmp = paramTmp.match(/^{(.*)}$/)[1].split('&&')\\\\n    } catch (e) { paramTmp = [] }\\\\n    let UserAgent = paramTmp.find((v) => v.startsWith('User-Agent@')),\\\\n        Referer = paramTmp.find((v) => v.startsWith('Referer@'))\\\\n    urlParam[0] = urlParam[0] || 'GET'\\\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\\\n    try {\\\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\\\n    } catch (e) { urlParam[2] = [] }\\\\n    // 添加全局UA和上级Referer\\\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\\\n        if (UserAgent) urlParam[2].push(UserAgent)\\\\n        else if (ua == 'pc')\\\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n        else if (ua == 'mobile')\\\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n    }\\\\n    if (Referer && !urlParam[2].some((v) => v.startsWith('Referer@')))\\\\n        urlParam[2].push(Referer)\\\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\\\n    return urlParam.join(';')\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级[一]*\\\",\\\"path\\\":\\\"ejtool\\\",\\\"rule\\\":\\\"function cover(标题, 作者, 分类, 状态, 章节, 更新, 简介,封面图片,true_url, hasLine) {\\\\r\\\\nvar 标题, 作者, 分类, 状态, 章节, 更新, 简介,封面图片,true_url, hasLine;\\\\r\\\\n\\\\ttry {\\\\r\\\\n\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\ttitle: '‘‘’’<small><font color=\\\\\\\"#FA7298\\\\\\\">'+作者.slice(0,15)+\\\\\\\"&nbsp;\\\\\\\"+状态+'</font></small>'+'‘‘’’<small><font color=\\\\\\\"#B15BFF\\\\\\\">'+\\\\\\\"\\\\\\\\n\\\\\\\"+分类+'</font></small>'+'‘‘’’<small><font color=\\\\\\\"#FF359A\\\\\\\">'+\\\\\\\"\\\\\\\\n\\\\\\\"+章节+\\\\\\\"&nbsp;\\\\\\\"+更新+'</font></small>',\\\\r\\\\n\\\\t\\\\t\\\\tdesc:'‘‘’’<small>' +简介+ '</small>',\\\\r\\\\n\\\\t\\\\t\\\\tpic_url:  封面图片,\\\\r\\\\n\\\\t\\\\t\\\\turl: true_url,\\\\r\\\\n\\\\t\\\\t\\\\tcol_type: 'movie_1_vertical_pic_blur'\\\\r\\\\n\\\\t\\\\t});\\\\n\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\tcol_type: 'line_blank',\\\\r\\\\n\\\\t\\\\t});\\\\n\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\tcol_type: 'line',\\\\r\\\\n\\\\t\\\\t});\\\\r\\\\n\\\\t\\\\tif (hasLine) {\\\\r\\\\n\\\\t\\\\t\\\\titem.extra = {\\\\r\\\\n\\\\t\\\\t\\\\t\\\\tlineVisible: false\\\\r\\\\n\\\\t\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\td.push(item);\\\\r\\\\n\\\\t} catch (e) {}\\\\r\\\\n}\\\\r\\\\nfunction chapter(title,pic_url,chapterList, chapterTitle, chapterUrl, defaultOrder, hasLine,downloadlazy) {\\\\r\\\\n\\\\tvar list = chapterList;\\\\r\\\\n\\\\tvar original = [{\\\\r\\\\n\\\\t\\\\turl: MY_URL,\\\\r\\\\n\\\\t\\\\torder: defaultOrder\\\\r\\\\n\\\\t}];\\\\r\\\\n\\\\t!fileExist('hiker://files/rules/comic/comicLogFile.js') ? (writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(original))) : 0;\\\\r\\\\n\\\\tvar log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));\\\\r\\\\n\\\\tfor (var i in log) {\\\\r\\\\n\\\\t\\\\tif (log[i].url == MY_URL) {\\\\r\\\\n\\\\t\\\\t\\\\tvar now = i;\\\\r\\\\n\\\\t\\\\t\\\\tvar order = log[i].order;\\\\r\\\\n\\\\t\\\\t\\\\tbreak;\\\\r\\\\n\\\\t\\\\t} else {\\\\r\\\\n\\\\t\\\\t\\\\tvar now = '';\\\\r\\\\n\\\\t\\\\t\\\\tvar order = defaultOrder;\\\\r\\\\n\\\\t\\\\t}\\\\r\\\\n\\\\t}\\\\r\\\\n\\\\tlet orderItem = {\\\\r\\\\n\\\\t\\\\ttitle: \\\\\\\"““””\\\\\\\" + '<strong><font color=\\\\\\\"#098AC1\\\\\\\">' + '章节排序⇅' + '</font></strong>',\\\\r\\\\n\\\\t\\\\turl: MY_URL + `@lazyRule=.js:var log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));var now='` + now + `';if(now!=''){var now=parseInt(now);var order=log[now].order}else{var now=parseInt(log.length);var order=` + defaultOrder + `;log.push({url:input,order:order});}if(log[now].order){log[now].order=0;}else{log[now].order=1;};writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(log));refreshPage();'hiker://empty'`,\\\\r\\\\n\\\\t\\\\tcol_type: 'text_2'\\\\r\\\\n\\\\t}\\\\r\\\\n\\\\tif (hasLine) {\\\\r\\\\n\\\\t\\\\torderItem.title = \\\\\\\"““””\\\\\\\" + '<strong><font color=\\\\\\\"#098AC1\\\\\\\">' + '集数排序⇅' + '</font></strong>';\\\\r\\\\n\\\\t\\\\torderItem.col_type = \\\\\\\"text_2\\\\\\\"\\\\r\\\\n\\\\t}\\\\r\\\\n\\\\tlet chapterLists = list.map((item)=>({\\\\r\\\\n\\\\t\\\\ttitle: pdfh(item,\\\\\\\"a&&Text\\\\\\\"),\\\\r\\\\n\\\\t\\\\turl: pd(item,\\\\\\\"a&&href\\\\\\\"),\\\\r\\\\n\\\\t}));\\\\r\\\\nd.push({\\\\r\\\\n\\\\ttitle: '‘‘’’<strong><font color= \\\\\\\"#098AC1\\\\\\\">' + \\\\\\\"下载漫画\\\\\\\" + '</front></strong>',\\\\r\\\\n\\\\turl: \\\\\\\"hiker://page/download.view#noHistory##noRecordHistory##noRefresh#?rule=本地资源管理\\\\\\\",\\\\r\\\\n\\\\tcol_type: \\\\\\\"text_2\\\\\\\",\\\\r\\\\n\\\\textra: {\\\\r\\\\n\\\\t\\\\tchapterList: chapterLists,\\\\r\\\\n\\\\t\\\\tinfo:{\\\\r\\\\n\\\\t\\\\t\\\\tbookName: title,\\\\r\\\\n\\\\t\\\\t\\\\truleName: MY_RULE.title,\\\\r\\\\n\\\\t\\\\t\\\\tbookTopPic: pic_url,\\\\r\\\\n\\\\t\\\\t\\\\tparseCode: downloadlazy\\\\r\\\\n\\\\t\\\\t},\\\\r\\\\n\\\\t\\\\tdefaultView:\\\\\\\"1\\\\\\\"\\\\r\\\\n\\\\t}\\\\r\\\\n});\\\\r\\\\n\\\\td.push({\\\\r\\\\n\\\\t\\\\ttitle: '‘‘’’<strong><font color= \\\\\\\"#098AC1\\\\\\\">' + \\\\\\\"本地书架\\\\\\\" + '</front></strong>',\\\\r\\\\n\\\\t\\\\turl: \\\\\\\"hiker://page/Main.view?rule=本地资源管理\\\\\\\",\\\\r\\\\n\\\\t\\\\tcol_type: \\\\\\\"text_2\\\\\\\",\\\\r\\\\n\\\\t});  \\\\r\\\\n\\\\td.push(orderItem);\\\\r\\\\n\\\\td.push({col_type: 'line'});\\\\t\\\\r\\\\n\\\\tvar list = order ? list : list.reverse();\\\\n\\\\tif(!list||list==\\\\\\\"\\\\\\\"){\\\\r\\\\n\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\ttitle: '此漫画已下架!!',\\\\r\\\\n\\\\t\\\\t\\\\tcol_type: 'text_center_1',\\\\r\\\\n\\\\t\\\\t});\\\\r\\\\n\\\\t}\\\\r\\\\n\\\\tfor (var i in list) {\\\\r\\\\n\\\\t\\\\ttry {\\\\r\\\\n\\\\t\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\ttitle: pdfh(list[i], chapterTitle),\\\\r\\\\n\\\\t\\\\t\\\\t\\\\turl: pd(list[i], chapterUrl) + lazy,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\tcol_type: 'text_2',\\\\r\\\\n\\\\t\\\\t\\\\t});\\\\r\\\\n\\\\t\\\\t}catch (e) {}\\\\r\\\\n\\\\t}\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\nfunction line(lineList, lineTitleRule, varKey) {\\\\r\\\\n\\\\tlet list = lineList\\\\r\\\\n\\\\tvarKey = varKey == null ? (MY_RULE.url + '#line-index'): varKey;\\\\r\\\\n\\\\taddListener('onClose', $.toString((keyList) => {\\\\r\\\\n\\\\t\\\\tfor (let i in keyList) {clearVar(keyList[i])}\\\\r\\\\n\\\\t}, [varKey, MY_RULE.title + '#line-title']))\\\\r\\\\n\\\\tlet line0Title = '';\\\\r\\\\n\\\\ttry {\\\\r\\\\n\\\\t\\\\tline0Title = pdfh(list[0], lineTitleRule).replace(\\\\\\\"章节列表：\\\\\\\",\\\\\\\"\\\\\\\");\\\\r\\\\n\\\\t} catch (e) {}\\\\r\\\\n\\\\tlog(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')))\\\\r\\\\n\\\\tfor (let i in list) {\\\\r\\\\n\\\\t\\\\ttry {\\\\r\\\\n\\\\t\\\\t\\\\tlet lineTitle = pdfh(list[i], lineTitleRule).replace(\\\\\\\"章节列表：\\\\\\\",\\\\\\\"\\\\\\\");\\\\r\\\\n\\\\t\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\ttitle: getMyVar((MY_RULE.title + '#line-title'), line0Title) === lineTitle ? \\\\\\\"切换:‘‘\\\\\\\" + lineTitle+\\\\\\\"\\\\\\\":lineTitle+\\\\\\\"‘‘:切换\\\\\\\",\\\\r\\\\n\\\\t\\\\t\\\\t\\\\turl: $().lazyRule((varKey, lineIndex, lineTitle) => {\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\tputMyVar(varKey, lineIndex.toString());\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\tputMyVar((MY_RULE.title + '#line-title'), lineTitle);\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\tlog(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')));\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\trefreshPage();\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\treturn \\\\\\\"toast://已切换至\\\\\\\" + lineTitle;\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t}, varKey, i, lineTitle),\\\\r\\\\n\\\\t\\\\t\\\\t\\\\tcol_type: 'text_2',\\\\r\\\\n\\\\t\\\\t\\\\t});\\\\r\\\\n\\\\t\\\\t} catch (e) {}\\\\r\\\\n\\\\t}\\\\r\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级[二]*\\\",\\\"path\\\":\\\"comicFunctionFile.js\\\",\\\"rule\\\":\\\"function cover(coverTitle, coverTitle1, coverTitle2, coverTitle3, coverDesc, coverPic, coverUrl, hasLine) {\\\\n    try {\\\\n        const Color = \\\\\\\"#19B89D\\\\\\\";\\\\n        var des_desc = pdfh(html, coverDesc).replace('简　　介：', '').replace('漫画简介：', '');\\\\n        d.push({\\\\n            title: '‘‘’’<><font color=\\\\\\\"#FA7298\\\\\\\">' + pdfh(html, coverTitle) + '\\\\\\\\n' + '‘‘’’<><font color=\\\\\\\"#734338\\\\\\\">' + pdfh(html, coverTitle1) + '\\\\\\\\n',\\\\n            desc: '‘‘’’<><font color=\\\\\\\"#954A45\\\\\\\">' + pdfh(html, coverTitle2) + '\\\\\\\\n' + '‘‘’’<><font color=\\\\\\\"#954A45\\\\\\\">' + pdfh(html, coverTitle3),\\\\n            pic_url: pd(html, coverPic)||coverPic,\\\\n            url: 'hiker://search?s='+MY_PARAMS.ytitle+'&rule=阅漫君',\\\\n            col_type: 'movie_1_vertical_pic_blur'\\\\n        });\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        });\\\\n        //var jj = getMyVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"收起\\\\\\\");\\\\n        //var jjurl = 'hiker://empty@lazyRule=.js:getMyVar(\\\\\\\"jjs\\\\\\\") == \\\\\\\"收起\\\\\\\"?putMyVar(\\\\\\\"jjs\\\\\\\",\\\\\\\"展开\\\\\\\"):putMyVar(\\\\\\\"jjs\\\\\\\",\\\\\\\"收起\\\\\\\");\\\\\\\"hiker://empty\\\\\\\"';\\\\n        d.push({\\\\n            title: '简介 <small><small><span style=\\\\\\\"color:#19B89D\\\\\\\">展开></span></small></small>',\\\\n            img: \\\\\\\"https://lanmeiguojiang.com/tubiao/more/197.png\\\\\\\",\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((jjid, decid, des_desc) => {\\\\n                if (getMyVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"收起\\\\\\\") == \\\\\\\"收起\\\\\\\") {\\\\n                    putMyVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"展开\\\\\\\");\\\\n\\\\n                    updateItem({\\\\n                        extra: {\\\\n                            id: jjid\\\\n                        },\\\\n                        title: '简介 <small><small><span style=\\\\\\\"color:#19B89D\\\\\\\">收起></span></small></small>'\\\\n                    })\\\\n\\\\n                    updateItem({\\\\n                        extra: {\\\\n                            textSize: 14,\\\\n                            lineSpacing: 3,\\\\n                            id: decid\\\\n                        },\\\\n                        title: '<span style=\\\\\\\"color:#808080\\\\\\\">' + des_desc + '...</span>'\\\\n                    })\\\\n                    return \\\\\\\"hiker://empty\\\\\\\"\\\\n                } else {\\\\n                    putMyVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"收起\\\\\\\");\\\\n\\\\n                    updateItem({\\\\n                        extra: {\\\\n                            id: jjid\\\\n                        },\\\\n                        title: '简介 <small><small><span style=\\\\\\\"color:#19B89D\\\\\\\">展开></span></small></small>'\\\\n                    })\\\\n\\\\n                    updateItem({\\\\n                        extra: {\\\\n                            textSize: 14,\\\\n                            lineSpacing: 3,\\\\n                            id: decid\\\\n                        },\\\\n                        title: '<span style=\\\\\\\"color:#808080\\\\\\\">' + des_desc.substr(0, 30) + '...</span>'\\\\n                    })\\\\n                    return \\\\\\\"hiker://empty\\\\\\\"\\\\n                }\\\\n\\\\n            }, MY_RULE + \\\\\\\"_jjid\\\\\\\", MY_RULE + \\\\\\\"_decid\\\\\\\", des_desc),\\\\n            col_type: \\\\\\\"avatar\\\\\\\",\\\\n            extra: {\\\\n                id: MY_RULE + \\\\\\\"_jjid\\\\\\\"\\\\n            }\\\\n        });\\\\n\\\\n        d.push({\\\\n            title: '<span style=\\\\\\\"color:#808080\\\\\\\">' + des_desc.substr(0, 30) + '...</span>',\\\\n            col_type: \\\\\\\"rich_text\\\\\\\",\\\\n            extra: {\\\\n                textSize: 14,\\\\n                lineSpacing: 3,\\\\n                id: MY_RULE + \\\\\\\"_decid\\\\\\\"\\\\n            }\\\\n        });\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        })\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        })\\\\n    } catch (e) {}\\\\n}\\\\n\\\\nfunction down(Title, chapterPic, list, chapterTitle, chapterLine, downloadlazy) {\\\\n    try {\\\\n        let doList = list.map((item) => ({\\\\n            title: pdfh(item, chapterTitle),\\\\n            url: pd(item, chapterLine),\\\\n        }));\\\\n        d.push({\\\\n            title: '““””<b><span style=\\\\\\\"color: #1aad19\\\\\\\">下载漫画🔹</span></b>',\\\\n            url: \\\\\\\"hiker://page/download.view#noRecordHistory##noRefresh#?rule=本地资源管理\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            extra: {\\\\n                chapterList: doList,\\\\n                info: {\\\\n                    bookName: pdfh(html, Title),\\\\n                    ruleName: MY_RULE.title,\\\\n                    bookTopPic: pd(html, chapterPic),\\\\n                    parseCode: downloadlazy\\\\n                },\\\\n                defaultView: \\\\\\\"1\\\\\\\"\\\\n            }\\\\n        });\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        });\\\\n    } catch (e) {}\\\\n}\\\\n\\\\nfunction chapter(chapterList, chapterTitle, chapterUrl, defaultOrder, hasLine) {\\\\n    var list = chapterList;\\\\n    var original = [{\\\\n        url: MY_URL,\\\\n        order: defaultOrder\\\\n    }];\\\\n    !fileExist('hiker://files/rules/comic/comicLogFile.js') ? (writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(original))) : 0;\\\\n    var log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));\\\\n    for (var i in log) {\\\\n        if (log[i].url == MY_URL) {\\\\n            var now = i;\\\\n            var order = log[i].order;\\\\n            break;\\\\n        } else {\\\\n            var now = '';\\\\n            var order = defaultOrder;\\\\n        }\\\\n    }\\\\n    let orderItem = {\\\\n        title: \\\\\\\"““””\\\\\\\" + '<font color=\\\\\\\"#f37335\\\\\\\">' + '章节排序⇅' + '</font>',\\\\n        url: MY_URL + `@lazyRule=.js:var log = JSON.parse(fetch('hiker://files/rules/comic/comicLogFile.js'));var now='` + now + `';if(now!=''){var now=parseInt(now);var order=log[now].order}else{var now=parseInt(log.length);var order=` + defaultOrder + `;log.push({url:input,order:order});}if(log[now].order){log[now].order=0;}else{log[now].order=1;};writeFile('hiker://files/rules/comic/comicLogFile.js', JSON.stringify(log));refreshPage();'hiker://empty'`,\\\\n        col_type: 'text_center_1'\\\\n    }\\\\n    if (hasLine) {\\\\n        orderItem.title = \\\\\\\"““””\\\\\\\" + '<font color=\\\\\\\"#f37335\\\\\\\">' + '集数排序⇅' + '</font>';\\\\n        orderItem.col_type = \\\\\\\"text_center_1\\\\\\\"\\\\n    }\\\\n    d.push(orderItem);\\\\n    d.push({\\\\n        col_type: 'line'\\\\n    });\\\\n\\\\n    var list = order ? list : list.reverse();\\\\n    for (let i in list) {\\\\n        try {\\\\n            d.push({\\\\n                title: '““””<small>' + pdfh(list[i], chapterTitle) + '</small>',\\\\n                url: pd(list[i], chapterUrl) + lazy,\\\\n                col_type: 'text_2',\\\\n            });\\\\n        } catch (e) {}\\\\n    }\\\\n}\\\\n\\\\nfunction line(lineList, lineTitleRule, varKey) {\\\\n    let list = lineList\\\\n    varKey = varKey == null ? (MY_RULE.url + '#line-index') : varKey;\\\\n    addListener('onClose', $.toString((keyList) => {\\\\n        for (let i in keyList) {\\\\n            clearVar(keyList[i])\\\\n        }\\\\n\\\\n    }, [varKey, MY_RULE.title + '#line-title']))\\\\n    let line0Title = ''\\\\n    try {\\\\n        line0Title = pdfh(list[0], lineTitleRule);\\\\n    } catch (e) {}\\\\n    log(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')))\\\\n    for (let i in list) {\\\\n        try {\\\\n            let lineTitle = pdfh(list[i], lineTitleRule);\\\\n            d.push({\\\\n                title: getMyVar((MY_RULE.title + '#line-title'), line0Title) === lineTitle ? \\\\\\\"切换:‘‘\\\\\\\" + lineTitle + \\\\\\\"\\\\\\\" : lineTitle + \\\\\\\"‘‘:切换\\\\\\\",\\\\n                url: $().lazyRule((varKey, lineIndex, lineTitle) => {\\\\n                    putMyVar(varKey, lineIndex.toString())\\\\n                    // log(MY_RULE.url)\\\\n                    putMyVar((MY_RULE.title + '#line-title'), lineTitle)\\\\n                    log(MY_RULE.title + getMyVar((MY_RULE.title + '#line-title')))\\\\n                    refreshPage()\\\\n                    return \\\\\\\"toast://已切换至\\\\\\\" + lineTitle\\\\n                }, varKey, i, lineTitle),\\\\n                col_type: 'flex_button'\\\\n            });\\\\n        } catch (e) {}\\\\n    }\\\\n    d.push({\\\\n                col_type: 'line'\\\\n            });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"动态[二]*\\\",\\\"path\\\":\\\"dtfl\\\",\\\"rule\\\":\\\"const empty = \\\\\\\"hiker://empty\\\\\\\"\\\\n\\\\nif (typeof(拼接分类) != 'undefined' && 拼接分类 != '') {\\\\n    var categories = pdfa(html, 大类定位).concat(pdfa(html, 拼接分类))\\\\n} else {\\\\n    var categories = pdfa(html, 大类定位)\\\\n}\\\\n\\\\nlet init_cate = []\\\\n\\\\nfor (let i = 0; i < 20; i++) {\\\\n    init_cate.push(\\\\\\\"0\\\\\\\")\\\\n}\\\\n\\\\nconst fold = getMyVar(MY_RULE.group, \\\\\\\"0\\\\\\\")\\\\nconst cate_temp_json = getMyVar(MY_RULE.title, JSON.stringify(init_cate))\\\\nconst cate_temp = JSON.parse(cate_temp_json)\\\\n\\\\nif (parseInt(page) === 1) {\\\\n    d.push({\\\\n        title: fold === '1' ? '““””<b>' + '∨'.fontcolor(\\\\\\\"#FF0000\\\\\\\") + '</b>' : '““””<b>' + '∧'.fontcolor(\\\\\\\"#1aad19\\\\\\\") + '</b>',\\\\n        url: $().lazyRule((fold) => {\\\\n            putMyVar(MY_RULE.group, fold === '1' ? '0' : '1');\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, fold),\\\\n        col_type: 'scroll_button',\\\\n    })\\\\n    categories.forEach((category, index) => {\\\\n        let sub_categories = pdfa(category, 小类定位);\\\\n        if (index === 0) {\\\\n            sub_categories.forEach((item, key) => {\\\\n                let title = pdfh(item, 分类标题)\\\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\\\n                    title = title.replace(new RegExp(排除, \\\\\\\"g\\\\\\\"), \\\\\\\"\\\\\\\")\\\\n                }\\\\n                d.push({\\\\n                    title: key.toString() === cate_temp[index] ? \\\\\\\"““””\\\\\\\" + title.fontcolor(分类颜色) : title,\\\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\\\n                        let new_cate = []\\\\n                        params.cate_temp.forEach((cate, index) => {\\\\n                            new_cate.push(index === 0 ? params.key.toString() : \\\\\\\"0\\\\\\\")\\\\n                        })\\\\n                        putMyVar(MY_RULE.title, JSON.stringify(new_cate))\\\\n                        putMyVar(MY_RULE.url, input)\\\\n                        refreshPage(true)\\\\n                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                    }, {\\\\n                        cate_temp: cate_temp,\\\\n                        key: key,\\\\n                        page: page,\\\\n                    }),\\\\n                    col_type: 'scroll_button',\\\\n                })\\\\n            })\\\\n            d.push({\\\\n                col_type: \\\\\\\"blank_block\\\\\\\"\\\\n            });\\\\n        } else if (fold === '1') {\\\\n            sub_categories.forEach((item, key) => {\\\\n                let title = pdfh(item, 分类标题)\\\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\\\n                    title = title.replace(new RegExp(排除, \\\\\\\"g\\\\\\\"), \\\\\\\"\\\\\\\")\\\\n                }\\\\n                d.push({\\\\n                    title: key.toString() === cate_temp[index] ? \\\\\\\"““””\\\\\\\" + title.fontcolor(分类颜色) : title,\\\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\\\n                        params.cate_temp[params.index] = params.key.toString()\\\\n\\\\n                        putMyVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\\\n                        putMyVar(MY_RULE.url, input)\\\\n                        refreshPage(true)\\\\n                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                    }, {\\\\n                        cate_temp: cate_temp,\\\\n                        index: index,\\\\n                        key: key,\\\\n                        page: page,\\\\n                    }),\\\\n                    col_type: 'scroll_button',\\\\n                })\\\\n            })\\\\n            d.push({\\\\n                col_type: \\\\\\\"blank_block\\\\\\\"\\\\n            });\\\\n        }\\\\n    })\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"动态[一]*\\\",\\\"path\\\":\\\"categories-header\\\",\\\"rule\\\":\\\"/**\\\\n * 本地网页插件链接 hiker://files/rules/js/categories-header.js\\\\n * 子页面链接 hiker://page/categories-header\\\\n * 道长仓库链接 http://hiker.nokia.press/hikerule/rulelist.json?id=2705\\\\n * 码云 Gitee 链接 https://gitee.com/reborn0/HikerRules/raw/master/plugins/categories-header.js\\\\n */\\\\n/**\\\\n * Object.assign 用法参考链接\\\\n *\\\\n * 1.https://www.daimajiaoliu.com/daima/47139a9e7100407\\\\n * 2.https://segmentfault.com/a/1190000011778875\\\\n * 3.https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\\\\n */\\\\n// 利用 Symbol 实现私有变量和私有方法，外界不可访问（参考链接2）\\\\nconst symbolMap = {\\\\n    // checkParams: Symbol('checkParams'),\\\\n    mLayout: Symbol('mLayout'),\\\\n    true_url: Symbol('true_url'),\\\\n    mPage: Symbol('mPage'),\\\\n    src: Symbol('src'),\\\\n    ruleObjList: Symbol('ruleObjList'),\\\\n    mFold: Symbol('mFold'),\\\\n    mFoldInnerEnable: Symbol('mFoldInnerEnable'),\\\\n    mFoldIndex: Symbol('mFoldIndex'),\\\\n    mFoldLayout: Symbol('mFoldLayout'),\\\\n    mColor: Symbol('mColor'),\\\\n    mTag: Symbol('mTag'),\\\\n}\\\\n\\\\nfunction CategoriesHeader(color) {\\\\n    // 'use strict';\\\\n    // ...\\\\n    // this[symbolMap.listRule] = []\\\\n    // this[symbolMap.subListRule] = []\\\\n    this[symbolMap.mColor] = color || \\\\\\\"#FA7298\\\\\\\";\\\\n    this[symbolMap.ruleObjList] = []\\\\n    this.VARMAP = {\\\\n        CATEGORY: \\\\\\\"header.category\\\\\\\",\\\\n        URL: \\\\\\\"header.url\\\\\\\",\\\\n        FOLD: \\\\\\\"header.fold\\\\\\\",\\\\n    }\\\\n    this[symbolMap.mFoldLayout] = {\\\\n        injectIndex: 1\\\\n    }\\\\n    this[symbolMap.mFoldIndex] = 1\\\\n}\\\\n\\\\nObject.assign(CategoriesHeader.prototype, {\\\\n    // Override 构造方法，相当于 function.prototype.constructor = (...) => {...}，new function() 的时候会自动执行\\\\n    constructor: CategoriesHeader,\\\\n    // 定义私有方法\\\\n    VERSION: 202111301900,\\\\n    checkParams() {\\\\n        if (!this[symbolMap.mLayout]) {\\\\n            throw new Error(\\\\\\\"请调用 layout(d) 传入当前界面\\\\\\\")\\\\n        }\\\\n        if (!this[symbolMap.true_url]) {\\\\n            throw new Error(\\\\\\\"请调用 trueUrl(url) 传入当前分类的链接\\\\\\\")\\\\n        }\\\\n        if (!this[symbolMap.mPage]) {\\\\n            throw new Error(\\\\\\\"请调用 page(mPage) 传入当前页数\\\\\\\")\\\\n        }\\\\n        if (this[symbolMap.ruleObjList].length < 1) {\\\\n            throw new Error(\\\\\\\"请调用相关方法传入定位规则\\\\\\\")\\\\n        }\\\\n        if (!this[symbolMap.mFold]) {\\\\n            this[symbolMap.mFold] = '0'\\\\n        }\\\\n    },\\\\n    layout(mLayout) {\\\\n        this[symbolMap.mLayout] = mLayout\\\\n        return this\\\\n    },\\\\n    trueUrl(url) {\\\\n        this[symbolMap.true_url] = url\\\\n        return this\\\\n    },\\\\n    page(mPage) {\\\\n        if (typeof (mPage) === 'string') {\\\\n            mPage = parseInt(mPage)\\\\n        }\\\\n        this[symbolMap.mPage] = mPage\\\\n        return this\\\\n    },\\\\n    html(mSrc) {\\\\n        this[symbolMap.src] = mSrc\\\\n        return this\\\\n    },\\\\n    list(rule) {\\\\n        if (this[symbolMap.ruleObjList].length > 0) {\\\\n            throw new Error(\\\\\\\"list(rule) add(ruleObj) 只能二选一！\\\\\\\")\\\\n        }\\\\n        this[symbolMap.ruleObjList] = [{}]\\\\n        this[symbolMap.ruleObjList][0].listRule = rule\\\\n        this[symbolMap.ruleObjList][0]['一级分类'] = rule\\\\n        return this\\\\n    },\\\\n    subList(rule) {\\\\n        if (this[symbolMap.ruleObjList].length > 1) {\\\\n            throw new Error(\\\\\\\"subList(rule) add(ruleObj) 只能二选一！\\\\\\\")\\\\n        }\\\\n        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {\\\\n            throw new Error(\\\\\\\"请先调用 list(rule) 或 一级分类(rule) 定位一级分类\\\\\\\")\\\\n        }\\\\n        this[symbolMap.ruleObjList][0].subListRule = rule\\\\n        this[symbolMap.ruleObjList][0]['子分类'] = rule\\\\n        return this\\\\n    },\\\\n    title(rule) {\\\\n        if (this[symbolMap.ruleObjList].length > 1) {\\\\n            throw new Error(\\\\\\\"title(rule) add(ruleObj) 只能二选一！\\\\\\\")\\\\n        }\\\\n        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {\\\\n            throw new Error(\\\\\\\"请先调用 list(rule) 或 一级分类(rule) 定位一级分类\\\\\\\")\\\\n        }\\\\n        this[symbolMap.ruleObjList][0].titleRule = rule\\\\n        this[symbolMap.ruleObjList][0]['分类标题'] = this[symbolMap.ruleObjList][0].titleRule\\\\n        return this\\\\n    },\\\\n    url(rule) {\\\\n        if (this[symbolMap.ruleObjList].length > 1) {\\\\n            throw new Error(\\\\\\\"url(rule) add(ruleObj) 只能二选一！\\\\\\\")\\\\n        }\\\\n        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {\\\\n            throw new Error(\\\\\\\"请先调用 list(rule) 或 一级分类(rule) 定位一级分类\\\\\\\")\\\\n        }\\\\n        this[symbolMap.ruleObjList][0].urlRule = rule\\\\n        this[symbolMap.ruleObjList][0]['分类链接'] = this[symbolMap.ruleObjList][0].urlRule\\\\n        return this\\\\n    },\\\\n    /**\\\\n     * 是否开启折叠功能\\\\n     *\\\\n     * @param enabled true 表示开启，false 表示禁用\\\\n     * @returns {CategoriesHeader}\\\\n     */\\\\n    foldInner(enabled) {\\\\n        if (!(typeof (enabled) === 'boolean')) {\\\\n            throw new Error(\\\\\\\"请传入 true 或 false 表示开启或关闭折叠功能！\\\\\\\")\\\\n        }\\\\n        this[symbolMap.mFoldInnerEnable] = enabled\\\\n        return this\\\\n    },\\\\n    /**\\\\n     * 从第 index 行开始折叠\\\\n     *\\\\n     * @param index 开始折叠的行数\\\\n     * @returns {CategoriesHeader}\\\\n     */\\\\n    foldIndex(index) {\\\\n        if (!(typeof (index) === 'number')) {\\\\n            throw new Error(\\\\\\\"开始折叠行请传入数字！\\\\\\\")\\\\n        }\\\\n        if (index < 1) {\\\\n            throw new Error(\\\\\\\"开始折叠行请传入大于 0 的整数！\\\\\\\")\\\\n        }\\\\n        this[symbolMap.mFoldIndex] = index || 1;\\\\n        return this\\\\n    },\\\\n    /**\\\\n     * 折叠按钮的界面\\\\n     *\\\\n     * @param layout 与 d.push 结构一致，\\\\n     *        例：{ title:\\\\\\\"标题1\\\\\\\", url:\\\\\\\"xxx\\\\\\\", col_type:\\\\\\\"scroll_button\\\\\\\" };\\\\n     *        参数采用可选覆盖模式，不写的参数则使用默认;\\\\n     *        比如传入 { col_type:\\\\\\\"text_1\\\\\\\" }，那最终结果就是 { title:\\\\\\\"标题1\\\\\\\", url:\\\\\\\"xxx\\\\\\\", col_type:\\\\\\\"text_1\\\\\\\" }\\\\n     * @returns {CategoriesHeader}\\\\n     */\\\\n    foldLayout(layout) {\\\\n        if (typeof layout === 'object') {\\\\n            let keys = Object.keys(layout)\\\\n            let injectIndex = layout.injectIndex || layout['折叠按钮插入行']\\\\n            if (layout.title || layout.url || layout.col_type || injectIndex) {\\\\n                for (let i = 0; i < keys.length; i++) {\\\\n                    const key = keys[i]\\\\n                    this[symbolMap.mFoldLayout][key] = layout[key];\\\\n                }\\\\n            } else {\\\\n                throw new Error(\\\\\\\"请传入正确的折叠界面元素！\\\\\\\")\\\\n            }\\\\n            // injectIndex 折叠按钮插入第 injectIndex 行\\\\n            if (injectIndex) {\\\\n                if (!(typeof (injectIndex) === 'number')) {\\\\n                    throw new Error(\\\\\\\"折叠按钮插入行请传入数字！\\\\\\\")\\\\n                }\\\\n                if (injectIndex < 1) {\\\\n                    throw new Error(\\\\\\\"折叠按钮插入行请传入大于 0 的整数！\\\\\\\")\\\\n                }\\\\n                if (injectIndex > this[symbolMap.mFoldIndex]) {\\\\n                    throw new Error(\\\\\\\"折叠按钮插入行不得大于显示折叠行数！请调用 .foldIndex(index) 或 .第几行开始折叠(index) 传入正确的显示折叠行数\\\\\\\")\\\\n                }\\\\n                this[symbolMap.mFoldLayout].injectIndex = injectIndex || 1;\\\\n            }\\\\n        } else {\\\\n            throw new Error(\\\\\\\"请传入正确的折叠界面元素！\\\\\\\")\\\\n        }\\\\n        return this;\\\\n    },\\\\n    // 当前是否折叠\\\\n    fold(isFold) {\\\\n        if (typeof (isFold) === 'string') {\\\\n            isFold = isFold === '1'\\\\n        }\\\\n        if (isFold) {\\\\n            this[symbolMap.mFold] = '1';\\\\n        } else {\\\\n            this[symbolMap.mFold] = '0';\\\\n        }\\\\n        return this\\\\n    },\\\\n    color(mColor) {\\\\n        this[symbolMap.mColor] = mColor\\\\n        return this\\\\n    },\\\\n    tag(mTag) {\\\\n        this[symbolMap.mTag] = mTag\\\\n        return this\\\\n    },\\\\n    add(ruleObj) {\\\\n        // log($.stringify(ruleObj))\\\\n        if (ruleObj.constructor === Array) {\\\\n            this[symbolMap.ruleObjList] = this[symbolMap.ruleObjList].concat(ruleObj)\\\\n        } else {\\\\n            this[symbolMap.ruleObjList].push(ruleObj)\\\\n        }\\\\n        return this;\\\\n    },\\\\n    evalJSRule(item, jsRule) {\\\\n        let rule = jsRule.replace(\\\\\\\"@js:\\\\\\\", \\\\\\\"\\\\\\\")\\\\n        rule = rule.trim()\\\\n        // log($.stringify(rule))\\\\n        let input = item\\\\n        if (rule.startsWith(\\\\\\\"(\\\\\\\")) {\\\\n            eval('result = ' + rule)\\\\n        } else {\\\\n            /**\\\\n             * 还原成 $.toString(...) 的最终结果，达到最终处理方式跟上面的 if 一致的目的\\\\n             */\\\\n            eval('result = ' + '(() => {' + rule + '})()')\\\\n        }\\\\n        return (result || '')\\\\n    },\\\\n    getTitle(src, category) {\\\\n        let title = ''\\\\n        let titleRule = category.titleRule || 'a&&Text'\\\\n        if (titleRule.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n            title = this.evalJSRule(src, titleRule)\\\\n        } else {\\\\n            title = parseDomForHtml(src, titleRule)\\\\n        }\\\\n        return title || \\\\\\\"\\\\\\\";\\\\n    },\\\\n    getUrl(src, category) {\\\\n        let url = ''\\\\n        let urlRule = category.urlRule || 'a&&href'\\\\n        if (typeof urlRule === 'object') {\\\\n            let mUrlRule = urlRule.rule || urlRule['解析规则'] || 'a&&href';\\\\n            if (mUrlRule.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n                url = this.evalJSRule(src, mUrlRule);\\\\n            } else {\\\\n                let parse = parseDom;\\\\n                if (urlRule.parseOption) {\\\\n                    switch (urlRule.parseOption) {\\\\n                        case \\\\\\\"parseDom\\\\\\\":\\\\n                        case \\\\\\\"pd\\\\\\\":\\\\n                            parse = parseDom;\\\\n                            break;\\\\n                        case \\\\\\\"parseDomForHtml\\\\\\\":\\\\n                        case \\\\\\\"pdfh\\\\\\\":\\\\n                            parse = parseDomForHtml;\\\\n                            break;\\\\n                        default:\\\\n                            parse = parseDom;\\\\n                    }\\\\n                } else if (urlRule[\\\\\\\"解析方法\\\\\\\"]) {\\\\n                    switch (urlRule[\\\\\\\"解析方法\\\\\\\"]) {\\\\n                        case \\\\\\\"parseDom\\\\\\\":\\\\n                        case \\\\\\\"pd\\\\\\\":\\\\n                            parse = parseDom;\\\\n                            break;\\\\n                        case \\\\\\\"parseDomForHtml\\\\\\\":\\\\n                        case \\\\\\\"pdfh\\\\\\\":\\\\n                            parse = parseDomForHtml;\\\\n                            break;\\\\n                        default:\\\\n                            parse = parseDom;\\\\n                    }\\\\n                }\\\\n                url = parse(src, mUrlRule);\\\\n            }\\\\n            if (urlRule.dealUrl) {\\\\n                url = urlRule.dealUrl(url)\\\\n            } else if (urlRule['二次处理']) {\\\\n                url = urlRule['二次处理'](url)\\\\n            }\\\\n        } else {\\\\n            if (urlRule.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n                url = this.evalJSRule(src, urlRule);\\\\n            } else {\\\\n                url = parseDom(src, urlRule);\\\\n            }\\\\n        }\\\\n        return url || \\\\\\\"\\\\\\\";\\\\n    },\\\\n    build() {\\\\n        // 检测是否传入需要的参数\\\\n        this.checkParams()\\\\n        // 每一个分类的唯一标识\\\\n        let mTag = this[symbolMap.mTag] || \\\\\\\"\\\\\\\"\\\\n        //翻页 需要根据实际替换\\\\n        const html = this[symbolMap.src] || request(this[symbolMap.true_url])\\\\n        const empty = \\\\\\\"hiker://empty\\\\\\\"\\\\n        //获取列表\\\\n        const categories = []\\\\n        this[symbolMap.ruleObjList].map(ruleObj => {\\\\n            let list = []\\\\n            let listRule = ruleObj.listRule || ruleObj[\\\\\\\"一级分类\\\\\\\"]\\\\n            if (listRule.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n                // log($.stringify(listRule))\\\\n                list = this.evalJSRule(html, listRule)\\\\n            } else {\\\\n                list = parseDomForArray(html, listRule)\\\\n            }\\\\n            // log(list)\\\\n            list.map(category => {\\\\n                categories.push({\\\\n                    list: category,\\\\n                    subListRule: ruleObj.subListRule || ruleObj[\\\\\\\"子分类\\\\\\\"],\\\\n                    titleRule: ruleObj.titleRule || ruleObj[\\\\\\\"分类标题\\\\\\\"],\\\\n                    urlRule: ruleObj.urlRule || ruleObj[\\\\\\\"分类链接\\\\\\\"],\\\\n                });\\\\n            })\\\\n        })\\\\n\\\\n        // log($.stringify(categories))\\\\n\\\\n        let init_cate = []\\\\n        for (let i = 0; i < 20; i++) {\\\\n            init_cate.push(\\\\\\\"0\\\\\\\")\\\\n        }\\\\n\\\\n        const cate_temp_json = getMyVar(mTag + this.VARMAP.CATEGORY, JSON.stringify(init_cate))\\\\n        const cate_temp = JSON.parse(cate_temp_json)\\\\n\\\\n        if (this[symbolMap.mPage] === 1) {\\\\n\\\\n            categories.forEach((category, index) => {\\\\n\\\\n                // 折叠 UI\\\\n                if (this[symbolMap.mFoldInnerEnable] && this[symbolMap.mFoldLayout].injectIndex === (index+1)) {\\\\n                    let foldLayout = {\\\\n                        title: this[symbolMap.mFoldLayout].title || (this[symbolMap.mFold] === '1' ? '““””<b><span style=\\\\\\\"color: #FF0000\\\\\\\">∨</span></b>' : '““””<b><span style=\\\\\\\"color: #1aad19\\\\\\\">∧</span></b>'),\\\\n                        url: this[symbolMap.mFoldLayout].url || $(\\\\\\\"hiker://empty#noHistory#\\\\\\\").lazyRule((params) => {\\\\n                            putMyVar(params.mTag + params.VARMAP.FOLD, getMyVar(params.mTag + params.VARMAP.FOLD, params.isFold) === '1' ? '0' : '1')\\\\n                            refreshPage(false);\\\\n                            return \\\\\\\"hiker://empty\\\\\\\"\\\\n                        }, {\\\\n                            mTag: mTag,\\\\n                            isFold: this[symbolMap.mFold],\\\\n                            VARMAP: this.VARMAP\\\\n                        }),\\\\n                        col_type: this[symbolMap.mFoldLayout].col_type || \\\\\\\"scroll_button\\\\\\\",\\\\n                    }\\\\n                    this[symbolMap.mLayout].push(foldLayout)\\\\n                }\\\\n\\\\n                //具体列表下的分类\\\\n                let sub_categories = [];\\\\n                if (category.subListRule.startsWith(\\\\\\\"@js:\\\\\\\")) {\\\\n                    sub_categories = this.evalJSRule(category.list, category.subListRule)\\\\n                } else {\\\\n                    sub_categories = parseDomForArray(category.list, category.subListRule);\\\\n                }\\\\n                if (index < (this[symbolMap.mFoldIndex] || 1)) {\\\\n                    sub_categories.forEach((item, key) => {\\\\n                        let title = this.getTitle(item, category)\\\\n                        let url = this.getUrl(item, category)\\\\n\\\\n                        this[symbolMap.mLayout].push({\\\\n                            title: key.toString() === cate_temp[index] ? '““””<b><font color=' + this[symbolMap.mColor] + '>' + title + ' </font></b>' : title,\\\\n                            url: $(url).lazyRule((params) => {\\\\n                                let new_cate = []\\\\n                                if (params.index === 0) {\\\\n                                    params.cate_temp.forEach((cate, index) => {\\\\n                                        new_cate.push(index === 0 ? params.key.toString() : \\\\\\\"0\\\\\\\")\\\\n                                    });\\\\n                                } else {\\\\n                                    params.cate_temp[params.index] = params.key.toString()\\\\n                                }\\\\n                                putMyVar(params.tag + params.VARMAP.CATEGORY, JSON.stringify(params.index === 0 ? new_cate : params.cate_temp))\\\\n                                putMyVar(params.tag + params.VARMAP.URL, input)\\\\n                                refreshPage(true)\\\\n                                return \\\\\\\"hiker://empty\\\\\\\"\\\\n                            }, {\\\\n                                cate_temp: cate_temp,\\\\n                                index: index,\\\\n                                VARMAP: this.VARMAP,\\\\n                                tag: mTag,\\\\n                                key: key,\\\\n                                page: this[symbolMap.mPage],\\\\n                            }),\\\\n                            col_type: 'scroll_button',\\\\n                        })\\\\n                    })\\\\n                    this[symbolMap.mLayout].push({\\\\n                        col_type: \\\\\\\"blank_block\\\\\\\"\\\\n                    });\\\\n                } else if (this[symbolMap.mFold] === '0') {\\\\n                    sub_categories.forEach((item, key) => {\\\\n                        let title = this.getTitle(item, category)\\\\n                        let url = this.getUrl(item, category)\\\\n\\\\n                        this[symbolMap.mLayout].push({\\\\n                            title: key.toString() === cate_temp[index] ? '““””<b><font color=' + this[symbolMap.mColor] + '>' + title + ' </font></b>' : title,\\\\n                            url: $(url).lazyRule((params) => {\\\\n                                params.cate_temp[params.index] = params.key.toString()\\\\n\\\\n                                putMyVar(params.tag + params.VARMAP.CATEGORY, JSON.stringify(params.cate_temp))\\\\n                                putMyVar(params.tag + params.VARMAP.URL, input)\\\\n                                refreshPage(true)\\\\n                                return \\\\\\\"hiker://empty\\\\\\\"\\\\n                            }, {\\\\n                                cate_temp: cate_temp,\\\\n                                index: index,\\\\n                                VARMAP: this.VARMAP,\\\\n                                tag: mTag,\\\\n                                key: key,\\\\n                                page: this[symbolMap.mPage],\\\\n                            }),\\\\n                            col_type: 'scroll_button',\\\\n                        })\\\\n                    })\\\\n                    this[symbolMap.mLayout].push({\\\\n                        col_type: \\\\\\\"blank_block\\\\\\\"\\\\n                    });\\\\n                }\\\\n            });\\\\n        }\\\\n    },\\\\n\\\\n    界面(layout) {\\\\n        return this.layout(layout)\\\\n    },\\\\n    分类链接(trueUrl) {\\\\n        return this.trueUrl(trueUrl);\\\\n    },\\\\n    页码(page) {\\\\n        return this.page(page);\\\\n    },\\\\n    源码(html) {\\\\n        return this.html(html);\\\\n    },\\\\n    定位一级分类(list) {\\\\n        return this.list(list);\\\\n    },\\\\n    定位子分类(subList) {\\\\n        return this.subList(subList);\\\\n    },\\\\n    定位分类标题(title) {\\\\n        return this.title(title);\\\\n    },\\\\n    定位分类链接(url) {\\\\n        return this.url(url);\\\\n    },\\\\n    开启内置折叠功能() {\\\\n        return this.foldInner(true);\\\\n    },\\\\n    关闭内置折叠功能() {\\\\n        return this.foldInner(false);\\\\n    },\\\\n    第几行开始折叠(index) {\\\\n        return this.foldIndex(index);\\\\n    },\\\\n    折叠按钮样式(layout) {\\\\n        return this.foldLayout(layout)\\\\n    },\\\\n    折叠(fold) {\\\\n        return this.fold(fold);\\\\n    },\\\\n    选中的分类颜色(color) {\\\\n        return this.color(color);\\\\n    },\\\\n    唯一标识(mTag) {\\\\n        return this.tag(mTag)\\\\n    },\\\\n    添加分类定位(ruleObj) {\\\\n        return this.add(ruleObj);\\\\n    },\\\\n    开始打造分类() {\\\\n        return this.build();\\\\n    },\\\\n\\\\n})\\\\n$.exports = new CategoriesHeader();\\\\n$.exports\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"链接处理[二]*\\\",\\\"path\\\":\\\"url-processor\\\",\\\"rule\\\":\\\"/**\\\\n * 本地网页插件链接 hiker://files/rules/js/UrlProcessor.js\\\\n * 子页面链接 hiker://page/url-processor\\\\n * 道长仓库链接 http://hiker.nokia.press/hikerule/rulelist.json?id=2849\\\\n * 码云 Gitee 链接 https://gitee.com/reborn0/HikerRules/raw/master/plugins/UrlProcessor.js\\\\n */\\\\nfunction UrlProcessor() {\\\\n    this.params = {}\\\\n    this.regexMap = [\\\\n        {\\\\n            reg: '(vodtype|videot)\\\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\w+',\\\\n            exec: () => {\\\\n                return this.params.url\\\\n                    .replace(/-\\\\\\\\d+.html/, '-' + this.params.page + '.html')\\\\n                    .replace(/((vodtype|videot)\\\\\\\\/\\\\\\\\w+).html/, '$1-' + this.params.page + '.html')\\\\n            }\\\\n        },\\\\n        {\\\\n            reg: '\\\\\\\\\\\\\\\\/?[\\\\\\\\\\\\\\\\w\\\\\\\\\\\\\\\\d]+-.*?-.*?-.*?-.*?-.*?-.*?-.*?-\\\\\\\\\\\\\\\\d*---\\\\\\\\\\\\\\\\d*.html',\\\\n            exec: () => {\\\\n                return this.params.url\\\\n                    .replace(/\\\\\\\\d*(---.html)/, this.params.page + '$1')\\\\n                    .replace(/(---\\\\\\\\d+.html)/, this.params.page + '$1'); // 拼接页码\\\\n            }\\\\n        },\\\\n        {\\\\n            reg: '((\\\\\\\\\\\\\\\\/vod\\\\\\\\\\\\\\\\/show)?(\\\\\\\\\\\\\\\\/area\\\\\\\\\\\\\\\\/[\\\\\\\\\\\\\\\\w\\\\\\\\\\\\\\\\d%]+)?(\\\\\\\\\\\\\\\\/by\\\\\\\\\\\\\\\\/[\\\\\\\\\\\\\\\\w\\\\\\\\\\\\\\\\d%]+)?(\\\\\\\\\\\\\\\\/id\\\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\d+)?(\\\\\\\\\\\\\\\\/letter\\\\\\\\\\\\\\\\/[\\\\\\\\\\\\\\\\w\\\\\\\\\\\\\\\\d%]+)?)(\\\\\\\\\\\\\\\\/page\\\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\d+)?(\\\\\\\\\\\\\\\\/year\\\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\d+)?\\\\\\\\\\\\\\\\.html',\\\\n            exec: () => {\\\\n                let regExp = /((\\\\\\\\/vod\\\\\\\\/show)?(\\\\\\\\/area\\\\\\\\/[\\\\\\\\w\\\\\\\\d%]+)?(\\\\\\\\/by\\\\\\\\/[\\\\\\\\w\\\\\\\\d%]+)?(\\\\\\\\/id\\\\\\\\/\\\\\\\\d+)?(\\\\\\\\/letter\\\\\\\\/[\\\\\\\\w\\\\\\\\d%]+)?)(\\\\\\\\/page\\\\\\\\/\\\\\\\\d+)?(\\\\\\\\/year\\\\\\\\/\\\\\\\\d+)?\\\\\\\\.html/\\\\n                return this.params.url\\\\n                    .replace(regExp, '$1' + (\\\\\\\"/page/\\\\\\\" + this.params.page) + '$8' + \\\\\\\".html\\\\\\\")\\\\n            }\\\\n        }\\\\n    ]\\\\n}\\\\n\\\\nObject.assign(UrlProcessor.prototype, {\\\\n    constructor: UrlProcessor,\\\\n    checkParams() {\\\\n        if (!this.params.url) {\\\\n            throw new Error(\\\\\\\"请先调用 .baseUrl(url) 传入链接进行初始化!\\\\\\\")\\\\n        }\\\\n        if (!this.params.page) {\\\\n            throw new Error(\\\\\\\"请先调用 .page(page) 传入页码进行初始化!\\\\\\\")\\\\n        }\\\\n    },\\\\n    baseUrl(url){\\\\n        this.params.url = url\\\\n        return this\\\\n    },\\\\n    page(page){\\\\n        this.params.page = page\\\\n        return this\\\\n    },\\\\n    addExtra(regExp) {\\\\n        if (regExp.constructor === Array) {\\\\n            this.regexMap = this.regexMap.concat(regExp)\\\\n        } else {\\\\n            this.regexMap.push(regExp)\\\\n        }\\\\n        return this;\\\\n    },\\\\n    debug() {\\\\n        this.params.debug = true\\\\n        return this;\\\\n    },\\\\n    exec() {\\\\n        this.checkParams()\\\\n        let true_url = ''\\\\n        for (let i = 0; i < this.regexMap.length; i++) {\\\\n            let regObj = this.regexMap[i];\\\\n            let urlExp = regObj.reg;\\\\n            if (typeof urlExp === 'string') {\\\\n                urlExp = new RegExp(urlExp)\\\\n            }\\\\n            if (urlExp.test(this.params.url)) {\\\\n                if (this.params.debug) {\\\\n                    log(urlExp.toString())\\\\n                }\\\\n                true_url = regObj.exec();\\\\n                break;\\\\n            }\\\\n        }\\\\n        if (true_url) {\\\\n            return true_url;\\\\n        } else {\\\\n            return this.params.url\\\\n        }\\\\n    },\\\\n    获取处理结果() {\\\\n        return this.exec()\\\\n    },\\\\n    链接(url) {\\\\n        return this.baseUrl(url)\\\\n    },\\\\n    页码(page) {\\\\n        return this.page(page)\\\\n    },\\\\n    插入新处理规则(regExp) {\\\\n        return this.addExtra(regExp)\\\\n    },\\\\n    调试模式() {\\\\n        return this.debug();\\\\n    }\\\\n})\\\\n$.exports=new UrlProcessor()\\\\n$.exports\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"一级*\\\",\\\"path\\\":\\\"yjtool\\\",\\\"rule\\\":\\\"function convert1(str) {\\\\n    let c = str.split(\\\\\\\";\\\\\\\")\\\\n    return {\\\\n        列表: c[0],\\\\n        标题: c[1],\\\\n        图片: c[2],\\\\n        描述: c[3],\\\\n        链接: c[4]\\\\n    }\\\\n}\\\\n\\\\nfunction merge(source, target) {\\\\n    let keys = Object.keys(source)\\\\n    for (let i in keys) {\\\\n        target[keys[i]] = source[keys[i]]\\\\n    }\\\\n}\\\\n\\\\nfunction 一级(obj) {\\\\n    var d = [];\\\\n    if ($.type(obj) == \\\\\\\"string\\\\\\\") {\\\\n        obj = convert1(obj)\\\\n    }\\\\n    if (obj.规则) {\\\\n        let c = convert1(obj.规则)\\\\n        merge(c, obj)\\\\n    }\\\\n    let arr = pdfa(getResCode(), obj.列表);\\\\n       if (obj.列表处理 != null) {\\\\n            arr = obj.链接处理(arr)\\\\n        }\\\\n    for (let it of arr) {\\\\n        let url = pd(it, obj.链接)\\\\n        if (obj.链接处理 != null) {\\\\n            url = obj.链接处理(url)\\\\n        }\\\\n        let title = pdfh(it, obj.标题)\\\\n        if (obj.标题处理 != null) {\\\\n            title = obj.标题处理(title)\\\\n        }\\\\n        let pic = pd(it, obj.图片)\\\\n        if (obj.图片处理 != null) {\\\\n            pic = obj.图片处理(pic)\\\\n        }\\\\n        d.push({\\\\n            title: obj.标题 ? pdfh(it, obj.标题) : \\\\\\\"\\\\\\\",\\\\n            url: url+'#autoCache#',\\\\n            col_type: \\\\\\\"\\\\\\\",\\\\n            desc: obj.描述 ? pdfh(it, obj.描述) : \\\\\\\"\\\\\\\",\\\\n            pic_url: pic,\\\\n            extra: {\\\\n                ytitle: title,\\\\n                ypic: pic,\\\\n                yurl: url.replace('hiker://empty##','')\\\\n            }\\\\n        });\\\\n\\\\n    }\\\\n    setResult(d);\\\\n}\\\\nvar tool = {\\\\n    一级: 一级\\\\n}\\\\n$.exports = tool\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"一级[二]*\\\",\\\"path\\\":\\\"yiji\\\",\\\"rule\\\":\\\"function 一级() {};\\\\r\\\\nObject.assign(一级.prototype, {\\\\r\\\\n\\\\tconstructor: 一级,\\\\r\\\\n\\\\ttest() {},\\\\r\\\\n\\\\t获取源码(url, header) {return fetch(true_url, {headers: header || {'User-Agent': PC_UA}}) },// 默认统一使用MOBILE_UA\\\\r\\\\n\\\\t搜索框架(page) {\\\\r\\\\n\\\\t\\\\tif (page == '1') {\\\\n/*\\\\r\\\\n\\\\t\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\ttitle: \\\\\\\"搜索本规则\\\\\\\",\\\\r\\\\n\\\\t\\\\t\\\\t\\\\turl: \\\\\\\"'hiker://search?rule=\\\\\\\" + MY_RULE.title + \\\\\\\"&s='+input\\\\\\\",\\\\r\\\\n\\\\t\\\\t\\\\t\\\\tdesc: \\\\\\\" \\\\\\\",\\\\r\\\\n\\\\t\\\\t\\\\t\\\\tcol_type: \\\\\\\"input\\\\\\\"\\\\r\\\\n\\\\t\\\\t\\\\t});\\\\n*/\\\\r\\\\n\\\\t\\\\t}\\\\r\\\\n\\\\t},\\\\r\\\\n\\\\t获取链接(page, regex) {\\\\r\\\\n\\\\t\\\\tlet true_url = getMyVar('header.url', MY_URL);\\\\r\\\\n\\\\t\\\\t//let 链接处理工具 = requireCache(config.链接处理工具依赖)\\\\r\\\\n\\\\t\\\\t//let 链接处理工具 = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2849')\\\\r\\\\n\\\\t\\\\t//let 链接处理工具 = $.require('hiker://page/url-processor')\\\\r\\\\n\\\\t\\\\tlet 链接处理工具 = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2849')\\\\r\\\\n\\\\t\\\\ttrue_url = 链接处理工具\\\\r\\\\n\\\\t\\\\t\\\\t.链接(true_url)\\\\r\\\\n\\\\t\\\\t\\\\t.页码(page)\\\\r\\\\n\\\\t\\\\t\\\\t.插入新处理规则(regex || [])\\\\r\\\\n\\\\t\\\\t\\\\t.获取处理结果();\\\\r\\\\n\\\\t\\\\treturn true_url;\\\\r\\\\n\\\\t},\\\\r\\\\n\\\\t打造分类(ruleList) {\\\\r\\\\n\\\\t\\\\t//  let htmlCategories = requireCache(config.动态分类依赖)\\\\r\\\\n\\\\t\\\\t//let htmlCategories = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2705')\\\\r\\\\n\\\\t\\\\tif (!ruleList) {\\\\r\\\\n\\\\t\\\\t\\\\tlet 分类定位 = [{\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t一级分类: 一级定位A,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t子分类: 统一定位B || 一级定位B,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t分类链接: {二次处理(url) {try {return 一级处理C(url)} catch (e) {return url}}}\\\\r\\\\n\\\\t\\\\t\\\\t}]\\\\r\\\\n\\\\t\\\\t\\\\tif (二级定位A && (统一定位B || 二级定位B)) {\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t分类定位.push({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t一级分类: 二级定位A,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t子分类: 统一定位B || 二级定位B,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t分类链接: {二次处理(url) {try {return 二级处理C(url)} catch (e) {return url}}}\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t})\\\\r\\\\n\\\\t\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\t\\\\tif (三级定位A && (统一定位B || 三级定位B)) {\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t分类定位.push({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t一级分类: 三级定位A,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t子分类: 统一定位B || 三级定位B,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t分类链接: {二次处理(url) {try {return 三级处理C(url)} catch (e) {return url}}}\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t})\\\\r\\\\n\\\\t\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\t\\\\tif (四级定位A && (统一定位B || 四级定位B)) {\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t分类定位.push({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t一级分类: 四级定位A,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t子分类: 统一定位B || 四级定位B,\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t分类链接: {二次处理(url) {try {return 四级处理C(url)} catch (e) {return url}}}\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t})\\\\r\\\\n\\\\t\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\t\\\\truleList = 分类定位;\\\\r\\\\n\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\t// '0' 为默认不折叠，'1' 为默认折叠\\\\r\\\\n\\\\t\\\\tconst 当前折叠状态 = getMyVar('header.fold', '0')\\\\r\\\\n\\\\t\\\\t// 引入动态分类依赖\\\\r\\\\n\\\\t\\\\tlet htmlCategories = requireCache('http://hiker.nokia.press/hikerule/rulelist.json?id=2705')\\\\r\\\\n\\\\t\\\\tvar getRangeColors = function() {\\\\r\\\\n\\\\t\\\\t\\\\treturn '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\\\r\\\\n\\\\t\\\\t} // 随机选中的分类颜色\\\\r\\\\n\\\\t\\\\tvar colour;\\\\r\\\\n\\\\t\\\\tif (分类颜色 !== '') {\\\\r\\\\n\\\\t\\\\t\\\\tcolour = 分类颜色\\\\r\\\\n\\\\t\\\\t} else {\\\\r\\\\n\\\\t\\\\t\\\\tcolour = getRangeColors()\\\\r\\\\n\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\thtmlCategories.界面(d)\\\\r\\\\n\\\\t\\\\t\\\\t//.分类链接(true_url)\\\\r\\\\n\\\\t\\\\t\\\\t.源码(html)\\\\r\\\\n\\\\t\\\\t\\\\t.页码(page)\\\\r\\\\n\\\\t\\\\t\\\\t.添加分类定位(ruleList)\\\\r\\\\n\\\\t\\\\t\\\\t.开启内置折叠功能() // 必须\\\\r\\\\n\\\\t\\\\t\\\\t.折叠(当前折叠状态) // 必须\\\\r\\\\n\\\\t\\\\t\\\\t.折叠按钮样式({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\ttitle: 当前折叠状态 == \\\\\\\"1\\\\\\\" ? \\\\\\\"““””<big><b><font color='#5959AB'>\\\\\\\" + 动态缩小 + \\\\\\\"</font></b></big>\\\\\\\" : \\\\\\\"““””<big><b><font color='#F75D59'>\\\\\\\" + 动态扩展 + \\\\\\\"</font></b></big>\\\\\\\"\\\\r\\\\n\\\\t\\\\t\\\\t}) // 可选\\\\r\\\\n\\\\t\\\\t\\\\t// .第几行开始折叠(2) // 可选\\\\r\\\\n\\\\t\\\\t\\\\t// .折叠按钮样式({ 折叠按钮插入行: 2 })  // 可选，但必须先调用 .第几行开始折叠(index)，然后再传入 { 折叠按钮插入行: index }\\\\r\\\\n\\\\t\\\\t\\\\t.选中的分类颜色(colour)\\\\r\\\\n\\\\t\\\\t\\\\t.开始打造分类();\\\\r\\\\n\\\\t},\\\\r\\\\n\\\\r\\\\n\\\\t生成片单(d,html) {\\\\r\\\\n\\\\r\\\\n\\\\t\\\\tvar 列表\\\\r\\\\n\\\\t\\\\tvar 标题\\\\r\\\\n\\\\t\\\\tvar 描述\\\\r\\\\n\\\\t\\\\tvar 图片\\\\r\\\\n\\\\t\\\\tvar 链接\\\\r\\\\n\\\\r\\\\n\\\\t\\\\tif (框架类型 === 'myui-vodlist') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = '.myui-vodlist&&li';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'h4&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = '.pic-tag||.pic-text&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = '.lazyload&&data-original';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t\\\\t//log('框架类型·myui-vodlist')\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === '#data_list') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = '#data_list&&li';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'a&&title';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = 'em&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = 'img&&data-srcl';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t\\\\t//log('框架类型·data_list')\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === 'fed-list-title') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = '.fed-list-info&&li';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = '.fed-list-title&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = '.fed-text-center&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = 'a&&data-original';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t\\\\t//log('框架类型·.fed-list-info')\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === 'item') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = 'body&&.item';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'img&&alt';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = 'p&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = 'img&&srcl';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === 'module-items') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = '.module-items&&.module-item';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'a&&title';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = '.module-item-text&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = 'img||.lazy&&data-src';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === 'pack-ykpack') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = 'body&&.pack-ykpack';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'a&&title';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = 'span,-1&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = '.eclazy&&data-original';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === 'stui-vodlist') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = '.stui-vodlist&&li';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'a&&title';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = '.pic-text&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = '.lazyload||a&&data-original';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === 'vodlist') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = '.vodlist&&li';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'a&&title';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = 'a&&Text';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = '.lazyload&&data-original';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'a&&href';\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === '测试') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = 'body&&a';\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 'body&&a';\\\\r\\\\n\\\\t\\\\t\\\\t描述 = 'body&&a';\\\\r\\\\n\\\\t\\\\t\\\\t图片 = 'body&&a';\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 'body&&a';\\\\r\\\\n\\\\t\\\\t} else if (框架类型 === '') {\\\\r\\\\n\\\\t\\\\t\\\\t列表 = 框架列表;\\\\r\\\\n\\\\t\\\\t\\\\t标题 = 框架标题;\\\\r\\\\n\\\\t\\\\t\\\\t描述 = 框架描述;\\\\r\\\\n\\\\t\\\\t\\\\t图片 = 框架图片;\\\\r\\\\n\\\\t\\\\t\\\\t链接 = 框架链接;\\\\r\\\\n\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\tlet list = pdfa(html, 列表);\\\\r\\\\n\\\\t\\\\tfor (let k in list) {\\\\r\\\\n\\\\t\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\t\\\\ttitle: pdfh(list[k], 标题),\\\\r\\\\n\\\\t\\\\t\\\\t\\\\tdesc: pdfh(list[k], 描述),\\\\r\\\\n\\\\t\\\\t\\\\t\\\\timg: pd(list[k], 图片) + '@Referer=',\\\\r\\\\n\\\\t\\\\t\\\\t\\\\turl: pd(list[k], 链接)+\\\\\\\"#immersiveTheme##autoCache#\\\\\\\",\\\\r\\\\n\\\\t\\\\t\\\\t});\\\\r\\\\n\\\\t\\\\t}\\\\r\\\\n\\\\t\\\\td.push({\\\\r\\\\n\\\\t\\\\t\\\\tcol_type: 'big_big_blank_block',\\\\r\\\\n\\\\t\\\\t});\\\\r\\\\n\\\\t}\\\\r\\\\n})\\\\r\\\\n\\\\r\\\\n$.exports = new 一级();\\\\r\\\\n$.exports\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"函数组件*\\\",\\\"path\\\":\\\"qs\\\",\\\"rule\\\":\\\"function 优化路线章节数据(多路线否, 源数据, 路线列表, 路线名, 选集总列表, 选集列表, 集名, 集url, 前缀, 标题, 图片) {\\\\n\\\\n    //当多路线否 选集总列表为空\\\\n    //最终返回 [{title: '路线名',list: [{title:'选集名',url:'选集url',...}],sjss:'下载资料'},....]\\\\n    //选集列表 第一项是css选择器，之后可以用$分割添加要删除章节名\\\\n\\\\n\\\\n    var 章节json = [];\\\\n    var 单路线章节 = '章节列表'\\\\n\\\\n    var 列表名 = [];\\\\n    if (!多路线否) {\\\\n\\\\n        列表名.push(单路线章节)\\\\n\\\\n    } else {\\\\n\\\\n        pdfa(源数据, 路线列表).forEach(function(data) {\\\\n            列表名.push(pdfh(data, 路线名))\\\\n        });\\\\n\\\\n    }\\\\n\\\\n    var 集数组 = [];\\\\n\\\\n\\\\nvar 排除章节 = [];\\\\nif(选集列表.includes('$')){\\\\n排除章节 = 选集列表.split('$')\\\\n选集列表 = 排除章节.shift()\\\\n}\\\\n\\\\n    if (!多路线否) {\\\\n        集数组.push(pdfa(源数据, 选集列表))\\\\n    } else {\\\\n        pdfa(源数据, 选集总列表).forEach(function(data) {\\\\n            集数组.push(pdfa(data, 选集列表))\\\\n        });\\\\n    }\\\\n\\\\n\\\\n    for (let i in 集数组) {\\\\n\\\\n        var doList = [];\\\\n\\\\n排除章节.forEach(function(data) {\\\\n    var 标识id = 集数组[i].findIndex(返回 => 返回.indexOf(data) != -1);\\\\n    if (标识id != -1) {\\\\n      集数组[i].splice(标识id, 1)\\\\n    };\\\\n  });\\\\n\\\\n        for (let it of 集数组[i]) {\\\\n            var doListurl = pdfh(it, 集url)\\\\n            doListurl = doListurl.includes(\\\\\\\"http\\\\\\\") ? doListurl : 前缀 + doListurl\\\\n            doList.push({\\\\n                title: '““””<small>' + pdfh(it, 集名) + '</small>',\\\\n                url: doListurl\\\\n            })\\\\n        }\\\\n\\\\n        var bookName = !多路线否 ? 标题 : 标题 + '-' + 列表名[i]\\\\n\\\\n        章节json.push({\\\\n            title: 列表名[i],\\\\n            list: doList,\\\\n            sjss: {\\\\n                chapterList: doList,\\\\n                info: {\\\\n                    bookName: bookName, //漫画名称,\\\\n                    ruleName: MY_RULE.title,\\\\n                    bookTopPic: 图片,\\\\n                    parseCode: downloadlazy,\\\\n                },\\\\n                defaultView: \\\\\\\"1\\\\\\\"\\\\n            }\\\\n        })\\\\n    }\\\\n    return 章节json\\\\n}\\\\n\\\\n\\\\nfunction 添加头部列表(d, 标题, 图片, 描述, 作者, 时间, 分类,页URL) {\\\\n\\\\n    标题 = !标题 ? '' : 标题 + '\\\\\\\\n'\\\\n    图片 = !图片 ? '' : 图片\\\\n    描述 = !描述 ? '' : 描述.replace(\\\\\\\"更新至：\\\\\\\", '')\\\\n\\\\n    作者 = !作者 ? '' : '\\\\\\\\n' + 作者\\\\n    时间 = !时间 ? '' : '\\\\\\\\n' + 时间\\\\n    分类 = !分类 ? '' : '\\\\\\\\n' + 分类\\\\n\\\\n\\\\n    var 头部title = ['‘‘’’<b>','</b> <small><font color=#FA7298>','</font>','</small>']\\\\n    var 头部desc = ['‘‘’’<font color=#f8ecc9>','</font>']\\\\n\\\\n\\\\n\\\\n    头部title = 头部title[0]+标题+头部title[1]+描述+头部title[2]+作者+头部title[3]\\\\n\\\\n    头部desc = 头部desc[0]+时间+分类+头部desc[1]\\\\n\\\\n    d.push({\\\\n        title: 头部title,\\\\n        desc: 头部desc,\\\\n        pic_url: 图片,\\\\n        url: 'hiker://search?s='+getParam('Name')+'&rule=阅漫君',\\\\n        col_type: 'movie_1_vertical_pic_blur'\\\\n    });\\\\n\\\\n}\\\\n\\\\n\\\\nfunction 添加简介(d, 数据源, 页URL, 图片) {\\\\n    //获取数据\\\\n    var 简介内容 = 数据源\\\\n    简介内容 = 简介内容.replace(\\\\\\\"简介：\\\\\\\", \\\\\\\"\\\\\\\").replace(\\\\\\\"介绍:\\\\\\\", \\\\\\\"\\\\\\\").replace(\\\\\\\"漫画\\\\\\\", \\\\\\\"\\\\\\\").replace(\\\\\\\"……\\\\\\\", \\\\\\\"\\\\\\\").replace(\\\\\\\"简介\\\\\\\", \\\\\\\"\\\\\\\")\\\\n\\\\n    var 简介内容收;\\\\n    if (简介内容.length > 45) {\\\\n        简介内容收 = 简介内容.substr(0, 45) + '...'\\\\n    } else {\\\\n        简介内容收 = 简介内容 + '...'\\\\n    }\\\\n\\\\n    //图标获取\\\\n    if (!图片) {\\\\n        图片 = 'https://lanmeiguojiang.com/tubiao/q/107.png'\\\\n    }\\\\n\\\\n    //页URL 获取\\\\n    if (!页URL) {\\\\n        页URL = MY_RULE.title\\\\n    }\\\\n\\\\n    //标题与简介样式\\\\n    var mztext = \\\\\\\"&nbsp;&nbsp;&nbsp;&nbsp;<small>简介</small><br>\\\\\\\"\\\\n    var bttitle = '<font color=\\\\\\\"#098AC1\\\\\\\">漫画简介  </font><small><small><font color=\\\\\\\"#f47983\\\\\\\">简介收></font></small></small>'\\\\n\\\\n    //展开与收缩操作\\\\n    var jj = getMyVar(页URL + \\\\\\\"简介收\\\\\\\", \\\\\\\"已收起\\\\\\\");\\\\n    var jjurl = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((简介内容, 简介内容收, 收, 收内容, 当前URL) => {\\\\n        var jsbl = 当前URL + \\\\\\\"简介收\\\\\\\";\\\\n        var jj = getMyVar(当前URL + \\\\\\\"简介收\\\\\\\", \\\\\\\"已收起\\\\\\\");\\\\n        jj = jj == \\\\\\\"已收起\\\\\\\" ? \\\\\\\"展开\\\\\\\" : \\\\\\\"已收起\\\\\\\";\\\\n        putMyVar(jsbl, jj)\\\\n        updateItem({\\\\n            extra: {\\\\n                id: 当前URL + \\\\\\\"_bt\\\\\\\"\\\\n            },\\\\n            title: 收.replace(\\\\\\\"简介收\\\\\\\", jj)\\\\n        })\\\\n\\\\n        updateItem({\\\\n            extra: {\\\\n                id: 当前URL + \\\\\\\"_mz\\\\\\\"\\\\n            },\\\\n            title: jj == \\\\\\\"已收起\\\\\\\" ? 收内容.replace(\\\\\\\"简介\\\\\\\", 简介内容收) : 收内容.replace(\\\\\\\"简介\\\\\\\", 简介内容)\\\\n        })\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, 简介内容, 简介内容收, bttitle, mztext, 页URL)\\\\n\\\\n\\\\n    //标题\\\\n    d.push({\\\\n        title: bttitle.replace(\\\\\\\"简介收\\\\\\\", jj),\\\\n        url: jjurl,\\\\n        col_type: \\\\\\\"avatar\\\\\\\",\\\\n        pic_url: 图片,\\\\n        extra: {\\\\n            id: 页URL + \\\\\\\"_bt\\\\\\\"\\\\n        }\\\\n    });\\\\n\\\\n    //简介\\\\n    d.push({\\\\n        title: jj == \\\\\\\"已收起\\\\\\\" ? mztext.replace(\\\\\\\"简介\\\\\\\", 简介内容收) : mztext.replace(\\\\\\\"简介\\\\\\\", 简介内容),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n        extra: {\\\\n            id: 页URL + \\\\\\\"_mz\\\\\\\"\\\\n        }\\\\n    });\\\\n\\\\n}\\\\n\\\\nfunction 添加列表章节(d, 标题数据, 列表数据, 解析代码, 页URL, 图片) {\\\\n\\\\n\\\\n    //d与外界d，为同内存地址，不用返回\\\\n    //标题数据  即标题名字\\\\n    //列表数据必须是JSON  格式是[{title:'',url:'',},.....]  且url必须有前缀\\\\n\\\\n    //图标获取\\\\n    if (!图片) {\\\\n        图片 = 'https://lanmeiguojiang.com/tubiao/q/18.png'\\\\n    }\\\\n\\\\n    //页URL 获取\\\\n    if (!页URL) {\\\\n        页URL = MY_RULE.title\\\\n    }\\\\n\\\\n    //标题名\\\\n    var 标题名 = '<b>路线</b>  <small><small><font color=#f9906f>排序 ></font></small></small>'\\\\n\\\\n\\\\n    var 排序 = getMyVar(页URL + \\\\\\\"章节排序\\\\\\\", \\\\\\\"正序\\\\\\\");\\\\n    var 提示 = 排序 == '倒序' ? '正序' : '倒序';\\\\n\\\\n    var 排序url = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((标题名, 标题数据, 列表数据, 解析代码, 页URL) => {\\\\n        var 排序 = getMyVar(页URL + \\\\\\\"章节排序\\\\\\\", \\\\\\\"正序\\\\\\\");\\\\n        var 提示 = 排序 == '倒序' ? '正序' : '倒序';\\\\n        updateItem({\\\\n            extra: {\\\\n                id: 页URL + \\\\\\\"_排序\\\\\\\"\\\\n            },\\\\n            title: 标题名.replace('路线', 标题数据).replace('排序', 提示)\\\\n        })\\\\n\\\\n\\\\n        if (提示 == '倒序') {\\\\n            列表数据.reverse()\\\\n        }\\\\n        列表数据.forEach(function(data, ssid) {\\\\n            updateItem({\\\\n                title: data.title,\\\\n                url: data.url + 解析代码,\\\\n                extra: {\\\\n                    id: 页URL + \\\\\\\"_选集\\\\\\\" + ssid\\\\n                }\\\\n            });\\\\n        });\\\\n\\\\n\\\\n        putMyVar(页URL + \\\\\\\"章节排序\\\\\\\", 提示)\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, 标题名, 标题数据, 列表数据, 解析代码, 页URL)\\\\n\\\\n    d.push({\\\\n        title: 标题名.replace('路线', 标题数据).replace('排序', 排序),\\\\n        pic_url: 图片,\\\\n        url: 排序url,\\\\n        col_type: \\\\\\\"avatar\\\\\\\",\\\\n        extra: {\\\\n            id: 页URL + \\\\\\\"_排序\\\\\\\"\\\\n        }\\\\n    });\\\\n\\\\n    if (排序 == '倒序') {\\\\n        列表数据.reverse()\\\\n    }\\\\n\\\\n    列表数据.forEach(function(data, id) {\\\\n        d.push({\\\\n            title: data.title,\\\\n            url: data.url + 解析代码,\\\\n            col_type: \\\\\\\"text_2\\\\\\\",\\\\n            extra: {\\\\n                id: 页URL + \\\\\\\"_选集\\\\\\\" + id\\\\n            }\\\\n        });\\\\n    });\\\\n\\\\n}\\\\n\\\\n/*\\\\nfunction 添加防止网页(项url, UA) {\\\\n\\\\n    //上级跳转到当前页的链接必须是hiker://empty；不然一刷新还是会重复加载\\\\n    //UA ''或false或'手机' 默认是手机端 ; 电脑 'PC'\\\\n\\\\n    var 刷新重复 = MY_RULE.title + \\\\\\\"网页源码\\\\\\\"\\\\n    var pc链接 = 项url.replace(\\\\\\\"m.\\\\\\\", \\\\\\\"www.\\\\\\\")\\\\n    var 手机链接 = 项url.replace(\\\\\\\"www.\\\\\\\", \\\\\\\"m.\\\\\\\")\\\\n\\\\n    var code;\\\\n    if (getMyVar(刷新重复, \\\\\\\"false\\\\\\\") == \\\\\\\"false\\\\\\\") {\\\\n\\\\n        code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\\\n        putMyVar(刷新重复, getParam('url') + \\\\\\\"￥&￥\\\\\\\" + code)\\\\n\\\\n    } else {\\\\n\\\\n        var pm = getMyVar(刷新重复).split(\\\\\\\"￥&￥\\\\\\\")\\\\n        if (pm[0] == getParam('url')) {\\\\n            code = pm[1]\\\\n        } else {\\\\n            code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\\\n            putMyVar(刷新重复, getParam('url') + \\\\\\\"￥&￥\\\\\\\" + code)\\\\n        }\\\\n    }\\\\n    return code\\\\n}\\\\n*/\\\\n\\\\nfunction 添加选择路线(d, 路线数据, 页URL, 多路线否) {\\\\n\\\\n    //路线数据 格式[{title:'路线名'},....]\\\\n    //多路线否  false 则不启用选择路线；true 则启用\\\\n\\\\n    var 选择列表 = getItem(页URL + \\\\\\\"选择列表\\\\\\\", \\\\\\\"0\\\\\\\")\\\\n\\\\n    if (多路线否) {\\\\n\\\\n        var 路线选中 = '‘‘’’<font color=#098AC1>选中</font>'\\\\n\\\\n\\\\n        d.push({\\\\n            title: '‘‘’’📖<font color=\\\\\\\"#FA7298\\\\\\\"> 图源列表</font> ：',\\\\n            url: \\\\\\\"toast://点我干啥呢\\\\\\\",\\\\n            col_type: 'flex_button'\\\\n        });\\\\n\\\\n\\\\n        路线数据.forEach(function(data, id) {\\\\n\\\\n            var jjurl = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((页URL,id) => {\\\\n                setItem(页URL + '选择列表',id+'');\\\\n                refreshPage(false);\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n            },页URL,id);\\\\n\\\\n            var 标题名 = id == 选择列表 ? 路线选中.replace('选中', data.title) : data.title;\\\\n            d.push({\\\\n                title: 标题名,\\\\n                url: jjurl,\\\\n                col_type: 'flex_button',\\\\n                extra: {\\\\n                    id: 页URL + \\\\\\\"_路线\\\\\\\" + id\\\\n                }\\\\n            });\\\\n        });\\\\n\\\\n    }\\\\n    return 选择列表\\\\n}\\\\n\\\\n\\\\nfunction 添加选择下载(d, 路线数据, 多路线否) {\\\\n    d.push({\\\\n    title: '‘‘’’🗳<font color=\\\\\\\"#f47983\\\\\\\"> 书架</font> ',\\\\n    url: \\\\\\\"hiker://page/Bookrack.view?rule=本地资源管理&ruleName=\\\\\\\"+MY_RULE.title,\\\\n    col_type: 'scroll_button'\\\\n});\\\\n\\\\n    //路线数据 格式[{title:'路线名',sjss:'下载资料信息'},....]\\\\n    //多路线否  false 则只有①个下载 标题为 点击下载；true 则多个下载\\\\n\\\\nif(多路线否){\\\\n\\\\nd.push({\\\\n        title: '‘‘’’📥<font color=\\\\\\\"#f47983\\\\\\\"> 下载</font> ：',\\\\n        url: \\\\\\\"toast://点我干啥呢\\\\\\\",\\\\n        col_type: 'scroll_button'\\\\n    });\\\\n\\\\n}\\\\n\\\\n    路线数据.forEach(function(data, id) {\\\\n\\\\n        d.push({\\\\n            title: data.title.includes('章节列表') ? '点击下载' : data.title,\\\\n            url: 'hiker://page/download.view#noRecordHistory##noRefresh##noHistory#?rule=本地资源管理',\\\\n            col_type: 'scroll_button',\\\\n            extra: data.sjss\\\\n        });\\\\n    });\\\\n\\\\n    if (多路线否) {\\\\n        d.push({\\\\n            col_type: \\\\\\\"line_blank\\\\\\\"\\\\n        });\\\\n    }\\\\n\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"CSS选择器模版*\\\",\\\"path\\\":\\\"ejwb.js\\\",\\\"rule\\\":\\\"function 一级(列表, 标题, 图片, 集数, 链接, 访问头) {\\\\n    访问头 = !访问头 ? '' : 访问头\\\\n    var d = [];\\\\n    var code = getCode()\\\\n    pdfa(code, 列表).forEach(function(data) {\\\\n        d.push({\\\\n            title: pdfh(data, 标题),\\\\n            desc: pdfh(data, 集数),\\\\n            pic_url: pd(data, 图片)||图片 + \\\\\\\"@Referer=\\\\\\\" + 访问头,\\\\n            url: 'hiker://empty#immersiveTheme##autoCache#',\\\\n            col_type: \\\\\\\"movie_3\\\\\\\",\\\\nextra: {\\\\n            name: pdfh(data, 标题),\\\\n            url: pd(data, 链接),\\\\n            qz: MY_HOME\\\\n        }\\\\n        });\\\\n    });\\\\n    setResult(d);\\\\n}\\\\n\\\\n\\\\n\\\\nfunction 搜索(列表, 标题, 链接, 描述, 详情, 图片, 访问头) {\\\\n    var d = [];\\\\n    访问头 = !访问头 ? '' : 访问头\\\\n    pdfa(getResCode(), 列表).forEach(function(data) {\\\\n        d.push({\\\\n            title: pdfh(data, 标题),\\\\n            desc: pdfh(data, 描述),\\\\n            pic_url: pd(data, 图片) + \\\\\\\"@Referer=\\\\\\\" + 访问头,\\\\n            url: 'hiker://empty#immersiveTheme##autoCache#',\\\\n            content: pdfh(data, 详情),\\\\n\\\\nextra: {\\\\n            name: pdfh(data, 标题),\\\\n            url: pd(data, 链接),\\\\n            qz: MY_HOME\\\\n        }\\\\n        });\\\\n    });\\\\n    setResult(d);\\\\n}\\\\n\\\\n\\\\n\\\\n\\\\nfunction 最新(选择器, UA) {\\\\n    if (UA == \\\\\\\"PC\\\\\\\") {\\\\n        var code = fetch(getParam('url').replace(\\\\\\\"m.\\\\\\\", \\\\\\\"www.\\\\\\\"));\\\\n    } else {\\\\n        var code = request(getParam('url').replace(\\\\\\\"www.\\\\\\\", \\\\\\\"m.\\\\\\\"));\\\\n    }\\\\n    setResult(pdfh(code, 选择器))\\\\n}\\\\n\\\\n\\\\n\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/qs?rule=阅漫君\\\\\\\")).rule)\\\\n\\\\nfunction 二级(头部列表, 标题, 图片, 描述, 访问头, 作者, 时间, 分类, 简介, 多路线否, 路线列表, 路线名, 选集总列表, 选集列表, 集名, 集url, downloadlazy,当前URL,当前页名,前缀,UA,防重载否) {\\\\n    var d = [];\\\\n\\\\n//头部列表  则默认使用 code 来作为头部列表数据\\\\n//多路线否  true 则使用多路线；false 则使用章路线\\\\n//UA  不填则使用手机端  'PC'则手机端\\\\n\\\\nif (当前页名) {\\\\n    setPageTitle(当前页名)\\\\n}\\\\n\\\\nif(防重载否){\\\\n//网页内容+防止重拉\\\\n    var code = 添加防止网页(当前URL, UA)\\\\n}else{\\\\n    var code = getCode()\\\\n}\\\\n    \\\\n\\\\n    //头部列表数据\\\\n    var 头部 = !头部列表 ? code : pdfa(code, 头部列表)[0];\\\\n    标题 = pdfh(头部, 标题)\\\\n    图片 = pdfh(头部, 图片)||图片\\\\n    if (图片) {\\\\n        图片 = 图片.includes('http') ? 图片 : 前缀 + 图片\\\\n        if (!访问头) {} else if (访问头.substr(0, 1) == '@') {\\\\n            图片 = 图片 + 访问头\\\\n        } else {\\\\n            图片 = 图片 + \\\\\\\"@Referer=\\\\\\\" + 访问头\\\\n        }\\\\n    }\\\\n    \\\\n\\\\n描述 = 描述.includes('$') ? 描述.split('$')[1] + pdfh(头部, 描述.split('$')[0]) : pdfh(头部, 描述)\\\\n\\\\n作者 = 作者.includes('$') ? 作者.split('$')[1] + pdfh(头部, 作者.split('$')[0]) : pdfh(头部, 作者)\\\\n    \\\\n时间 = 时间.includes('$') ? 时间.split('$')[1] + pdfh(头部, 时间.split('$')[0]) : pdfh(头部, 时间)\\\\n\\\\n分类 = 分类.includes('$') ? 分类.split('$')[1] + pdfh(头部, 分类.split('$')[0]) : pdfh(头部, 分类)\\\\n\\\\n    \\\\n    //头部列表\\\\n    添加头部列表(d, 标题, 图片, 描述, 作者, 时间, 分类,当前URL)\\\\n    \\\\n    //路线名与选集数据\\\\n    var 章节json = 优化路线章节数据(多路线否, code, 路线列表,路线名,选集总列表,选集列表,集名,集url,前缀,当前页名,图片)\\\\n\\\\n    //简介\\\\n    添加简介(d, pdfh(code, 简介), 当前URL, '')\\\\n\\\\n   //当没有章节内容，就不显示\\\\n    if (章节json.length > 0) {\\\\n\\\\n        //路线选择\\\\n        var 选择列表 = 添加选择路线(d, 章节json, 当前URL, 多路线否)\\\\n\\\\n        //选择下载\\\\n        添加选择下载(d, 章节json,多路线否)\\\\n\\\\n        //排序与选集\\\\n        添加列表章节(d, 章节json[选择列表].title, 章节json[选择列表].list, lazy, 当前URL, '')\\\\n\\\\n        d.push({\\\\n            col_type: \\\\\\\"long_text\\\\\\\"\\\\n        });\\\\n    }\\\\n    setResult(d)\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级列表*\\\",\\\"path\\\":\\\"ejlb\\\",\\\"rule\\\":\\\"var tabs = []\\\\nvar lists = []\\\\nvar arts = pdfa(html, 线路);\\\\narts.forEach((data, id) => {\\\\n    tabs.push(pdfh(data, 线路名))\\\\n})\\\\nvar conts = pdfa(html, 选集);\\\\nconts.forEach((data, id) => {\\\\n    lists.push(pdfa(data, 选集列表))\\\\n})\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\"lists\\\\\\\");\\\\n}));\\\\nstorage0.putMyVar(\\\\\\\"lists\\\\\\\", lists);\\\\nvar list = lists[getMyVar(MY_URL, '0')];\\\\nvar 排序 = getMyVar(MY_URL + \\\\\\\"章节排序\\\\\\\", '#1aad19\\\\\\\">正序');\\\\nvar 提示 = 排序 == '#FF0000\\\\\\\">倒序' ? '#1aad19\\\\\\\">正序' : '#FF0000\\\\\\\">倒序';\\\\nvar 排序名 = '““””<b><span style=\\\\\\\"color:排序</span></b>'\\\\n\\\\nd.push({\\\\n    title: '““””<b><span style=\\\\\\\"color: ' + 排序 + '</span></b>',\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((排序名, lazy) => {\\\\n        var lists = storage0.getMyVar(\\\\\\\"lists\\\\\\\");\\\\n        var 章节 = lists[getMyVar(MY_URL, '0')];\\\\n        var 排序 = getMyVar(MY_URL + \\\\\\\"章节排序\\\\\\\", '#1aad19\\\\\\\">正序');\\\\n        var 提示 = 排序 == '#FF0000\\\\\\\">倒序' ? '#1aad19\\\\\\\">正序' : '#FF0000\\\\\\\">倒序';\\\\n        updateItem({\\\\n            extra: {\\\\n                id: MY_URL + \\\\\\\"_排序\\\\\\\"\\\\n            },\\\\n            title: 排序名.replace('排序', 提示)\\\\n        })\\\\n        if (排序 == '#1aad19\\\\\\\">正序') {\\\\n            章节.reverse()\\\\n        }\\\\n        let cp = 章节.map((data, ssid) => {\\\\n            return {\\\\n                title: pdfh(data, 'a&&Text'),\\\\n                url: pd(data, 'a&&href') + lazy,\\\\n                col_type: 'text_2',\\\\n                extra: {\\\\n                    cls: MY_URL + \\\\\\\"_选集\\\\\\\"\\\\n                }\\\\n            };\\\\n        });\\\\n        deleteItemByCls(MY_URL + \\\\\\\"_选集\\\\\\\");\\\\n        addItemBefore(MY_URL + \\\\\\\"footer\\\\\\\", cp);\\\\n        putMyVar(MY_URL + \\\\\\\"章节排序\\\\\\\", 提示)\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, 排序名, lazy),\\\\n    col_type: 'text_center_1',\\\\n    extra: {\\\\n        id: MY_URL + \\\\\\\"_排序\\\\\\\"\\\\n    }\\\\n})\\\\ntabs.forEach((data, id) => {\\\\n    d.push({\\\\n        title: getMyVar(MY_URL, '0') == id ? '““' + data + '””' : data,\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((线路, lazy, id) => {\\\\n            var lists = storage0.getMyVar(\\\\\\\"lists\\\\\\\");\\\\n            var 排序 = getMyVar(MY_URL + \\\\\\\"章节排序\\\\\\\", '#1aad19\\\\\\\">正序');\\\\n            var 提示 = 排序 == '#FF0000\\\\\\\">倒序' ? '#1aad19\\\\\\\">正序' : '#FF0000\\\\\\\">倒序';\\\\n\\\\n            线路.forEach((data, xlid) => {\\\\n                updateItem({\\\\n                    title: id == xlid ? '““' + data + '””' : data,\\\\n                    extra: {\\\\n                        id: MY_URL + \\\\\\\"_线路\\\\\\\" + xlid\\\\n                    }\\\\n                });\\\\n            })\\\\n            putMyVar(MY_URL, id)\\\\n            var 章节 = lists[getMyVar(MY_URL, '0')];\\\\n            if (排序 == '#FF0000\\\\\\\">倒序') {\\\\n                章节.reverse()\\\\n            }\\\\n            let cp = 章节.map((data, ssid) => {\\\\n                return {\\\\n                    title: pdfh(data, 'a&&Text'),\\\\n                    url: pd(data, 'a&&href') + lazy,\\\\n                    col_type: 'text_2',\\\\n                    extra: {\\\\n                        cls: MY_URL + \\\\\\\"_选集\\\\\\\"\\\\n                    }\\\\n                };\\\\n            });\\\\n            deleteItemByCls(MY_URL + \\\\\\\"_选集\\\\\\\");\\\\n            addItemBefore(MY_URL + \\\\\\\"footer\\\\\\\", cp);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, tabs, lazy, id),\\\\n        col_type: 'text_center_1',\\\\n        extra: {\\\\n            id: MY_URL + \\\\\\\"_线路\\\\\\\" + id\\\\n        }\\\\n    });\\\\n})\\\\n\\\\nif (排序 == '#FF0000\\\\\\\">倒序') {\\\\n    list.reverse()\\\\n}\\\\nlist.forEach((data, id) => {\\\\n    d.push({\\\\n        title: pdfh(data, 'a&&Text'),\\\\n        url: pd(data, 'a&&href') + lazy,\\\\n        col_type: 'text_2',\\\\n        extra: {\\\\n            cls: MY_URL + \\\\\\\"_选集\\\\\\\"\\\\n        }\\\\n    });\\\\n})\\\\nlet newstip = list.length;\\\\nif (newstip) {\\\\n    setLastChapterRule('js:' + $.toString((newstip) => {\\\\n        setResult('更新至: 第' + newstip + \\\\\\\"集\\\\\\\");\\\\n    }, newstip));\\\\n}\\\\n\\\\nd.push({\\\\n    col_type: \\\\\\\"big_blank_block\\\\\\\",\\\\n    extra: {\\\\n        id: MY_URL + \\\\\\\"footer\\\\\\\"\\\\n    }\\\\n});\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"环境劫持\\\",\\\"path\\\":\\\"hijackEnv\\\",\\\"rule\\\":\\\"var { RULE, isIndex, pageTitle } = MY_PARAMS\\\\nRULE = JSON.parse(base64Decode(RULE))\\\\nvar oriRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE).find((v) => v.title == RULE.title)\\\\nif (isIndex) {\\\\n    RULE = oriRULE\\\\n    var { tabHeader, fyAll } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, RULE))\\\\n    // 处理MY_RULE\\\\n    MY_RULE.class_url = tabHeader.getClass(fyAll ? 'fyAll' : 'fyclass').url\\\\n    MY_RULE.area_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyarea').url\\\\n    MY_RULE.year_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyyear').url\\\\n    MY_RULE.sort_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fysort').url\\\\n    MY_RULE.url = RULE.url\\\\n    MY_RULE.col_type = RULE.col_type\\\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.find_rule\\\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = {}\\\\n} else {\\\\n    RULE.pages = oriRULE.pages\\\\n    // 处理MY_RULE\\\\n    MY_RULE.url = MY_PARAMS.url\\\\n    MY_RULE.col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = RULE.params\\\\n}\\\\nMY_RULE.pages = RULE.pages\\\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\\\nMY_RULE.title = RULE.title\\\\nMY_RULE.ua = RULE.ua\\\\nlog(MY_RULE.url)\\\\n// 载入函数工具\\\\nvar { genMyRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE, {\\\\n    QING_TITLE: QING_TITLE,\\\\n    MY_RULE: MY_RULE,\\\\n    isIndex: isIndex\\\\n})\\\\n// 防止require多次运行\\\\nconst myColl_required = {}\\\\nrequire = function(param0, param1, param2, param3, param4) {\\\\n    if (myColl_required[param0]) return\\\\n    myColl_required[param0] = true\\\\n    param2 = param2 != null ? param2 : 0\\\\n    param3 = MY_TICKET\\\\n    param4 = eval\\\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\\\n}\\\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\\\n    if (myColl_required[param0]) return\\\\n    myColl_required[param0] = true\\\\n    param3 = param3 != null ? param3 : 0\\\\n    param4 = MY_TICKET\\\\n    param5 = eval\\\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\\\n}\\\\nrc = requireCache\\\\n// 最新章节规则环境劫持\\\\nsetLastChapterRule = function(param0) {\\\\n    if (param0.startsWith(\\\\\\\"js:\\\\\\\")) {\\\\n        param0 = 'js:' + $.toString((QING_TITLE, MY_PARAMS) => {\\\\n            eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\\\n            var { runPreRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\n            runPreRule(oriRULE.preRule)\\\\n        }, QING_TITLE, { url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex }) + ';' + param0.slice(3)\\\\n    }\\\\n    method_setLastChapterRule.invoke(javaContext, param0)\\\\n}\\\\n// 动态新增函数劫持\\\\naddItemAfter = function(param0, param1) {\\\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\\\n    else param1 = hijackEl(param1)\\\\n    method_addItemAfter.invoke(javaContext, param0, param1)\\\\n}\\\\naddItemBefore = function(param0, param1) {\\\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\\\n    else param1 = hijackEl(param1)\\\\n    method_addItemBefore.invoke(javaContext, param0, param1)\\\\n}\\\\n//@菜团 环境劫持劫持哪里加个这个-L佬\\\\nrequest = function(param0, param1, param2) {\\\\n    if (param0.includes(\\\\\\\"hiker://page/\\\\\\\")) {\\\\n        let rule = (param0.split(/\\\\\\\\?.*rule=/)[1] || \\\\\\\"\\\\\\\").split(\\\\\\\"&\\\\\\\")[0];\\\\n        let pageUrl = param0.split(\\\\\\\"hiker://page/\\\\\\\")[1].split(\\\\\\\"?\\\\\\\")[0];\\\\n        if (rule !== QING_TITLE) {\\\\n            let ruleCode;\\\\n            if (!rule || rule === RULE.title) {\\\\n                ruleCode = (RULE.pageList || (RULE.pageList = JSON.parse(RULE.pages))).find(v => v.path === pageUrl);\\\\n            }\\\\n            if(ruleCode){\\\\n                return JSON.stringify(ruleCode);\\\\n            }else{\\\\n                return \\\\\\\"\\\\\\\";\\\\n            }\\\\n        }\\\\n    }\\\\n    param2 = MY_RULE;\\\\n    var retStr = method_request.invoke(javaContext, param0, param1, param2);\\\\n    try {\\\\n        if (retStr instanceof java.io.InputStream) {\\\\n            return retStr;\\\\n        }\\\\n    } catch (e) {}\\\\n    return retStr == null ? retStr : retStr + \\\\\\\"\\\\\\\";\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"函数工具\\\",\\\"path\\\":\\\"funcTools\\\",\\\"rule\\\":\\\"let { QING_TITLE, MY_RULE, isIndex } = $.importParam\\\\nif (!MY_RULE) MY_RULE = {}\\\\n\\\\nfunction runCode(rule) {\\\\n    try {\\\\n        let [input, code] = rule.split('.js:')\\\\n        return code ? eval(code) : rule\\\\n    } catch (e) { return rule }\\\\n}\\\\n// 首页链接替换分类\\\\nfunction indexUrl(param) {\\\\n    MY_RULE = JSON.parse(base64Decode(MY_RULE))\\\\n    let pageNum = parseInt(param.split('###')[1]),\\\\n        url = MY_RULE.url,\\\\n        { fyAll, tabHeader } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, MY_RULE))\\\\n\\\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\\\n    url = url.replace(/fypage(?:@(-?\\\\\\\\d+)@)?(?:\\\\\\\\*(\\\\\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\\\n    url = /^([\\\\\\\\s\\\\\\\\S]*?)(?:\\\\\\\\[firstPage=([\\\\\\\\s\\\\\\\\S]*?)\\\\\\\\])?(?:(\\\\\\\\.js:[\\\\\\\\s\\\\\\\\S]*?))?$/.exec(url)\\\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\\\n    return runCode(url[1])\\\\n}\\\\n\\\\nfunction paramHandle(urlParam, ua, urlTmp) {\\\\n    let charset, paramTmp\\\\n    try { // 链接的编码、UA和Referer应该是首先继承首页链接\\\\n        [, , charset, paramTmp] = urlTmp.split(';')\\\\n        paramTmp = paramTmp.match(/^{(.*)}$/)[1].split('&&')\\\\n    } catch (e) { paramTmp = [] }\\\\n    let UserAgent = paramTmp.find((v) => v.startsWith('User-Agent@')),\\\\n        Referer = paramTmp.find((v) => v.startsWith('Referer@'))\\\\n    urlParam[0] = urlParam[0] || 'GET'\\\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\\\n    try {\\\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\\\n    } catch (e) { urlParam[2] = [] }\\\\n    // 添加全局UA和上级Referer\\\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\\\n        if (UserAgent) urlParam[2].push(UserAgent)\\\\n        else if (ua == 'pc')\\\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n        else if (ua == 'mobile')\\\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n    }\\\\n    if (Referer && !urlParam[2].some((v) => v.startsWith('Referer@')))\\\\n        urlParam[2].push(Referer)\\\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\\\n    return urlParam.join(';')\\\\n}\\\\n// 预处理并初始化config\\\\nfunction runPreRule(rule) {\\\\n    if ((typeof MY_PAGE != 'undefined' &&  MY_PAGE == 1) &&\\\\n         (isIndex || !getMyVar('$preRule_' + MY_RULE.title))) {\\\\n        eval(rule)\\\\n        putMyVar('$preRule_' + MY_RULE.title, 'T')\\\\n    }\\\\n    let _cfg = getMyVar('initConfig', '{}')\\\\n    if (_cfg && _cfg.length > 0) {\\\\n        config = JSON.parse(_cfg)\\\\n    }\\\\n}\\\\n// 正文解析通用变量\\\\nfunction genMyRule() {\\\\n    let RULE = Object.assign({}, MY_RULE)\\\\n    delete RULE.last_chapter_rule\\\\n    delete RULE.preRule\\\\n    delete RULE.pageList\\\\n    delete RULE.pages\\\\n    return RULE\\\\n}\\\\n\\\\nfunction genExUrl(url) {\\\\n    url = url.split(';')\\\\n    return url.shift() + ';' + paramHandle(url, MY_RULE.ua, MY_RULE.url)\\\\n}\\\\n\\\\nhijackLazyRule = $.toString((QING_TITLE, MY_PARAMS) => {\\\\n    if (!MY_RULE) MY_RULE = {}\\\\n    MY_PARAMS = JSON.parse(base64Decode(MY_PARAMS))\\\\n    eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\\\n    var {\\\\n        paramHandle,\\\\n        genExUrl,\\\\n        hijackLazyRule,\\\\n        hijackEl\\\\n    } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\n}, QING_TITLE, base64Encode(JSON.stringify({ url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex })))\\\\n\\\\nfunction hijackEl(el) {\\\\n    if(!el || typeof el != 'object') return\\\\n    if (!el.extra) el.extra = {}\\\\n    el.col_type = el.col_type || MY_RULE.col_type\\\\n    let NOW_RULE = Object.assign(genMyRule(), { params: el.extra })\\\\n\\\\n    if (typeof el.url != 'string' ||\\\\n        ['x5_webview_single', 'input'].some((v) => el.col_type == v) ||\\\\n        ['海阔视界', 'javascript:'].some((v) => el.url.startsWith(v)) ||\\\\n        ['rule', 'pics', 'toast', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'x5Rule', 'webRule',\\\\n            'download', 'share', 'fileSelect', 'video'].some((v) => el.url.startsWith(v + '://'))) {\\\\n        return el\\\\n    } else if (el.url.startsWith('input://')) {\\\\n        let para = JSON.parse(el.url.slice(8))\\\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\\\n        el.url = 'input://' + JSON.stringify(para)\\\\n        return el\\\\n    } else if (el.url.startsWith('confirm://')) {\\\\n        let reIndex = el.url.indexOf('.js:')\\\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\\\n        return el\\\\n    } else if (el.url.startsWith('select://')) {\\\\n        let para = JSON.parse(el.url.slice(9))\\\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\\\n        el.url = 'select://' + JSON.stringify(para)\\\\n        return el\\\\n    } else if (el.url.includes('@rule=')) {\\\\n        let [_, url, rule] = el.url.match(/^([\\\\\\\\s\\\\\\\\S]*?)@rule=([\\\\\\\\s\\\\\\\\S]*)$/)\\\\n        el.url = url\\\\n        NOW_RULE.detail_find_rule = rule\\\\n        NOW_RULE.detail_col_type = MY_RULE.col_type\\\\n    } else if (el.url.startsWith('hiker://page/')) {\\\\n        if (el.url.includes('rule=') || el.extra.rule)\\\\n            return el\\\\n        let [_, path, flag, params] = el.url.match(/^hiker:\\\\\\\\/\\\\\\\\/page\\\\\\\\/(.+?)(#.*?)?(?:\\\\\\\\?(.*))?$/),\\\\n            subPage = MY_RULE.pageList.find((v) => v.path == path),\\\\n            subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\\\n        el.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (el.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\\\n        NOW_RULE.detail_find_rule = subPage.rule\\\\n        NOW_RULE.detail_col_type = subPage.col_type\\\\n    } else if (el.url.includes('@lazyRule=')) {\\\\n        let reIndex = el.url.indexOf('.js:')\\\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\\\n        return el\\\\n    } else if (isIndex) {\\\\n        if (!MY_RULE.detail_find_rule || /hiker:\\\\\\\\/\\\\\\\\/(?!empty.+$)/.test(el.url)) return el\\\\n    } else {\\\\n        return el\\\\n    }\\\\n    el.extra = Object.assign({}, el.extra, {\\\\n        url: genExUrl(el.url),\\\\n        RULE: base64Encode(JSON.stringify(NOW_RULE)),\\\\n        pageTitle: isIndex && el.title\\\\n    })\\\\n    el.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n    return el\\\\n}\\\\n$.exports = {\\\\n    runCode: runCode,\\\\n    indexUrl: indexUrl,\\\\n    paramHandle: paramHandle,\\\\n    runPreRule: runPreRule,\\\\n    genMyRule: genMyRule,\\\\n    genExUrl: genExUrl,\\\\n    hijackLazyRule: hijackLazyRule,\\\\n    hijackEl: hijackEl\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"漫画解析*\\\",\\\"path\\\":\\\"js\\\",\\\"rule\\\":\\\"function 爱米推类(input) {\\\\n\\\\ttry{\\\\n        var url = input\\\\n        .replace('m.'||'mh.'||'wap.', 'www.')\\\\n        .replace('ikr.', 'icekr.');\\\\n        var html = request(url, {\\\\n    headers: {\\\\n        'User-Agent': PC_UA,\\\\n        'Referer': url\\\\n    }\\\\n})\\\\n    eval(pdfh(pdfa(html, 'body&&script:not([src]):not([type])')[0], 'script&&Html'));\\\\n    var pics = [];\\\\n    if (chapterImages.length > 0) {\\\\n        var host = request(input).match(/img src=\\\\\\\"(.*?)\\\\\\\\/image/)[1];\\\\n        chapterImages.forEach(img => {\\\\n            if (img.indexOf(\\\\\\\"http\\\\\\\") > -1) {\\\\n            pics.push(img + '@Referer=' + url)\\\\n            } else {\\\\n            pics.push(host + img + '@Referer=' + url)\\\\n            }\\\\n        })\\\\n    } else {\\\\n        var html = request(input);\\\\n        var pics = [];\\\\n        if(/k_total/.test(html)){\\\\n            var Page = pdfh(html, '#k_total&&Text');\\\\n            if(Page.length > 0){\\\\n                var host = html.match(/mip-img src=\\\\\\\"(.*?)image/)[1];\\\\n            for (var i = 0; i < Page; i++) {\\\\n        pics.push(host + 'image/view/' + input.match(/\\\\\\\\d+/)[0] + '/' + i + '.webp'+ '@Referer=')\\\\n            }\\\\n    } else {\\\\n        var res1 = {};\\\\n        var d1 = [];\\\\n        var jsHtml = fetch(input, {\\\\n            headers: {\\\\n                \\\\\\\"content-type\\\\\\\": \\\\\\\"UTF-8\\\\\\\",\\\\n                \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mobile\\\\\\\"\\\\n            },\\\\n            method: \\\\\\\"GET\\\\\\\"\\\\n        });\\\\n        var pics = [];\\\\n        for (var k = 1;; k++) {\\\\n            try {\\\\n                var jsHtml = fetch(input.split(\\\\\\\".html\\\\\\\")[0] + \\\\\\\"-\\\\\\\" + k + \\\\\\\".html\\\\\\\", {\\\\n                    headers: {\\\\n                        \\\\\\\"content-type\\\\\\\": \\\\\\\"UTF-8\\\\\\\",\\\\n                        \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mobile\\\\\\\"\\\\n                    },\\\\n                    method: \\\\\\\"GET\\\\\\\"\\\\n                });\\\\n                let page = pdfh(jsHtml, \\\\\\\"\\\\\\\");\\\\n                if (page && page.includes(\\\\\\\"/\\\\\\\")) {\\\\n                    page = parseInt(page.split(\\\\\\\"/\\\\\\\")[1]);\\\\n                    var jsUrl = parseDomForHtml(jsHtml, \\\\\\\".erPag&&mip-img||img&&src\\\\\\\")+ '@Referer=';\\\\n                    if (jsUrl.indexOf(\\\\\\\"png\\\\\\\") > -1) {\\\\n                        break\\\\n                    }\\\\n                    let urls = [];\\\\n                    for (let i = 2; i <= page; i++) {\\\\n                        urls.push({\\\\n                            url: input.split(\\\\\\\".html\\\\\\\")[0] + \\\\\\\"-\\\\\\\" + i + \\\\\\\".html\\\\\\\",\\\\n                            options: {\\\\n                                headers: {\\\\n                                    \\\\\\\"content-type\\\\\\\": \\\\\\\"UTF-8\\\\\\\",\\\\n                                    \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mobile\\\\\\\"\\\\n                                },\\\\n                                method: \\\\\\\"GET\\\\\\\"\\\\n                            }\\\\n                        })\\\\n                    }\\\\n                    let htmls = bf(urls);\\\\n                    for (let i = 0; i < htmls.length; i++) {\\\\n                        var jsUrl = parseDomForHtml(htmls[i], \\\\\\\".erPag&&mip-img||img&&src\\\\\\\")+ '@Referer=';\\\\n                        if (jsUrl.indexOf(\\\\\\\"png\\\\\\\") > -1) {\\\\n                            break\\\\n                        }\\\\n                    }\\\\n                    pics.push(jsUrl);\\\\n                }\\\\n                var jsUrl = parseDomForHtml(jsHtml, \\\\\\\".erPag&&mip-img||img&&src\\\\\\\")+ '@Referer=';\\\\n                if (jsUrl.indexOf(\\\\\\\"png\\\\\\\") > -1) {\\\\n                    break\\\\n                } else {\\\\n                    pics.push(jsUrl);\\\\n                }\\\\n            } catch (e) {\\\\n                break\\\\n            }\\\\n        }\\\\n    }\\\\n        } else {\\\\n            var list = pdfa(html, 'body&&.scroll-item||.image-content||#scroll-image');\\\\n        var first = pdfa(html, 'body&&#image');\\\\n        list = first.concat(list);\\\\n        list.forEach(img => {\\\\n            pics.push(pdfh(img, 'img&&data-src||src') + '@Referer=' + input)\\\\n        })\\\\n        }\\\\n    }\\\\n    } catch(e) {\\\\n        var html = request(input);\\\\n        var pics = [];\\\\n        var list = pdfa(html, 'body&&.scroll-item||.image-content||#scroll-image');\\\\n        var first = pdfa(html, 'body&&#image');\\\\n        list = first.concat(list);\\\\n        list.forEach(img => {\\\\n            pics.push(pdfh(img, 'img&&data-src||src') + '@Referer=' + input)\\\\n        })\\\\n    }\\\\n    return \\\\\\\"pics://\\\\\\\" + pics.join(\\\\\\\"&&\\\\\\\")\\\\n}\\\\n$.exports.jx=爱米推类;\\\\n\\\\nfunction 包子(input) {\\\\n    var id = true;\\\\n    var code = request(input)\\\\n    var pics = [];\\\\n    var to_Repeat = false;\\\\n\\\\n\\\\n    while (id) {\\\\n        pdfa(code, \\\\\\\".chapter-main&&amp-img\\\\\\\")\\\\n            .forEach(data => pics.push(pdfh(data, \\\\\\\"amp-img&&src\\\\\\\") + '@Referer=https://www.webmota.com/'));\\\\n        var next_Page = pdfh(code, \\\\\\\".next_chapter,-1&&Html\\\\\\\")\\\\n        if (next_Page.includes('下一页')) {\\\\n            code = request(pdfh(next_Page, \\\\\\\"a&&href\\\\\\\"))\\\\n            to_Repeat = true;\\\\n        } else {\\\\n            id = false;\\\\n        }\\\\n    }\\\\n\\\\n    //去除重复图片\\\\n    if (to_Repeat) {\\\\n        for (let i = 0; i < pics.length; i++) {\\\\n            while (pics.indexOf(pics[i], i + 1) != -1) {\\\\n                pics.splice(pics.indexOf(pics[i], i + 1), 1)\\\\n            }\\\\n        }\\\\n    }\\\\n\\\\n    return \\\\\\\"pics://\\\\\\\" + pics.join(\\\\\\\"&&\\\\\\\");\\\\n}\\\\n$.exports.bz=包子;\\\\n\\\\nfunction 古风(input) {\\\\n\\\\tvar html = fetchPC(input);\\\\n\\\\teval(pdfh(pdfa(html, 'body&&script:not([src]):not([type])')[0], 'script&&Html'));\\\\n\\\\tvar pics = [];\\\\n\\\\tfor (var i in chapterImages) {\\\\n\\\\t\\\\tpics.push('https://res.xiaoqinre.com/' + chapterPath + chapterImages[i] + '@Referer=https://www.123gf.com')\\\\n\\\\t\\\\t}\\\\n\\\\treturn \\\\\\\"pics://\\\\\\\" + pics.join(\\\\\\\"&&\\\\\\\")\\\\n}\\\\n$.exports.GF=古风;\\\\n\\\\nfunction 爱米(input) {\\\\n        var html = request(input);\\\\n        var pics = [];\\\\n        var list = pdfa(html, 'body&&.scroll-item||.image-content||#scroll-image');\\\\n        var first = pdfa(html, 'body&&#image');\\\\n        list = first.concat(list);\\\\n        list.forEach(img => {\\\\n            pics.push(pdfh(img, 'img&&data-src||src') + '@Referer=' + input)\\\\n        })\\\\n        return \\\\\\\"pics://\\\\\\\" + pics.join(\\\\\\\"&&\\\\\\\")\\\\n}\\\\n$.exports.IM=爱米;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"云口令*\\\",\\\"path\\\":\\\"import\\\",\\\"rule\\\":\\\"writeFile('hiker://files//rules/Tz/JM',fetch(input))\\\\n'toast://已从云口令获取阅漫君源'\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"更新详情*\\\",\\\"path\\\":\\\"Up\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar items = [];\\\\nvar img = 'https://bing.img.run/1366x768.php';\\\\nitems.push({\\\\n    img: img,\\\\n    url: img + \\\\\\\"#.jpg\\\\\\\",\\\\n    desc: '0',\\\\n    col_type: 'card_pic_1'\\\\n});\\\\n\\\\nitems.push({\\\\n    title: \\\\\\\"““””<h4>【阅漫君反馈收集】</h4>\\\\\\\" + '<span style=\\\\\\\"color: grey\\\\\\\">小小</span>',\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/manageRule#noHistory##noRecordHistory#?rule=道长仓库Pro\\\\\\\",\\\\n    extra: {\\\\n        lver: MY_PARAMS.version || \\\\\\\"获取版本失败，自行查看\\\\\\\",\\\\n        id: \\\\\\\"6975\\\\\\\"\\\\n    }\\\\n});\\\\n\\\\nif (getItem(\\\\\\\"read_policy\\\\\\\") !== \\\\\\\"1\\\\\\\") {\\\\n    items.push({\\\\n        title: '““””<small><font color=#871f78>本规则数据来源于网络，如您喜欢，请支持官方</font></small>',\\\\n        desc: '““””<small><font color=#f20c00>本规则仅限免费学习交流使用，请于导入后24小时内删除，任何组织或个人不得以任何方式方法传播或售卖此规则的整体或部分！</font></small>',\\\\n        url: $('#noHistory#').lazyRule(() => {\\\\n            setItem(\\\\\\\"read_policy\\\\\\\", \\\\\\\"1\\\\\\\")\\\\n            refreshPage(false)\\\\n            return \\\\\\\"toast://你已同意该协议\\\\\\\"\\\\n        }),\\\\n        col_type: 'text_center_1'\\\\n    })\\\\n}\\\\n\\\\nitems.push({\\\\n    title: '““””<b>使用说明</b>',\\\\n    url: \\\\\\\"切换分组搜索即可\\\\\\\",\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n});\\\\n\\\\nlet newVersion;\\\\nlet myVersion = MY_PARAMS.version;\\\\ntry {\\\\n    newVersion = JSON.parse(fetchPC(\\\\\\\"http://hiker.nokia.press/hikerule/dev/getbyid?id=6975\\\\\\\", {\\\\n        timeout: 1000\\\\n    })).result.ver;\\\\n} catch (e) {\\\\n    toast(\\\\\\\"道长仓库抽风了，本次未检测到新版信息\\\\\\\");\\\\n    newVersion = myVersion;\\\\n}\\\\nlet isUpdate = Number(newVersion) > Number(myVersion);\\\\nlet isVer = Number(newVersion) === Number(myVersion);\\\\nif (isUpdate) {\\\\n    log('有新版本:' + newVersion + ',当前:' + myVersion);\\\\n}\\\\nitems.push({\\\\n    title: isUpdate ? \\\\\\\"🆙新版本\\\\\\\" : \\\\\\\"规则发布页&反馈\\\\\\\",\\\\n    url: isUpdate ? \\\\\\\"rule://5rW36ZiU6KeG55WM6aaW6aG16aKR6YGT6KeE5YiZ44CQ6IGa5ryr8J+UruOAke+/pWhvbWVfcnVsZV91cmzvv6VodHRwOi8vaGlrZXIubm9raWEucHJlc3MvaGlrZXJ1bGUvcnVsZWxpc3QuanNvbj9pZD0yODQ3\\\\\\\" : \\\\\\\"hiker://page/manageRule#noHistory##noRecordHistory#?rule=道长仓库Pro\\\\\\\",\\\\n    col_type: \\\\\\\"text_2\\\\\\\",\\\\n    extra: {\\\\n        lver: MY_PARAMS.version || \\\\\\\"获取版本失败，自行查看\\\\\\\",\\\\n        id: \\\\\\\"6975\\\\\\\"\\\\n    }\\\\n});\\\\nconst Color = \\\\\\\"#19B89D\\\\\\\";\\\\nvar des_desc = \\\\n'<h1 style=\\\\\\\"text-align: center;\\\\\\\">🐾更新[202412.3]</h1>' +\\\\n    '<<blockquote><font color=\\\\\\\"red\\\\\\\">①剔除失效源，漫蛙/包子修复</br></<blockquote>' +\\\\n\\\\n'<h1 style=\\\\\\\"text-align: center;\\\\\\\">🐾更新[1105]</h1>' +\\\\n    '<<blockquote><font color=\\\\\\\"red\\\\\\\">①更换远程仓库，优化加载速度 并增加更新长按规则名 清除缓存即可</br>②修复漫蛙图源加载不出来<br></<blockquote>' +\\\\n\\\\n'<h1 style=\\\\\\\"text-align: center;\\\\\\\">🐾更新[231213]</h1>' +\\\\n    '<<blockquote><font color=\\\\\\\"<br>剔除无用源，修复部分源报错</br></<blockquote>'\\\\n\\\\nitems.push({\\\\n    title: '更新详情 <small><small><span style=\\\\\\\"color:#19B89D\\\\\\\">展开></span></small></small>',\\\\n    img: \\\\\\\"https://lanmeiguojiang.com/tubiao/more/197.png\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((jjid, decid, des_desc) => {\\\\n        if (getMyVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"收起\\\\\\\") == \\\\\\\"收起\\\\\\\") {\\\\n            putMyVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"展开\\\\\\\");\\\\n\\\\n            updateItem({\\\\n                extra: {\\\\n                    id: jjid\\\\n                },\\\\n                title: '更新详情 <small><small><span style=\\\\\\\"color:#19B89D\\\\\\\">收起></span></small></small>'\\\\n            })\\\\n\\\\n            updateItem({\\\\n                extra: {\\\\n                    textSize: 14,\\\\n                    lineSpacing: 3,\\\\n                    id: decid\\\\n                },\\\\n                title: '<span style=\\\\\\\"color:#808080\\\\\\\">' + des_desc + '</span>'\\\\n            })\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        } else {\\\\n            putMyVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"收起\\\\\\\");\\\\n\\\\n            updateItem({\\\\n                extra: {\\\\n                    id: jjid\\\\n                },\\\\n                title: '更新详情<small><small><span style=\\\\\\\"color:#19B89D\\\\\\\">展开></span></small></small>'\\\\n            })\\\\n\\\\n            updateItem({\\\\n                extra: {\\\\n                    textSize: 14,\\\\n                    lineSpacing: 3,\\\\n                    id: decid\\\\n                },\\\\n                title: '<span style=\\\\\\\"color:#808080\\\\\\\">' + des_desc.substr(0, 150)\\\\n            })\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }\\\\n\\\\n    }, MY_RULE + \\\\\\\"_jjid\\\\\\\", MY_RULE + \\\\\\\"_decid\\\\\\\", des_desc),\\\\n    col_type: \\\\\\\"avatar\\\\\\\",\\\\n    extra: {\\\\n        id: MY_RULE + \\\\\\\"_jjid\\\\\\\"\\\\n    }\\\\n});\\\\n\\\\nitems.push({\\\\n    title: '<span style=\\\\\\\"color:#808080\\\\\\\">' + des_desc.substr(0, 150),\\\\n    col_type: \\\\\\\"rich_text\\\\\\\",\\\\n    extra: {\\\\n        textSize: 14,\\\\n        lineSpacing: 3,\\\\n        id: MY_RULE + \\\\\\\"_decid\\\\\\\"\\\\n    }\\\\n});\\\\n\\\\nres.data = items;\\\\nsetHomeResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"使用帮助*\\\",\\\"path\\\":\\\"Help\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar items = [];\\\\n\\\\nitems.push({\\\\n    title:'二级页面标题双击优化，在顶部则双击到底部，否则双击回顶部',\\\\n    col_type: 'rich_text'\\\\n});\\\\n\\\\nitems.push({\\\\n    img: 'https://s1.ax1x.com/2022/11/04/xLhgoR.jpg',\\\\n    desc: '0',\\\\n    col_type: 'pic_1_full'\\\\n});\\\\n\\\\nitems.push({\\\\n    img: 'https://s1.ax1x.com/2022/11/04/xLhcw9.jpg',\\\\n    desc: '0',\\\\n    col_type: 'pic_1_full'\\\\n});\\\\n\\\\nres.data = items;\\\\nsetHomeResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索*\\\",\\\"path\\\":\\\"search\\\",\\\"rule\\\":\\\"function convert1(str) {\\\\n    let c = str.split(\\\\\\\";\\\\\\\")\\\\n    return {\\\\n        列表: c[0],\\\\n        标题: c[1],\\\\n        链接: c[2],\\\\n        描述: c[3],\\\\n        详情: c[4],\\\\n        图片: c[5]\\\\n    }\\\\n}\\\\n\\\\nfunction merge(source, target) {\\\\n    let keys = Object.keys(source)\\\\n    for (let i in keys) {\\\\n        target[keys[i]] = source[keys[i]]\\\\n    }\\\\n}\\\\n\\\\nfunction 搜索(obj) {\\\\n    var d = [];\\\\n    if ($.type(obj) == \\\\\\\"string\\\\\\\") {\\\\n        obj = convert1(obj)\\\\n    }\\\\n    if (obj.规则) {\\\\n        let c = convert1(obj.规则)\\\\n        merge(c, obj)\\\\n    }\\\\n    let arr = pdfa(getResCode(), obj.列表);\\\\n       if (obj.列表处理 != null) {\\\\n            arr = obj.链接处理(arr)\\\\n        }\\\\n    for (let it of arr) {\\\\n        let url = pd(it, obj.链接)\\\\n        if (obj.链接处理 != null) {\\\\n            url = obj.链接处理(url)\\\\n        }\\\\n        let title = pdfh(it, obj.标题)\\\\n        if (obj.标题处理 != null) {\\\\n            title = obj.标题处理(title)\\\\n        }\\\\n        let pic = pd(it, obj.图片)\\\\n        if (obj.图片处理 != null) {\\\\n            pic = obj.图片处理(pic)\\\\n        }\\\\n        d.push({\\\\n            title: obj.标题 ? pdfh(it, obj.标题) : \\\\\\\"\\\\\\\",\\\\n            url: url+'#autoCache#',\\\\n            col_type: \\\\\\\"\\\\\\\",\\\\n            desc: obj.描述 ? pdfh(it, obj.描述) : \\\\\\\"\\\\\\\",\\\\n            content: obj.详情 ? pdfh(it, obj.详情) : \\\\\\\"\\\\\\\",\\\\n            pic_url: pic,\\\\n            extra: {\\\\n                ytitle: title,\\\\n                ypic: pic,\\\\n                yurl: url.replace('hiker://empty##','')\\\\n            }\\\\n        });\\\\n\\\\n    }\\\\n    setResult(d);\\\\n}\\\\nvar tool = {\\\\n    搜索: 搜索\\\\n}\\\\n$.exports = tool\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"DES*\\\",\\\"path\\\":\\\"des\\\",\\\"rule\\\":\\\"var javaImport = new JavaImporter();\\\\njavaImport.importPackage(\\\\n    Packages.java.lang,\\\\n    Packages.java.security,\\\\n    Packages.java.util,\\\\n    Packages.java.io,\\\\n    Packages.java.text,\\\\n    Packages.javax.crypto,\\\\n    Packages.javax.crypto.spec\\\\n);\\\\nwith(javaImport) {\\\\n   function De(str) {\\\\n        var generateSecret = SecretKeyFactory.getInstance(\\\\\\\"desede\\\\\\\").generateSecret(new DESedeKeySpec(String('OW84U8Eerdb99rtsTXWSILDO').getBytes()));\\\\n        var instance = Cipher.getInstance(\\\\\\\"desede/CBC/PKCS5Padding\\\\\\\");\\\\n        instance.init(2, generateSecret, new IvParameterSpec(String('SK8bncVu').getBytes()));\\\\n        return String(instance.doFinal(_base64.decode(str, 2)));        \\\\n    }\\\\n}\\\\n\\\\n/*\\\\neval(getCryptoJS())\\\\nvar key = CryptoJS.enc.Utf8.parse('OW84U8Eerdb99rtsTXWSILDO')\\\\nvar iv = CryptoJS.enc.Utf8.parse('SK8bncVu')\\\\n\\\\nfunction De(data, encoding) {\\\\n    var decrypted = CryptoJS.TripleDES.decrypt(data, key, {\\\\n        iv: iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7\\\\n    });\\\\n    if (!encoding) {\\\\n        return decrypted.toString(CryptoJS.enc.Utf8);\\\\n    }\\\\n    return decrypted.toString(CryptoJS.enc.Base64);\\\\n};\\\\n*/\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"解密\\\",\\\"path\\\":\\\"image\\\",\\\"rule\\\":\\\"$.exports.imageDecrypt = function() {\\\\n        var javaImport = new JavaImporter();\\\\n        javaImport.importPackage(\\\\n            Packages.com.example.hikerview.utils,\\\\n            Packages.java.lang,\\\\n            Packages.java.security,\\\\n            Packages.java.util,\\\\n            Packages.java.io,\\\\n            Packages.java.text,\\\\n            Packages.javax.crypto,\\\\n            Packages.javax.crypto.spec\\\\n        );\\\\n        with(javaImport) {\\\\n            let bytes = FileUtil.toBytes(input);\\\\n            function decryptData(bArr) {\\\\n                var cipher = Cipher.getInstance(\\\\\\\"AES/CBC/PKCS7Padding\\\\\\\");\\\\n                cipher.init(2, new SecretKeySpec(String('my2ecret782ecret').getBytes(), 'AES'), new IvParameterSpec(String('my2ecret782ecret').getBytes()));\\\\n                return cipher.doFinal(bArr);\\\\n            }\\\\n            bytes = decryptData(bytes);\\\\n            return FileUtil.toInputStream(bytes);\\\\n        }\\\\n    }\\\"}]\",\"proxy\":\"\"}","picUrl":"https://www.helloimg.com/i/2024/12/25/676c1ff5b4df8.jpg","title":"漫蛙"}