API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：分享者

xiaomianao666
Jul 20th, 2022
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 143.93 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥分享者@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"const ClassTab = function(classArray, params) {\\n    Object.assign(this, params)\\n    this.arr = classArray.map(v => this.init(v))\\n    this.sign = '$' + QING_TITLE + '_' + (this.name || '') + '_'\\n    this.color = this.color || '#12b668'\\n    this.boundary = this.boundary || 'blank_block'\\n}\\nClassTab.prototype = {\\n    constructor: ClassTab,\\n    load(el) {\\n        let folded = this.fold && getVar('fold_' + this.sign, '')\\n        if (this.arr.length > 1 && this.fold) el.push({\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\n                putVar('fold_' + sign, { '': 'T', 'T': '' } [folded])\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, this.sign, folded),\\n            col_type: 'scroll_button'\\n        })\\n        let arr = folded ? [this.arr[0]] : this.arr\\n        arr.forEach((v) => {\\n            let { id, class_name, class_url } = v,\\n            selected = JSON.stringify(this.getClass(id))\\n            class_name.forEach((name, i) => {\\n                let url = class_url[i],\\n                    now = JSON.stringify({ name: name, url: url })\\n                el.push({\\n                    title: selected == now ? '““””' + name.fontcolor(this.color).bold() : name,\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\n                        putVar(sign + id, now)\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, this.sign, id, now),\\n                    col_type: 'scroll_button'\\n                })\\n            })\\n            el.push({ col_type: this.boundary })\\n        })\\n    },\\n    init(classObject) {\\n        if (typeof classObject.class_name == 'string')\\n            classObject.class_name = classObject.class_name.split('&')\\n        if (typeof classObject.class_url == 'string')\\n            classObject.class_url = classObject.class_url.split('&').map((v) => v.trim())\\n        return classObject\\n    },\\n    push(classObject) {\\n        this.arr.push(this.init(classObject))\\n    },\\n    getClass(id) {\\n        let defaultClass = this.arr.find(item => item.id == id)\\n        defaultClass = JSON.stringify(defaultClass ? {\\n            name: defaultClass.class_name[0],\\n            url: defaultClass.class_url[0]\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\n    },\\n    setUrl(url) {\\n        return url.replace(/\\\\$\\\\{([^}]*)\\\\}/g, (_, id) => this.getClass(id).url)\\n    }\\n}\\n// 生成头部分类\\nconst fyAll = RULE.url.includes('fyAll')\\nlet tabHeader = []\\nif (RULE.class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: RULE.class_name,\\n    class_url: RULE.class_url\\n})\\nif (RULE.area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: RULE.area_name,\\n    class_url: RULE.area_url\\n})\\nif (RULE.year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: RULE.year_name,\\n    class_url: RULE.year_url\\n})\\nif (RULE.sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: RULE.sort_name,\\n    class_url: RULE.sort_url\\n})\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title, fold: readFile('tabFold'), })\\n\"},{\"col_type\":\"icon_2_round\",\"name\":\"设置\",\"path\":\"Config\",\"rule\":\"js:\\naddListener('onClose', 'clearMyVar(\\\"sortFlag\\\");refreshPage()');\\nsetPageTitle('⚙ 轻合集设置 ⚙');\\nconst defaultDisTabModify = false; //默认禁用自定义分类关闭.就是开启自定义\\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            }\\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    disTabModify = readFile('disTabModify'),\\n    disableCustom = readFile('disableCustom'),\\n    editMode = disableCustom ? '导入海阔' : getMyVar('editMode', '启用/禁用');\\nif(disTabModify===''){\\n    saveFile('disTabModify', defaultDisTabModify+'');\\n    disTabModify = defaultDisTabModify;\\n}else if(/true|false/.test(disTabModify)){\\n    disTabModify = JSON.parse(disTabModify);\\n}\\n\\nel.push({\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\n本地文件链接无效').input(() => {\\n        input = parseInt(input)\\n        if(Number.isNaN(input)) input = 1\\n        else if(input < 1) input = 0\\n        saveFile('updateInterval', input.toString())\\n        refreshPage()\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  🖥 独立首页: ' + (newWindow ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((newWindow) => {\\n        saveFile('newWindow', newWindow ? '' : '1')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, newWindow),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\n        saveFile('tabFold', tabFold ? '' : '1')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, tabFold),\\n    col_type: 'scroll_button'\\n},  {\\n    title: '  💠 分类自定义: ' + (disTabModify ? '否' : '是') + '  ',\\n    url: $('#noLoading#').lazyRule((disTabModify) => {\\n        saveFile('disTabModify', disTabModify ? 'false' : 'true');\\n        putMyVar('typeShow', '');\\n        refreshPage();\\n        return 'hiker://empty'\\n    }, disTabModify),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💼 备份恢复  ',\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\n        let url = getMyVar('remoteUrl')\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\n        else if(url.startsWith('hiker://page/')) url = 'hiker://empty'\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\n                let rules = request(url),\\n                    customData = readFile('customData')\\n                writeFile(input, JSON.stringify({\\n                    updateInterval: updateInterval,\\n                    newWindow: newWindow,\\n                    tabFold: tabFold,\\n                    disableCustom: disableCustom,\\n                    customData: customData,\\n                    rules: rules\\n                }))\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\n            saveFile('updateInterval', updateInterval)\\n            saveFile('newWindow', newWindow)\\n            saveFile('tabFold', tabFold)\\n            saveFile('disableCustom', disableCustom)\\n            saveFile('customData', customData)\\n            if(rules) writeFile(url, rules)\\n            refreshPage()\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\n        }, url)\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '““””<font color=\\\"#666666\\\"><small>特别鸣谢，小程序提供者：\\\\n' +\\n        data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\n            .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、'),\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\n\\nel.push({ col_type: 'line' }, {\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\n        if (input == '清除自定义数据') {\\n            deleteFile('customData')\\n        } else if (input == '启用合集自定义') {\\n            saveFile('disableCustom', '')\\n        } else {\\n            saveFile('disableCustom', '1')\\n            input += '\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\n        }\\n        refreshPage(false)\\n        return 'toast://已' + input\\n    }),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\n    el.push({\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putMyVar('editMode', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'scroll_button'\\n    })\\n});\\nif(editMode == '导入海阔') el.push({\\n    title: '全部导入',\\n    url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\n    let d = { title: v.title, img: data[i].icon }\\n    switch (editMode) {\\n        case '启用/禁用':\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                rules[i].visible = !rules[i].visible\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '重新排序':\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\n            if (sortFlag == -1)\\n                d.url = $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('sortFlag', i.toString())\\n                    refreshPage(false)\\n                    return 'toast://选择要移动到的位置'\\n                }, i)\\n            else\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\n                    saveFile('customData', JSON.stringify(rules))\\n                    putMyVar('sortFlag', '-1')\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, sortFlag, i)\\n            break\\n        case '更改图标':\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                if (input)\\n                    rules[i].icon = input\\n                else\\n                    delete rules[i].icon\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '导入海阔':\\n            d.url = 'rule://' + base64Encode(JSON.stringify(data[i]))\\n            break\\n    }\\n    el.push(d)\\n})\\nsetResult(el)\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面载入\",\"path\":\"frameLoad\",\"rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nlet myCollection_el = [],\\n    { RULE, isIndex, pageTitle } = MY_PARAMS,\\n    thisRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)().find((v) => v.title == RULE.title)\\nif (isIndex) {\\n    RULE = thisRULE\\n} else {\\n    RULE.pages = thisRULE.pages\\n}\\neval(JSON.parse(fetch('hiker://page/preFunc?rule=' + QING_TITLE)).rule)\\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\\n\\nif (isIndex) {\\n    if (MY_PAGE == 1) {\\n        // 加载ClassTab组件\\n        eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n        tabHeader.load(myCollection_el)\\n        if (RULE.search_url) myCollection_el.push({\\n            title: \\\"搜索\\\",\\n            desc: \\\"搜你想要的...\\\",\\n            url: '\\\"hiker://search?s=\\\"+input',\\n            extra: {\\n                rules: $.toString((QING_TITLE, title) => {\\n                    let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)()\\n                    rules = [rules.find((v) => v.title == title)]\\n                    return JSON.stringify(rules)\\n                }, QING_TITLE, RULE.title),\\n                defaultValue: getMyVar('searchKey', ''),\\n                onChange: \\\"putMyVar('searchKey',input)\\\"\\n            },\\n            col_type: \\\"input\\\",\\n        })\\n    }\\n    // 处理MY_RULE\\n    MY_RULE.url = RULE.url\\n    MY_RULE.col_type = RULE.col_type\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.find_rule\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\n    MY_RULE.params = {}\\n} else {\\n    MY_RULE.url = MY_PARAMS.url\\n    MY_RULE.col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.detail_find_rule\\n    MY_RULE.params = RULE.params\\n}\\nMY_RULE.pages = RULE.pages\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\nMY_RULE.title = RULE.title\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(thisRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n}\\n// 预处理并初始化config\\nif (isIndex && MY_PAGE == 1) eval(thisRULE.preRule)\\nlet _cfg = getMyVar('initConfig', '{}')\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\n\\n// 正文解析通用变量\\nlet assignLazyRule = $.toString((QING_TITLE, title) => {\\n    let RULE = $.require(\\\"hiker://page/dataLoad?rule=\\\" + QING_TITLE)().find((v) => v.title == title)\\n    return { pages: RULE.pages, pageList: JSON.parse(RULE.pages || '[]') }\\n}, QING_TITLE, RULE.title)\\nfunction genMyRule() {\\n    let rule = Object.assign({}, MY_RULE)\\n    delete rule.last_chapter_rule\\n    delete rule.preRule\\n    delete rule.pageList\\n    delete rule.pages\\n    return rule\\n}\\nfunction runCode(rule) {\\n    try {\\n        let [input, code] = rule.split('.js:')\\n        return code ? eval(code) : rule\\n    } catch (e) { return rule }\\n}\\nfunction genExUrl(url) {\\n    url = url.split(';')\\n    return url.shift() + ';' + paramHandle(url, thisRULE.ua, MY_RULE.url)\\n}\\n// 正文解析\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    setResult = function(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(el.data)) el = el.data\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra || {} })\\n            v.col_type = v.col_type || MY_RULE.col_type\\n\\n            if (!v.url || ['rule', 'pics', 'toast', 'input', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'select', 'x5Rule', 'webRule', 'download', 'share'].find((vv) => v.url.startsWith(vv + '://')) || ['x5_webview_single', 'input'].find((vv) => v.col_type == vv)) {\\n                return v\\n            } else if (v.url.includes('@rule=')) {\\n                let [_, url, rule] = v.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n                v.url = url\\n                MY__RULE.detail_find_rule = rule\\n                MY__RULE.detail_col_type = MY_RULE.col_type\\n            } else if (v.url.startsWith('hiker://page/')) {\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\n                    return v\\n                let [_, path, flag, params] = v.url.match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(#.*?)?(?:\\\\?(.*))?$/),\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path),\\n                    subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\n                v.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (v.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\n                MY__RULE.detail_find_rule = subPage.rule\\n                MY__RULE.detail_col_type = subPage.col_type\\n            } else if (v.url.includes('@lazyRule=')) {\\n                let reIndex = v.url.indexOf('.js:')\\n                if (reIndex >= 0) v.url = v.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + v.url.slice(reIndex + 4)\\n                return v\\n            } else if (isIndex) {\\n                if (!MY_RULE.detail_find_rule || /hiker:\\\\/\\\\/(?!empty.+$)/.test(v.url)) return v\\n            } else {\\n                return v\\n            }\\n            v.extra = {\\n                url: genExUrl(v.url),\\n                RULE: MY__RULE,\\n                pageTitle: isIndex && v.title\\n            }\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.split(';')\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: Object.assign(genMyRule(), { detail_find_rule: detailFindRule }),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: genMyRule(),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"数据载入\",\"path\":\"dataLoad\",\"rule\":\"$.exports = function(showAll) {\\n    let url = getMyVar('remoteUrl'),\\n        data = []\\n    if (url.startsWith('hiker://') || url.startsWith('file://')) {\\n        // 如果为本地文件则不进行缓存\\n        try {\\n            let oriData = fetch(url)\\n            if (url.startsWith('hiker://page/'))\\n                oriData = JSON.parse(oriData).rule\\n            data = JSON.parse(oriData)\\n        } catch (e) {}\\n    } else {\\n        // 获取远程数据，检查间隔默认一天\\n        let interval = parseInt(readFile('updateInterval') || '1'),\\n            oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\n            remoteData = []\\n        if(interval == 0) interval = -1\\n        try { remoteData = JSON.parse(fetchCache(url, 24 * interval, {timeout:50000})) } catch(e) {}\\n        if(!Array.isArray(remoteData)) remoteData = []\\n        if (remoteData.length < 3) {\\n            log('未获取到数据')\\n            if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData)\\n            data = JSON.parse(oldData || '[]')\\n        } else {\\n            log('已获取到数据')\\n            data = remoteData\\n        }\\n    }\\n    data = data.filter((v) => { return v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器') })\\n    if (readFile('disableCustom')) return data\\n    else { // 写入自定义数据\\n        let customData = JSON.parse(readFile('customData') || '[]'),\\n            rewriteData = []\\n        customData = customData.reduce((self, v) => {\\n            let index = data.findIndex((vv) => v.title == vv.title)\\n            if (index >= 0) {\\n                self.push(v)\\n                let rule = data.splice(index, 1)[0]\\n                if (showAll || v.visible)\\n                    rewriteData.push(Object.assign(rule, v))\\n            }\\n            return self\\n        }, [])\\n        data.forEach((v) => customData.push({ title: v.title, visible: true }))\\n        saveFile('customData', JSON.stringify(customData))\\n        return rewriteData.concat(data)\\n    }\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"函数重写\",\"path\":\"preFunc\",\"rule\":\"// 防止require多次运行\\nlet rCache = {}\\nrequire = function(param0, param1, param2, param3, param4) {\\n    if (!param0 || rCache[param0] != null) {\\n        return\\n    }\\n    rCache[param0] = 1\\n    param2 = param2 || 0\\n    param3 = MY_TICKET\\n    param4 = eval\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\n}\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\n    if (!param0 || rCache[param0] != null) {\\n        return\\n    }\\n    rCache[param0] = 1\\n    param3 = param3 || 0\\n    param4 = MY_TICKET\\n    param5 = eval\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\n}\\nrc = requireCache\\n\\n// 最新章节规则注入预处理代码\\nsetLastChapterRule = function(param0) {\\n    if (!param0) return\\n    if (param0.startsWith(\\\"js:\\\") && thisRULE.preRule) {\\n        param0 = 'js:\\\\ntry{eval(JSON.parse(fetch(\\\"hiker://page/preFunc?rule=' + QING_TITLE + '\\\")).rule);\\\\\\n            eval(base64Decode(\\\"' + base64Encode(thisRULE.preRule) + '\\\"));\\\\\\n            let _cfg = getMyVar(\\\"initConfig\\\", \\\"{}\\\");\\\\\\n            if (_cfg && _cfg.length>0) {config = JSON.parse(_cfg)}}catch(e){log(e.message)}\\\\n;' +\\n            param0.slice(3)\\n    }\\n    method_setLastChapterRule.invoke(javaContext, param0);\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"链接处理\",\"path\":\"urlParse\",\"rule\":\"// 首页链接替换分类\\nfunction indexUrl(param) {\\n    function runCode(rule) {\\n        try {\\n            let [input, code] = rule.split('.js:')\\n            return code ? eval(code) : rule\\n        } catch (e) { return rule }\\n    }\\n    let { RULE, pageNum, QING_TITLE } = JSON.parse(param.split('###')[1])\\n    RULE = JSON.parse(base64Decode(RULE))\\n    pageNum = parseInt(pageNum)\\n    let url = RULE.url\\n\\n    eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\n    url = url.replace(/fypage(?:@(-?\\\\d+)@)?(?:\\\\*(\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\n    url = /^([\\\\s\\\\S]*?)(?:\\\\[firstPage=([\\\\s\\\\S]*?)\\\\])?(?:(\\\\.js:[\\\\s\\\\S]*?))?$/.exec(url)\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\n    return runCode(url[1])\\n}\\n// 链接参数处理\\nfunction paramHandle(urlParam, ua, urlTmp) {\\n    let charset, UserAgent\\n    try { // 链接的编码和ua应该是首先继承首页链接\\n        [, , charset, UserAgent] = urlTmp.split(';')\\n        UserAgent = UserAgent.match(/^{(.*)}$/)[1].split('&&').find((v) => v.startsWith('User-Agent@'))\\n    } catch (e) {}\\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\\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    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\n    return urlParam.join(';')\\n}\\n\"},{\"name\":\"仓库工具\",\"path\":\"tools\",\"rule\":\"js:\\n$.exports.range = function(m, n) {\\n    return Math.floor(Math.random() * (m - n + 1) + n);\\n}\\n$.exports.color = function(text, color) {\\n    text += \\\"\\\";\\n    if (text.indexOf(\\\"““””\\\") === 0) {\\n        text.replace(\\\"““””\\\", \\\"\\\");\\n    }\\n    return \\\"““””<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n}\\nfunction htmlTag(tag, text) {\\n    text += \\\"\\\";\\n    if (text.indexOf(\\\"““””\\\") === 0) {\\n        text.replace(\\\"““””\\\", \\\"\\\");\\n    }\\n    return \\\"““””\\\" + \\\"<\\\" + tag + \\\">\\\" + text + \\\"</\\\" + tag + \\\">\\\";\\n\\n}\\n\\nfunction getNowFormatDate() {\\n            let date = new Date();\\n            let seperator1 = \\\"-\\\";\\n            let seperator2 = \\\":\\\";\\n            let month = date.getMonth() + 1;\\n            let strDate = date.getDate();\\n            let strHours = date.getHours();\\n            let strMinutes = date.getMinutes();\\n            let strSeconds = date.getSeconds()+1;\\n            if (month >= 1 && month <= 9) {\\n                month = \\\"0\\\" + month\\n            }\\n            if (strDate >= 0 && strDate <= 9) {\\n                strDate = \\\"0\\\" + strDate\\n            }\\n            if (strHours >= 0 && strHours <= 9) {\\n                strHours = \\\"0\\\" + strHours\\n            }\\n            if (strMinutes >= 0 && strMinutes <= 9) {\\n                strMinutes = \\\"0\\\" + strMinutes\\n            }\\n            if (strSeconds >= 0 && strSeconds <= 9) {\\n                strSeconds = \\\"0\\\" + strSeconds\\n            }\\n            //let currentdate = date.getFullYear() + seperator1 + month + seperator1 + strDate + \\\" \\\" + strHours + seperator2 + strMinutes + seperator2 + strSeconds;\\n            let currentdate = (date.getFullYear()-2020)+''+ month +''+ strDate +''+ strHours+'' + strMinutes +''+ Math.ceil(strSeconds/7);\\n            return parseInt(currentdate)\\n        }\\n$.exports.getNowFormatDate = getNowFormatDate;\\n$.exports.htmlTag = htmlTag;\\n$.exports.small = function(text) {\\n    return htmlTag(\\\"small\\\", text);\\n}\\n$.exports.unique2 = function unique2(array){\\n    return Array.from(new Set(array));\\n}\\n$.exports.strDeal = function strDeal(str){\\n    str = str.split('');\\n    str = str.filter(e => (e >= 0 && e <= 9) || (e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z') || (e >= '\\\\u4e00' && e <= '\\\\u9fa5'));\\n    str = str.join('');\\n    return str\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"规则列表\",\"path\":\"data\",\"rule\":\"[{\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"吾爱破解𝔥\\\",\\n    \\\"author\\\": \\\"Hood\\\",\\n    \\\"url\\\": \\\"https://www.52pojie.cn/forum.php?mod=guide&view=fyclass&page=fypage;get;GBK\\\",\\n    \\\"version\\\": 4,\\n    \\\"col_type\\\": \\\"text_1\\\",\\n    \\\"class_name\\\": \\\"最新热门&最新精华&最新回复&最新发表\\\",\\n    \\\"class_url\\\": \\\"hot&digest&new&newthread\\\",\\n    \\\"area_name\\\": \\\"\\\",\\n    \\\"area_url\\\": \\\"\\\",\\n    \\\"sort_name\\\": \\\"\\\",\\n    \\\"year_name\\\": \\\"\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"\\\",\\n    \\\"find_rule\\\": \\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar html = getResCode();\\\\n\\\\n//列表\\\\nvar list = parseDomForArray(html,'body&&tbody[id]');\\\\n\\\\nfor(var i=1;i<list.length+1;i++){\\\\nd.push({\\\\ntitle: (i)+ '. ' +parseDomForHtml(list[i-1],'.xst&&Text'),\\\\nurl:'x5://https://www.52pojie.cn/'+parseDomForHtml(list[i-1],'a&&href'),\\\\ncol_type: 'text_1'});\\\\n}\\\\n\\\\r\\\\nres.data = d;\\\\nsetHomeResult(res);\\\",\\n    \\\"search_url\\\": \\\"http://zhannei.baidu.com/cse/site?q=**&p=fypage&cc=52pojie.cn\\\",\\n    \\\"group\\\": \\\"①推荐\\\",\\n    \\\"searchFind\\\": \\\"body&&.result;\\\\nh3&&Text;\\\\na&&href;\\\\n*;\\\\n.c-abstract&&Text;\\\\n*\\\",\\n    \\\"detail_col_type\\\": \\\"movie_1\\\",\\n    \\\"detail_find_rule\\\": \\\"\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"\\\",\\n    \\\"ua\\\": \\\"pc\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"https://www.52pojie.cn/favicon.ico\\\"\\n}, {\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"423Down\\\",\\n    \\\"author\\\": \\\"香雅情\\\",\\n    \\\"url\\\": \\\"https://www.423down.com/fyAllpage/fypage;get;utf-8;{User-Agent@Mozilla/5.0 (Linux；； Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/80.0.3987.132 Mobile Safari/537.36}\\\",\\n    \\\"version\\\": 1,\\n    \\\"col_type\\\": \\\"movie_1\\\",\\n    \\\"class_name\\\": \\\"首页&安卓软件\\\",\\n    \\\"type\\\": \\\"news\\\",\\n    \\\"class_url\\\": \\\"&apk/\\\",\\n    \\\"area_name\\\": \\\"原创软件&媒体播放&网页浏览&图形图像&聊天软件&办公软件&上传下载&实用软件&系统辅助&系统必备&安全软件&补丁相关&硬件相关&游戏软件\\\",\\n    \\\"area_url\\\": \\\"zd423/&multimedia/&browser/&image/&im/&work/&down/&safewore/&systemsoft/&systemplus/&security/&patch/&hardware/&game/\\\",\\n    \\\"sort_name\\\": \\\"\\\",\\n    \\\"year_name\\\": \\\"\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"\\\",\\n    \\\"find_rule\\\": \\\"js:\\\\nvar items = [];var html=getResCode();\\\\n//log(html);\\\\nvar list = parseDomForArray(html,'.archive-list&&li:not(:contains(优惠推荐))');\\\\n\\\\r\\\\n    for (var i = 0; i < list.length; i++) {\\\\r\\\\n        var title = parseDomForHtml(list[i], 'h2&&Text');\\\\n        var img = parseDom(list[i], 'img&&src');\\\\r\\\\n        var url = parseDom(list[i], 'a&&href');\\\\n        var desc = parseDomForHtml(list[i], '.item-meta&&Text');\\\\r\\\\n        items.push({\\\\r\\\\n            title: title,\\\\n            pic_url: img,\\\\r\\\\n            url: url,\\\\n            desc: desc\\\\r\\\\n        });\\\\r\\\\n    }\\\\n\\\\nsetHomeResult({data:items});\\\",\\n    \\\"search_url\\\": \\\"https://www.423down.com/page/fypage?s=**;get;utf-8;{User-Agent@Mozilla/5.0 (Linux；； Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/80.0.3987.132 Mobile Safari/537.36}\\\",\\n    \\\"group\\\": \\\"其它\\\",\\n    \\\"searchFind\\\": \\\".archive-list&&li;h2&&Text;a&&href;.item-category&&Text;.item-meta&&Text;img&&src\\\",\\n    \\\"detail_col_type\\\": \\\"movie_1\\\",\\n    \\\"detail_find_rule\\\": \\\"js:\\\\nvar d=[];\\\\nvar html=getResCode();\\\\nvar tabs=parseDomForHtml(html,'body&&.entry&&Html');\\\\n\\\\nd.push({\\\\n\\\\t\\\\t\\\\ttitle: tabs,\\\\n    desc:'',\\\\n    pic_url:'',\\\\n    url:'',\\\\n\\\\t\\\\tcol_type: 'rich_text'\\\\n});\\\\n\\\\nsetHomeResult({data:d});\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"*\\\",\\n    \\\"ua\\\": \\\"auto\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"\\\"\\n}, {\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"落尘之木ᴺᵐ\\\",\\n    \\\"author\\\": \\\"Namo\\\",\\n    \\\"url\\\": \\\"https://www.luochenzhimu.com/page/fypage\\\",\\n    \\\"version\\\": 1,\\n    \\\"col_type\\\": \\\"movie_1_left_pic\\\",\\n    \\\"class_name\\\": \\\"\\\",\\n    \\\"type\\\": \\\"other\\\",\\n    \\\"class_url\\\": \\\"\\\",\\n    \\\"area_name\\\": \\\"\\\",\\n    \\\"area_url\\\": \\\"\\\",\\n    \\\"sort_name\\\": \\\"\\\",\\n    \\\"year_name\\\": \\\"\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"\\\",\\n    \\\"find_rule\\\": \\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar list = parseDomForArray(getResCode(), '.content&&.excerpt');\\\\nfor (var i in list) {\\\\n    d.push({\\\\n        title: parseDomForHtml(list[i], 'h2&&Text'),\\\\n        desc: parseDomForHtml(list[i], '.meta&&Text'),\\\\n        pic_url: parseDom(list[i], 'img&&data-src') + \\\\\\\"@Referer=\\\\\\\",\\\\n        url: parseDom(list[i], 'a&&href'),\\\\n    })\\\\n}\\\\nres.data = d;\\\\nsetHomeResult(res);\\\",\\n    \\\"search_url\\\": \\\"https://www.luochenzhimu.com/?s=**\\\",\\n    \\\"group\\\": \\\"其它\\\",\\n    \\\"searchFind\\\": \\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar list = parseDomForArray(getResCode(), 'body&&article');\\\\nfor (var i in list) {\\\\n    d.push({\\\\n        title: parseDomForHtml(list[i], 'h2&&Text'),\\\\n        desc: parseDomForHtml(list[i], '.note&&Text'),        \\\\n        url: parseDom(list[i], 'a&&href'),\\\\n    })\\\\n}\\\\nres.data = d;\\\\nsetHomeResult(res);\\\",\\n    \\\"detail_col_type\\\": \\\"movie_1\\\",\\n    \\\"detail_find_rule\\\": \\\"js:var res={};\\\\nvar d = [];\\\\nd.push({\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    title: \\\\\\\"““””<big>\\\\\\\" + parseDomForHtml(getResCode(), \\\\\\\"h1&&Text\\\\\\\") + \\\\\\\"</big>\\\\\\\",\\\\n});\\\\nd.push({\\\\n    title: parseDomForHtml(getResCode(), \\\\\\\".article-content&&Html\\\\\\\").split('push({});')[1],\\\\n    col_type: 'rich_text',\\\\n    extra: {\\\\n        textSize: 16,\\\\n        click: true\\\\n    }\\\\n});\\\\nsetResult(d);\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"*\\\",\\n    \\\"ua\\\": \\\"pc\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"https://img.luochenzhimu.com/public/2020/01/home.png\\\"\\n}, {\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"分享者\\\",\\n    \\\"author\\\": \\\"小🔥星\\\",\\n    \\\"url\\\": \\\"https://sharerw.com/a/fyAll/fypage/\\\",\\n    \\\"version\\\": 9,\\n    \\\"col_type\\\": \\\"movie_1_vertical_pic\\\",\\n    \\\"class_name\\\": \\\"手机软件&车机软件&电脑软件&\\\",\\n    \\\"class_url\\\": \\\"ganhuo&qiche&jingyan&\\\",\\n    \\\"area_name\\\": \\\"盒子软件&TV资讯&精选TV\\\",\\n    \\\"area_url\\\": \\\"ziyuan&tvzx&jxtv\\\",\\n    \\\"sort_name\\\": \\\"\\\",\\n    \\\"year_name\\\": \\\"\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"\\\",\\n    \\\"find_rule\\\": \\\"body&&.article-list;img&&alt;img&&src;.time&&Text;a&&href\\\",\\n    \\\"search_url\\\": \\\"https://sharerw.com/search.php?q=**&page=fypage\\\",\\n    \\\"group\\\": \\\"其它\\\",\\n    \\\"searchFind\\\": \\\"body&&.article-list;img&&alt;a&&href;.time&&Text;p,1&&Text;img&&src\\\",\\n    \\\"detail_col_type\\\": \\\"movie_1\\\",\\n    \\\"detail_find_rule\\\": \\\"js:var res={};var d=[];html=getResCode();text=parseDomForHtml(html,\\\\\\\".art-content&&Html\\\\\\\");d.push({title:text,col_type:'rich_text'});res.data=d;setHomeResult(res);\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"*\\\",\\n    \\\"ua\\\": \\\"mobile\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"https://z3.ax1x.com/2021/11/05/ImzSvd.png\\\"\\n}, {\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"发现小软件\\\",\\n    \\\"author\\\": \\\"居然\\\",\\n    \\\"url\\\": \\\"https://www.x6g.com/html/23-fypage.html\\\",\\n    \\\"version\\\": 3,\\n    \\\"col_type\\\": \\\"movie_1_vertical_pic\\\",\\n    \\\"class_name\\\": \\\"\\\",\\n    \\\"class_url\\\": \\\"\\\",\\n    \\\"area_name\\\": \\\"\\\",\\n    \\\"area_url\\\": \\\"\\\",\\n    \\\"sort_name\\\": \\\"\\\",\\n    \\\"year_name\\\": \\\"\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"\\\",\\n    \\\"find_rule\\\": \\\".list-soft&&li;.list-info&&a&&Text;.layui-clear&&img&&src;.list-ca&&Text;.list-info&&a&&href\\\",\\n    \\\"search_url\\\": \\\"\\\",\\n    \\\"group\\\": \\\"其它\\\",\\n    \\\"searchFind\\\": \\\"\\\",\\n    \\\"detail_col_type\\\": \\\"text_3\\\",\\n    \\\"detail_find_rule\\\": \\\"body&&.article-down;a&&Text;*;*;a&&data-url\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"\\\",\\n    \\\"ua\\\": \\\"mobile\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"\\\"\\n}, {\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"VXAT\\\",\\n    \\\"author\\\": \\\"小🔥星\\\",\\n    \\\"url\\\": \\\"https://www.vxat.com/fyAll_fypage.html\\\",\\n    \\\"version\\\": 1,\\n    \\\"col_type\\\": \\\"movie_1_vertical_pic\\\",\\n    \\\"class_name\\\": \\\"软件下载&Windows&Android&电视软件&\\\",\\n    \\\"class_url\\\": \\\"RuanJianXiaZai&Windows&Android&TV&\\\",\\n    \\\"area_name\\\": \\\"优惠活动&网站源码&服务器&技术教程&\\\",\\n    \\\"area_url\\\": \\\"YouHuiHuoDong&WangZhanYuanMa&VPS&JiShuJiaoCheng&\\\",\\n    \\\"sort_name\\\": \\\"一级页面提示错误为没有下一页！\\\",\\n    \\\"year_name\\\": \\\"其他&游戏&网友分享&&\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"QiTa&YouXi&WangYouFenXiang&&\\\",\\n    \\\"find_rule\\\": \\\"body&&.post;a&&title;img&&src;.time&&Text;a&&href\\\",\\n    \\\"search_url\\\": \\\"https://www.vxat.com/search.php?q=**&page=fypage\\\",\\n    \\\"group\\\": \\\"其它\\\",\\n    \\\"searchFind\\\": \\\"body&&.post;a&&title;a&&href;.time&&Text;.post&&Text;img&&src\\\",\\n    \\\"detail_col_type\\\": \\\"movie_1\\\",\\n    \\\"detail_find_rule\\\": \\\"js:var res={};var d=[];html=getResCode();text=parseDomForHtml(html,\\\\\\\".article-content&&Html\\\\\\\");d.push({title:text,col_type:'rich_text'});res.data=d;setHomeResult(res);\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"*\\\",\\n    \\\"ua\\\": \\\"mobile\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"\\\"\\n}, {\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"异星软件\\\",\\n    \\\"author\\\": \\\"香雅情\\\",\\n    \\\"url\\\": \\\"http://www.yxssp.com/fyclass/page/fypage\\\",\\n    \\\"version\\\": 1,\\n    \\\"col_type\\\": \\\"movie_1\\\",\\n    \\\"class_name\\\": \\\"Android&Windows\\\",\\n    \\\"class_url\\\": \\\"os/android&os/windows\\\",\\n    \\\"area_name\\\": \\\"\\\",\\n    \\\"area_url\\\": \\\"\\\",\\n    \\\"sort_name\\\": \\\"\\\",\\n    \\\"year_name\\\": \\\"\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"\\\",\\n    \\\"find_rule\\\": \\\".td-ss-main-content&&.td_module_wrap;h3&&Text;img&&src;.td-module-meta-info&&Text;a&&href\\\",\\n    \\\"search_url\\\": \\\"http://www.yxssp.com/page/fypage?s=**\\\",\\n    \\\"group\\\": \\\"其它\\\",\\n    \\\"searchFind\\\": \\\".td-ss-main-content&&.td_module_wrap;h3&&Text;a&&href;;.td-module-meta-info&&Text;img&&src\\\",\\n    \\\"detail_col_type\\\": \\\"movie_1\\\",\\n    \\\"detail_find_rule\\\": \\\"js:\\\\nvar d=[];\\\\nvar html=getResCode();\\\\nvar tabs=parseDomForHtml(html,'body&&.td-post-content&&Html').replace(/\\\\\\\\<script[\\\\\\\\S\\\\\\\\s]*?<\\\\\\\\/script\\\\\\\\>/g,'');\\\\n\\\\nd.push({\\\\n\\\\t\\\\t\\\\ttitle: tabs,\\\\n    desc:'',\\\\n    pic_url:'',\\\\n    url:'',\\\\n\\\\t\\\\tcol_type: 'rich_text'\\\\n});\\\\n\\\\nsetHomeResult({data:d});\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"*\\\",\\n    \\\"ua\\\": \\\"pc\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"\\\"\\n}, {\\n    \\\"last_chapter_rule\\\": \\\"\\\",\\n    \\\"title\\\": \\\"apk4all\\\",\\n    \\\"author\\\": \\\"tee\\\",\\n    \\\"url\\\": \\\"https://apk4all.com/android/genres/fyAll/page/fypage/\\\",\\n    \\\"version\\\": 8,\\n    \\\"col_type\\\": \\\"movie_1_left_pic\\\",\\n    \\\"class_name\\\": \\\"Art ＆＆ Design&Auto ＆＆ Vehicles&Books ＆＆ Reference&Business&Comics&Communication&Education&Entertainment&Finance&Health ＆＆ Fitness&House ＆＆ Home&Libraries ＆＆ Demo&Lifestyle&Maps ＆＆ Navigation&Medical&Music ＆＆ Audio&News ＆＆ Magazines&Parenting&Personalization&Photography&Productivity&Shopping&Social&Tools&Travel ＆＆ Local&Video Players ＆＆ Editors&Weather\\\",\\n    \\\"type\\\": \\\"tool\\\",\\n    \\\"class_url\\\": \\\"art-design/&auto-vehicles/&books-reference/&business-app/&comics-app/&communication-app/&education-mod-app/&entertainment-apps/&finance/&health-fitness/&house-home/&libraries-demo/&lifestyle-app/&maps-navigation/&medical-app/&music-audio/&news-magazines/&parenting/&personalization-mod-app/&photography/&productivity-app/&shopping-app/&social-app/&tools-mod-app/&travel-local-app/&video-players-editors/&weather-app/\\\",\\n    \\\"area_name\\\": \\\"Action&Adventure&Arcade&Board&Card&Casual&Educational&Music&Puzzle&Racing&Role Playing&Simulation&Sports&Strategy&Trivia&Word\\\",\\n    \\\"area_url\\\": \\\"action-games/&adventure-games/&arcade-games/&board-games/&card-games/&casual-games/&educational-games/&music-games/&puzzle-games/&racing-games/&role-playing-games/&simulation-apk-games/&sports-games/&strategy-games/&trivia-games/&word-games/\\\",\\n    \\\"sort_name\\\": \\\"\\\",\\n    \\\"year_name\\\": \\\"\\\",\\n    \\\"sort_url\\\": \\\"\\\",\\n    \\\"year_url\\\": \\\"\\\",\\n    \\\"find_rule\\\": \\\"main&&article;h3&&Text;img,1&&src;dd&&Text;a&&href.js:input+'#immersiveTheme#'\\\",\\n    \\\"search_url\\\": \\\"https://apk4all.com/search/**/page/fypage/\\\",\\n    \\\"group\\\": \\\"其它\\\",\\n    \\\"searchFind\\\": \\\"main&&article;h3&&Text;a&&href.js:input+'#immersiveTheme#';dd&&Text;*;img,1&&src\\\",\\n    \\\"detail_col_type\\\": \\\"rich_text\\\",\\n    \\\"detail_find_rule\\\": \\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar html = getResCode();\\\\nvar desc = pdfh(html, \\\\\\\".desc&&Text\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\" + pdfh(html, \\\\\\\"h2&&Text\\\\\\\") + \\\\\\\"   \\\\\\\\/   10\\\\\\\";\\\\n\\\\nvar dl = pd(html, \\\\\\\".dllinks,1&&a&&href\\\\\\\") + \\\\\\\"#immersiveTheme#\\\\\\\";\\\\n\\\\nd.push({ //标题、缩略图、简介\\\\n    title: \\\\\\\"““””<big>\\\\\\\" + pdfh(html, \\\\\\\"h1&&Text\\\\\\\") + \\\\\\\"</big>\\\\\\\",\\\\n    col_type: \\\\\\\"movie_1_vertical_pic_blur\\\\\\\",\\\\n    desc: desc,\\\\n    pic_url: pd(html, \\\\\\\"article&&img,1&&src\\\\\\\"),\\\\n    url: dl\\\\n});\\\\n\\\\nd.push({ //线条\\\\n    col_type: \\\\\\\"line_blank\\\\\\\",\\\\n});\\\\n\\\\nvar list = pdfa(html, \\\\\\\".app-desc&&p||li\\\\\\\");\\\\nfor (i of list) {\\\\n    d.push({\\\\n        title: pdfh(i, \\\\\\\"p||li&&Text\\\\\\\"),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\",\\\\n        extra: {\\\\n            textSize: 13,\\\\n            click: true\\\\n        }\\\\n    });\\\\n};\\\\n\\\\nvar gallery = pdfa(html, \\\\\\\"#gallery-1&&a\\\\\\\");\\\\n\\\\nfor (let n of gallery) {\\\\n    d.push({\\\\n        title: pdfh(n, \\\\\\\"img,1&&title\\\\\\\"),\\\\n        col_type: \\\\\\\"pic_3_square\\\\\\\",\\\\n        pic_url: pd(n, \\\\\\\"img,1&&src\\\\\\\") + '@Referer=',\\\\n        url: pd(n, \\\\\\\"img,1&&src\\\\\\\") + '#autoPage##readTheme#'\\\\n    });\\\\n};\\\\n\\\\nd.push({ //线条\\\\n    col_type: \\\\\\\"line_blank\\\\\\\",\\\\n});\\\\n\\\\n//底部下载模块\\\\nd.push({\\\\n    col_type: 'text_center_1',\\\\n    title: \\\\\\\"““””<big>\\\\\\\" + '点此下载' + \\\\\\\"</big>\\\\\\\",\\\\n    url: dl\\\\n});\\\\n\\\\nd.push({ //线条\\\\n    col_type: \\\\\\\"line_blank\\\\\\\",\\\\n});\\\\n\\\\nres.data = d;\\\\nsetResult(res);\\\",\\n    \\\"sdetail_col_type\\\": \\\"movie_1\\\",\\n    \\\"sdetail_find_rule\\\": \\\"*\\\",\\n    \\\"ua\\\": \\\"mobile\\\",\\n    \\\"preRule\\\": \\\"\\\",\\n    \\\"pages\\\": \\\"[]\\\",\\n    \\\"icon\\\": \\\"https://apk4all.com/favicon.ico\\\"\\n}]\"}],\"params\":\"{\\\"RULE\\\":{\\\"title\\\":\\\"分享者\\\"},\\\"isIndex\\\":true,\\\"url\\\":\\\"https://sharerw.com/#noHistory##noRecordHistory####{\\\\\\\"RULE\\\\\\\":\\\\\\\"eyJ0aXRsZSI6IuWIhuS6q+iAhSIsInVybCI6Imh0dHBzOi8vc2hhcmVydy5jb20vYS9meUFsbC9meXBhZ2UvIiwiY2xhc3NfbmFtZSI6IuaJi+acuui9r+S7tibovabmnLrova/ku7Ym55S16ISR6L2v5Lu2JiIsImNsYXNzX3VybCI6Imdhbmh1byZxaWNoZSZqaW5neWFuJiIsImFyZWFfbmFtZSI6IuebkuWtkOi9r+S7tiZUVui1hOiurybnsr7pgIlUViIsImFyZWFfdXJsIjoieml5dWFuJnR2engmanh0diIsInllYXJfbmFtZSI6IiIsInllYXJfdXJsIjoiIiwic29ydF9uYW1lIjoiIiwic29ydF91cmwiOiIifQ==\\\\\\\",\\\\\\\"pageNum\\\\\\\":\\\\\\\"fypage\\\\\\\",\\\\\\\"QING_TITLE\\\\\\\":\\\\\\\"资源轻合集\\\\\\\"}.js:eval(JSON.parse(fetch(\\\\\\\"hiker://page/urlParse？？rule=资源轻合集\\\\\\\")).rule)；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\\\"}\",\"saved\":false,\"title\":\"资源轻合集\",\"version\":0,\"url\":\"https://sharerw.com/#noHistory##noRecordHistory####{\\\"RULE\\\":\\\"eyJ0aXRsZSI6IuWIhuS6q+iAhSIsInVybCI6Imh0dHBzOi8vc2hhcmVydy5jb20vYS9meUFsbC9meXBhZ2UvIiwiY2xhc3NfbmFtZSI6IuaJi+acuui9r+S7tibovabmnLrova/ku7Ym55S16ISR6L2v5Lu2JiIsImNsYXNzX3VybCI6Imdhbmh1byZxaWNoZSZqaW5neWFuJiIsImFyZWFfbmFtZSI6IuebkuWtkOi9r+S7tiZUVui1hOiurybnsr7pgIlUViIsImFyZWFfdXJsIjoieml5dWFuJnR2engmanh0diIsInllYXJfbmFtZSI6IiIsInllYXJfdXJsIjoiIiwic29ydF9uYW1lIjoiIiwic29ydF91cmwiOiIifQ==\\\",\\\"pageNum\\\":\\\"fypage\\\",\\\"QING_TITLE\\\":\\\"资源轻合集\\\"}.js:eval(JSON.parse(fetch(\\\"hiker://page/urlParse？？rule=资源轻合集\\\")).rule)；；indexUrl(input);GET;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nlet myCollection_el = [],\\n    { RULE, isIndex, pageTitle } = MY_PARAMS,\\n    thisRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)().find((v) => v.title == RULE.title)\\nif (isIndex) {\\n    RULE = thisRULE\\n} else {\\n    RULE.pages = thisRULE.pages\\n}\\neval(JSON.parse(fetch('hiker://page/preFunc?rule=' + QING_TITLE)).rule)\\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\\n\\nif (isIndex) {\\n    if (MY_PAGE == 1) {\\n        // 加载ClassTab组件\\n        eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n        tabHeader.load(myCollection_el)\\n        if (RULE.search_url) myCollection_el.push({\\n            title: \\\"搜索\\\",\\n            desc: \\\"搜你想要的...\\\",\\n            url: '\\\"hiker://search?s=\\\"+input',\\n            extra: {\\n                rules: $.toString((QING_TITLE, title) => {\\n                    let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)()\\n                    rules = [rules.find((v) => v.title == title)]\\n                    return JSON.stringify(rules)\\n                }, QING_TITLE, RULE.title),\\n                defaultValue: getMyVar('searchKey', ''),\\n                onChange: \\\"putMyVar('searchKey',input)\\\"\\n            },\\n            col_type: \\\"input\\\",\\n        })\\n    }\\n    // 处理MY_RULE\\n    MY_RULE.url = RULE.url\\n    MY_RULE.col_type = RULE.col_type\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.find_rule\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\n    MY_RULE.params = {}\\n} else {\\n    MY_RULE.url = MY_PARAMS.url\\n    MY_RULE.col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.detail_find_rule\\n    MY_RULE.params = RULE.params\\n}\\nMY_RULE.pages = RULE.pages\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\nMY_RULE.title = RULE.title\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(thisRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n}\\n// 预处理并初始化config\\nif (isIndex && MY_PAGE == 1) eval(thisRULE.preRule)\\nlet _cfg = getMyVar('initConfig', '{}')\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\n\\n// 正文解析通用变量\\nlet assignLazyRule = $.toString((QING_TITLE, title) => {\\n    let RULE = $.require(\\\"hiker://page/dataLoad?rule=\\\" + QING_TITLE)().find((v) => v.title == title)\\n    return { pages: RULE.pages, pageList: JSON.parse(RULE.pages || '[]') }\\n}, QING_TITLE, RULE.title)\\nfunction genMyRule() {\\n    let rule = Object.assign({}, MY_RULE)\\n    delete rule.last_chapter_rule\\n    delete rule.preRule\\n    delete rule.pageList\\n    delete rule.pages\\n    return rule\\n}\\nfunction runCode(rule) {\\n    try {\\n        let [input, code] = rule.split('.js:')\\n        return code ? eval(code) : rule\\n    } catch (e) { return rule }\\n}\\nfunction genExUrl(url) {\\n    url = url.split(';')\\n    return url.shift() + ';' + paramHandle(url, thisRULE.ua, MY_RULE.url)\\n}\\n// 正文解析\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    setResult = function(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(el.data)) el = el.data\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra || {} })\\n            v.col_type = v.col_type || MY_RULE.col_type\\n\\n            if (!v.url || ['rule', 'pics', 'toast', 'input', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'select', 'x5Rule', 'webRule', 'download', 'share'].find((vv) => v.url.startsWith(vv + '://')) || ['x5_webview_single', 'input'].find((vv) => v.col_type == vv)) {\\n                return v\\n            } else if (v.url.includes('@rule=')) {\\n                let [_, url, rule] = v.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n                v.url = url\\n                MY__RULE.detail_find_rule = rule\\n                MY__RULE.detail_col_type = MY_RULE.col_type\\n            } else if (v.url.startsWith('hiker://page/')) {\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\n                    return v\\n                let [_, path, flag, params] = v.url.match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(#.*?)?(?:\\\\?(.*))?$/),\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path),\\n                    subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\n                v.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (v.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\n                MY__RULE.detail_find_rule = subPage.rule\\n                MY__RULE.detail_col_type = subPage.col_type\\n            } else if (v.url.includes('@lazyRule=')) {\\n                let reIndex = v.url.indexOf('.js:')\\n                if (reIndex >= 0) v.url = v.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + v.url.slice(reIndex + 4)\\n                return v\\n            } else if (isIndex) {\\n                if (!MY_RULE.detail_find_rule || /hiker:\\\\/\\\\/(?!empty.+$)/.test(v.url)) return v\\n            } else {\\n                return v\\n            }\\n            v.extra = {\\n                url: genExUrl(v.url),\\n                RULE: MY__RULE,\\n                pageTitle: isIndex && v.title\\n            }\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.split(';')\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: Object.assign(genMyRule(), { detail_find_rule: detailFindRule }),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: genMyRule(),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\",\"group\":\"①轻合集\",\"ua\":\"auto\",\"preRule\":\"putMyVar('myCollection', MY_RULE.title);\\nputMyVar('remoteUrl', 'hiker://page/data');\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"ClassTab\\\",\\\"path\\\":\\\"ClassTab\\\",\\\"rule\\\":\\\"const ClassTab = function(classArray, params) {\\\\n    Object.assign(this, params)\\\\n    this.arr = classArray.map(v => this.init(v))\\\\n    this.sign = '$' + QING_TITLE + '_' + (this.name || '') + '_'\\\\n    this.color = this.color || '#12b668'\\\\n    this.boundary = this.boundary || 'blank_block'\\\\n}\\\\nClassTab.prototype = {\\\\n    constructor: ClassTab,\\\\n    load(el) {\\\\n        let folded = this.fold && getVar('fold_' + this.sign, '')\\\\n        if (this.arr.length > 1 && this.fold) el.push({\\\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\\\n                putVar('fold_' + sign, { '': 'T', 'T': '' } [folded])\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, this.sign, folded),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n        let arr = folded ? [this.arr[0]] : this.arr\\\\n        arr.forEach((v) => {\\\\n            let { id, class_name, class_url } = v,\\\\n            selected = JSON.stringify(this.getClass(id))\\\\n            class_name.forEach((name, i) => {\\\\n                let url = class_url[i],\\\\n                    now = JSON.stringify({ name: name, url: url })\\\\n                el.push({\\\\n                    title: selected == now ? '““””' + name.fontcolor(this.color).bold() : name,\\\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\\\n                        putVar(sign + id, now)\\\\n                        refreshPage(false)\\\\n                        return 'hiker://empty'\\\\n                    }, this.sign, id, now),\\\\n                    col_type: 'scroll_button'\\\\n                })\\\\n            })\\\\n            el.push({ col_type: this.boundary })\\\\n        })\\\\n    },\\\\n    init(classObject) {\\\\n        if (typeof classObject.class_name == 'string')\\\\n            classObject.class_name = classObject.class_name.split('&')\\\\n        if (typeof classObject.class_url == 'string')\\\\n            classObject.class_url = classObject.class_url.split('&').map((v) => v.trim())\\\\n        return classObject\\\\n    },\\\\n    push(classObject) {\\\\n        this.arr.push(this.init(classObject))\\\\n    },\\\\n    getClass(id) {\\\\n        let defaultClass = this.arr.find(item => item.id == id)\\\\n        defaultClass = JSON.stringify(defaultClass ? {\\\\n            name: defaultClass.class_name[0],\\\\n            url: defaultClass.class_url[0]\\\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\\\n    },\\\\n    setUrl(url) {\\\\n        return url.replace(/\\\\\\\\$\\\\\\\\{([^}]*)\\\\\\\\}/g, (_, id) => this.getClass(id).url)\\\\n    }\\\\n}\\\\n// 生成头部分类\\\\nconst fyAll = RULE.url.includes('fyAll')\\\\nlet tabHeader = []\\\\nif (RULE.class_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyclass',\\\\n    class_name: RULE.class_name,\\\\n    class_url: RULE.class_url\\\\n})\\\\nif (RULE.area_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyarea',\\\\n    class_name: RULE.area_name,\\\\n    class_url: RULE.area_url\\\\n})\\\\nif (RULE.year_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyyear',\\\\n    class_name: RULE.year_name,\\\\n    class_url: RULE.year_url\\\\n})\\\\nif (RULE.sort_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fysort',\\\\n    class_name: RULE.sort_name,\\\\n    class_url: RULE.sort_url\\\\n})\\\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title, fold: readFile('tabFold'), })\\\\n\\\"},{\\\"col_type\\\":\\\"icon_2_round\\\",\\\"name\\\":\\\"设置\\\",\\\"path\\\":\\\"Config\\\",\\\"rule\\\":\\\"js:\\\\naddListener('onClose', 'clearMyVar(\\\\\\\"sortFlag\\\\\\\");refreshPage()');\\\\nsetPageTitle('⚙ 轻合集设置 ⚙');\\\\nconst defaultDisTabModify = false; //默认禁用自定义分类关闭.就是开启自定义\\\\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            }\\\\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    disTabModify = readFile('disTabModify'),\\\\n    disableCustom = readFile('disableCustom'),\\\\n    editMode = disableCustom ? '导入海阔' : getMyVar('editMode', '启用/禁用');\\\\nif(disTabModify===''){\\\\n    saveFile('disTabModify', defaultDisTabModify+'');\\\\n    disTabModify = defaultDisTabModify;\\\\n}else if(/true|false/.test(disTabModify)){\\\\n    disTabModify = JSON.parse(disTabModify);\\\\n}\\\\n\\\\nel.push({\\\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\\\\\n本地文件链接无效').input(() => {\\\\n        input = parseInt(input)\\\\n        if(Number.isNaN(input)) input = 1\\\\n        else if(input < 1) input = 0\\\\n        saveFile('updateInterval', input.toString())\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  🖥 独立首页: ' + (newWindow ? '是' : '否') + '  ',\\\\n    url: $('#noLoading#').lazyRule((newWindow) => {\\\\n        saveFile('newWindow', newWindow ? '' : '1')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }, newWindow),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\\\n        saveFile('tabFold', tabFold ? '' : '1')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }, tabFold),\\\\n    col_type: 'scroll_button'\\\\n},  {\\\\n    title: '  💠 分类自定义: ' + (disTabModify ? '否' : '是') + '  ',\\\\n    url: $('#noLoading#').lazyRule((disTabModify) => {\\\\n        saveFile('disTabModify', disTabModify ? 'false' : 'true');\\\\n        putMyVar('typeShow', '');\\\\n        refreshPage();\\\\n        return 'hiker://empty'\\\\n    }, disTabModify),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  💼 备份恢复  ',\\\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n        let url = getMyVar('remoteUrl')\\\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\\\n        else if(url.startsWith('hiker://page/')) url = 'hiker://empty'\\\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n                let rules = request(url),\\\\n                    customData = readFile('customData')\\\\n                writeFile(input, JSON.stringify({\\\\n                    updateInterval: updateInterval,\\\\n                    newWindow: newWindow,\\\\n                    tabFold: tabFold,\\\\n                    disableCustom: disableCustom,\\\\n                    customData: customData,\\\\n                    rules: rules\\\\n                }))\\\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\\\n            saveFile('updateInterval', updateInterval)\\\\n            saveFile('newWindow', newWindow)\\\\n            saveFile('tabFold', tabFold)\\\\n            saveFile('disableCustom', disableCustom)\\\\n            saveFile('customData', customData)\\\\n            if(rules) writeFile(url, rules)\\\\n            refreshPage()\\\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\\\n        }, url)\\\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '““””<font color=\\\\\\\"#666666\\\\\\\"><small>特别鸣谢，小程序提供者：\\\\\\\\n' +\\\\n        data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\\\n            .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、'),\\\\n    url: 'hiker://empty',\\\\n    col_type: 'text_center_1'\\\\n})\\\\n\\\\nel.push({ col_type: 'line' }, {\\\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\\\n        if (input == '清除自定义数据') {\\\\n            deleteFile('customData')\\\\n        } else if (input == '启用合集自定义') {\\\\n            saveFile('disableCustom', '')\\\\n        } else {\\\\n            saveFile('disableCustom', '1')\\\\n            input += '\\\\\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\\\n        }\\\\n        refreshPage(false)\\\\n        return 'toast://已' + input\\\\n    }),\\\\n    col_type: 'text_center_1',\\\\n    extra: { lineVisible: false }\\\\n});\\\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\\\n    el.push({\\\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\\\n            putMyVar('editMode', v)\\\\n            refreshPage(false)\\\\n            return 'hiker://empty'\\\\n        }, v),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n});\\\\nif(editMode == '导入海阔') el.push({\\\\n    title: '全部导入',\\\\n    url: '海阔视界￥home_rule_url￥' + (url.startsWith('hiker://') || url.startsWith('file://') ? url : 'hiker://files/libs/' + md5(url) + '.js'),\\\\n    col_type: 'text_center_1',\\\\n    extra: { lineVisible: false }\\\\n});\\\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\\\n    let d = { title: v.title, img: data[i].icon }\\\\n    switch (editMode) {\\\\n        case '启用/禁用':\\\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\\\n            d.url = $('#noLoading#').lazyRule((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                rules[i].visible = !rules[i].visible\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '重新排序':\\\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\\\n            if (sortFlag == -1)\\\\n                d.url = $('#noLoading#').lazyRule((i) => {\\\\n                    putMyVar('sortFlag', i.toString())\\\\n                    refreshPage(false)\\\\n                    return 'toast://选择要移动到的位置'\\\\n                }, i)\\\\n            else\\\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\\\n                    saveFile('customData', JSON.stringify(rules))\\\\n                    putMyVar('sortFlag', '-1')\\\\n                    refreshPage(false)\\\\n                    return 'hiker://empty'\\\\n                }, sortFlag, i)\\\\n            break\\\\n        case '更改图标':\\\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                if (input)\\\\n                    rules[i].icon = input\\\\n                else\\\\n                    delete rules[i].icon\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '导入海阔':\\\\n            d.url = 'rule://' + base64Encode(JSON.stringify(data[i]))\\\\n            break\\\\n    }\\\\n    el.push(d)\\\\n})\\\\nsetResult(el)\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面载入\\\",\\\"path\\\":\\\"frameLoad\\\",\\\"rule\\\":\\\"js:\\\\nconst QING_TITLE = getMyVar('myCollection')\\\\nlet myCollection_el = [],\\\\n    { RULE, isIndex, pageTitle } = MY_PARAMS,\\\\n    thisRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)().find((v) => v.title == RULE.title)\\\\nif (isIndex) {\\\\n    RULE = thisRULE\\\\n} else {\\\\n    RULE.pages = thisRULE.pages\\\\n}\\\\neval(JSON.parse(fetch('hiker://page/preFunc?rule=' + QING_TITLE)).rule)\\\\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\\\\n\\\\nif (isIndex) {\\\\n    if (MY_PAGE == 1) {\\\\n        // 加载ClassTab组件\\\\n        eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\\\n        tabHeader.load(myCollection_el)\\\\n        if (RULE.search_url) myCollection_el.push({\\\\n            title: \\\\\\\"搜索\\\\\\\",\\\\n            desc: \\\\\\\"搜你想要的...\\\\\\\",\\\\n            url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n            extra: {\\\\n                rules: $.toString((QING_TITLE, title) => {\\\\n                    let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)()\\\\n                    rules = [rules.find((v) => v.title == title)]\\\\n                    return JSON.stringify(rules)\\\\n                }, QING_TITLE, RULE.title),\\\\n                defaultValue: getMyVar('searchKey', ''),\\\\n                onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n            },\\\\n            col_type: \\\\\\\"input\\\\\\\",\\\\n        })\\\\n    }\\\\n    // 处理MY_RULE\\\\n    MY_RULE.url = RULE.url\\\\n    MY_RULE.col_type = RULE.col_type\\\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.find_rule\\\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = {}\\\\n} else {\\\\n    MY_RULE.url = MY_PARAMS.url\\\\n    MY_RULE.col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = RULE.params\\\\n}\\\\nMY_RULE.pages = RULE.pages\\\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\\\nMY_RULE.title = RULE.title\\\\n\\\\nif (!isIndex) {\\\\n    if (pageTitle) setPageTitle(pageTitle)\\\\n    setLastChapterRule(thisRULE.last_chapter_rule)\\\\n    MY_PARAMS = MY_RULE.params\\\\n}\\\\n// 预处理并初始化config\\\\nif (isIndex && MY_PAGE == 1) eval(thisRULE.preRule)\\\\nlet _cfg = getMyVar('initConfig', '{}')\\\\nif (_cfg && _cfg.length > 0) {\\\\n    config = JSON.parse(_cfg)\\\\n}\\\\n\\\\n// 正文解析通用变量\\\\nlet assignLazyRule = $.toString((QING_TITLE, title) => {\\\\n    let RULE = $.require(\\\\\\\"hiker://page/dataLoad?rule=\\\\\\\" + QING_TITLE)().find((v) => v.title == title)\\\\n    return { pages: RULE.pages, pageList: JSON.parse(RULE.pages || '[]') }\\\\n}, QING_TITLE, RULE.title)\\\\nfunction genMyRule() {\\\\n    let rule = Object.assign({}, MY_RULE)\\\\n    delete rule.last_chapter_rule\\\\n    delete rule.preRule\\\\n    delete rule.pageList\\\\n    delete rule.pages\\\\n    return rule\\\\n}\\\\nfunction runCode(rule) {\\\\n    try {\\\\n        let [input, code] = rule.split('.js:')\\\\n        return code ? eval(code) : rule\\\\n    } catch (e) { return rule }\\\\n}\\\\nfunction genExUrl(url) {\\\\n    url = url.split(';')\\\\n    return url.shift() + ';' + paramHandle(url, thisRULE.ua, MY_RULE.url)\\\\n}\\\\n// 正文解析\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    setResult = function(el, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n        if (Array.isArray(el.data)) el = el.data\\\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra || {} })\\\\n            v.col_type = v.col_type || MY_RULE.col_type\\\\n\\\\n            if (!v.url || ['rule', 'pics', 'toast', 'input', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'select', 'x5Rule', 'webRule', 'download', 'share'].find((vv) => v.url.startsWith(vv + '://')) || ['x5_webview_single', 'input'].find((vv) => v.col_type == vv)) {\\\\n                return v\\\\n            } else if (v.url.includes('@rule=')) {\\\\n                let [_, url, rule] = v.url.match(/^([\\\\\\\\s\\\\\\\\S]*?)@rule=([\\\\\\\\s\\\\\\\\S]*)$/)\\\\n                v.url = url\\\\n                MY__RULE.detail_find_rule = rule\\\\n                MY__RULE.detail_col_type = MY_RULE.col_type\\\\n            } else if (v.url.startsWith('hiker://page/')) {\\\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\\\n                    return v\\\\n                let [_, path, flag, params] = v.url.match(/^hiker:\\\\\\\\/\\\\\\\\/page\\\\\\\\/(.+?)(#.*?)?(?:\\\\\\\\?(.*))?$/),\\\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path),\\\\n                    subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\\\n                v.url = (subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (v.extra || {}).url) || 'hiker://empty' + flag + '?' + (params || '')\\\\n                MY__RULE.detail_find_rule = subPage.rule\\\\n                MY__RULE.detail_col_type = subPage.col_type\\\\n            } else if (v.url.includes('@lazyRule=')) {\\\\n                let reIndex = v.url.indexOf('.js:')\\\\n                if (reIndex >= 0) v.url = v.url.slice(0, reIndex) + '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + v.url.slice(reIndex + 4)\\\\n                return v\\\\n            } else if (isIndex) {\\\\n                if (!MY_RULE.detail_find_rule || /hiker:\\\\\\\\/\\\\\\\\/(?!empty.+$)/.test(v.url)) return v\\\\n            } else {\\\\n                return v\\\\n            }\\\\n            v.extra = {\\\\n                url: genExUrl(v.url),\\\\n                RULE: MY__RULE,\\\\n                pageTitle: isIndex && v.title\\\\n            }\\\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            return v\\\\n        }))\\\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\\\n    }\\\\n    setHomeResult = setResult\\\\n    setSearchResult = setResult\\\\n\\\\n    eval(MY_RULE.find_rule.slice(3))\\\\n} else {\\\\n    let [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\\\\\s\\\\\\\\S]*?)(?:==>([\\\\\\\\s\\\\\\\\S]*))?$/)\\\\n    findRule = findRule.split(';')\\\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\\\n                try {\\\\n                    if (v == '*') return ''\\\\n                    else v = (i == 1 || i == 3) ?\\\\n                        parseDom(data, v) :\\\\n                        parseDomForHtml(data, v)\\\\n                    if (i != 3) v = runCode(v)\\\\n                    return v\\\\n                } catch (e) { return '' }\\\\n            }),\\\\n            res = {\\\\n                title: title, url: url,\\\\n                desc: desc, img: img,\\\\n                col_type: MY_RULE.col_type\\\\n            }\\\\n        if (res.url) {\\\\n            if (res.url.includes('@lazyRule=')) {\\\\n                let reIndex = res.url.indexOf('.js:')\\\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\\\n            } else  if (detailFindRule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: Object.assign(genMyRule(), { detail_find_rule: detailFindRule }),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: genMyRule(),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            }\\\\n        }\\\\n        myCollection_el.push(res)\\\\n    })\\\\n    setResult(myCollection_el)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据载入\\\",\\\"path\\\":\\\"dataLoad\\\",\\\"rule\\\":\\\"$.exports = function(showAll) {\\\\n    let url = getMyVar('remoteUrl'),\\\\n        data = []\\\\n    if (url.startsWith('hiker://') || url.startsWith('file://')) {\\\\n        // 如果为本地文件则不进行缓存\\\\n        try {\\\\n            let oriData = fetch(url)\\\\n            if (url.startsWith('hiker://page/'))\\\\n                oriData = JSON.parse(oriData).rule\\\\n            data = JSON.parse(oriData)\\\\n        } catch (e) {}\\\\n    } else {\\\\n        // 获取远程数据，检查间隔默认一天\\\\n        let interval = parseInt(readFile('updateInterval') || '1'),\\\\n            oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\\\n            remoteData = []\\\\n        if(interval == 0) interval = -1\\\\n        try { remoteData = JSON.parse(fetchCache(url, 24 * interval, {timeout:50000})) } catch(e) {}\\\\n        if(!Array.isArray(remoteData)) remoteData = []\\\\n        if (remoteData.length < 3) {\\\\n            log('未获取到数据')\\\\n            if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData)\\\\n            data = JSON.parse(oldData || '[]')\\\\n        } else {\\\\n            log('已获取到数据')\\\\n            data = remoteData\\\\n        }\\\\n    }\\\\n    data = data.filter((v) => { return v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器') })\\\\n    if (readFile('disableCustom')) return data\\\\n    else { // 写入自定义数据\\\\n        let customData = JSON.parse(readFile('customData') || '[]'),\\\\n            rewriteData = []\\\\n        customData = customData.reduce((self, v) => {\\\\n            let index = data.findIndex((vv) => v.title == vv.title)\\\\n            if (index >= 0) {\\\\n                self.push(v)\\\\n                let rule = data.splice(index, 1)[0]\\\\n                if (showAll || v.visible)\\\\n                    rewriteData.push(Object.assign(rule, v))\\\\n            }\\\\n            return self\\\\n        }, [])\\\\n        data.forEach((v) => customData.push({ title: v.title, visible: true }))\\\\n        saveFile('customData', JSON.stringify(customData))\\\\n        return rewriteData.concat(data)\\\\n    }\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"函数重写\\\",\\\"path\\\":\\\"preFunc\\\",\\\"rule\\\":\\\"// 防止require多次运行\\\\nlet rCache = {}\\\\nrequire = function(param0, param1, param2, param3, param4) {\\\\n    if (!param0 || rCache[param0] != null) {\\\\n        return\\\\n    }\\\\n    rCache[param0] = 1\\\\n    param2 = param2 || 0\\\\n    param3 = MY_TICKET\\\\n    param4 = eval\\\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\\\n}\\\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\\\n    if (!param0 || rCache[param0] != null) {\\\\n        return\\\\n    }\\\\n    rCache[param0] = 1\\\\n    param3 = param3 || 0\\\\n    param4 = MY_TICKET\\\\n    param5 = eval\\\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\\\n}\\\\nrc = requireCache\\\\n\\\\n// 最新章节规则注入预处理代码\\\\nsetLastChapterRule = function(param0) {\\\\n    if (!param0) return\\\\n    if (param0.startsWith(\\\\\\\"js:\\\\\\\") && thisRULE.preRule) {\\\\n        param0 = 'js:\\\\\\\\ntry{eval(JSON.parse(fetch(\\\\\\\"hiker://page/preFunc?rule=' + QING_TITLE + '\\\\\\\")).rule);\\\\\\\\\\\\n            eval(base64Decode(\\\\\\\"' + base64Encode(thisRULE.preRule) + '\\\\\\\"));\\\\\\\\\\\\n            let _cfg = getMyVar(\\\\\\\"initConfig\\\\\\\", \\\\\\\"{}\\\\\\\");\\\\\\\\\\\\n            if (_cfg && _cfg.length>0) {config = JSON.parse(_cfg)}}catch(e){log(e.message)}\\\\\\\\n;' +\\\\n            param0.slice(3)\\\\n    }\\\\n    method_setLastChapterRule.invoke(javaContext, param0);\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"链接处理\\\",\\\"path\\\":\\\"urlParse\\\",\\\"rule\\\":\\\"// 首页链接替换分类\\\\nfunction indexUrl(param) {\\\\n    function runCode(rule) {\\\\n        try {\\\\n            let [input, code] = rule.split('.js:')\\\\n            return code ? eval(code) : rule\\\\n        } catch (e) { return rule }\\\\n    }\\\\n    let { RULE, pageNum, QING_TITLE } = JSON.parse(param.split('###')[1])\\\\n    RULE = JSON.parse(base64Decode(RULE))\\\\n    pageNum = parseInt(pageNum)\\\\n    let url = RULE.url\\\\n\\\\n    eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\\\n    url = url.replace(/fypage(?:@(-?\\\\\\\\d+)@)?(?:\\\\\\\\*(\\\\\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\\\n    url = /^([\\\\\\\\s\\\\\\\\S]*?)(?:\\\\\\\\[firstPage=([\\\\\\\\s\\\\\\\\S]*?)\\\\\\\\])?(?:(\\\\\\\\.js:[\\\\\\\\s\\\\\\\\S]*?))?$/.exec(url)\\\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\\\n    return runCode(url[1])\\\\n}\\\\n// 链接参数处理\\\\nfunction paramHandle(urlParam, ua, urlTmp) {\\\\n    let charset, UserAgent\\\\n    try { // 链接的编码和ua应该是首先继承首页链接\\\\n        [, , charset, UserAgent] = urlTmp.split(';')\\\\n        UserAgent = UserAgent.match(/^{(.*)}$/)[1].split('&&').find((v) => v.startsWith('User-Agent@'))\\\\n    } catch (e) {}\\\\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\\\\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    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\\\n    return urlParam.join(';')\\\\n}\\\\n\\\"},{\\\"name\\\":\\\"仓库工具\\\",\\\"path\\\":\\\"tools\\\",\\\"rule\\\":\\\"js:\\\\n$.exports.range = function(m, n) {\\\\n    return Math.floor(Math.random() * (m - n + 1) + n);\\\\n}\\\\n$.exports.color = function(text, color) {\\\\n    text += \\\\\\\"\\\\\\\";\\\\n    if (text.indexOf(\\\\\\\"““””\\\\\\\") === 0) {\\\\n        text.replace(\\\\\\\"““””\\\\\\\", \\\\\\\"\\\\\\\");\\\\n    }\\\\n    return \\\\\\\"““””<font color='\\\\\\\" + color + \\\\\\\"'>\\\\\\\" + text + \\\\\\\"</font>\\\\\\\";\\\\n}\\\\nfunction htmlTag(tag, text) {\\\\n    text += \\\\\\\"\\\\\\\";\\\\n    if (text.indexOf(\\\\\\\"““””\\\\\\\") === 0) {\\\\n        text.replace(\\\\\\\"““””\\\\\\\", \\\\\\\"\\\\\\\");\\\\n    }\\\\n    return \\\\\\\"““””\\\\\\\" + \\\\\\\"<\\\\\\\" + tag + \\\\\\\">\\\\\\\" + text + \\\\\\\"</\\\\\\\" + tag + \\\\\\\">\\\\\\\";\\\\n\\\\n}\\\\n\\\\nfunction getNowFormatDate() {\\\\n            let date = new Date();\\\\n            let seperator1 = \\\\\\\"-\\\\\\\";\\\\n            let seperator2 = \\\\\\\":\\\\\\\";\\\\n            let month = date.getMonth() + 1;\\\\n            let strDate = date.getDate();\\\\n            let strHours = date.getHours();\\\\n            let strMinutes = date.getMinutes();\\\\n            let strSeconds = date.getSeconds()+1;\\\\n            if (month >= 1 && month <= 9) {\\\\n                month = \\\\\\\"0\\\\\\\" + month\\\\n            }\\\\n            if (strDate >= 0 && strDate <= 9) {\\\\n                strDate = \\\\\\\"0\\\\\\\" + strDate\\\\n            }\\\\n            if (strHours >= 0 && strHours <= 9) {\\\\n                strHours = \\\\\\\"0\\\\\\\" + strHours\\\\n            }\\\\n            if (strMinutes >= 0 && strMinutes <= 9) {\\\\n                strMinutes = \\\\\\\"0\\\\\\\" + strMinutes\\\\n            }\\\\n            if (strSeconds >= 0 && strSeconds <= 9) {\\\\n                strSeconds = \\\\\\\"0\\\\\\\" + strSeconds\\\\n            }\\\\n            //let currentdate = date.getFullYear() + seperator1 + month + seperator1 + strDate + \\\\\\\" \\\\\\\" + strHours + seperator2 + strMinutes + seperator2 + strSeconds;\\\\n            let currentdate = (date.getFullYear()-2020)+''+ month +''+ strDate +''+ strHours+'' + strMinutes +''+ Math.ceil(strSeconds/7);\\\\n            return parseInt(currentdate)\\\\n        }\\\\n$.exports.getNowFormatDate = getNowFormatDate;\\\\n$.exports.htmlTag = htmlTag;\\\\n$.exports.small = function(text) {\\\\n    return htmlTag(\\\\\\\"small\\\\\\\", text);\\\\n}\\\\n$.exports.unique2 = function unique2(array){\\\\n    return Array.from(new Set(array));\\\\n}\\\\n$.exports.strDeal = function strDeal(str){\\\\n    str = str.split('');\\\\n    str = str.filter(e => (e >= 0 && e <= 9) || (e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z') || (e >= '\\\\\\\\u4e00' && e <= '\\\\\\\\u9fa5'));\\\\n    str = str.join('');\\\\n    return str\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"规则列表\\\",\\\"path\\\":\\\"data\\\",\\\"rule\\\":\\\"[{\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"吾爱破解𝔥\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"Hood\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.52pojie.cn/forum.php?mod=guide&view=fyclass&page=fypage;get;GBK\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 4,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"text_1\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"最新热门&最新精华&最新回复&最新发表\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"hot&digest&new&newthread\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\"js:\\\\\\\\nvar res = {};\\\\\\\\nvar d = [];\\\\\\\\nvar html = getResCode();\\\\\\\\n\\\\\\\\n//列表\\\\\\\\nvar list = parseDomForArray(html,'body&&tbody[id]');\\\\\\\\n\\\\\\\\nfor(var i=1;i<list.length+1;i++){\\\\\\\\nd.push({\\\\\\\\ntitle: (i)+ '. ' +parseDomForHtml(list[i-1],'.xst&&Text'),\\\\\\\\nurl:'x5://https://www.52pojie.cn/'+parseDomForHtml(list[i-1],'a&&href'),\\\\\\\\ncol_type: 'text_1'});\\\\\\\\n}\\\\\\\\n\\\\\\\\r\\\\\\\\nres.data = d;\\\\\\\\nsetHomeResult(res);\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"http://zhannei.baidu.com/cse/site?q=**&p=fypage&cc=52pojie.cn\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"①推荐\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\"body&&.result;\\\\\\\\nh3&&Text;\\\\\\\\na&&href;\\\\\\\\n*;\\\\\\\\n.c-abstract&&Text;\\\\\\\\n*\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"pc\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"https://www.52pojie.cn/favicon.ico\\\\\\\"\\\\n}, {\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"423Down\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"香雅情\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.423down.com/fyAllpage/fypage;get;utf-8;{User-Agent@Mozilla/5.0 (Linux；； Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/80.0.3987.132 Mobile Safari/537.36}\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 1,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"首页&安卓软件\\\\\\\",\\\\n    \\\\\\\"type\\\\\\\": \\\\\\\"news\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"&apk/\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"原创软件&媒体播放&网页浏览&图形图像&聊天软件&办公软件&上传下载&实用软件&系统辅助&系统必备&安全软件&补丁相关&硬件相关&游戏软件\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"zd423/&multimedia/&browser/&image/&im/&work/&down/&safewore/&systemsoft/&systemplus/&security/&patch/&hardware/&game/\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\"js:\\\\\\\\nvar items = [];var html=getResCode();\\\\\\\\n//log(html);\\\\\\\\nvar list = parseDomForArray(html,'.archive-list&&li:not(:contains(优惠推荐))');\\\\\\\\n\\\\\\\\r\\\\\\\\n    for (var i = 0; i < list.length; i++) {\\\\\\\\r\\\\\\\\n        var title = parseDomForHtml(list[i], 'h2&&Text');\\\\\\\\n        var img = parseDom(list[i], 'img&&src');\\\\\\\\r\\\\\\\\n        var url = parseDom(list[i], 'a&&href');\\\\\\\\n        var desc = parseDomForHtml(list[i], '.item-meta&&Text');\\\\\\\\r\\\\\\\\n        items.push({\\\\\\\\r\\\\\\\\n            title: title,\\\\\\\\n            pic_url: img,\\\\\\\\r\\\\\\\\n            url: url,\\\\\\\\n            desc: desc\\\\\\\\r\\\\\\\\n        });\\\\\\\\r\\\\\\\\n    }\\\\\\\\n\\\\\\\\nsetHomeResult({data:items});\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"https://www.423down.com/page/fypage?s=**;get;utf-8;{User-Agent@Mozilla/5.0 (Linux；； Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/80.0.3987.132 Mobile Safari/537.36}\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"其它\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\".archive-list&&li;h2&&Text;a&&href;.item-category&&Text;.item-meta&&Text;img&&src\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"js:\\\\\\\\nvar d=[];\\\\\\\\nvar html=getResCode();\\\\\\\\nvar tabs=parseDomForHtml(html,'body&&.entry&&Html');\\\\\\\\n\\\\\\\\nd.push({\\\\\\\\n\\\\\\\\t\\\\\\\\t\\\\\\\\ttitle: tabs,\\\\\\\\n    desc:'',\\\\\\\\n    pic_url:'',\\\\\\\\n    url:'',\\\\\\\\n\\\\\\\\t\\\\\\\\tcol_type: 'rich_text'\\\\\\\\n});\\\\\\\\n\\\\\\\\nsetHomeResult({data:d});\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"*\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"auto\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"\\\\\\\"\\\\n}, {\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"落尘之木ᴺᵐ\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"Namo\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.luochenzhimu.com/page/fypage\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 1,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"movie_1_left_pic\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"type\\\\\\\": \\\\\\\"other\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\"js:\\\\\\\\nvar res = {};\\\\\\\\nvar d = [];\\\\\\\\nvar list = parseDomForArray(getResCode(), '.content&&.excerpt');\\\\\\\\nfor (var i in list) {\\\\\\\\n    d.push({\\\\\\\\n        title: parseDomForHtml(list[i], 'h2&&Text'),\\\\\\\\n        desc: parseDomForHtml(list[i], '.meta&&Text'),\\\\\\\\n        pic_url: parseDom(list[i], 'img&&data-src') + \\\\\\\\\\\\\\\"@Referer=\\\\\\\\\\\\\\\",\\\\\\\\n        url: parseDom(list[i], 'a&&href'),\\\\\\\\n    })\\\\\\\\n}\\\\\\\\nres.data = d;\\\\\\\\nsetHomeResult(res);\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"https://www.luochenzhimu.com/?s=**\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"其它\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\"js:\\\\\\\\nvar res = {};\\\\\\\\nvar d = [];\\\\\\\\nvar list = parseDomForArray(getResCode(), 'body&&article');\\\\\\\\nfor (var i in list) {\\\\\\\\n    d.push({\\\\\\\\n        title: parseDomForHtml(list[i], 'h2&&Text'),\\\\\\\\n        desc: parseDomForHtml(list[i], '.note&&Text'),        \\\\\\\\n        url: parseDom(list[i], 'a&&href'),\\\\\\\\n    })\\\\\\\\n}\\\\\\\\nres.data = d;\\\\\\\\nsetHomeResult(res);\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"js:var res={};\\\\\\\\nvar d = [];\\\\\\\\nd.push({\\\\\\\\n    col_type: \\\\\\\\\\\\\\\"text_1\\\\\\\\\\\\\\\",\\\\\\\\n    title: \\\\\\\\\\\\\\\"““””<big>\\\\\\\\\\\\\\\" + parseDomForHtml(getResCode(), \\\\\\\\\\\\\\\"h1&&Text\\\\\\\\\\\\\\\") + \\\\\\\\\\\\\\\"</big>\\\\\\\\\\\\\\\",\\\\\\\\n});\\\\\\\\nd.push({\\\\\\\\n    title: parseDomForHtml(getResCode(), \\\\\\\\\\\\\\\".article-content&&Html\\\\\\\\\\\\\\\").split('push({});')[1],\\\\\\\\n    col_type: 'rich_text',\\\\\\\\n    extra: {\\\\\\\\n        textSize: 16,\\\\\\\\n        click: true\\\\\\\\n    }\\\\\\\\n});\\\\\\\\nsetResult(d);\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"*\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"pc\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"https://img.luochenzhimu.com/public/2020/01/home.png\\\\\\\"\\\\n}, {\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"分享者\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"小🔥星\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"https://sharerw.com/a/fyAll/fypage/\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 9,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"movie_1_vertical_pic\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"手机软件&车机软件&电脑软件&\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"ganhuo&qiche&jingyan&\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"盒子软件&TV资讯&精选TV\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"ziyuan&tvzx&jxtv\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\"body&&.article-list;img&&alt;img&&src;.time&&Text;a&&href\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"https://sharerw.com/search.php?q=**&page=fypage\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"其它\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\"body&&.article-list;img&&alt;a&&href;.time&&Text;p,1&&Text;img&&src\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"js:var res={};var d=[];html=getResCode();text=parseDomForHtml(html,\\\\\\\\\\\\\\\".art-content&&Html\\\\\\\\\\\\\\\");d.push({title:text,col_type:'rich_text'});res.data=d;setHomeResult(res);\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"*\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"mobile\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"https://z3.ax1x.com/2021/11/05/ImzSvd.png\\\\\\\"\\\\n}, {\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"发现小软件\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"居然\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.x6g.com/html/23-fypage.html\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 3,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"movie_1_vertical_pic\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\".list-soft&&li;.list-info&&a&&Text;.layui-clear&&img&&src;.list-ca&&Text;.list-info&&a&&href\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"其它\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"text_3\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"body&&.article-down;a&&Text;*;*;a&&data-url\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"mobile\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"\\\\\\\"\\\\n}, {\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"VXAT\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"小🔥星\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.vxat.com/fyAll_fypage.html\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 1,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"movie_1_vertical_pic\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"软件下载&Windows&Android&电视软件&\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"RuanJianXiaZai&Windows&Android&TV&\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"优惠活动&网站源码&服务器&技术教程&\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"YouHuiHuoDong&WangZhanYuanMa&VPS&JiShuJiaoCheng&\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"一级页面提示错误为没有下一页！\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"其他&游戏&网友分享&&\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"QiTa&YouXi&WangYouFenXiang&&\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\"body&&.post;a&&title;img&&src;.time&&Text;a&&href\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"https://www.vxat.com/search.php?q=**&page=fypage\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"其它\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\"body&&.post;a&&title;a&&href;.time&&Text;.post&&Text;img&&src\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"js:var res={};var d=[];html=getResCode();text=parseDomForHtml(html,\\\\\\\\\\\\\\\".article-content&&Html\\\\\\\\\\\\\\\");d.push({title:text,col_type:'rich_text'});res.data=d;setHomeResult(res);\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"*\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"mobile\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"\\\\\\\"\\\\n}, {\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"异星软件\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"香雅情\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.yxssp.com/fyclass/page/fypage\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 1,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"Android&Windows\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"os/android&os/windows\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\".td-ss-main-content&&.td_module_wrap;h3&&Text;img&&src;.td-module-meta-info&&Text;a&&href\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"http://www.yxssp.com/page/fypage?s=**\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"其它\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\".td-ss-main-content&&.td_module_wrap;h3&&Text;a&&href;;.td-module-meta-info&&Text;img&&src\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"js:\\\\\\\\nvar d=[];\\\\\\\\nvar html=getResCode();\\\\\\\\nvar tabs=parseDomForHtml(html,'body&&.td-post-content&&Html').replace(/\\\\\\\\\\\\\\\\<script[\\\\\\\\\\\\\\\\S\\\\\\\\\\\\\\\\s]*?<\\\\\\\\\\\\\\\\/script\\\\\\\\\\\\\\\\>/g,'');\\\\\\\\n\\\\\\\\nd.push({\\\\\\\\n\\\\\\\\t\\\\\\\\t\\\\\\\\ttitle: tabs,\\\\\\\\n    desc:'',\\\\\\\\n    pic_url:'',\\\\\\\\n    url:'',\\\\\\\\n\\\\\\\\t\\\\\\\\tcol_type: 'rich_text'\\\\\\\\n});\\\\\\\\n\\\\\\\\nsetHomeResult({data:d});\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"*\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"pc\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"\\\\\\\"\\\\n}, {\\\\n    \\\\\\\"last_chapter_rule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"title\\\\\\\": \\\\\\\"apk4all\\\\\\\",\\\\n    \\\\\\\"author\\\\\\\": \\\\\\\"tee\\\\\\\",\\\\n    \\\\\\\"url\\\\\\\": \\\\\\\"https://apk4all.com/android/genres/fyAll/page/fypage/\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": 8,\\\\n    \\\\\\\"col_type\\\\\\\": \\\\\\\"movie_1_left_pic\\\\\\\",\\\\n    \\\\\\\"class_name\\\\\\\": \\\\\\\"Art ＆＆ Design&Auto ＆＆ Vehicles&Books ＆＆ Reference&Business&Comics&Communication&Education&Entertainment&Finance&Health ＆＆ Fitness&House ＆＆ Home&Libraries ＆＆ Demo&Lifestyle&Maps ＆＆ Navigation&Medical&Music ＆＆ Audio&News ＆＆ Magazines&Parenting&Personalization&Photography&Productivity&Shopping&Social&Tools&Travel ＆＆ Local&Video Players ＆＆ Editors&Weather\\\\\\\",\\\\n    \\\\\\\"type\\\\\\\": \\\\\\\"tool\\\\\\\",\\\\n    \\\\\\\"class_url\\\\\\\": \\\\\\\"art-design/&auto-vehicles/&books-reference/&business-app/&comics-app/&communication-app/&education-mod-app/&entertainment-apps/&finance/&health-fitness/&house-home/&libraries-demo/&lifestyle-app/&maps-navigation/&medical-app/&music-audio/&news-magazines/&parenting/&personalization-mod-app/&photography/&productivity-app/&shopping-app/&social-app/&tools-mod-app/&travel-local-app/&video-players-editors/&weather-app/\\\\\\\",\\\\n    \\\\\\\"area_name\\\\\\\": \\\\\\\"Action&Adventure&Arcade&Board&Card&Casual&Educational&Music&Puzzle&Racing&Role Playing&Simulation&Sports&Strategy&Trivia&Word\\\\\\\",\\\\n    \\\\\\\"area_url\\\\\\\": \\\\\\\"action-games/&adventure-games/&arcade-games/&board-games/&card-games/&casual-games/&educational-games/&music-games/&puzzle-games/&racing-games/&role-playing-games/&simulation-apk-games/&sports-games/&strategy-games/&trivia-games/&word-games/\\\\\\\",\\\\n    \\\\\\\"sort_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_name\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"sort_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"year_url\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"find_rule\\\\\\\": \\\\\\\"main&&article;h3&&Text;img,1&&src;dd&&Text;a&&href.js:input+'#immersiveTheme#'\\\\\\\",\\\\n    \\\\\\\"search_url\\\\\\\": \\\\\\\"https://apk4all.com/search/**/page/fypage/\\\\\\\",\\\\n    \\\\\\\"group\\\\\\\": \\\\\\\"其它\\\\\\\",\\\\n    \\\\\\\"searchFind\\\\\\\": \\\\\\\"main&&article;h3&&Text;a&&href.js:input+'#immersiveTheme#';dd&&Text;*;img,1&&src\\\\\\\",\\\\n    \\\\\\\"detail_col_type\\\\\\\": \\\\\\\"rich_text\\\\\\\",\\\\n    \\\\\\\"detail_find_rule\\\\\\\": \\\\\\\"js:\\\\\\\\nvar res = {};\\\\\\\\nvar d = [];\\\\\\\\nvar html = getResCode();\\\\\\\\nvar desc = pdfh(html, \\\\\\\\\\\\\\\".desc&&Text\\\\\\\\\\\\\\\") + \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\n\\\\\\\\\\\\\\\" + pdfh(html, \\\\\\\\\\\\\\\"h2&&Text\\\\\\\\\\\\\\\") + \\\\\\\\\\\\\\\"   \\\\\\\\\\\\\\\\/   10\\\\\\\\\\\\\\\";\\\\\\\\n\\\\\\\\nvar dl = pd(html, \\\\\\\\\\\\\\\".dllinks,1&&a&&href\\\\\\\\\\\\\\\") + \\\\\\\\\\\\\\\"#immersiveTheme#\\\\\\\\\\\\\\\";\\\\\\\\n\\\\\\\\nd.push({ //标题、缩略图、简介\\\\\\\\n    title: \\\\\\\\\\\\\\\"““””<big>\\\\\\\\\\\\\\\" + pdfh(html, \\\\\\\\\\\\\\\"h1&&Text\\\\\\\\\\\\\\\") + \\\\\\\\\\\\\\\"</big>\\\\\\\\\\\\\\\",\\\\\\\\n    col_type: \\\\\\\\\\\\\\\"movie_1_vertical_pic_blur\\\\\\\\\\\\\\\",\\\\\\\\n    desc: desc,\\\\\\\\n    pic_url: pd(html, \\\\\\\\\\\\\\\"article&&img,1&&src\\\\\\\\\\\\\\\"),\\\\\\\\n    url: dl\\\\\\\\n});\\\\\\\\n\\\\\\\\nd.push({ //线条\\\\\\\\n    col_type: \\\\\\\\\\\\\\\"line_blank\\\\\\\\\\\\\\\",\\\\\\\\n});\\\\\\\\n\\\\\\\\nvar list = pdfa(html, \\\\\\\\\\\\\\\".app-desc&&p||li\\\\\\\\\\\\\\\");\\\\\\\\nfor (i of list) {\\\\\\\\n    d.push({\\\\\\\\n        title: pdfh(i, \\\\\\\\\\\\\\\"p||li&&Text\\\\\\\\\\\\\\\"),\\\\\\\\n        col_type: \\\\\\\\\\\\\\\"rich_text\\\\\\\\\\\\\\\",\\\\\\\\n        extra: {\\\\\\\\n            textSize: 13,\\\\\\\\n            click: true\\\\\\\\n        }\\\\\\\\n    });\\\\\\\\n};\\\\\\\\n\\\\\\\\nvar gallery = pdfa(html, \\\\\\\\\\\\\\\"#gallery-1&&a\\\\\\\\\\\\\\\");\\\\\\\\n\\\\\\\\nfor (let n of gallery) {\\\\\\\\n    d.push({\\\\\\\\n        title: pdfh(n, \\\\\\\\\\\\\\\"img,1&&title\\\\\\\\\\\\\\\"),\\\\\\\\n        col_type: \\\\\\\\\\\\\\\"pic_3_square\\\\\\\\\\\\\\\",\\\\\\\\n        pic_url: pd(n, \\\\\\\\\\\\\\\"img,1&&src\\\\\\\\\\\\\\\") + '@Referer=',\\\\\\\\n        url: pd(n, \\\\\\\\\\\\\\\"img,1&&src\\\\\\\\\\\\\\\") + '#autoPage##readTheme#'\\\\\\\\n    });\\\\\\\\n};\\\\\\\\n\\\\\\\\nd.push({ //线条\\\\\\\\n    col_type: \\\\\\\\\\\\\\\"line_blank\\\\\\\\\\\\\\\",\\\\\\\\n});\\\\\\\\n\\\\\\\\n//底部下载模块\\\\\\\\nd.push({\\\\\\\\n    col_type: 'text_center_1',\\\\\\\\n    title: \\\\\\\\\\\\\\\"““””<big>\\\\\\\\\\\\\\\" + '点此下载' + \\\\\\\\\\\\\\\"</big>\\\\\\\\\\\\\\\",\\\\\\\\n    url: dl\\\\\\\\n});\\\\\\\\n\\\\\\\\nd.push({ //线条\\\\\\\\n    col_type: \\\\\\\\\\\\\\\"line_blank\\\\\\\\\\\\\\\",\\\\\\\\n});\\\\\\\\n\\\\\\\\nres.data = d;\\\\\\\\nsetResult(res);\\\\\\\",\\\\n    \\\\\\\"sdetail_col_type\\\\\\\": \\\\\\\"movie_1\\\\\\\",\\\\n    \\\\\\\"sdetail_find_rule\\\\\\\": \\\\\\\"*\\\\\\\",\\\\n    \\\\\\\"ua\\\\\\\": \\\\\\\"mobile\\\\\\\",\\\\n    \\\\\\\"preRule\\\\\\\": \\\\\\\"\\\\\\\",\\\\n    \\\\\\\"pages\\\\\\\": \\\\\\\"[]\\\\\\\",\\\\n    \\\\\\\"icon\\\\\\\": \\\\\\\"https://apk4all.com/favicon.ico\\\\\\\"\\\\n}]\\\"}]\"}","picUrl":"https://z3.ax1x.com/2021/11/05/ImzSvd.png","title":"分享者"}
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!