API tools faq
paste
xiaomianao666

小程序：聚漫🔮

xiaomianao666
Mar 2nd, 2024
212
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 187.58 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@聚漫🔮@{"last_chapter_rule":"","title":"聚漫🔮","author":"","url":"hiker://empty","version":230219109,"col_type":"icon_small_4","class_name":"","type":"all","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nconst QING_TITLE = getMyVar('myCollection'),\n    newWindow = readFile('newWindow'),\n    typeShow = getMyVar('typeShow', '@'),\n    types = {\n        'all': '🍀优质',\n        'video': '🖥动漫',\n        'music': '💽音乐',\n        'live': '🎛直播',\n        'cartoon': '🔮漫画',\n        'read': '📙书',\n        'picture': '📚图片',\n        'news': '🚫无搜索',\n        'tool': '📥下载',\n        'other': '✈️'\n    }\nlet el = [{\n        title: ' ' + QING_TITLE.bold() + ' &nbsp &nbsp ' + '⚙ 聚漫🔮设置 ⚙'.small(),\n        url: 'hiker://page/Config?rule=' + QING_TITLE + '&#noRecordHistory#',\n        img: MY_RULE.icon || 'hiker://images/icon1',\n        col_type: 'avatar',\n        extra: {\n            version: MY_RULE.version\n        }\n    }, {\n        desc: '0',\n        url: 'hiker://page/Main.view?rule=本地资源管理',\n        img: 'hiker://images/card_bg',\n        col_type: 'card_pic_1'\n    }, {\n        url: '\"hiker://search?s=\"+input',\n        desc: '这是聚漫🔮的搜索哦~~',\n        title: '搜索',\n        col_type: 'input',\n        extra: {\n            rules: $.toString((QING_TITLE, typeShow) => {\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\n                if (typeShow[0] == '@') {\n                    let filterKey = typeShow.slice(1)\n                    if (filterKey) rules = rules.filter((v) => v.title.includes(filterKey))\n                } else rules = rules.filter((v) => v.type == typeShow);\n                let yux=\"yux\"+Date.now();\n                let el = $.toString((QING_TITLE, yux) => {\n                    let {\n                        hijackEl\n                    } = $.require('hiker://page/funcTools?rule=' + QING_TITLE, {\n                        QING_TITLE:QING_TITLE,\n                        isIndex: $.hiker[yux],\n                        MY_RULE:MY_RULE\n                    })\n\n                    $.hiker.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                        param0 = param0.map(hijackEl);\n                        method_setResult.invoke(javaContext, param0, param1, param2, param3)\n                    }\n                    $.hiker.setHomeResult = setResult\n                    $.hiker.setSearchResult = setResult\n                }, QING_TITLE, yux);\n                rules = rules.map((v,i)=> {\n                    if (v.searchFind.startsWith('js:')) {\n                        v.searchFind = \"js:$.hiker.\"+yux+\"=\"+i+\";\" + el + \";\" + v.searchFind.slice(3);\n                    }\n                    return v;\n                });\n                return JSON.stringify(rules)\n            }, QING_TITLE, typeShow),\n            defaultValue: getMyVar('searchKey', ''),\n            onChange: \"putMyVar('searchKey',input)\"\n        }\n    }],\n    rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE),\n    rulesType = rules.reduce((obj, v) => {\n        let type = v.type\n        if (type) {\n            if (!Array.isArray(obj[type]))\n                obj[type] = []\n            obj[type].push(v)\n        }\n        return obj\n    }, {})\nif (typeShow[0] == '@') {\n    let filterKey = typeShow.slice(1)\n    if (filterKey) rules = rules.filter((v) => v.title.includes(filterKey))\n}\nel.push({\n    img: 'https://lanmeiguojiang.com/tubiao/ke/1.png',\n    title: '收藏',\n    url: \"hiker://collection?group=聚漫🔮\",\n    col_type: \"icon_2\"\n}, {\n    img: 'https://lanmeiguojiang.com/tubiao/ke/137.png',\n    title: '历史',\n    url: \"hiker://history\",\n    col_type: \"icon_2\"\n})\nel.push(typeShow[0] == '@' ? {\n    title: '““””' + ('全部' + (typeShow[1] ? '[' + typeShow.slice(1) + ']' : '')).bold().fontcolor('#12b668') + ' ' + (rules.length).toString().small(),\n    url: $(typeShow.slice(5), '查找小程序关键词').input(() => {\n        putMyVar('typeShow', '@' + input)\n        refreshPage(false)\n        return 'hiker://empty'\n    }),\n    col_type: 'scroll_button'\n} : {\n    title: '““””全部 ' + (rules.length).toString().small(),\n    url: $('#noLoading#').lazyRule(() => {\n        putMyVar('typeShow', '@')\n        refreshPage(false)\n        return 'toast://再次点击【全部】可查找小程序'\n    }),\n    col_type: 'scroll_button'\n})\n\nfor (let k in types)\n    if (k in rulesType)\n        el.push({\n            title: '““””' + (k == typeShow ? types[k].bold().fontcolor('#12b668') : types[k]) + ' ' + (rulesType[k].length).toString().small(),\n            url: k == typeShow ? 'hiker://empty' : $('#noLoading#').lazyRule((k) => {\n                putMyVar('typeShow', k)\n                refreshPage(false)\n                return 'hiker://empty'\n            }, k),\n            col_type: 'scroll_button'\n        })\nif (getItem(\"read_policy\") !== \"1\") {\n    el.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\nif (getItem(\"data\") !== \"1\") {\n    url = getMyVar('remoteUrl')\n    el.push({\n        title: '““””<small><font color=#871f78>点击获取漫画源</font></small>',\n        url: $('#noHistory#').lazyRule((url) => {\n            setItem(\"data\", \"1\")\n            requireDownload('https://agit.ai/DreamOvO/JuMan/raw/branch/master/JM', url)\n            back(false)\n            refreshPage(true)\n            return \"toast://数据已获取\"\n        }, url),\n        col_type: 'text_center_1'\n    })\n}\nif (typeShow[0] != '@') rules = rulesType[typeShow]\nlet { paramHandle } = $.require('hiker://page/funcTools?rule=' + QING_TITLE, {})\nrules.forEach((v) => {\n    let urlParam = v.url.split(';'),\n        ruleTmp = {\n            title: v.title, url: urlParam.shift(),\n            class_name: v.class_name, class_url: v.class_url,\n            area_name: v.area_name, area_url: v.area_url,\n            year_name: v.year_name, year_url: v.year_url,\n            sort_name: v.sort_name, sort_url: v.sort_url\n        },\n        fypage = ruleTmp.url.includes('fypage') ? 'fypage' : '1',\n        domain = (/^https?:\\/\\/[^/?#]+/i.exec(ruleTmp.url) || ['hiker://empty'])[0],\n        d = {\n            title: v.title,\n            url: 'hiker://page/frameLoad',\n            img: v.icon || 'hiker://images/icon1',\n            extra: {\n                url: domain + '/#noHistory##noRecordHistory####' + fypage +\n                    '.js:let { runCode, indexUrl } = $.require(\"hiker://page/funcTools？？rule=' + QING_TITLE + '\", '\n                     + JSON.stringify({\n                        MY_RULE: base64Encode(JSON.stringify(ruleTmp)),\n                        QING_TITLE: QING_TITLE\n                    }) + ')；；indexUrl(input);' + paramHandle(urlParam, v.ua),\n                RULE: base64Encode(JSON.stringify({ title: v.title })),\n                isIndex: true\n            }\n        }\n    if (newWindow) Object.assign(d.extra, {\n        newWindow: true,\n        windowId: QING_TITLE + '_' + d.title\n    })\n    el.push(d)\n})\nsetResult(el)","search_url":"hiker://empty?keyword=**","group":"①轻合集","searchFind":"js:\nsetResult([{\n    title: \"点我开始聚漫•视界聚搜\",\n    url: \"hiker://search?s=\" + getParam(\"keyword\"),\n    extra: {\n        rules: $.toString(() => {\n            const QING_TITLE = getMyVar('myCollection'),\n                typeShow = getMyVar('typeShow', '@')\n            let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\n                if (typeShow[0] == '@') {\n                    let filterKey = typeShow.slice(1)\n                    if (filterKey) rules = rules.filter((v) => v.title.includes(filterKey))\n                } else rules = rules.filter((v) => v.type == typeShow);\n                let yux=\"yux\"+Date.now();\n                let el = $.toString((QING_TITLE, yux) => {\n                    let {\n                        hijackEl\n                    } = $.require('hiker://page/funcTools?rule=' + QING_TITLE, {\n                        QING_TITLE:QING_TITLE,\n                        isIndex: $.hiker[yux],\n                        MY_RULE:MY_RULE\n                    })\n\n                    $.hiker.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                        param0 = param0.map(hijackEl);\n                        method_setResult.invoke(javaContext, param0, param1, param2, param3)\n                    }\n                    $.hiker.setHomeResult = setResult\n                    $.hiker.setSearchResult = setResult\n                }, QING_TITLE, yux);\n                rules = rules.map((v,i)=> {\n                    if (v.searchFind.startsWith('js:')) {\n                        v.searchFind = \"js:$.hiker.\"+yux+\"=\"+i+\";\" + el + \";\" + v.searchFind.slice(3);\n                    }\n                    return v;\n                });\n                return JSON.stringify(rules)\n        })\n    }\n}])\n","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"putMyVar('myCollection', MY_RULE.title)\nputMyVar('remoteUrl', 'hiker://files//rules/Tz/JM')\nif (request('hiker://home@本地资源管理') == 'null') {\n    confirm({\n        title: '依赖检测',\n        content: '检测到缺少模板依赖,请导入!',\n        confirm: () => {\n            return \"海阔视界首页频道规则【本地资源管理】￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=3559\"\n        }\n    })\n}\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://raw.iqiq.io/', 'https://ghproxy.net/https://raw.githubusercontent.com/', 'https://ghproxy.com/https://raw.githubusercontent.com/', 'https://cdn.staticaly.com/gh/', 'https://github.jevons.vip/https://raw.githubusercontent.com/']\\n            for (let i = 0; i < requirelist.length; i++) {\\n                try { //远程依赖索引\\n                    let res = request(requirelist[i] + 'DreamOzO/JM/main/JM', {\\n                        withStatusCode: true\\n                    })\\n                    if (JSON.parse(res).statusCode == 200) {\\n                        if (fileExist(url)) {\\n                            deleteFile(url)\\n                            requireDownload(requirelist[i] + 'DreamOzO/JM/main/JM',url)\\n                            break\\n                        } else {\\n                            requireDownload(requirelist[i] + 'DreamOzO/JM/main/JM',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/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\",\\n    extra: {\\n        lver: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\",\\n        id: \\\"2847\\\"\\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: \\\"hiker://page/Help#noHistory##noRecordHistory#\\\",\\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=2847\\\", {\\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/ruleDetail#noHistory##noRecordHistory#?rule=道长仓库Pro\\\",\\n    col_type: \\\"text_2\\\",\\n    extra: {\\n        lver: MY_PARAMS.version || \\\"获取版本失败，自行查看\\\",\\n        id: \\\"2847\\\"\\n    }\\n});\\nconst Color = \\\"#19B89D\\\";\\nvar des_desc = '<h1 style=\\\"text-align: center;\\\">🐾更新[230211]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①剔除无用源，修复部分失效源</br><br>②尝试优化页面加载速度（感谢L佬），拉远程，与旧规则不兼容，更新海阔至7.30</br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[1230]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①剔除无用源，拉远程，更新海阔至7.27</br><br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[1218]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①优化下载模式，需更新最新版本地资源管理，拉远程，更新海阔至7.26</br>②修复部分bug<br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[1126]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①增加APP图源：拉远程，更新海阔至7.23</br>②修复部分bug<br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[1116]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①增加三图源PS：拉远程，更新海阔至7.22</br>②修复部分bug<br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[1113]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①修复包子部分漫画章节列表定位错误PS：拉远程</br>②修复部分bug<br></<blockquote>' +\\n\\n'<h1 style=\\\"text-align: center;\\\">🐾更新[1108]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更新聚漫🔮本地修复子页面动态分类bug，修复部分源（多多，CC）</br><br></<blockquote>' +\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[1102]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更换聚漫🔮本体，更换部分样式，修复部分源。可直接订阅仓库链接更新（PS：随缘更）</br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[1005]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更换聚漫🔮本体，加入最新版缓存机制实现二次打开秒开，修复部分源</br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0926]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更换远程仓库，修复部分源</br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0816]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更新聚漫🔮本体，修复部分源</br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0809]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①删除失效源</br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0717]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①增加动态切换排序，PS：漫画吧<br>②搬模板Q动态分类&动态排序至聚漫🔮｜PS：需更新聚漫🔮</br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0526]</h1><<blockquote><font color=\\\"red\\\">①修复包子选集错误&解析错误<br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0527]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①新增若干图源<br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0529]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①美化部分图源<br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0530]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更新聚漫🔮模板<br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0602]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①修复&美化好漫8<br>②美化八极｜PS：需清理缓存</br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0606]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①更新包子，尝试解决收藏问题，PS：需更新聚漫🔮<br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0608]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①修复鬼萝莉搜索<br><br></<blockquote>' +\\n\\n    '<h1 style=\\\"text-align: center;\\\">🐾更新[0616]</h1>' +\\n    '<<blockquote><font color=\\\"red\\\">①美化部分图源，PS：需清理缓存<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\":\"图片解密*\",\"path\":\"imgDES\",\"rule\":\"$.exports.imgDecrypt = 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 generateSecret = SecretKeyFactory.getInstance(\\\"desede\\\").generateSecret(new DESedeKeySpec(String('OW84U8Eerdb99rtsTXWSILDO').getBytes()));\\n            var cipher = Cipher.getInstance(\\\"desede/CBC/PKCS5Padding\\\");\\n            cipher.init(2, generateSecret, new IvParameterSpec(String('SK8bncVu').getBytes()));\\n            return cipher.doFinal(bArr);\\n        }\\n        //decryptData为解密方法\\n        bytes = decryptData(bytes);\\n        return FileUtil.toInputStream(bytes);\\n    }\\n\\n}\"},{\"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\":\"js:\\nconst SoftReference = java.lang.ref.SoftReference;\\nconst Cipher = Cipher = javax.crypto.Cipher;\\nconst IvParameterSpec = javax.crypto.spec.IvParameterSpec;\\nconst SecretKeySpec = javax.crypto.spec.SecretKeySpec;\\nconst KEY = new java.lang.String(\\\"my2ecret782ecret\\\");\\nconst f2319IV = new java.lang.String(\\\"my2ecret782ecret\\\");\\nconst KEY_ALGORITHM = \\\"AES\\\";\\nconst AES_MODE = \\\"AES/CBC/PKCS7Padding\\\";\\n\\nfunction decryptData(file2Bytes) {\\n    try {\\n        let secretKeySpec = new SecretKeySpec(KEY.getBytes(), KEY_ALGORITHM);\\n        let ivParameterSpec = new IvParameterSpec(f2319IV.getBytes());\\n        let cipher = Cipher.getInstance(AES_MODE);\\n        cipher.init(2, secretKeySpec, ivParameterSpec);\\n        return cipher.doFinal(file2Bytes);\\n        return new SoftReference(cipher.doFinal(file2Bytes)).get();\\n    } catch (e) {\\n        //e.printStackTrace();\\n        log(e.toString());\\n        return null;\\n    }\\n}\\n\\n$.exports.imageDecrypt = function() {\\n    let javaImport = new JavaImporter();\\n    javaImport.importPackage(\\n        Packages.com.example.hikerview.utils\\n    );\\n    with(javaImport) {\\n        let bytes = FileUtil.toBytes(input);\\n        bytes = decryptData(bytes);\\n        return FileUtil.toInputStream(bytes);\\n    }\\n}\\n\"}]","icon":"https://hikerfans.com/tubiao/ke/28.png","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!