API tools faq
paste
xiaomianao666

邀您一起看：⚙ 轻合集设置 ⚙

xiaomianao666
Sep 29th, 2022
47
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 284.97 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥⚙ 轻合集设置 ⚙@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"const 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, { '': 'T', 'T': '' } [folded])\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, this.sign, folded),\\n            col_type: 'scroll_button'\\n        })\\n        let arr = folded ? [this.arr[0]] : this.arr\\n        arr.forEach((v) => {\\n            let { id, class_name, class_url } = v,\\n            selected = JSON.stringify(this.getClass(id))\\n            class_name.forEach((name, i) => {\\n                let url = class_url[i],\\n                    now = JSON.stringify({ name: name, url: url })\\n                el.push({\\n                    title: selected == now ? '““””' + 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// 生成头部分类\\nconst fyAll = RULE.url.includes('fyAll')\\nlet tabHeader = []\\nif (RULE.class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: RULE.class_name,\\n    class_url: RULE.class_url\\n})\\nif (RULE.area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: RULE.area_name,\\n    class_url: RULE.area_url\\n})\\nif (RULE.year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: RULE.year_name,\\n    class_url: RULE.year_url\\n})\\nif (RULE.sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: RULE.sort_name,\\n    class_url: RULE.sort_url\\n})\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title, fold: readFile('tabFold'), })\\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: $('#noLoading#').lazyRule((url) => {\\n            if (url.startsWith('hiker://') || url.startsWith('file://'))\\n                return 'toast://仓库为本地文件，不会进行缓存，本功能也无效'\\n            deleteCache(url)\\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 ? '' : '1')\\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 ? '' : '1')\\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})\\n\\nel.push({ col_type: 'line' }, {\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\n        if (input == '清除自定义数据') {\\n            deleteFile('customData')\\n        } else if (input == '启用合集自定义') {\\n            saveFile('disableCustom', '')\\n        } else {\\n            saveFile('disableCustom', '1')\\n            input += '\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\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})\\nsetResult(el)\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面载入\",\"path\":\"frameLoad\",\"rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nlet myCollection_el = [],\\n    { RULE, isIndex, pageTitle } = MY_PARAMS,\\n    thisRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)().find((v) => v.title == RULE.title)\\nif (isIndex) {\\n    RULE = thisRULE\\n} else {\\n    RULE.pages = thisRULE.pages\\n}\\neval(JSON.parse(fetch('hiker://page/preFunc?rule=' + QING_TITLE)).rule)\\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\\n\\nif (isIndex) {\\n    if (MY_PAGE == 1) {\\n        // 加载ClassTab组件\\n        eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n        tabHeader.load(myCollection_el)\\n        if (RULE.search_url) myCollection_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        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    }\\n    // 处理MY_RULE\\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    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\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(thisRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n}\\n// 预处理并初始化config\\nif (MY_PAGE == 1) {\\n    let loaded = getMyVar(MY_RULE.title + \\\"@pre\\\")\\n    if (!loaded || isIndex) {\\n        eval(thisRULE.preRule)\\n        putMyVar(MY_RULE.title + \\\"@pre\\\", \\\"1\\\")\\n    }\\n}\\nlet _cfg = getMyVar('initConfig', '{}')\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\n\\n// 正文解析通用变量\\nlet assignLazyRule = $.toString((QING_TITLE, title, url) => {\\n    let RULE = $.require(\\\"hiker://page/dataLoad?rule=\\\" + QING_TITLE)().find((v) => v.title == title)\\n    return { title:title, url: url, pages: RULE.pages, pageList: JSON.parse(RULE.pages || '[]') }\\n}, QING_TITLE, MY_RULE.title, MY_RULE.url)\\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}\\nfunction runCode(rule) {\\n    try {\\n        let [input, code] = rule.split('.js:')\\n        return code ? eval(code) : rule\\n    } catch (e) { return rule }\\n}\\nfunction genExUrl(url) {\\n    url = url.split(';')\\n    return url.shift() + ';' + paramHandle(url, thisRULE.ua, MY_RULE.url)\\n}\\n// 正文解析\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    setResult = function(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(el.data)) el = el.data\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\n            if(!v.extra) v.extra = {}\\n            v.col_type = v.col_type || MY_RULE.col_type\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra })\\n\\n            if (typeof v.url != 'string' || ['rule', 'pics', 'toast', 'input', 'confirm', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'select', 'x5Rule', 'webRule', 'download', 'share'].find((vv) => v.url.startsWith(vv + '://')) || ['x5_webview_single', 'input'].find((vv) => v.col_type == vv)) {\\n                return v\\n            } else if (v.url.includes('@rule=')) {\\n                let [_, url, rule] = v.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n                v.url = url\\n                MY__RULE.detail_find_rule = rule\\n                MY__RULE.detail_col_type = MY_RULE.col_type\\n            } else if (v.url.startsWith('hiker://page/')) {\\n                if (v.url.includes('rule=') || v.extra.rule)\\n                    return v\\n                let [_, path, flag, params] = v.url.match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(#.*?)?(?:\\\\?(.*))?$/),\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path),\\n                    subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\n                v.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (v.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\n                MY__RULE.detail_find_rule = subPage.rule\\n                MY__RULE.detail_col_type = subPage.col_type\\n            } else if (v.url.includes('@lazyRule=')) {\\n                let reIndex = v.url.indexOf('.js:')\\n                if (reIndex >= 0) v.url = v.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + v.url.slice(reIndex + 4)\\n                return v\\n            } else if (isIndex) {\\n                if (!MY_RULE.detail_find_rule || /hiker:\\\\/\\\\/(?!empty.+$)/.test(v.url)) return v\\n            } else {\\n                return v\\n            }\\n            v.extra = Object.assign({}, v.extra, {\\n                url: genExUrl(v.url),\\n                RULE: MY__RULE,\\n                pageTitle: isIndex && v.title\\n            })\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let [_, 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:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: 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: genMyRule(),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"数据载入\",\"path\":\"dataLoad\",\"rule\":\"$.exports = function(showAll) {\\n    let url = getMyVar('remoteUrl'),\\n        data = []\\n    if (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    }\\n    data = data.filter((v) => { return v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器') })\\n    if (readFile('disableCustom')) return data\\n    else { // 写入自定义数据\\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        return rewriteData.concat(data)\\n    }\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"函数重写\",\"path\":\"preFunc\",\"rule\":\"// 防止require多次运行\\nlet rCache = {}\\nrequire = function(param0, param1, param2, param3, param4) {\\n    if (!param0 || rCache[param0] != null) {\\n        return\\n    }\\n    rCache[param0] = 1\\n    param2 = 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 (!param0 || rCache[param0] != null) {\\n        return\\n    }\\n    rCache[param0] = 1\\n    param3 = 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\\n// 最新章节规则注入预处理代码\\nsetLastChapterRule = function(param0) {\\n    if (!param0) return\\n    if (param0.startsWith(\\\"js:\\\") && thisRULE.preRule) {\\n        param0 = 'js:\\\\ntry{eval(JSON.parse(fetch(\\\"hiker://page/preFunc?rule=' + QING_TITLE + '\\\")).rule);\\\\\\n            eval(base64Decode(\\\"' + base64Encode(thisRULE.preRule) + '\\\"));\\\\\\n            let _cfg = getMyVar(\\\"initConfig\\\", \\\"{}\\\");\\\\\\n            if (_cfg && _cfg.length>0) {config = JSON.parse(_cfg)}}catch(e){log(e.message)}\\\\n;' +\\n            param0.slice(3)\\n    }\\n    method_setLastChapterRule.invoke(javaContext, param0);\\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=\\\"#F17C67\\\">'+\\\"\\\\n\\\"+章节+\\\"&nbsp;\\\"+更新+'</font></small>',\\r\\n\\t\\t\\tdesc:'‘‘’’<small><font color=\\\"#52433D\\\">' +简介+ '</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_center_1'\\r\\n\\t}\\r\\n\\tif (hasLine) {\\r\\n\\t\\torderItem.title = \\\"““””\\\" + '<strong><font color=\\\"#098AC1\\\">' + '集数排序⇅' + '</font></strong>';\\r\\n\\t\\torderItem.col_type = \\\"scroll_button\\\"\\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: \\\"scroll_button\\\",\\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: \\\"scroll_button\\\",\\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_1',\\r\\n\\t\\t});\\r\\n\\t}\\n\\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_3'\\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 + getVar((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: getVar((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\\tputVar(varKey, lineIndex.toString());\\r\\n\\t\\t\\t\\t\\tputVar((MY_RULE.title + '#line-title'), lineTitle);\\r\\n\\t\\t\\t\\t\\tlog(MY_RULE.title + getVar((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: 'scroll_button',\\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),\\n            url: coverUrl,\\n            col_type: 'movie_1_vertical_pic_blur'\\n        });\\n        d.push({\\n            col_type: 'line'\\n        });\\n        //var jj = getVar(\\\"jjs\\\", \\\"收起\\\");\\n        //var jjurl = 'hiker://empty@lazyRule=.js:getVar(\\\"jjs\\\") == \\\"收起\\\"?putVar(\\\"jjs\\\",\\\"展开\\\"):putVar(\\\"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 (getVar(\\\"jjs\\\", \\\"收起\\\") == \\\"收起\\\") {\\n                    putVar(\\\"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                    putVar(\\\"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: pdfh(list[i], chapterTitle),\\n                url: pd(list[i], chapterUrl) + lazy,\\n                col_type: pdfh(list[0], chapterTitle).length > 6 ? 'text_2' : 'text_3',\\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 + getVar((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: getVar((MY_RULE.title + '#line-title'), line0Title) === lineTitle ? \\\"切换:‘‘\\\" + lineTitle + \\\"\\\" : lineTitle + \\\"‘‘:切换\\\",\\n                url: $().lazyRule((varKey, lineIndex, lineTitle) => {\\n                    putVar(varKey, lineIndex.toString())\\n                    // log(MY_RULE.url)\\n                    putVar((MY_RULE.title + '#line-title'), lineTitle)\\n                    log(MY_RULE.title + getVar((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\":\"bzjs\",\"rule\":\"var 漫画解析 = $.toString(() => {\\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://cn.baozimh.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\\nlet lazy = `@lazyRule=.js:` + 漫画解析;\"},{\"col_type\":\"movie_3\",\"name\":\"动态[二]\",\"path\":\"dtfl\",\"rule\":\"const empty = \\\"hiker://empty\\\"\\n\\ntry {\\n    var categories = pdfa(html, 大类定位).concat(pdfa(html, 拼接分类))\\n} catch (e) {\\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 = getVar(MY_RULE.group, \\\"1\\\")\\nconst cate_temp_json = getVar(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><span style=\\\"color: #FF0000\\\">∨</span></b>' : '““””<b><span style=\\\"color: #1aad19\\\">∧</span></b>',\\n        url: $().lazyRule((fold) => {\\n            putVar(MY_RULE.group, fold === '1' ? '0' : '1');\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, fold),\\n        col_type: 'scroll_button',\\n    })\\n\\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                d.push({\\n                    title: key.toString() === cate_temp[index] ? '““””<b><span style=\\\"color: ' + 分类颜色 + '\\\">' + title + '</span></b>' : 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                        putVar(MY_RULE.title, JSON.stringify(new_cate))\\n                        putVar(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                d.push({\\n                    title: key.toString() === cate_temp[index] ? '““””<b><span style=\\\"color: ' + 分类颜色 + '\\\">' + title + '</span></b>' : title,\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\n                        params.cate_temp[params.index] = params.key.toString()\\n\\n                        putVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\n                        putVar(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\":\"const 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: 202112011900,\\n    checkParams() {\\n        if (!this[symbolMap.mLayout]) {\\n            throw new Error(\\\"请调用 layout(d) 传入当前界面\\\")\\n        }\\n        if (!(this[symbolMap.src] || this[symbolMap.true_url])) {\\n            throw new Error(\\\"请调用 trueUrl(url) 传入当前分类的链接或调用 html(mHtml) 传入当前分类页面的源码\\\")\\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\\n\"},{\"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 pic = pd(it, obj.图片)\\n        if (obj.图片处理 != null) {\\n            pic = obj.图片处理(pic)\\n        }\\n        d.push({\\n            title: pdfh(it, obj.标题),\\n            url: url,\\n            col_type: \\\"\\\",\\n            desc: obj.描述 ? pdfh(it, obj.描述) : \\\"\\\",\\n            pic_url: pic\\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#\\\",\\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: pdfh(it, 集名),\\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: 漫画解析,\\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: 页URL + \\\"#noHistory#\\\",\\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 = getVar(页URL + \\\"简介收\\\", \\\"已收起\\\");\\n    var jjurl = $(\\\"#noLoading#\\\").lazyRule((简介内容, 简介内容收, 收, 收内容, 当前URL) => {\\n        var jsbl = 当前URL + \\\"简介收\\\";\\n        var jj = getVar(当前URL + \\\"简介收\\\", \\\"已收起\\\");\\n        jj = jj == \\\"已收起\\\" ? \\\"展开\\\" : \\\"已收起\\\";\\n        putVar(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 排序 = getVar(页URL + \\\"章节排序\\\", \\\"正序\\\");\\n    var 提示 = 排序 == '倒序' ? '正序' : '倒序';\\n\\n    var 排序url = $(\\\"#noLoading#\\\").lazyRule((标题名, 标题数据, 列表数据, 解析代码, 页URL) => {\\n        var 排序 = getVar(页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        putVar(页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 (getVar(刷新重复, \\\"false\\\") == \\\"false\\\") {\\n\\n        code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\n        putVar(刷新重复, getParam('url') + \\\"￥&￥\\\" + code)\\n\\n    } else {\\n\\n        var pm = getVar(刷新重复).split(\\\"￥&￥\\\")\\n        if (pm[0] == getParam('url')) {\\n            code = pm[1]\\n        } else {\\n            code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\n            putVar(刷新重复, 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\\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#',\\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#',\\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, 漫画解析,当前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描述 = 描述.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        var lazy = `@lazyRule=.js:` + 漫画解析;\\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: 'flex_button',\\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})\\nd.push({\\n    col_type: \\\"big_blank_block\\\",\\n    extra: {\\n        id: MY_URL + \\\"footer\\\"\\n    }\\n});\"}],\"saved\":false,\"title\":\"聚漫🔮\",\"version\":0,\"url\":\"hiker://page/Config?rule=聚漫🔮&#noRecordHistory#\",\"col_type\":\"icon_2_round\",\"find_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: $('#noLoading#').lazyRule((url) => {\\n            if (url.startsWith('hiker://') || url.startsWith('file://'))\\n                return 'toast://仓库为本地文件，不会进行缓存，本功能也无效'\\n            deleteCache(url)\\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 ? '' : '1')\\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 ? '' : '1')\\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})\\n\\nel.push({ col_type: 'line' }, {\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\n        if (input == '清除自定义数据') {\\n            deleteFile('customData')\\n        } else if (input == '启用合集自定义') {\\n            saveFile('disableCustom', '')\\n        } else {\\n            saveFile('disableCustom', '1')\\n            input += '\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\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})\\nsetResult(el)\\n\",\"group\":\"①轻合集\",\"ua\":\"auto\",\"preRule\":\"putMyVar('myCollection', MY_RULE.title)\\nputMyVar('remoteUrl', 'https://gitlab.com/DreamOzO/DreamOzO/-/raw/main/JM')\\n// \\n/*\\n*/\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"ClassTab\\\",\\\"path\\\":\\\"ClassTab\\\",\\\"rule\\\":\\\"const 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, { '': 'T', 'T': '' } [folded])\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, this.sign, folded),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n        let arr = folded ? [this.arr[0]] : this.arr\\\\n        arr.forEach((v) => {\\\\n            let { id, class_name, class_url } = v,\\\\n            selected = JSON.stringify(this.getClass(id))\\\\n            class_name.forEach((name, i) => {\\\\n                let url = class_url[i],\\\\n                    now = JSON.stringify({ name: name, url: url })\\\\n                el.push({\\\\n                    title: selected == now ? '““””' + 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// 生成头部分类\\\\nconst fyAll = RULE.url.includes('fyAll')\\\\nlet tabHeader = []\\\\nif (RULE.class_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyclass',\\\\n    class_name: RULE.class_name,\\\\n    class_url: RULE.class_url\\\\n})\\\\nif (RULE.area_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyarea',\\\\n    class_name: RULE.area_name,\\\\n    class_url: RULE.area_url\\\\n})\\\\nif (RULE.year_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyyear',\\\\n    class_name: RULE.year_name,\\\\n    class_url: RULE.year_url\\\\n})\\\\nif (RULE.sort_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fysort',\\\\n    class_name: RULE.sort_name,\\\\n    class_url: RULE.sort_url\\\\n})\\\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title, fold: readFile('tabFold'), })\\\\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: $('#noLoading#').lazyRule((url) => {\\\\n            if (url.startsWith('hiker://') || url.startsWith('file://'))\\\\n                return 'toast://仓库为本地文件，不会进行缓存，本功能也无效'\\\\n            deleteCache(url)\\\\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 ? '' : '1')\\\\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 ? '' : '1')\\\\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})\\\\n\\\\nel.push({ col_type: 'line' }, {\\\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\\\n        if (input == '清除自定义数据') {\\\\n            deleteFile('customData')\\\\n        } else if (input == '启用合集自定义') {\\\\n            saveFile('disableCustom', '')\\\\n        } else {\\\\n            saveFile('disableCustom', '1')\\\\n            input += '\\\\\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\\\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})\\\\nsetResult(el)\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面载入\\\",\\\"path\\\":\\\"frameLoad\\\",\\\"rule\\\":\\\"js:\\\\nconst QING_TITLE = getMyVar('myCollection')\\\\nlet myCollection_el = [],\\\\n    { RULE, isIndex, pageTitle } = MY_PARAMS,\\\\n    thisRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)().find((v) => v.title == RULE.title)\\\\nif (isIndex) {\\\\n    RULE = thisRULE\\\\n} else {\\\\n    RULE.pages = thisRULE.pages\\\\n}\\\\neval(JSON.parse(fetch('hiker://page/preFunc?rule=' + QING_TITLE)).rule)\\\\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\\\\n\\\\nif (isIndex) {\\\\n    if (MY_PAGE == 1) {\\\\n        // 加载ClassTab组件\\\\n        eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\\\n        tabHeader.load(myCollection_el)\\\\n        if (RULE.search_url) myCollection_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        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    }\\\\n    // 处理MY_RULE\\\\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    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\\\\n\\\\nif (!isIndex) {\\\\n    if (pageTitle) setPageTitle(pageTitle)\\\\n    setLastChapterRule(thisRULE.last_chapter_rule)\\\\n    MY_PARAMS = MY_RULE.params\\\\n}\\\\n// 预处理并初始化config\\\\nif (MY_PAGE == 1) {\\\\n    let loaded = getMyVar(MY_RULE.title + \\\\\\\"@pre\\\\\\\")\\\\n    if (!loaded || isIndex) {\\\\n        eval(thisRULE.preRule)\\\\n        putMyVar(MY_RULE.title + \\\\\\\"@pre\\\\\\\", \\\\\\\"1\\\\\\\")\\\\n    }\\\\n}\\\\nlet _cfg = getMyVar('initConfig', '{}')\\\\nif (_cfg && _cfg.length > 0) {\\\\n    config = JSON.parse(_cfg)\\\\n}\\\\n\\\\n// 正文解析通用变量\\\\nlet assignLazyRule = $.toString((QING_TITLE, title, url) => {\\\\n    let RULE = $.require(\\\\\\\"hiker://page/dataLoad?rule=\\\\\\\" + QING_TITLE)().find((v) => v.title == title)\\\\n    return { title:title, url: url, pages: RULE.pages, pageList: JSON.parse(RULE.pages || '[]') }\\\\n}, QING_TITLE, MY_RULE.title, MY_RULE.url)\\\\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}\\\\nfunction runCode(rule) {\\\\n    try {\\\\n        let [input, code] = rule.split('.js:')\\\\n        return code ? eval(code) : rule\\\\n    } catch (e) { return rule }\\\\n}\\\\nfunction genExUrl(url) {\\\\n    url = url.split(';')\\\\n    return url.shift() + ';' + paramHandle(url, thisRULE.ua, MY_RULE.url)\\\\n}\\\\n// 正文解析\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    setResult = function(el, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n        if (Array.isArray(el.data)) el = el.data\\\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\\\n            if(!v.extra) v.extra = {}\\\\n            v.col_type = v.col_type || MY_RULE.col_type\\\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra })\\\\n\\\\n            if (typeof v.url != 'string' || ['rule', 'pics', 'toast', 'input', 'confirm', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'select', 'x5Rule', 'webRule', 'download', 'share'].find((vv) => v.url.startsWith(vv + '://')) || ['x5_webview_single', 'input'].find((vv) => v.col_type == vv)) {\\\\n                return v\\\\n            } else if (v.url.includes('@rule=')) {\\\\n                let [_, url, rule] = v.url.match(/^([\\\\\\\\s\\\\\\\\S]*?)@rule=([\\\\\\\\s\\\\\\\\S]*)$/)\\\\n                v.url = url\\\\n                MY__RULE.detail_find_rule = rule\\\\n                MY__RULE.detail_col_type = MY_RULE.col_type\\\\n            } else if (v.url.startsWith('hiker://page/')) {\\\\n                if (v.url.includes('rule=') || v.extra.rule)\\\\n                    return v\\\\n                let [_, path, flag, params] = v.url.match(/^hiker:\\\\\\\\/\\\\\\\\/page\\\\\\\\/(.+?)(#.*?)?(?:\\\\\\\\?(.*))?$/),\\\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path),\\\\n                    subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\\\n                v.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (v.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\\\n                MY__RULE.detail_find_rule = subPage.rule\\\\n                MY__RULE.detail_col_type = subPage.col_type\\\\n            } else if (v.url.includes('@lazyRule=')) {\\\\n                let reIndex = v.url.indexOf('.js:')\\\\n                if (reIndex >= 0) v.url = v.url.slice(0, reIndex) + '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + v.url.slice(reIndex + 4)\\\\n                return v\\\\n            } else if (isIndex) {\\\\n                if (!MY_RULE.detail_find_rule || /hiker:\\\\\\\\/\\\\\\\\/(?!empty.+$)/.test(v.url)) return v\\\\n            } else {\\\\n                return v\\\\n            }\\\\n            v.extra = Object.assign({}, v.extra, {\\\\n                url: genExUrl(v.url),\\\\n                RULE: MY__RULE,\\\\n                pageTitle: isIndex && v.title\\\\n            })\\\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            return v\\\\n        }))\\\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\\\n    }\\\\n    setHomeResult = setResult\\\\n    setSearchResult = setResult\\\\n\\\\n    eval(MY_RULE.find_rule.slice(3))\\\\n} else {\\\\n    let [_, 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:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\\\n            } else  if (detailFindRule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: 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: genMyRule(),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            }\\\\n        }\\\\n        myCollection_el.push(res)\\\\n    })\\\\n    setResult(myCollection_el)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据载入\\\",\\\"path\\\":\\\"dataLoad\\\",\\\"rule\\\":\\\"$.exports = function(showAll) {\\\\n    let url = getMyVar('remoteUrl'),\\\\n        data = []\\\\n    if (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    }\\\\n    data = data.filter((v) => { return v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器') })\\\\n    if (readFile('disableCustom')) return data\\\\n    else { // 写入自定义数据\\\\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        return rewriteData.concat(data)\\\\n    }\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"函数重写\\\",\\\"path\\\":\\\"preFunc\\\",\\\"rule\\\":\\\"// 防止require多次运行\\\\nlet rCache = {}\\\\nrequire = function(param0, param1, param2, param3, param4) {\\\\n    if (!param0 || rCache[param0] != null) {\\\\n        return\\\\n    }\\\\n    rCache[param0] = 1\\\\n    param2 = 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 (!param0 || rCache[param0] != null) {\\\\n        return\\\\n    }\\\\n    rCache[param0] = 1\\\\n    param3 = 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\\\\n// 最新章节规则注入预处理代码\\\\nsetLastChapterRule = function(param0) {\\\\n    if (!param0) return\\\\n    if (param0.startsWith(\\\\\\\"js:\\\\\\\") && thisRULE.preRule) {\\\\n        param0 = 'js:\\\\\\\\ntry{eval(JSON.parse(fetch(\\\\\\\"hiker://page/preFunc?rule=' + QING_TITLE + '\\\\\\\")).rule);\\\\\\\\\\\\n            eval(base64Decode(\\\\\\\"' + base64Encode(thisRULE.preRule) + '\\\\\\\"));\\\\\\\\\\\\n            let _cfg = getMyVar(\\\\\\\"initConfig\\\\\\\", \\\\\\\"{}\\\\\\\");\\\\\\\\\\\\n            if (_cfg && _cfg.length>0) {config = JSON.parse(_cfg)}}catch(e){log(e.message)}\\\\\\\\n;' +\\\\n            param0.slice(3)\\\\n    }\\\\n    method_setLastChapterRule.invoke(javaContext, param0);\\\\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=\\\\\\\"#F17C67\\\\\\\">'+\\\\\\\"\\\\\\\\n\\\\\\\"+章节+\\\\\\\"&nbsp;\\\\\\\"+更新+'</font></small>',\\\\r\\\\n\\\\t\\\\t\\\\tdesc:'‘‘’’<small><font color=\\\\\\\"#52433D\\\\\\\">' +简介+ '</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_center_1'\\\\r\\\\n\\\\t}\\\\r\\\\n\\\\tif (hasLine) {\\\\r\\\\n\\\\t\\\\torderItem.title = \\\\\\\"““””\\\\\\\" + '<strong><font color=\\\\\\\"#098AC1\\\\\\\">' + '集数排序⇅' + '</font></strong>';\\\\r\\\\n\\\\t\\\\torderItem.col_type = \\\\\\\"scroll_button\\\\\\\"\\\\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: \\\\\\\"scroll_button\\\\\\\",\\\\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: \\\\\\\"scroll_button\\\\\\\",\\\\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_1',\\\\r\\\\n\\\\t\\\\t});\\\\r\\\\n\\\\t}\\\\n\\\\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_3'\\\\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 + getVar((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: getVar((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\\\\tputVar(varKey, lineIndex.toString());\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\tputVar((MY_RULE.title + '#line-title'), lineTitle);\\\\r\\\\n\\\\t\\\\t\\\\t\\\\t\\\\tlog(MY_RULE.title + getVar((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: 'scroll_button',\\\\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),\\\\n            url: coverUrl,\\\\n            col_type: 'movie_1_vertical_pic_blur'\\\\n        });\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        });\\\\n        //var jj = getVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"收起\\\\\\\");\\\\n        //var jjurl = 'hiker://empty@lazyRule=.js:getVar(\\\\\\\"jjs\\\\\\\") == \\\\\\\"收起\\\\\\\"?putVar(\\\\\\\"jjs\\\\\\\",\\\\\\\"展开\\\\\\\"):putVar(\\\\\\\"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 (getVar(\\\\\\\"jjs\\\\\\\", \\\\\\\"收起\\\\\\\") == \\\\\\\"收起\\\\\\\") {\\\\n                    putVar(\\\\\\\"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                    putVar(\\\\\\\"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: pdfh(list[i], chapterTitle),\\\\n                url: pd(list[i], chapterUrl) + lazy,\\\\n                col_type: pdfh(list[0], chapterTitle).length > 6 ? 'text_2' : 'text_3',\\\\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 + getVar((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: getVar((MY_RULE.title + '#line-title'), line0Title) === lineTitle ? \\\\\\\"切换:‘‘\\\\\\\" + lineTitle + \\\\\\\"\\\\\\\" : lineTitle + \\\\\\\"‘‘:切换\\\\\\\",\\\\n                url: $().lazyRule((varKey, lineIndex, lineTitle) => {\\\\n                    putVar(varKey, lineIndex.toString())\\\\n                    // log(MY_RULE.url)\\\\n                    putVar((MY_RULE.title + '#line-title'), lineTitle)\\\\n                    log(MY_RULE.title + getVar((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\\\":\\\"bzjs\\\",\\\"rule\\\":\\\"var 漫画解析 = $.toString(() => {\\\\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://cn.baozimh.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\\\\nlet lazy = `@lazyRule=.js:` + 漫画解析;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"动态[二]\\\",\\\"path\\\":\\\"dtfl\\\",\\\"rule\\\":\\\"const empty = \\\\\\\"hiker://empty\\\\\\\"\\\\n\\\\ntry {\\\\n    var categories = pdfa(html, 大类定位).concat(pdfa(html, 拼接分类))\\\\n} catch (e) {\\\\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 = getVar(MY_RULE.group, \\\\\\\"1\\\\\\\")\\\\nconst cate_temp_json = getVar(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><span style=\\\\\\\"color: #FF0000\\\\\\\">∨</span></b>' : '““””<b><span style=\\\\\\\"color: #1aad19\\\\\\\">∧</span></b>',\\\\n        url: $().lazyRule((fold) => {\\\\n            putVar(MY_RULE.group, fold === '1' ? '0' : '1');\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, fold),\\\\n        col_type: 'scroll_button',\\\\n    })\\\\n\\\\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                d.push({\\\\n                    title: key.toString() === cate_temp[index] ? '““””<b><span style=\\\\\\\"color: ' + 分类颜色 + '\\\\\\\">' + title + '</span></b>' : 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                        putVar(MY_RULE.title, JSON.stringify(new_cate))\\\\n                        putVar(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                d.push({\\\\n                    title: key.toString() === cate_temp[index] ? '““””<b><span style=\\\\\\\"color: ' + 分类颜色 + '\\\\\\\">' + title + '</span></b>' : title,\\\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\\\n                        params.cate_temp[params.index] = params.key.toString()\\\\n\\\\n                        putVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\\\n                        putVar(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\\\":\\\"const 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: 202112011900,\\\\n    checkParams() {\\\\n        if (!this[symbolMap.mLayout]) {\\\\n            throw new Error(\\\\\\\"请调用 layout(d) 传入当前界面\\\\\\\")\\\\n        }\\\\n        if (!(this[symbolMap.src] || this[symbolMap.true_url])) {\\\\n            throw new Error(\\\\\\\"请调用 trueUrl(url) 传入当前分类的链接或调用 html(mHtml) 传入当前分类页面的源码\\\\\\\")\\\\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\\\\n\\\"},{\\\"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 pic = pd(it, obj.图片)\\\\n        if (obj.图片处理 != null) {\\\\n            pic = obj.图片处理(pic)\\\\n        }\\\\n        d.push({\\\\n            title: pdfh(it, obj.标题),\\\\n            url: url,\\\\n            col_type: \\\\\\\"\\\\\\\",\\\\n            desc: obj.描述 ? pdfh(it, obj.描述) : \\\\\\\"\\\\\\\",\\\\n            pic_url: pic\\\\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#\\\\\\\",\\\\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: pdfh(it, 集名),\\\\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: 漫画解析,\\\\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: 页URL + \\\\\\\"#noHistory#\\\\\\\",\\\\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 = getVar(页URL + \\\\\\\"简介收\\\\\\\", \\\\\\\"已收起\\\\\\\");\\\\n    var jjurl = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((简介内容, 简介内容收, 收, 收内容, 当前URL) => {\\\\n        var jsbl = 当前URL + \\\\\\\"简介收\\\\\\\";\\\\n        var jj = getVar(当前URL + \\\\\\\"简介收\\\\\\\", \\\\\\\"已收起\\\\\\\");\\\\n        jj = jj == \\\\\\\"已收起\\\\\\\" ? \\\\\\\"展开\\\\\\\" : \\\\\\\"已收起\\\\\\\";\\\\n        putVar(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 排序 = getVar(页URL + \\\\\\\"章节排序\\\\\\\", \\\\\\\"正序\\\\\\\");\\\\n    var 提示 = 排序 == '倒序' ? '正序' : '倒序';\\\\n\\\\n    var 排序url = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((标题名, 标题数据, 列表数据, 解析代码, 页URL) => {\\\\n        var 排序 = getVar(页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        putVar(页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 (getVar(刷新重复, \\\\\\\"false\\\\\\\") == \\\\\\\"false\\\\\\\") {\\\\n\\\\n        code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\\\n        putVar(刷新重复, getParam('url') + \\\\\\\"￥&￥\\\\\\\" + code)\\\\n\\\\n    } else {\\\\n\\\\n        var pm = getVar(刷新重复).split(\\\\\\\"￥&￥\\\\\\\")\\\\n        if (pm[0] == getParam('url')) {\\\\n            code = pm[1]\\\\n        } else {\\\\n            code = UA == 'PC' ? fetch(pc链接) : request(手机链接);\\\\n            putVar(刷新重复, 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\\\\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#',\\\\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#',\\\\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, 漫画解析,当前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描述 = 描述.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        var lazy = `@lazyRule=.js:` + 漫画解析;\\\\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: 'flex_button',\\\\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})\\\\nd.push({\\\\n    col_type: \\\\\\\"big_blank_block\\\\\\\",\\\\n    extra: {\\\\n        id: MY_URL + \\\\\\\"footer\\\\\\\"\\\\n    }\\\\n});\\\"}]\",\"proxy\":\"\"}","picUrl":"https://lanmeiguojiang.com/tubiao/ke/28.png","title":"⚙ 轻合集设置 ⚙"}
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!