邀您一起看：玖玖

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥玖玖@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"var {\\n    QING_TITLE, title, url,\\n    class_name, class_url,\\n    area_name, area_url,\\n    year_name, year_url,\\n    sort_name, sort_url\\n} = $.importParam\\nconst ClassTab = function(classArray, params) {\\n    Object.assign(this, params)\\n    this.arr = classArray.map(v => this.init(v))\\n    this.sign = '$' + QING_TITLE + '_' + (this.name || '') + '_'\\n    this.color = this.color || '#12b668'\\n    this.boundary = this.boundary || 'blank_block'\\n}\\nClassTab.prototype = {\\n    constructor: ClassTab,\\n    load(el) {\\n        let folded = this.fold && getVar('$fold_' + this.sign, '')\\n        if (this.arr.length > 1 && this.fold) el.push({\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\n                putVar('$fold_' + sign, folded ? '' : 'T')\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, this.sign, folded),\\n            col_type: 'scroll_button'\\n        })\\n        let arr = folded ? [this.arr[0]] : this.arr\\n        arr.forEach((v) => {\\n            let { id, class_name, class_url } = v,\\n            selected = JSON.stringify(this.getClass(id))\\n            class_name.forEach((name, i) => {\\n                let url = class_url[i],\\n                    now = JSON.stringify({ name: name, url: url })\\n                el.push({\\n                    title: selected == now ? '““””' + name.fontcolor(this.color).bold() : name,\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\n                        putVar(sign + id, now)\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, this.sign, id, now),\\n                    col_type: 'scroll_button'\\n                })\\n            })\\n            el.push({ col_type: this.boundary })\\n        })\\n    },\\n    init(classObject) {\\n        if (typeof classObject.class_name == 'string')\\n            classObject.class_name = classObject.class_name.split('&')\\n        if (typeof classObject.class_url == 'string')\\n            classObject.class_url = classObject.class_url.split('&').map((v) => v.trim())\\n        return classObject\\n    },\\n    push(classObject) {\\n        this.arr.push(this.init(classObject))\\n    },\\n    getClass(id) {\\n        let defaultClass = this.arr.find(item => item.id == id)\\n        defaultClass = JSON.stringify(defaultClass ? {\\n            name: defaultClass.class_name[0],\\n            url: defaultClass.class_url[0]\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\n    },\\n    setUrl(url) {\\n        return url.replace(/\\\\$\\\\{([^}]*)\\\\}/g, (_, id) => this.getClass(id).url)\\n    }\\n}\\n// 生成头部分类\\nlet fyAll = url.includes('fyAll'),\\n    tabHeader = []\\nif (class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: class_name,\\n    class_url: class_url\\n})\\nif (area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: area_name,\\n    class_url: area_url\\n})\\nif (year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: year_name,\\n    class_url: year_url\\n})\\nif (sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: sort_name,\\n    class_url: sort_url\\n})\\n$.exports = {\\n    fyAll: fyAll,\\n    tabHeader: new ClassTab(tabHeader, { name: title, fold: readFile('tabFold'), })\\n}\\n\"},{\"col_type\":\"icon_2_round\",\"name\":\"设置\",\"path\":\"Config\",\"rule\":\"js:\\naddListener('onClose', 'clearMyVar(\\\"sortFlag\\\");refreshPage()')\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\nconst QING_TITLE = getMyVar('myCollection'),\\n    url = getMyVar('remoteUrl')\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE, true),\\n    el = [{\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，不要频繁点击）',\\n        url: $('#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 ? '' : 'T')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, newWindow),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\n        saveFile('tabFold', tabFold ? '' : 'T')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, tabFold),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💼 备份恢复  ',\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\n        let url = getMyVar('remoteUrl')\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\n        else if (url.startsWith('hiker://page/')) url = 'hiker://empty'\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\n                let rules = request(url),\\n                    customData = readFile('customData')\\n                writeFile(input, JSON.stringify({\\n                    updateInterval: updateInterval,\\n                    newWindow: newWindow,\\n                    tabFold: tabFold,\\n                    disableCustom: disableCustom,\\n                    customData: customData,\\n                    rules: rules\\n                }))\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\n            saveFile('updateInterval', updateInterval)\\n            saveFile('newWindow', newWindow)\\n            saveFile('tabFold', tabFold)\\n            saveFile('disableCustom', disableCustom)\\n            saveFile('customData', customData)\\n            if (rules) writeFile(url, rules)\\n            refreshPage()\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\n        }, url)\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '““””<font color=\\\"#666666\\\"><small>特别鸣谢，小程序提供者：\\\\n' +\\n        data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\n        .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、'),\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\n\\nel.push({ col_type: 'line' }, {\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据', '编辑JSON'], 1).select(() => {\\n        switch (input.slice(0, 2)) {\\n            case '清除':\\n                deleteFile('customData')\\n                break\\n            case '启用':\\n                saveFile('disableCustom', '')\\n                break\\n            case '禁用':\\n                saveFile('disableCustom', 'T')\\n                input += '\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\n                break\\n            case '编辑':\\n                let url = getMyVar('remoteUrl')\\n                if (!url.startsWith('hiker://files/') && !url.startsWith('file://'))\\n                    url = 'hiker://files/libs/' + md5(url) + '.js'\\n                return  'hiker://page/interface#noRefresh##noHistory##noRecordHistory#?rule=JSON编辑器&Json='+base64Encode(url)\\n        }\\n        refreshPage(false)\\n        return 'toast://已' + input\\n    }),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\n    el.push({\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putMyVar('editMode', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'scroll_button'\\n    })\\n});\\nif (editMode == '导入海阔') el.push({\\n    title: '全部导入',\\n    url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\n    let d = { title: v.title, img: data[i].icon }\\n    switch (editMode) {\\n        case '启用/禁用':\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                rules[i].visible = !rules[i].visible\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '重新排序':\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\n            if (sortFlag == -1)\\n                d.url = $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('sortFlag', i.toString())\\n                    refreshPage(false)\\n                    return 'toast://选择要移动到的位置'\\n                }, i)\\n            else\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\n                    saveFile('customData', JSON.stringify(rules))\\n                    putMyVar('sortFlag', '-1')\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, sortFlag, i)\\n            break\\n        case '更改图标':\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                if (input)\\n                    rules[i].icon = input\\n                else\\n                    delete rules[i].icon\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '导入海阔':\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let data = $.require('hiker://page/dataLoad?rule=' + getMyVar('myCollection'), true)\\n                return 'rule://' + base64Encode(JSON.stringify(data[i]))\\n            }, i)\\n            break\\n    }\\n    el.push(d)\\n})\\nsetResult(el)\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面载入\",\"path\":\"frameLoad\",\"rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nvar myColl_el = []\\neval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(oriRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n} else if (MY_PAGE == 1) {\\n    tabHeader.load(myColl_el)\\n    if (RULE.search_url) myColl_el.push({\\n        title: \\\"搜索\\\",\\n        desc: \\\"这是轻合集的搜索哦~~\\\",\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        extra: {\\n            rules: $.toString((QING_TITLE, title) => {\\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\\n                rules = [rules.find((v) => v.title == title)]\\n                return JSON.stringify(rules)\\n            }, QING_TITLE, RULE.title),\\n            defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"\\n        },\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 正文解析\\nvar {\\n    paramHandle,\\n    runPreRule,\\n    genExUrl,\\n    hijackLazyRule\\n} = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\nrunPreRule(oriRULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    let { hijackEl } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n    setResult = function(param0, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(param0.data)) param0 = param0.data\\n        Array.prototype.push.apply(myColl_el, param0.map(hijackEl))\\n        method_setResult.invoke(javaContext, myColl_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let { runCode } = $.require('hiker://page/funcTools?rule=' + QING_TITLE),\\n        [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.split(';')\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(Object.assign(genMyRule(), { detail_find_rule: detailFindRule }))),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(genMyRule())),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myColl_el.push(res)\\n    })\\n    setResult(myColl_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"数据载入\",\"path\":\"dataLoad\",\"rule\":\"let showAll = $.importParam,\\n    url = getMyVar('remoteUrl'),\\n    data = []\\nif (url.startsWith('hiker://') || url.startsWith('file://')) {\\n    // 如果为本地文件则不进行缓存\\n    try {\\n        let oriData = fetch(url)\\n        if (url.startsWith('hiker://page/'))\\n            oriData = JSON.parse(oriData).rule\\n        data = JSON.parse(oriData)\\n    } catch (e) {}\\n} else {\\n    // 获取远程数据，检查间隔默认一天\\n    let interval = parseInt(readFile('updateInterval') || '1'),\\n        oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\n        remoteData = []\\n    if (interval == 0) interval = -1\\n    try { remoteData = JSON.parse(fetchCache(url, 24 * interval, { timeout: 50000 })) } catch (e) {}\\n    if (!Array.isArray(remoteData)) remoteData = []\\n    if (remoteData.length < 3) {\\n        log('未获取到数据')\\n        if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData)\\n        data = JSON.parse(oldData || '[]')\\n    } else {\\n        log('已获取到数据')\\n        data = remoteData\\n    }\\n}\\ndata = data.filter((v) => v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器'))\\nif (readFile('disableCustom')) $.exports = data\\nelse { // 写入自定义数据\\n    let customData = JSON.parse(readFile('customData') || '[]'),\\n        rewriteData = []\\n    customData = customData.reduce((self, v) => {\\n        let index = data.findIndex((vv) => v.title == vv.title)\\n        if (index >= 0) {\\n            self.push(v)\\n            let rule = data.splice(index, 1)[0]\\n            if (showAll || v.visible)\\n                rewriteData.push(Object.assign(rule, v))\\n        }\\n        return self\\n    }, [])\\n    data.forEach((v) => customData.push({ title: v.title, visible: true }))\\n    saveFile('customData', JSON.stringify(customData))\\n    $.exports = rewriteData.concat(data)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"环境劫持\",\"path\":\"hijackEnv\",\"rule\":\"var { RULE, isIndex, pageTitle } = MY_PARAMS\\nRULE = JSON.parse(base64Decode(RULE))\\nvar oriRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE).find((v) => v.title == RULE.title)\\nif (isIndex) {\\n    RULE = oriRULE\\n    var { tabHeader, fyAll } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, RULE))\\n    // 处理MY_RULE\\n    MY_RULE.class_url = tabHeader.getClass(fyAll ? 'fyAll' : 'fyclass').url\\n    MY_RULE.area_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyarea').url\\n    MY_RULE.year_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyyear').url\\n    MY_RULE.sort_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fysort').url\\n    MY_RULE.url = RULE.url\\n    MY_RULE.col_type = RULE.col_type\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.find_rule\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\n    MY_RULE.params = {}\\n} else {\\n    RULE.pages = oriRULE.pages\\n    // 处理MY_RULE\\n    MY_RULE.url = MY_PARAMS.url\\n    MY_RULE.col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.detail_find_rule\\n    MY_RULE.params = RULE.params\\n}\\nMY_RULE.pages = RULE.pages\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\nMY_RULE.title = RULE.title\\nMY_RULE.ua = RULE.ua\\nlog(MY_RULE.url)\\n// 载入函数工具\\nvar { genMyRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE, {\\n    QING_TITLE: QING_TITLE,\\n    MY_RULE: MY_RULE,\\n    isIndex: isIndex\\n})\\n// 防止require多次运行\\nconst myColl_required = {}\\nrequire = function(param0, param1, param2, param3, param4) {\\n    if (myColl_required[param0]) return\\n    myColl_required[param0] = true\\n    param2 = param2 != null ? param2 : 0\\n    param3 = MY_TICKET\\n    param4 = eval\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\n}\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\n    if (myColl_required[param0]) return\\n    myColl_required[param0] = true\\n    param3 = param3 != null ? param3 : 0\\n    param4 = MY_TICKET\\n    param5 = eval\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\n}\\nrc = requireCache\\n// 最新章节规则环境劫持\\nsetLastChapterRule = function(param0) {\\n    if (param0.startsWith(\\\"js:\\\")) {\\n        param0 = 'js:' + $.toString((QING_TITLE, MY_PARAMS) => {\\n            eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n            var { runPreRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n            runPreRule(oriRULE.preRule)\\n        }, QING_TITLE, { url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex }) + ';' + param0.slice(3)\\n    }\\n    method_setLastChapterRule.invoke(javaContext, param0)\\n}\\n// 动态新增函数劫持\\naddItemAfter = function(param0, param1) {\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\n    else param1 = hijackEl(param1)\\n    method_addItemAfter.invoke(javaContext, param0, param1)\\n}\\naddItemBefore = function(param0, param1) {\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\n    else param1 = hijackEl(param1)\\n    method_addItemBefore.invoke(javaContext, param0, param1)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"函数工具\",\"path\":\"funcTools\",\"rule\":\"let { QING_TITLE, MY_RULE, isIndex } = $.importParam\\nif (!MY_RULE) MY_RULE = {}\\n\\nfunction runCode(rule) {\\n    try {\\n        let [input, code] = rule.split('.js:')\\n        return code ? eval(code) : rule\\n    } catch (e) { return rule }\\n}\\n// 首页链接替换分类\\nfunction indexUrl(param) {\\n    MY_RULE = JSON.parse(base64Decode(MY_RULE))\\n    let pageNum = parseInt(param.split('###')[1]),\\n        url = MY_RULE.url,\\n        { fyAll, tabHeader } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, MY_RULE))\\n\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\n    url = url.replace(/fypage(?:@(-?\\\\d+)@)?(?:\\\\*(\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\n    url = /^([\\\\s\\\\S]*?)(?:\\\\[firstPage=([\\\\s\\\\S]*?)\\\\])?(?:(\\\\.js:[\\\\s\\\\S]*?))?$/.exec(url)\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\n    return runCode(url[1])\\n}\\n\\nfunction paramHandle(urlParam, ua, urlTmp) {\\n    let charset, paramTmp\\n    try { // 链接的编码、UA和Referer应该是首先继承首页链接\\n        [, , charset, paramTmp] = urlTmp.split(';')\\n        paramTmp = paramTmp.match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { paramTmp = [] }\\n    let UserAgent = paramTmp.find((v) => v.startsWith('User-Agent@')),\\n        Referer = paramTmp.find((v) => v.startsWith('Referer@'))\\n    urlParam[0] = urlParam[0] || 'GET'\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\n    try {\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { urlParam[2] = [] }\\n    // 添加全局UA和上级Referer\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\n        if (UserAgent) urlParam[2].push(UserAgent)\\n        else if (ua == 'pc')\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n        else if (ua == 'mobile')\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n    }\\n    if (Referer && !urlParam[2].some((v) => v.startsWith('Referer@')))\\n        urlParam[2].push(Referer)\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\n    return urlParam.join(';')\\n}\\n// 预处理并初始化config\\nfunction runPreRule(rule) {\\n    if ((typeof MY_PAGE != 'undefined' &&  MY_PAGE == 1) &&\\n         (isIndex || !getMyVar('$preRule_' + MY_RULE.title))) {\\n        eval(rule)\\n        putMyVar('$preRule_' + MY_RULE.title, 'T')\\n    }\\n    let _cfg = getMyVar('initConfig', '{}')\\n    if (_cfg && _cfg.length > 0) {\\n        config = JSON.parse(_cfg)\\n    }\\n}\\n// 正文解析通用变量\\nfunction genMyRule() {\\n    let RULE = Object.assign({}, MY_RULE)\\n    delete RULE.last_chapter_rule\\n    delete RULE.preRule\\n    delete RULE.pageList\\n    delete RULE.pages\\n    return RULE\\n}\\n\\nfunction genExUrl(url) {\\n    url = url.split(';')\\n    return url.shift() + ';' + paramHandle(url, MY_RULE.ua, MY_RULE.url)\\n}\\n\\nhijackLazyRule = $.toString((QING_TITLE, MY_PARAMS) => {\\n    if (!MY_RULE) MY_RULE = {}\\n    MY_PARAMS = JSON.parse(base64Decode(MY_PARAMS))\\n    eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n    var {\\n        paramHandle,\\n        genExUrl,\\n        hijackLazyRule,\\n        hijackEl\\n    } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n}, QING_TITLE, base64Encode(JSON.stringify({ url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex })))\\n\\nfunction hijackEl(el) {\\n    if(!el || typeof el != 'object') return\\n    if (!el.extra) el.extra = {}\\n    el.col_type = el.col_type || MY_RULE.col_type\\n    let NOW_RULE = Object.assign(genMyRule(), { params: el.extra })\\n\\n    if (typeof el.url != 'string' ||\\n        ['x5_webview_single', 'input'].some((v) => el.col_type == v) ||\\n        ['海阔视界', 'javascript:'].some((v) => el.url.startsWith(v)) ||\\n        ['rule', 'pics', 'toast', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'x5Rule', 'webRule',\\n            'download', 'share', 'fileSelect', 'video'].some((v) => el.url.startsWith(v + '://'))) {\\n        return el\\n    } else if (el.url.startsWith('input://')) {\\n        let para = JSON.parse(el.url.slice(8))\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\n        el.url = 'input://' + JSON.stringify(para)\\n        return el\\n    } else if (el.url.startsWith('confirm://')) {\\n        let reIndex = el.url.indexOf('.js:')\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\n        return el\\n    } else if (el.url.startsWith('select://')) {\\n        let para = JSON.parse(el.url.slice(9))\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\n        el.url = 'select://' + JSON.stringify(para)\\n        return el\\n    } else if (el.url.includes('@rule=')) {\\n        let [_, url, rule] = el.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n        el.url = url\\n        NOW_RULE.detail_find_rule = rule\\n        NOW_RULE.detail_col_type = MY_RULE.col_type\\n    } else if (el.url.startsWith('hiker://page/')) {\\n        if (el.url.includes('rule=') || el.extra.rule)\\n            return el\\n        let [_, path, flag, params] = el.url.match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(#.*?)?(?:\\\\?(.*))?$/),\\n            subPage = MY_RULE.pageList.find((v) => v.path == path),\\n            subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\n        el.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (el.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\n        NOW_RULE.detail_find_rule = subPage.rule\\n        NOW_RULE.detail_col_type = subPage.col_type\\n    } else if (el.url.includes('@lazyRule=')) {\\n        let reIndex = el.url.indexOf('.js:')\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\n        return el\\n    } else if (isIndex) {\\n        if (!MY_RULE.detail_find_rule || /hiker:\\\\/\\\\/(?!empty.+$)/.test(el.url)) return el\\n    } else {\\n        return el\\n    }\\n    el.extra = Object.assign({}, el.extra, {\\n        url: genExUrl(el.url),\\n        RULE: base64Encode(JSON.stringify(NOW_RULE)),\\n        pageTitle: isIndex && el.title\\n    })\\n    el.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n    return el\\n}\\n$.exports = {\\n    runCode: runCode,\\n    indexUrl: indexUrl,\\n    paramHandle: paramHandle,\\n    runPreRule: runPreRule,\\n    genMyRule: genMyRule,\\n    genExUrl: genExUrl,\\n    hijackLazyRule: hijackLazyRule,\\n    hijackEl: hijackEl\\n}\\n\"}],\"params\":\"{\\\"RULE\\\":\\\"eyJ0aXRsZSI6IueOlueOliJ9\\\",\\\"isIndex\\\":true,\\\"url\\\":\\\"hiker://empty/#noHistory##noRecordHistory####fypage.js:let { runCode, indexUrl } = $.require(\\\\\\\"hiker://page/funcTools？？rule=4_8_share-home-rules.json\\\\\\\", {\\\\\\\"MY_RULE\\\\\\\":\\\\\\\"eyJ0aXRsZSI6IueOlueOliIsInVybCI6Imhpa2VyOi8vZW1wdHkjI2h0dHA6Ly85OXp5d2NqLmNvbS9pbmMvc2FwaS5waHAjcGc9ZnlwYWdlIiwiY2xhc3NfbmFtZSI6IiIsImNsYXNzX3VybCI6IiIsImFyZWFfbmFtZSI6IiIsImFyZWFfdXJsIjoiIiwieWVhcl9uYW1lIjoiIiwieWVhcl91cmwiOiIiLCJzb3J0X25hbWUiOiIiLCJzb3J0X3VybCI6IuWlveWtqeWtkDEyMjkifQ==\\\\\\\",\\\\\\\"QING_TITLE\\\\\\\":\\\\\\\"4_8_share-home-rules.json\\\\\\\"})；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 12；； TAS-AN00 Build/HUAWEITAS-AN00；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.105 Mobile Safari/537.36}\\\"}\",\"saved\":false,\"title\":\"4_8_share-home-rules.json\",\"version\":0,\"url\":\"hiker://empty/#noHistory##noRecordHistory####fypage.js:let { runCode, indexUrl } = $.require(\\\"hiker://page/funcTools？？rule=4_8_share-home-rules.json\\\", {\\\"MY_RULE\\\":\\\"eyJ0aXRsZSI6IueOlueOliIsInVybCI6Imhpa2VyOi8vZW1wdHkjI2h0dHA6Ly85OXp5d2NqLmNvbS9pbmMvc2FwaS5waHAjcGc9ZnlwYWdlIiwiY2xhc3NfbmFtZSI6IiIsImNsYXNzX3VybCI6IiIsImFyZWFfbmFtZSI6IiIsImFyZWFfdXJsIjoiIiwieWVhcl9uYW1lIjoiIiwieWVhcl91cmwiOiIiLCJzb3J0X25hbWUiOiIiLCJzb3J0X3VybCI6IuWlveWtqeWtkDEyMjkifQ==\\\",\\\"QING_TITLE\\\":\\\"4_8_share-home-rules.json\\\"})；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 12；； TAS-AN00 Build/HUAWEITAS-AN00；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.105 Mobile Safari/537.36}\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nvar myColl_el = []\\neval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(oriRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n} else if (MY_PAGE == 1) {\\n    tabHeader.load(myColl_el)\\n    if (RULE.search_url) myColl_el.push({\\n        title: \\\"搜索\\\",\\n        desc: \\\"这是轻合集的搜索哦~~\\\",\\n        url: '\\\"hiker://search?s=\\\"+input',\\n        extra: {\\n            rules: $.toString((QING_TITLE, title) => {\\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\\n                rules = [rules.find((v) => v.title == title)]\\n                return JSON.stringify(rules)\\n            }, QING_TITLE, RULE.title),\\n            defaultValue: getMyVar('searchKey', ''),\\n            onChange: \\\"putMyVar('searchKey',input)\\\"\\n        },\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 正文解析\\nvar {\\n    paramHandle,\\n    runPreRule,\\n    genExUrl,\\n    hijackLazyRule\\n} = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\nrunPreRule(oriRULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    let { hijackEl } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\n    setResult = function(param0, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(param0.data)) param0 = param0.data\\n        Array.prototype.push.apply(myColl_el, param0.map(hijackEl))\\n        method_setResult.invoke(javaContext, myColl_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let { runCode } = $.require('hiker://page/funcTools?rule=' + QING_TITLE),\\n        [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.split(';')\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(Object.assign(genMyRule(), { detail_find_rule: detailFindRule }))),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: base64Encode(JSON.stringify(genMyRule())),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myColl_el.push(res)\\n    })\\n    setResult(myColl_el)\\n}\\n\",\"group\":\"👌轻合集\",\"ua\":\"mobile\",\"preRule\":\"putMyVar('myCollection', MY_RULE.title)\\nputMyVar('remoteUrl', 'https://gitcode.net/m0_64486304/TVBox/-/raw/main/4_8_share-home-rules.json')\\n// \\n/*\\n*/\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"ClassTab\\\",\\\"path\\\":\\\"ClassTab\\\",\\\"rule\\\":\\\"var {\\\\n    QING_TITLE, title, url,\\\\n    class_name, class_url,\\\\n    area_name, area_url,\\\\n    year_name, year_url,\\\\n    sort_name, sort_url\\\\n} = $.importParam\\\\nconst ClassTab = function(classArray, params) {\\\\n    Object.assign(this, params)\\\\n    this.arr = classArray.map(v => this.init(v))\\\\n    this.sign = '$' + QING_TITLE + '_' + (this.name || '') + '_'\\\\n    this.color = this.color || '#12b668'\\\\n    this.boundary = this.boundary || 'blank_block'\\\\n}\\\\nClassTab.prototype = {\\\\n    constructor: ClassTab,\\\\n    load(el) {\\\\n        let folded = this.fold && getVar('$fold_' + this.sign, '')\\\\n        if (this.arr.length > 1 && this.fold) el.push({\\\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\\\n                putVar('$fold_' + sign, folded ? '' : 'T')\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, this.sign, folded),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n        let arr = folded ? [this.arr[0]] : this.arr\\\\n        arr.forEach((v) => {\\\\n            let { id, class_name, class_url } = v,\\\\n            selected = JSON.stringify(this.getClass(id))\\\\n            class_name.forEach((name, i) => {\\\\n                let url = class_url[i],\\\\n                    now = JSON.stringify({ name: name, url: url })\\\\n                el.push({\\\\n                    title: selected == now ? '““””' + name.fontcolor(this.color).bold() : name,\\\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\\\n                        putVar(sign + id, now)\\\\n                        refreshPage(false)\\\\n                        return 'hiker://empty'\\\\n                    }, this.sign, id, now),\\\\n                    col_type: 'scroll_button'\\\\n                })\\\\n            })\\\\n            el.push({ col_type: this.boundary })\\\\n        })\\\\n    },\\\\n    init(classObject) {\\\\n        if (typeof classObject.class_name == 'string')\\\\n            classObject.class_name = classObject.class_name.split('&')\\\\n        if (typeof classObject.class_url == 'string')\\\\n            classObject.class_url = classObject.class_url.split('&').map((v) => v.trim())\\\\n        return classObject\\\\n    },\\\\n    push(classObject) {\\\\n        this.arr.push(this.init(classObject))\\\\n    },\\\\n    getClass(id) {\\\\n        let defaultClass = this.arr.find(item => item.id == id)\\\\n        defaultClass = JSON.stringify(defaultClass ? {\\\\n            name: defaultClass.class_name[0],\\\\n            url: defaultClass.class_url[0]\\\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\\\n    },\\\\n    setUrl(url) {\\\\n        return url.replace(/\\\\\\\\$\\\\\\\\{([^}]*)\\\\\\\\}/g, (_, id) => this.getClass(id).url)\\\\n    }\\\\n}\\\\n// 生成头部分类\\\\nlet fyAll = url.includes('fyAll'),\\\\n    tabHeader = []\\\\nif (class_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyclass',\\\\n    class_name: class_name,\\\\n    class_url: class_url\\\\n})\\\\nif (area_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyarea',\\\\n    class_name: area_name,\\\\n    class_url: area_url\\\\n})\\\\nif (year_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyyear',\\\\n    class_name: year_name,\\\\n    class_url: year_url\\\\n})\\\\nif (sort_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fysort',\\\\n    class_name: sort_name,\\\\n    class_url: sort_url\\\\n})\\\\n$.exports = {\\\\n    fyAll: fyAll,\\\\n    tabHeader: new ClassTab(tabHeader, { name: title, fold: readFile('tabFold'), })\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"icon_2_round\\\",\\\"name\\\":\\\"设置\\\",\\\"path\\\":\\\"Config\\\",\\\"rule\\\":\\\"js:\\\\naddListener('onClose', 'clearMyVar(\\\\\\\"sortFlag\\\\\\\");refreshPage()')\\\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\\\nconst QING_TITLE = getMyVar('myCollection'),\\\\n    url = getMyVar('remoteUrl')\\\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE, true),\\\\n    el = [{\\\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，不要频繁点击）',\\\\n        url: $('#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 ? '' : 'T')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }, newWindow),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\\\n        saveFile('tabFold', tabFold ? '' : 'T')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }, tabFold),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  💼 备份恢复  ',\\\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n        let url = getMyVar('remoteUrl')\\\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\\\n        else if (url.startsWith('hiker://page/')) url = 'hiker://empty'\\\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n                let rules = request(url),\\\\n                    customData = readFile('customData')\\\\n                writeFile(input, JSON.stringify({\\\\n                    updateInterval: updateInterval,\\\\n                    newWindow: newWindow,\\\\n                    tabFold: tabFold,\\\\n                    disableCustom: disableCustom,\\\\n                    customData: customData,\\\\n                    rules: rules\\\\n                }))\\\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\\\n            saveFile('updateInterval', updateInterval)\\\\n            saveFile('newWindow', newWindow)\\\\n            saveFile('tabFold', tabFold)\\\\n            saveFile('disableCustom', disableCustom)\\\\n            saveFile('customData', customData)\\\\n            if (rules) writeFile(url, rules)\\\\n            refreshPage()\\\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\\\n        }, url)\\\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '““””<font color=\\\\\\\"#666666\\\\\\\"><small>特别鸣谢，小程序提供者：\\\\\\\\n' +\\\\n        data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\\\n        .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、'),\\\\n    url: 'hiker://empty',\\\\n    col_type: 'text_center_1'\\\\n})\\\\n\\\\nel.push({ col_type: 'line' }, {\\\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据', '编辑JSON'], 1).select(() => {\\\\n        switch (input.slice(0, 2)) {\\\\n            case '清除':\\\\n                deleteFile('customData')\\\\n                break\\\\n            case '启用':\\\\n                saveFile('disableCustom', '')\\\\n                break\\\\n            case '禁用':\\\\n                saveFile('disableCustom', 'T')\\\\n                input += '\\\\\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\\\n                break\\\\n            case '编辑':\\\\n                let url = getMyVar('remoteUrl')\\\\n                if (!url.startsWith('hiker://files/') && !url.startsWith('file://'))\\\\n                    url = 'hiker://files/libs/' + md5(url) + '.js'\\\\n                return  'hiker://page/interface#noRefresh##noHistory##noRecordHistory#?rule=JSON编辑器&Json='+base64Encode(url)\\\\n        }\\\\n        refreshPage(false)\\\\n        return 'toast://已' + input\\\\n    }),\\\\n    col_type: 'text_center_1',\\\\n    extra: { lineVisible: false }\\\\n});\\\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\\\n    el.push({\\\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\\\n            putMyVar('editMode', v)\\\\n            refreshPage(false)\\\\n            return 'hiker://empty'\\\\n        }, v),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n});\\\\nif (editMode == '导入海阔') el.push({\\\\n    title: '全部导入',\\\\n    url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\\\n    col_type: 'text_center_1',\\\\n    extra: { lineVisible: false }\\\\n});\\\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\\\n    let d = { title: v.title, img: data[i].icon }\\\\n    switch (editMode) {\\\\n        case '启用/禁用':\\\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\\\n            d.url = $('#noLoading#').lazyRule((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                rules[i].visible = !rules[i].visible\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '重新排序':\\\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\\\n            if (sortFlag == -1)\\\\n                d.url = $('#noLoading#').lazyRule((i) => {\\\\n                    putMyVar('sortFlag', i.toString())\\\\n                    refreshPage(false)\\\\n                    return 'toast://选择要移动到的位置'\\\\n                }, i)\\\\n            else\\\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\\\n                    saveFile('customData', JSON.stringify(rules))\\\\n                    putMyVar('sortFlag', '-1')\\\\n                    refreshPage(false)\\\\n                    return 'hiker://empty'\\\\n                }, sortFlag, i)\\\\n            break\\\\n        case '更改图标':\\\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                if (input)\\\\n                    rules[i].icon = input\\\\n                else\\\\n                    delete rules[i].icon\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '导入海阔':\\\\n            d.url = $('#noLoading#').lazyRule((i) => {\\\\n                let data = $.require('hiker://page/dataLoad?rule=' + getMyVar('myCollection'), true)\\\\n                return 'rule://' + base64Encode(JSON.stringify(data[i]))\\\\n            }, i)\\\\n            break\\\\n    }\\\\n    el.push(d)\\\\n})\\\\nsetResult(el)\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面载入\\\",\\\"path\\\":\\\"frameLoad\\\",\\\"rule\\\":\\\"js:\\\\nconst QING_TITLE = getMyVar('myCollection')\\\\nvar myColl_el = []\\\\neval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\\\n\\\\nif (!isIndex) {\\\\n    if (pageTitle) setPageTitle(pageTitle)\\\\n    setLastChapterRule(oriRULE.last_chapter_rule)\\\\n    MY_PARAMS = MY_RULE.params\\\\n} else if (MY_PAGE == 1) {\\\\n    tabHeader.load(myColl_el)\\\\n    if (RULE.search_url) myColl_el.push({\\\\n        title: \\\\\\\"搜索\\\\\\\",\\\\n        desc: \\\\\\\"这是轻合集的搜索哦~~\\\\\\\",\\\\n        url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n        extra: {\\\\n            rules: $.toString((QING_TITLE, title) => {\\\\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)\\\\n                rules = [rules.find((v) => v.title == title)]\\\\n                return JSON.stringify(rules)\\\\n            }, QING_TITLE, RULE.title),\\\\n            defaultValue: getMyVar('searchKey', ''),\\\\n            onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n        },\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n    })\\\\n}\\\\n// 正文解析\\\\nvar {\\\\n    paramHandle,\\\\n    runPreRule,\\\\n    genExUrl,\\\\n    hijackLazyRule\\\\n} = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\nrunPreRule(oriRULE.preRule)\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    let { hijackEl } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\n    setResult = function(param0, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n        if (Array.isArray(param0.data)) param0 = param0.data\\\\n        Array.prototype.push.apply(myColl_el, param0.map(hijackEl))\\\\n        method_setResult.invoke(javaContext, myColl_el, param1, param2, param3)\\\\n    }\\\\n    setHomeResult = setResult\\\\n    setSearchResult = setResult\\\\n\\\\n    eval(MY_RULE.find_rule.slice(3))\\\\n} else {\\\\n    let { runCode } = $.require('hiker://page/funcTools?rule=' + QING_TITLE),\\\\n        [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\\\\\s\\\\\\\\S]*?)(?:==>([\\\\\\\\s\\\\\\\\S]*))?$/)\\\\n    findRule = findRule.split(';')\\\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\\\n                try {\\\\n                    if (v == '*') return ''\\\\n                    else v = (i == 1 || i == 3) ?\\\\n                        parseDom(data, v) :\\\\n                        parseDomForHtml(data, v)\\\\n                    if (i != 3) v = runCode(v)\\\\n                    return v\\\\n                } catch (e) { return '' }\\\\n            }),\\\\n            res = {\\\\n                title: title, url: url,\\\\n                desc: desc, img: img,\\\\n                col_type: MY_RULE.col_type\\\\n            }\\\\n        if (res.url) {\\\\n            if (res.url.includes('@lazyRule=')) {\\\\n                let reIndex = res.url.indexOf('.js:')\\\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + res.url.slice(reIndex + 4)\\\\n            } else  if (detailFindRule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: base64Encode(JSON.stringify(Object.assign(genMyRule(), { detail_find_rule: detailFindRule }))),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: base64Encode(JSON.stringify(genMyRule())),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            }\\\\n        }\\\\n        myColl_el.push(res)\\\\n    })\\\\n    setResult(myColl_el)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据载入\\\",\\\"path\\\":\\\"dataLoad\\\",\\\"rule\\\":\\\"let showAll = $.importParam,\\\\n    url = getMyVar('remoteUrl'),\\\\n    data = []\\\\nif (url.startsWith('hiker://') || url.startsWith('file://')) {\\\\n    // 如果为本地文件则不进行缓存\\\\n    try {\\\\n        let oriData = fetch(url)\\\\n        if (url.startsWith('hiker://page/'))\\\\n            oriData = JSON.parse(oriData).rule\\\\n        data = JSON.parse(oriData)\\\\n    } catch (e) {}\\\\n} else {\\\\n    // 获取远程数据，检查间隔默认一天\\\\n    let interval = parseInt(readFile('updateInterval') || '1'),\\\\n        oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\\\n        remoteData = []\\\\n    if (interval == 0) interval = -1\\\\n    try { remoteData = JSON.parse(fetchCache(url, 24 * interval, { timeout: 50000 })) } catch (e) {}\\\\n    if (!Array.isArray(remoteData)) remoteData = []\\\\n    if (remoteData.length < 3) {\\\\n        log('未获取到数据')\\\\n        if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData)\\\\n        data = JSON.parse(oldData || '[]')\\\\n    } else {\\\\n        log('已获取到数据')\\\\n        data = remoteData\\\\n    }\\\\n}\\\\ndata = data.filter((v) => v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器'))\\\\nif (readFile('disableCustom')) $.exports = data\\\\nelse { // 写入自定义数据\\\\n    let customData = JSON.parse(readFile('customData') || '[]'),\\\\n        rewriteData = []\\\\n    customData = customData.reduce((self, v) => {\\\\n        let index = data.findIndex((vv) => v.title == vv.title)\\\\n        if (index >= 0) {\\\\n            self.push(v)\\\\n            let rule = data.splice(index, 1)[0]\\\\n            if (showAll || v.visible)\\\\n                rewriteData.push(Object.assign(rule, v))\\\\n        }\\\\n        return self\\\\n    }, [])\\\\n    data.forEach((v) => customData.push({ title: v.title, visible: true }))\\\\n    saveFile('customData', JSON.stringify(customData))\\\\n    $.exports = rewriteData.concat(data)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"环境劫持\\\",\\\"path\\\":\\\"hijackEnv\\\",\\\"rule\\\":\\\"var { RULE, isIndex, pageTitle } = MY_PARAMS\\\\nRULE = JSON.parse(base64Decode(RULE))\\\\nvar oriRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE).find((v) => v.title == RULE.title)\\\\nif (isIndex) {\\\\n    RULE = oriRULE\\\\n    var { tabHeader, fyAll } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, RULE))\\\\n    // 处理MY_RULE\\\\n    MY_RULE.class_url = tabHeader.getClass(fyAll ? 'fyAll' : 'fyclass').url\\\\n    MY_RULE.area_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyarea').url\\\\n    MY_RULE.year_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyyear').url\\\\n    MY_RULE.sort_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fysort').url\\\\n    MY_RULE.url = RULE.url\\\\n    MY_RULE.col_type = RULE.col_type\\\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.find_rule\\\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = {}\\\\n} else {\\\\n    RULE.pages = oriRULE.pages\\\\n    // 处理MY_RULE\\\\n    MY_RULE.url = MY_PARAMS.url\\\\n    MY_RULE.col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = RULE.params\\\\n}\\\\nMY_RULE.pages = RULE.pages\\\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\\\nMY_RULE.title = RULE.title\\\\nMY_RULE.ua = RULE.ua\\\\nlog(MY_RULE.url)\\\\n// 载入函数工具\\\\nvar { genMyRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE, {\\\\n    QING_TITLE: QING_TITLE,\\\\n    MY_RULE: MY_RULE,\\\\n    isIndex: isIndex\\\\n})\\\\n// 防止require多次运行\\\\nconst myColl_required = {}\\\\nrequire = function(param0, param1, param2, param3, param4) {\\\\n    if (myColl_required[param0]) return\\\\n    myColl_required[param0] = true\\\\n    param2 = param2 != null ? param2 : 0\\\\n    param3 = MY_TICKET\\\\n    param4 = eval\\\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\\\n}\\\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\\\n    if (myColl_required[param0]) return\\\\n    myColl_required[param0] = true\\\\n    param3 = param3 != null ? param3 : 0\\\\n    param4 = MY_TICKET\\\\n    param5 = eval\\\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\\\n}\\\\nrc = requireCache\\\\n// 最新章节规则环境劫持\\\\nsetLastChapterRule = function(param0) {\\\\n    if (param0.startsWith(\\\\\\\"js:\\\\\\\")) {\\\\n        param0 = 'js:' + $.toString((QING_TITLE, MY_PARAMS) => {\\\\n            eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\\\n            var { runPreRule } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\n            runPreRule(oriRULE.preRule)\\\\n        }, QING_TITLE, { url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex }) + ';' + param0.slice(3)\\\\n    }\\\\n    method_setLastChapterRule.invoke(javaContext, param0)\\\\n}\\\\n// 动态新增函数劫持\\\\naddItemAfter = function(param0, param1) {\\\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\\\n    else param1 = hijackEl(param1)\\\\n    method_addItemAfter.invoke(javaContext, param0, param1)\\\\n}\\\\naddItemBefore = function(param0, param1) {\\\\n    if (Array.isArray(param1)) param1 = param1.map(hijackEl)\\\\n    else param1 = hijackEl(param1)\\\\n    method_addItemBefore.invoke(javaContext, param0, param1)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"函数工具\\\",\\\"path\\\":\\\"funcTools\\\",\\\"rule\\\":\\\"let { QING_TITLE, MY_RULE, isIndex } = $.importParam\\\\nif (!MY_RULE) MY_RULE = {}\\\\n\\\\nfunction runCode(rule) {\\\\n    try {\\\\n        let [input, code] = rule.split('.js:')\\\\n        return code ? eval(code) : rule\\\\n    } catch (e) { return rule }\\\\n}\\\\n// 首页链接替换分类\\\\nfunction indexUrl(param) {\\\\n    MY_RULE = JSON.parse(base64Decode(MY_RULE))\\\\n    let pageNum = parseInt(param.split('###')[1]),\\\\n        url = MY_RULE.url,\\\\n        { fyAll, tabHeader } = $.require('hiker://page/ClassTab?rule=' + QING_TITLE, Object.assign({ QING_TITLE: QING_TITLE }, MY_RULE))\\\\n\\\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\\\n    url = url.replace(/fypage(?:@(-?\\\\\\\\d+)@)?(?:\\\\\\\\*(\\\\\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\\\n    url = /^([\\\\\\\\s\\\\\\\\S]*?)(?:\\\\\\\\[firstPage=([\\\\\\\\s\\\\\\\\S]*?)\\\\\\\\])?(?:(\\\\\\\\.js:[\\\\\\\\s\\\\\\\\S]*?))?$/.exec(url)\\\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\\\n    return runCode(url[1])\\\\n}\\\\n\\\\nfunction paramHandle(urlParam, ua, urlTmp) {\\\\n    let charset, paramTmp\\\\n    try { // 链接的编码、UA和Referer应该是首先继承首页链接\\\\n        [, , charset, paramTmp] = urlTmp.split(';')\\\\n        paramTmp = paramTmp.match(/^{(.*)}$/)[1].split('&&')\\\\n    } catch (e) { paramTmp = [] }\\\\n    let UserAgent = paramTmp.find((v) => v.startsWith('User-Agent@')),\\\\n        Referer = paramTmp.find((v) => v.startsWith('Referer@'))\\\\n    urlParam[0] = urlParam[0] || 'GET'\\\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\\\n    try {\\\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\\\n    } catch (e) { urlParam[2] = [] }\\\\n    // 添加全局UA和上级Referer\\\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\\\n        if (UserAgent) urlParam[2].push(UserAgent)\\\\n        else if (ua == 'pc')\\\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n        else if (ua == 'mobile')\\\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n    }\\\\n    if (Referer && !urlParam[2].some((v) => v.startsWith('Referer@')))\\\\n        urlParam[2].push(Referer)\\\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\\\n    return urlParam.join(';')\\\\n}\\\\n// 预处理并初始化config\\\\nfunction runPreRule(rule) {\\\\n    if ((typeof MY_PAGE != 'undefined' &&  MY_PAGE == 1) &&\\\\n         (isIndex || !getMyVar('$preRule_' + MY_RULE.title))) {\\\\n        eval(rule)\\\\n        putMyVar('$preRule_' + MY_RULE.title, 'T')\\\\n    }\\\\n    let _cfg = getMyVar('initConfig', '{}')\\\\n    if (_cfg && _cfg.length > 0) {\\\\n        config = JSON.parse(_cfg)\\\\n    }\\\\n}\\\\n// 正文解析通用变量\\\\nfunction genMyRule() {\\\\n    let RULE = Object.assign({}, MY_RULE)\\\\n    delete RULE.last_chapter_rule\\\\n    delete RULE.preRule\\\\n    delete RULE.pageList\\\\n    delete RULE.pages\\\\n    return RULE\\\\n}\\\\n\\\\nfunction genExUrl(url) {\\\\n    url = url.split(';')\\\\n    return url.shift() + ';' + paramHandle(url, MY_RULE.ua, MY_RULE.url)\\\\n}\\\\n\\\\nhijackLazyRule = $.toString((QING_TITLE, MY_PARAMS) => {\\\\n    if (!MY_RULE) MY_RULE = {}\\\\n    MY_PARAMS = JSON.parse(base64Decode(MY_PARAMS))\\\\n    eval(JSON.parse(fetch('hiker://page/hijackEnv?rule=' + QING_TITLE)).rule)\\\\n    var {\\\\n        paramHandle,\\\\n        genExUrl,\\\\n        hijackLazyRule,\\\\n        hijackEl\\\\n    } = $.require('hiker://page/funcTools?rule=' + QING_TITLE)\\\\n}, QING_TITLE, base64Encode(JSON.stringify({ url: MY_RULE.url, RULE: base64Encode(JSON.stringify(genMyRule())), isIndex: isIndex })))\\\\n\\\\nfunction hijackEl(el) {\\\\n    if(!el || typeof el != 'object') return\\\\n    if (!el.extra) el.extra = {}\\\\n    el.col_type = el.col_type || MY_RULE.col_type\\\\n    let NOW_RULE = Object.assign(genMyRule(), { params: el.extra })\\\\n\\\\n    if (typeof el.url != 'string' ||\\\\n        ['x5_webview_single', 'input'].some((v) => el.col_type == v) ||\\\\n        ['海阔视界', 'javascript:'].some((v) => el.url.startsWith(v)) ||\\\\n        ['rule', 'pics', 'toast', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'x5Rule', 'webRule',\\\\n            'download', 'share', 'fileSelect', 'video'].some((v) => el.url.startsWith(v + '://'))) {\\\\n        return el\\\\n    } else if (el.url.startsWith('input://')) {\\\\n        let para = JSON.parse(el.url.slice(8))\\\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\\\n        el.url = 'input://' + JSON.stringify(para)\\\\n        return el\\\\n    } else if (el.url.startsWith('confirm://')) {\\\\n        let reIndex = el.url.indexOf('.js:')\\\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\\\n        return el\\\\n    } else if (el.url.startsWith('select://')) {\\\\n        let para = JSON.parse(el.url.slice(9))\\\\n        if (para.js) para.js = hijackLazyRule + ';' + para.js\\\\n        el.url = 'select://' + JSON.stringify(para)\\\\n        return el\\\\n    } else if (el.url.includes('@rule=')) {\\\\n        let [_, url, rule] = el.url.match(/^([\\\\\\\\s\\\\\\\\S]*?)@rule=([\\\\\\\\s\\\\\\\\S]*)$/)\\\\n        el.url = url\\\\n        NOW_RULE.detail_find_rule = rule\\\\n        NOW_RULE.detail_col_type = MY_RULE.col_type\\\\n    } else if (el.url.startsWith('hiker://page/')) {\\\\n        if (el.url.includes('rule=') || el.extra.rule)\\\\n            return el\\\\n        let [_, path, flag, params] = el.url.match(/^hiker:\\\\\\\\/\\\\\\\\/page\\\\\\\\/(.+?)(#.*?)?(?:\\\\\\\\?(.*))?$/),\\\\n            subPage = MY_RULE.pageList.find((v) => v.path == path),\\\\n            subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\\\n        el.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (el.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\\\n        NOW_RULE.detail_find_rule = subPage.rule\\\\n        NOW_RULE.detail_col_type = subPage.col_type\\\\n    } else if (el.url.includes('@lazyRule=')) {\\\\n        let reIndex = el.url.indexOf('.js:')\\\\n        if (reIndex >= 0) el.url = el.url.slice(0, reIndex) + '.js:' + hijackLazyRule + ';' + el.url.slice(reIndex + 4)\\\\n        return el\\\\n    } else if (isIndex) {\\\\n        if (!MY_RULE.detail_find_rule || /hiker:\\\\\\\\/\\\\\\\\/(?!empty.+$)/.test(el.url)) return el\\\\n    } else {\\\\n        return el\\\\n    }\\\\n    el.extra = Object.assign({}, el.extra, {\\\\n        url: genExUrl(el.url),\\\\n        RULE: base64Encode(JSON.stringify(NOW_RULE)),\\\\n        pageTitle: isIndex && el.title\\\\n    })\\\\n    el.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n    return el\\\\n}\\\\n$.exports = {\\\\n    runCode: runCode,\\\\n    indexUrl: indexUrl,\\\\n    paramHandle: paramHandle,\\\\n    runPreRule: runPreRule,\\\\n    genMyRule: genMyRule,\\\\n    genExUrl: genExUrl,\\\\n    hijackLazyRule: hijackLazyRule,\\\\n    hijackEl: hijackEl\\\\n}\\\\n\\\"}]\",\"proxy\":\"\"}","picUrl":"http://1.117.152.239:39000/tupian.php?text=玖玖","title":"玖玖"}