API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：幕启星河APP

xiaomianao666
Dec 3rd, 2024
251
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 141.05 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥幕启星河APP@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"var {\\n    QING_TITLE, title, url,\\n    class_name, class_url,\\n    area_name, area_url,\\n    year_name, year_url,\\n    sort_name, sort_url\\n} = $.importParam\\nconst ClassTab = function(classArray, params) {\\n    Object.assign(this, params)\\n    this.arr = classArray.map(v => this.init(v))\\n    this.sign = '$' + QING_TITLE + '_' + (this.name || '') + '_'\\n    this.color = this.color || '#12b668'\\n    this.boundary = this.boundary || 'blank_block'\\n}\\nClassTab.prototype = {\\n    constructor: ClassTab,\\n    load(el) {\\n        let folded = this.fold && getVar('$fold_' + this.sign, '')\\n        if (this.arr.length > 1 && this.fold) el.push({\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\n                putVar('$fold_' + sign, folded ? '' : 'T')\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, this.sign, folded),\\n            col_type: 'scroll_button'\\n        })\\n        let arr = folded ? [this.arr[0]] : this.arr\\n        arr.forEach((v) => {\\n            let { id, class_name, class_url } = v,\\n            selected = JSON.stringify(this.getClass(id))\\n            class_name.forEach((name, i) => {\\n                let url = class_url[i],\\n                    now = JSON.stringify({ name: name, url: url })\\n                el.push({\\n                    title: selected == now ? '““””' + name.fontcolor(this.color).bold() : name,\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\n                        putVar(sign + id, now)\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, this.sign, id, now),\\n                    col_type: 'scroll_button'\\n                })\\n            })\\n            el.push({ col_type: this.boundary })\\n        })\\n    },\\n    init(classObject) {\\n        if (typeof classObject.class_name == 'string')\\n            classObject.class_name = classObject.class_name.split('&')\\n        if (typeof classObject.class_url == 'string')\\n            classObject.class_url = classObject.class_url.split('&').map((v) => v.trim())\\n        return classObject\\n    },\\n    push(classObject) {\\n        this.arr.push(this.init(classObject))\\n    },\\n    getClass(id) {\\n        let defaultClass = this.arr.find(item => item.id == id)\\n        defaultClass = JSON.stringify(defaultClass ? {\\n            name: defaultClass.class_name[0],\\n            url: defaultClass.class_url[0]\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\n    },\\n    setUrl(url) {\\n        return url.replace(/\\\\$\\\\{([^}]*)\\\\}/g, (_, id) => this.getClass(id).url)\\n    }\\n}\\n// 生成头部分类\\nlet fyAll = url.includes('fyAll'),\\n    tabHeader = []\\nif (class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: class_name,\\n    class_url: class_url\\n})\\nif (area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: area_name,\\n    class_url: area_url\\n})\\nif (year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: year_name,\\n    class_url: year_url\\n})\\nif (sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: sort_name,\\n    class_url: sort_url\\n})\\n$.exports = {\\n    fyAll: fyAll,\\n    tabHeader: new ClassTab(tabHeader, { name: title, fold: readFile('tabFold'), })\\n}\\n\"},{\"col_type\":\"icon_2_round\",\"name\":\"设置\",\"path\":\"Config\",\"rule\":\"js:\\naddListener('onClose', 'clearMyVar(\\\"sortFlag\\\");refreshPage()')\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\nconst QING_TITLE = getMyVar('myCollection'),\\n    url = getMyVar('remoteUrl')\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE, true),\\n    el = [{\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，不要频繁点击）',\\n        url: $('#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\\\":\\\"eyJ0aXRsZSI6IuW5leWQr+aYn+ays0FQUCJ9\\\",\\\"isIndex\\\":true,\\\"url\\\":\\\"hiker://empty/#noHistory##noRecordHistory####fypage.js:let { runCode, indexUrl } = $.require(\\\\\\\"hiker://page/funcTools？？rule=轻合集.zhao\\\\\\\", {\\\\\\\"MY_RULE\\\\\\\":\\\\\\\"eyJ0aXRsZSI6IuW5leWQr+aYn+ays0FQUCIsInVybCI6Imhpa2VyOi8vZW1wdHkjIy9hcGkucGhwL3YxLnZvZD90eXBlPWZ5Y2xhc3MmY2xhc3M9JmFyZWE9JnllYXI9Znl5ZWFyJmJ5PWZ5c29ydCZwYWdlPWZ5cGFnZSZsaW1pdD0xOCIsImNsYXNzX25hbWUiOiLnlLXlvbEm5Ymn6ZuGJue7vOiJuibliqjmvKsm5bCR5YS/JuefreWJpybnm7Tmkq0iLCJjbGFzc191cmwiOiIxJjImMyY0JjUmNiY3IiwiYXJlYV9uYW1lIjoiIiwiYXJlYV91cmwiOiIiLCJ5ZWFyX25hbWUiOiLlhajpg6gmMjAyNCYyMDIzJjIwMjImMjAyMSYyMDIwJjIwMTkmMjAxOCYyMDE3JjIwMTYmMjAxNSYyMDE0JjIwMTMmMjAxMiYyMDExJjIwMTAmMjAwOSYyMDA4JjIwMDcmMjAwNiYyMDA1JjIwMDQmMjAwMyYyMDAyJjIwMDEmMjAwMCIsInllYXJfdXJsIjoiJjIwMjQmMjAyMyYyMDIyJjIwMjEmMjAyMCYyMDE5JjIwMTgmMjAxNyYyMDE2JjIwMTUmMjAxNCYyMDEzJjIwMTImMjAxMSYyMDEwJjIwMDkmMjAwOCYyMDA3JjIwMDYmMjAwNSYyMDA0JjIwMDMmMjAwMiYyMDAxJjIwMDAiLCJzb3J0X25hbWUiOiLmjInmm7TmlrAm5oyJ5pKt5pS+JuaMieivhOWIhiIsInNvcnRfdXJsIjoiJmhpdHMmc2NvcmUifQ==\\\\\\\",\\\\\\\"QING_TITLE\\\\\\\":\\\\\\\"轻合集.zhao\\\\\\\"})；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 10；； CDY-AN90 Build/HUAWEICDY-AN90；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/92.0.4515.105 Mobile Safari/537.36}\\\"}\",\"saved\":false,\"title\":\"轻合集.zhao\",\"version\":0,\"url\":\"hiker://empty/#noHistory##noRecordHistory####fypage.js:let { runCode, indexUrl } = $.require(\\\"hiker://page/funcTools？？rule=轻合集.zhao\\\", {\\\"MY_RULE\\\":\\\"eyJ0aXRsZSI6IuW5leWQr+aYn+ays0FQUCIsInVybCI6Imhpa2VyOi8vZW1wdHkjIy9hcGkucGhwL3YxLnZvZD90eXBlPWZ5Y2xhc3MmY2xhc3M9JmFyZWE9JnllYXI9Znl5ZWFyJmJ5PWZ5c29ydCZwYWdlPWZ5cGFnZSZsaW1pdD0xOCIsImNsYXNzX25hbWUiOiLnlLXlvbEm5Ymn6ZuGJue7vOiJuibliqjmvKsm5bCR5YS/JuefreWJpybnm7Tmkq0iLCJjbGFzc191cmwiOiIxJjImMyY0JjUmNiY3IiwiYXJlYV9uYW1lIjoiIiwiYXJlYV91cmwiOiIiLCJ5ZWFyX25hbWUiOiLlhajpg6gmMjAyNCYyMDIzJjIwMjImMjAyMSYyMDIwJjIwMTkmMjAxOCYyMDE3JjIwMTYmMjAxNSYyMDE0JjIwMTMmMjAxMiYyMDExJjIwMTAmMjAwOSYyMDA4JjIwMDcmMjAwNiYyMDA1JjIwMDQmMjAwMyYyMDAyJjIwMDEmMjAwMCIsInllYXJfdXJsIjoiJjIwMjQmMjAyMyYyMDIyJjIwMjEmMjAyMCYyMDE5JjIwMTgmMjAxNyYyMDE2JjIwMTUmMjAxNCYyMDEzJjIwMTImMjAxMSYyMDEwJjIwMDkmMjAwOCYyMDA3JjIwMDYmMjAwNSYyMDA0JjIwMDMmMjAwMiYyMDAxJjIwMDAiLCJzb3J0X25hbWUiOiLmjInmm7TmlrAm5oyJ5pKt5pS+JuaMieivhOWIhiIsInNvcnRfdXJsIjoiJmhpdHMmc2NvcmUifQ==\\\",\\\"QING_TITLE\\\":\\\"轻合集.zhao\\\"})；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 10；； CDY-AN90 Build/HUAWEICDY-AN90；； 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', 'http://hiker.nokia.press/hikerule/dev/json_list?name=3261982579')\\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":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIoAAACKCAYAAAB1h9JkAAAAAXNSR0IArs4c6QAAAARzQklUCAgI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\nRngF3AAAAABJRU5ErkJggg==","title":"幕启星河APP"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!