API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：热舞.dm

xiaomianao666
Jan 4th, 2022
92
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 103.81 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥热舞.dm@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"function ClassTab(classArray, params) {\\n    Object.assign(this, params)\\n    this.arr = classArray.map(v => this.init(v))\\n    this.sign = '$' + MY_RULE.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 = getVar('fold_' + this.sign, '')\\n        if (this.fold) el.push({\\n            title: '““””<span style=\\\"color:#049eff\\\">' + (folded ? '▶' : '▼'),\\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 ? '““””<span style=\\\"color:' + this.color + '\\\"><b>' : '') + name,\\n                    url: $('#noLoading#').lazyRule((sign, id, now) => {\\n                        putVar(sign + id, now)\\n                        putVar(sign, 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        if (defaultClass) defaultClass = JSON.stringify({\\n            name: defaultClass.class_name[0],\\n            url: defaultClass.class_url[0]\\n        })\\n        else throw new Error('cannot find id: ' + id + ' in classTab: ' + this.sign)\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\n    },\\n    getLastClick() {\\n        return JSON.parse(getVar(this.sign, '{}'))\\n    },\\n    setUrl(url) {\\n        return url.replace(/\\\\$\\\\{([^}]*)\\\\}/g, (_, id) => this.getClass(id).url)\\n    }\\n}\\n$.exports = ClassTab\\n\"},{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"indexLoad\",\"rule\":\"js:\\n\\nlet myCollection_el = [],\\n    pageNum = parseInt(MY_URL.split('#')[1]),\\n    RULE = MY_PARAMS.RULE,\\n    fyAll = RULE.url.includes('fyAll'),\\n    // 加载ClassTab组件\\n    ClassTab = $.require('hiker://page/ClassTab?rule=' + getItem('myCollection')),\\n    tabHeader = []\\n\\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, {\\n    name: RULE.title\\n})\\nif (pageNum == 1) {\\n    addListener('onClose', 'clearVar(\\\"myCollection-searchMode\\\")')\\n    putVar('myCollection-searchMode', RULE.title)\\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            rule: getItem('myCollection'),\\n            RULE: RULE,\\n            rules: $.toString((r) => {\\n                return JSON.stringify([r])\\n            }, RULE)\\n        },\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 处理MY_URL和MY_RULE\\nMY_RULE.ua = RULE.ua\\nMY_RULE.title = RULE.title\\nMY_RULE.col_type = RULE.col_type\\nMY_RULE.detail_col_type = RULE.detail_col_type\\nMY_RULE.find_rule = RULE.find_rule\\nMY_RULE.detail_find_rule = RULE.detail_find_rule\\nMY_RULE.preRule = RULE.preRule\\nMY_RULE.pageList = JSON.parse(RULE.pages || '[]')\\nMY_RULE.pages = JSON.stringify(MY_RULE.pageList)\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\nMY_RULE.params = {}\\n\\nlet _r = fetch(\\\"hiker://page/reset?rule=\\\" + getItem('myCollection'))\\neval(JSON.parse(_r).rule).home()\\n\\nconst {\\n    runCode,\\n    urlParse\\n} = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nvar {\\n    MY_URL,\\n    MY_URL_Options\\n} = urlParse(RULE.url, {}, pageNum, (url) => {\\n        url[0] = fyAll ? url[0].replace(/fyAll/g, '$${fyAll}') : url[0].replace(/fy(class|area|year|sort)/g, '$${fy$1}')\\n        url[0] = tabHeader.setUrl(url[0])\\n    }),\\n    indexHtml = fetch(MY_URL, MY_URL_Options)\\nMY_RULE.url = MY_URL\\nMY_RULE.urlHeaders = MY_URL_Options.headers\\n// 正文解析\\n\\nif (pageNum == 1) eval(MY_RULE.preRule)\\n//重新初始化config\\nlet _cfg = getMyVar('initConfig', '{}');\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    getUrl = function() {\\n        return MY_URL\\n    }\\n\\n    getResCode = function() {\\n        return indexHtml\\n    }\\n\\n    setResult = function(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n\\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({}, MY_RULE)\\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'].find((vv) => v.url.startsWith(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                MY__RULE.params = v.extra || {}\\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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\"[]\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + v.url.slice(reIndex + 4)\\n                return v\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) {\\n                if (!v.url.startsWith('hiker://empty#'))\\n                    return v\\n            }\\n            v.extra = {\\n                url: v.url,\\n                RULE: MY__RULE,\\n                pageTitle: v.title\\n            }\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n            if (v.extra.RULE.url.includes('#immersiveTheme#')) v.url += '&#immersiveTheme#'\\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 = MY_RULE.find_rule.split(';')\\n    parseDomForArray(indexHtml, 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) {\\n                    return ''\\n                }\\n            }),\\n            res = {\\n                title: title,\\n                url: url,\\n                desc: desc,\\n                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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\"[]\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + res.url.slice(reIndex + 4)\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: url,\\n                    RULE: MY_RULE,\\n                    pageTitle: title\\n                }\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n                if (res.extra.RULE.url.includes('#immersiveTheme#')) res.url += '&#immersiveTheme#'\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"详情\",\"path\":\"detailLoad\",\"rule\":\"js:\\nlet myCollection_el = [],\\n    pageNum = 1\\n\\n// 处理MY_URL和MY_RULE\\nlet RULE = MY_PARAMS.RULE\\nMY_RULE.ua = RULE.ua\\nMY_RULE.title = RULE.title\\nMY_RULE.col_type = RULE.detail_col_type\\nMY_RULE.find_rule = RULE.detail_find_rule\\nMY_RULE.preRule = RULE.preRule\\nMY_RULE.pageList = RULE.pageList\\nMY_RULE.pages = RULE.pages\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\nMY_RULE.params = RULE.params\\n\\nlet _r = fetch(\\\"hiker://page/reset?rule=\\\" + getItem('myCollection'))\\neval(JSON.parse(_r).rule).detail()\\n\\nconst {\\n    runCode,\\n    urlParse\\n} = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nlet fypageFlag = MY_PARAMS.url.indexOf('fypage')\\nif (fypageFlag >= 0) pageNum = parseInt(/^\\\\d+/.exec(MY_URL.slice(fypageFlag)))\\nvar {\\n    MY_URL,\\n    MY_URL_Options\\n} = urlParse(MY_PARAMS.url, RULE.urlHeaders, pageNum),\\n    indexHtml = fetch(MY_URL, MY_URL_Options)\\nMY_RULE.url = MY_URL\\nMY_RULE.urlHeaders = MY_URL_Options.headers\\n// 解析正文\\nif (MY_PARAMS.pageTitle) setPageTitle(MY_PARAMS.pageTitle)\\neval(MY_RULE.preRule)\\n//重新初始化config\\nlet _cfg = getMyVar('initConfig', '{}');\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\n\\nsetLastChapterRule(MY_RULE.last_chapter_rule)\\nMY_PARAMS = MY_RULE.params\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    getUrl = function() {\\n        return MY_URL\\n    }\\n\\n    getResCode = function() {\\n        return indexHtml\\n    }\\n\\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({}, MY_RULE)\\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'].find((vv) => v.url.startsWith(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                MY__RULE.params = v.extra || {}\\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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\"[]\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + v.url.slice(reIndex + 4)\\n                return v\\n            } else {\\n                return v\\n            }\\n            v.extra = {\\n                url: v.url,\\n                RULE: MY__RULE\\n            }\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n            if (v.extra.RULE.url.includes('#immersiveTheme#')) v.url += '&#immersiveTheme#'\\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(/^(.*?)(?:==>(.*))?$/)\\n    findRule = findRule.split(';')\\n    parseDomForArray(indexHtml, 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) {\\n                    return ''\\n                }\\n            }),\\n            res = {\\n                title: title,\\n                url: url,\\n                desc: desc,\\n                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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\"[]\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + res.url.slice(reIndex + 4)\\n            } else if (detailFindRule) {\\n                res.extra = {\\n                    url: url,\\n                    RULE: Object.assign({}, MY_RULE, {\\n                        detail_find_rule: detailFindRule\\n                    })\\n                }\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n                if (res.extra.RULE.url.includes('#immersiveTheme#')) res.url += '&#immersiveTheme#'\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"工具集\",\"path\":\"utility\",\"rule\":\"$.exports = {\\n    dataLoad: function(showAll) {\\n        //检查间隔，默认一天\\n        let interval = parseInt(readFile('updateInterval') || '1'),\\n            time = parseInt(readFile('updateTime')) || 0,\\n            now = new Date().getTime(),\\n            data = []\\n        if (time == 0 || interval > 0 && now - time > 1000 * 60 * 60 * 24 * interval) {\\n            // 获取远程数据\\n            let url = getItem('remoteUrl')\\n            try {\\n                let remoteData = fetch(url)\\n                if (url.startsWith('hiker://page/'))\\n                    remoteData = JSON.parse(remoteData).rule\\n                data = JSON.parse(remoteData)\\n            } catch (e) {}\\n            if(data.length == 0) {\\n                data = JSON.parse(readFile('dataCache') || '[]')\\n                log('没有获取到更新数据')\\n            } else {\\n                data = data.filter((v) => { return v.title != getItem('myCollection') && !v.author.includes('轻合集生成器') })\\n                saveFile('dataCache', JSON.stringify(data))\\n                saveFile('updateTime', now.toString())\\n                log('更新数据已写入本地')\\n            }\\n        } else {\\n            data = JSON.parse(readFile('dataCache') || '[]')\\n        }\\n        // 写入自定义数据\\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    runCode: function(rule) {\\n        try {\\n            let [input, code] = rule.split('.js:')\\n            return code ? eval(code) : rule\\n        } catch (e) { return rule }\\n    },\\n    urlParse: function(url, headers, pageNum, func) {\\n        url = url.split(';').map((v) => v.replace(/；；/g, ';'))\\n        if (func) func(url)\\n        url[0] = url[0].replace(/fypage(?:@(-?\\\\d+)@)?(?:\\\\*(\\\\d+)@)?/, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\n        url[0] = /^([\\\\s\\\\S]*?)(?:\\\\[firstPage=([\\\\s\\\\S]*?)\\\\])?$/.exec(url[0])\\n        url[0] = runCode(url[0][2] && pageNum == 1 ? url[0][2] : url[0][1])\\n        let options = { headers: headers, method: url[1] }\\n        // post方法时转换参数\\n        if (/^post$/i.test(options['method'])) {\\n            let [oriUrl, body] = url[0].split('?')\\n            url[0] = oriUrl.replace(/？？/g, '?')\\n            if (body.startsWith('JsonBody=')) body = body.slice(9)\\n            options['body'] = body\\n        }\\n        if (url[2]) options.headers['Content-Type'] = 'text/plain;charst=' + url[2]\\n        if (url[3]) url[3].match(/{(.*)}/)[1].split('&&').forEach((v) => {\\n            let [key, value] = v.split('@')\\n            options.headers[key] = runCode(value)\\n        })\\n        // 添加全局UA\\n        if (!options.headers['User-Agent']) {\\n            if (MY_RULE.ua == 'pc')\\n                options.headers['User-Agent'] = PC_UA\\n            else if (MY_RULE.ua == 'mobile')\\n                options.headers['User-Agent'] = MOBILE_UA\\n        }\\n        return { MY_URL: url[0], MY_URL_Options: options }\\n    }\\n}\\n\"},{\"col_type\":\"icon_2_round\",\"name\":\"设置\",\"path\":\"Config\",\"rule\":\"js:\\naddListener('onClose', 'clearVar(\\\"myCollection-sortFlag\\\");refreshPage()')\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\nconst { dataLoad } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nlet data = dataLoad(true),\\n    el = [{\\n        title: '清除缓存,立即更新 <small> （基于远程仓库,不要频繁点击）',\\n        url: $().lazyRule(() => {\\n            deleteFile('updateTime')\\n            back(false)\\n            return 'toast://已更新'\\n        }),\\n        img: 'hiker://images/icon1',\\n        col_type: 'avatar'\\n    }],\\n    searchThd = readFile('searchThd') || '5',\\n    updateInterval = readFile('updateInterval') || '1',\\n    newWindow = readFile('newWindow'),\\n    editMode = getVar('myCollection-editMode', '启用/禁用')\\n\\nel.push({\\n    title: '  🔍 搜索模式: ' + (searchThd == 0 ? '列' : '聚' + searchThd) + '  ',\\n    url: $(['列表搜索', '聚合搜索'], 1).select((searchThd) => {\\n        if (input == '列表搜索') {\\n            saveFile('searchThd', '0')\\n            refreshPage()\\n        } else {\\n            if (searchThd == 0) searchThd = 5\\n            return $(searchThd, '输入搜索线程，最好不要超过16').input(() => {\\n                saveFile('searchThd', input)\\n                refreshPage()\\n            })\\n        }\\n    }, searchThd),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💡 更新频率: ' + (updateInterval < 1 ? '手动' : updateInterval + '天') + '  ',\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新').input(() => {\\n        saveFile('updateInterval', input)\\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: '““””<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' }, { col_type: 'big_blank_block' });\\n['启用/禁用', '重新排序', '更改图标', '导入海阔'].forEach((v) => {\\n    el.push({\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putVar('myCollection-editMode', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'scroll_button'\\n    })\\n})\\nel.push({\\n    title: '恢复出厂数据',\\n    url: $('确定要恢复出厂，清楚自定义数据吗？').confirm(() => {\\n        deleteFile('customData')\\n        refreshPage(false)\\n        return 'toast://已恢复出厂数据'\\n    }),\\n    col_type: 'scroll_button'\\n})\\n\\nJSON.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((rule) => {\\n                let rules = JSON.parse(readFile('customData') || '[]'),\\n                    index = rules.findIndex((v) => v.title == rule.title)\\n                rules[index].visible = !rules[index].visible\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, v)\\n            break\\n        case '重新排序':\\n            let sortFlag = parseInt(getVar('myCollection-sortFlag', '-1'))\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\n            if (sortFlag == -1)\\n                d.url = $('#noLoading#').lazyRule((i) => {\\n                    putVar('myCollection-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                    putVar('myCollection-sortFlag', '-1')\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, sortFlag, i)\\n            break\\n        case '更改图标':\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((rule) => {\\n                let rules = JSON.parse(readFile('customData') || '[]'),\\n                    index = rules.findIndex((v) => v.title == rule.title)\\n                if (input)\\n                    rules[index].icon = input\\n                else\\n                    delete rules[index].icon\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, v)\\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\":\"reset\",\"rule\":\"function common() {\\n    let rCache = {};\\n    require = 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    }\\n    requireCache = function(param0, param1, param2, param3, param4, param5) {\\n        if (!param0 || rCache[param0] != null) {\\n            return\\n        }\\n        //log(param0)\\n        param3 = param3 || 0;\\n        param4 = MY_TICKET;\\n        param5 = eval;\\n        return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5);\\n    }\\n    rc = requireCache;\\n\\n}\\n\\nlet resetter = {\\n    home: function() {\\n        common();\\n    },\\n    search: function() {\\n        common();\\n    },\\n    c: function() {\\n        common();\\n    },\\n    detail: function() {\\n        common();\\n        let _pre = MY_RULE.preRule;\\n        let _myc = getItem('myCollection')\\n        //给最新章节规则注入预处理代码\\n        setLastChapterRule = function(param0) {\\n            if (!param0) {\\n                return\\n            }\\n            if (param0.startsWith(\\\"js:\\\") && MY_RULE.preRule) {\\n                let inject = \\\"let _r = fetch(\\\\\\\"hiker://page/reset?rule=\\\" + _myc + \\\"\\\\\\\");\\\\n\\\" +\\n                    \\\"eval(JSON.parse(_r).rule).c();\\\\n\\\" +\\n                    \\\"eval(unescape('\\\" + escape(_pre) + \\\"'));\\\\n\\\" +\\n                    \\\"let _cfg = getMyVar('initConfig', '{}');\\\\nif (_cfg && _cfg.length > 0) {\\\\nconfig = JSON.parse(_cfg);\\\\n}\\\\n\\\" +\\n                    \\\"eval(unescape('\\\" + escape(param0.slice(3)) + \\\"'));\\\";\\n                param0 = \\\"js:\\\\n\\\" + inject\\n            }\\n            log(param0)\\n            method_setLastChapterRule.invoke(javaContext, param0);\\n        }\\n    }\\n}\\n\\nresetter\"},{\"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}\"},{\"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}\"}],\"params\":\"{\\\"RULE\\\":{\\\"area_name\\\":\\\"\\\",\\\"area_url\\\":\\\"\\\",\\\"author\\\":\\\"道长\\\",\\\"class_name\\\":\\\"向上滑动即可播放\\\",\\\"class_url\\\":\\\"资源加载可能比较慢\\\",\\\"col_type\\\":\\\"movie_3\\\",\\\"detail_col_type\\\":\\\"movie_1\\\",\\\"detail_find_rule\\\":\\\"\\\",\\\"find_rule\\\":\\\"js:\\\\nevalPrivateJS('4ZFai6WdmDyH6oz/nhtVROAIx1c0dRGZtfmf6PyWCr6dHnPVIOLddKI4gXInyEoixmC+cyqM8V/plDjccHPKYdMRRu3DLjeWtkw/W5GbPWQVKdbbEohqdTqYxEM0KWdh');\\\\n/** 无需下载APP，点返回即可。*/\\\\nrequire(config.模板);\\\\nsetResult([{\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    url: \\\\\\\"https://tvv.tw/xjj/index.html\\\\\\\",\\\\n    desc: \\\\\\\"float&&100%\\\\\\\",\\\\n    extra: {\\\\n        canBack: true,\\\\n        js:注入()\\\\n    }\\\\n}])\\\",\\\"group\\\":\\\"#️⃣道长\\\",\\\"icon\\\":\\\"https://lanmeiguojiang.com/tubiao/08/72.png\\\",\\\"last_chapter_rule\\\":\\\"\\\",\\\"pageList\\\":[],\\\"pages\\\":\\\"[]\\\",\\\"preRule\\\":\\\"require('https://gitlab.com/hjdhnx/hiker/-/raw/main/js/预处理.js');\\\",\\\"sdetail_col_type\\\":\\\"movie_1\\\",\\\"sdetail_find_rule\\\":\\\"\\\",\\\"searchFind\\\":\\\"\\\",\\\"search_url\\\":\\\"\\\",\\\"sort_name\\\":\\\"\\\",\\\"sort_url\\\":\\\"小姐姐\\\",\\\"title\\\":\\\"热舞.dm\\\",\\\"type\\\":\\\"video\\\",\\\"ua\\\":\\\"mobile\\\",\\\"url\\\":\\\"hiker://empty\\\",\\\"version\\\":4,\\\"visible\\\":true,\\\"year_name\\\":\\\"\\\",\\\"year_url\\\":\\\"\\\"}}\",\"saved\":false,\"title\":\"道长dr合集\",\"version\":0,\"url\":\"hiker://page/indexLoad?#1#noHistory#\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\n\\nlet myCollection_el = [],\\n    pageNum = parseInt(MY_URL.split('#')[1]),\\n    RULE = MY_PARAMS.RULE,\\n    fyAll = RULE.url.includes('fyAll'),\\n    // 加载ClassTab组件\\n    ClassTab = $.require('hiker://page/ClassTab?rule=' + getItem('myCollection')),\\n    tabHeader = []\\n\\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, {\\n    name: RULE.title\\n})\\nif (pageNum == 1) {\\n    addListener('onClose', 'clearVar(\\\"myCollection-searchMode\\\")')\\n    putVar('myCollection-searchMode', RULE.title)\\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            rule: getItem('myCollection'),\\n            RULE: RULE,\\n            rules: $.toString((r) => {\\n                return JSON.stringify([r])\\n            }, RULE)\\n        },\\n        col_type: \\\"input\\\",\\n    })\\n}\\n// 处理MY_URL和MY_RULE\\nMY_RULE.ua = RULE.ua\\nMY_RULE.title = RULE.title\\nMY_RULE.col_type = RULE.col_type\\nMY_RULE.detail_col_type = RULE.detail_col_type\\nMY_RULE.find_rule = RULE.find_rule\\nMY_RULE.detail_find_rule = RULE.detail_find_rule\\nMY_RULE.preRule = RULE.preRule\\nMY_RULE.pageList = JSON.parse(RULE.pages || '[]')\\nMY_RULE.pages = JSON.stringify(MY_RULE.pageList)\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\nMY_RULE.params = {}\\n\\nlet _r = fetch(\\\"hiker://page/reset?rule=\\\" + getItem('myCollection'))\\neval(JSON.parse(_r).rule).home()\\n\\nconst {\\n    runCode,\\n    urlParse\\n} = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nvar {\\n    MY_URL,\\n    MY_URL_Options\\n} = urlParse(RULE.url, {}, pageNum, (url) => {\\n        url[0] = fyAll ? url[0].replace(/fyAll/g, '$${fyAll}') : url[0].replace(/fy(class|area|year|sort)/g, '$${fy$1}')\\n        url[0] = tabHeader.setUrl(url[0])\\n    }),\\n    indexHtml = fetch(MY_URL, MY_URL_Options)\\nMY_RULE.url = MY_URL\\nMY_RULE.urlHeaders = MY_URL_Options.headers\\n// 正文解析\\n\\nif (pageNum == 1) eval(MY_RULE.preRule)\\n//重新初始化config\\nlet _cfg = getMyVar('initConfig', '{}');\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    getUrl = function() {\\n        return MY_URL\\n    }\\n\\n    getResCode = function() {\\n        return indexHtml\\n    }\\n\\n    setResult = function(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n\\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({}, MY_RULE)\\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'].find((vv) => v.url.startsWith(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                MY__RULE.params = v.extra || {}\\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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\"[]\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + v.url.slice(reIndex + 4)\\n                return v\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) {\\n                if (!v.url.startsWith('hiker://empty#'))\\n                    return v\\n            }\\n            v.extra = {\\n                url: v.url,\\n                RULE: MY__RULE,\\n                pageTitle: v.title\\n            }\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n            if (v.extra.RULE.url.includes('#immersiveTheme#')) v.url += '&#immersiveTheme#'\\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 = MY_RULE.find_rule.split(';')\\n    parseDomForArray(indexHtml, 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) {\\n                    return ''\\n                }\\n            }),\\n            res = {\\n                title: title,\\n                url: url,\\n                desc: desc,\\n                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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\"[]\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + res.url.slice(reIndex + 4)\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: url,\\n                    RULE: MY_RULE,\\n                    pageTitle: title\\n                }\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\n                if (res.extra.RULE.url.includes('#immersiveTheme#')) res.url += '&#immersiveTheme#'\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\",\"group\":\"①轻合集\",\"ua\":\"mobile\",\"preRule\":\"setItem('myCollection', MY_RULE.title)\\nsetItem('remoteUrl', 'http://hiker.nokia.press/hikerule/rulelist.json?id=2812')\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"ClassTab\\\",\\\"path\\\":\\\"ClassTab\\\",\\\"rule\\\":\\\"function ClassTab(classArray, params) {\\\\n    Object.assign(this, params)\\\\n    this.arr = classArray.map(v => this.init(v))\\\\n    this.sign = '$' + MY_RULE.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 = getVar('fold_' + this.sign, '')\\\\n        if (this.fold) el.push({\\\\n            title: '““””<span style=\\\\\\\"color:#049eff\\\\\\\">' + (folded ? '▶' : '▼'),\\\\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 ? '““””<span style=\\\\\\\"color:' + this.color + '\\\\\\\"><b>' : '') + name,\\\\n                    url: $('#noLoading#').lazyRule((sign, id, now) => {\\\\n                        putVar(sign + id, now)\\\\n                        putVar(sign, 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        if (defaultClass) defaultClass = JSON.stringify({\\\\n            name: defaultClass.class_name[0],\\\\n            url: defaultClass.class_url[0]\\\\n        })\\\\n        else throw new Error('cannot find id: ' + id + ' in classTab: ' + this.sign)\\\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\\\n    },\\\\n    getLastClick() {\\\\n        return JSON.parse(getVar(this.sign, '{}'))\\\\n    },\\\\n    setUrl(url) {\\\\n        return url.replace(/\\\\\\\\$\\\\\\\\{([^}]*)\\\\\\\\}/g, (_, id) => this.getClass(id).url)\\\\n    }\\\\n}\\\\n$.exports = ClassTab\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"首页\\\",\\\"path\\\":\\\"indexLoad\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nlet myCollection_el = [],\\\\n    pageNum = parseInt(MY_URL.split('#')[1]),\\\\n    RULE = MY_PARAMS.RULE,\\\\n    fyAll = RULE.url.includes('fyAll'),\\\\n    // 加载ClassTab组件\\\\n    ClassTab = $.require('hiker://page/ClassTab?rule=' + getItem('myCollection')),\\\\n    tabHeader = []\\\\n\\\\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, {\\\\n    name: RULE.title\\\\n})\\\\nif (pageNum == 1) {\\\\n    addListener('onClose', 'clearVar(\\\\\\\"myCollection-searchMode\\\\\\\")')\\\\n    putVar('myCollection-searchMode', RULE.title)\\\\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            rule: getItem('myCollection'),\\\\n            RULE: RULE,\\\\n            rules: $.toString((r) => {\\\\n                return JSON.stringify([r])\\\\n            }, RULE)\\\\n        },\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n    })\\\\n}\\\\n// 处理MY_URL和MY_RULE\\\\nMY_RULE.ua = RULE.ua\\\\nMY_RULE.title = RULE.title\\\\nMY_RULE.col_type = RULE.col_type\\\\nMY_RULE.detail_col_type = RULE.detail_col_type\\\\nMY_RULE.find_rule = RULE.find_rule\\\\nMY_RULE.detail_find_rule = RULE.detail_find_rule\\\\nMY_RULE.preRule = RULE.preRule\\\\nMY_RULE.pageList = JSON.parse(RULE.pages || '[]')\\\\nMY_RULE.pages = JSON.stringify(MY_RULE.pageList)\\\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\\\nMY_RULE.params = {}\\\\n\\\\nlet _r = fetch(\\\\\\\"hiker://page/reset?rule=\\\\\\\" + getItem('myCollection'))\\\\neval(JSON.parse(_r).rule).home()\\\\n\\\\nconst {\\\\n    runCode,\\\\n    urlParse\\\\n} = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\\\nvar {\\\\n    MY_URL,\\\\n    MY_URL_Options\\\\n} = urlParse(RULE.url, {}, pageNum, (url) => {\\\\n        url[0] = fyAll ? url[0].replace(/fyAll/g, '$${fyAll}') : url[0].replace(/fy(class|area|year|sort)/g, '$${fy$1}')\\\\n        url[0] = tabHeader.setUrl(url[0])\\\\n    }),\\\\n    indexHtml = fetch(MY_URL, MY_URL_Options)\\\\nMY_RULE.url = MY_URL\\\\nMY_RULE.urlHeaders = MY_URL_Options.headers\\\\n// 正文解析\\\\n\\\\nif (pageNum == 1) eval(MY_RULE.preRule)\\\\n//重新初始化config\\\\nlet _cfg = getMyVar('initConfig', '{}');\\\\nif (_cfg && _cfg.length > 0) {\\\\n    config = JSON.parse(_cfg)\\\\n}\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    getUrl = function() {\\\\n        return MY_URL\\\\n    }\\\\n\\\\n    getResCode = function() {\\\\n        return indexHtml\\\\n    }\\\\n\\\\n    setResult = function(el, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n\\\\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({}, MY_RULE)\\\\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'].find((vv) => v.url.startsWith(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                MY__RULE.params = v.extra || {}\\\\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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\\\\\"[]\\\\\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + v.url.slice(reIndex + 4)\\\\n                return v\\\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) {\\\\n                if (!v.url.startsWith('hiker://empty#'))\\\\n                    return v\\\\n            }\\\\n            v.extra = {\\\\n                url: v.url,\\\\n                RULE: MY__RULE,\\\\n                pageTitle: v.title\\\\n            }\\\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\\\n            if (v.extra.RULE.url.includes('#immersiveTheme#')) v.url += '&#immersiveTheme#'\\\\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 = MY_RULE.find_rule.split(';')\\\\n    parseDomForArray(indexHtml, 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) {\\\\n                    return ''\\\\n                }\\\\n            }),\\\\n            res = {\\\\n                title: title,\\\\n                url: url,\\\\n                desc: desc,\\\\n                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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\\\\\"[]\\\\\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + res.url.slice(reIndex + 4)\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.extra = {\\\\n                    url: url,\\\\n                    RULE: MY_RULE,\\\\n                    pageTitle: title\\\\n                }\\\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\\\n                if (res.extra.RULE.url.includes('#immersiveTheme#')) res.url += '&#immersiveTheme#'\\\\n            }\\\\n        }\\\\n        myCollection_el.push(res)\\\\n    })\\\\n    setResult(myCollection_el)\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"详情\\\",\\\"path\\\":\\\"detailLoad\\\",\\\"rule\\\":\\\"js:\\\\nlet myCollection_el = [],\\\\n    pageNum = 1\\\\n\\\\n// 处理MY_URL和MY_RULE\\\\nlet RULE = MY_PARAMS.RULE\\\\nMY_RULE.ua = RULE.ua\\\\nMY_RULE.title = RULE.title\\\\nMY_RULE.col_type = RULE.detail_col_type\\\\nMY_RULE.find_rule = RULE.detail_find_rule\\\\nMY_RULE.preRule = RULE.preRule\\\\nMY_RULE.pageList = RULE.pageList\\\\nMY_RULE.pages = RULE.pages\\\\nMY_RULE.last_chapter_rule = RULE.last_chapter_rule\\\\nMY_RULE.params = RULE.params\\\\n\\\\nlet _r = fetch(\\\\\\\"hiker://page/reset?rule=\\\\\\\" + getItem('myCollection'))\\\\neval(JSON.parse(_r).rule).detail()\\\\n\\\\nconst {\\\\n    runCode,\\\\n    urlParse\\\\n} = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\\\nlet fypageFlag = MY_PARAMS.url.indexOf('fypage')\\\\nif (fypageFlag >= 0) pageNum = parseInt(/^\\\\\\\\d+/.exec(MY_URL.slice(fypageFlag)))\\\\nvar {\\\\n    MY_URL,\\\\n    MY_URL_Options\\\\n} = urlParse(MY_PARAMS.url, RULE.urlHeaders, pageNum),\\\\n    indexHtml = fetch(MY_URL, MY_URL_Options)\\\\nMY_RULE.url = MY_URL\\\\nMY_RULE.urlHeaders = MY_URL_Options.headers\\\\n// 解析正文\\\\nif (MY_PARAMS.pageTitle) setPageTitle(MY_PARAMS.pageTitle)\\\\neval(MY_RULE.preRule)\\\\n//重新初始化config\\\\nlet _cfg = getMyVar('initConfig', '{}');\\\\nif (_cfg && _cfg.length > 0) {\\\\n    config = JSON.parse(_cfg)\\\\n}\\\\n\\\\nsetLastChapterRule(MY_RULE.last_chapter_rule)\\\\nMY_PARAMS = MY_RULE.params\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    getUrl = function() {\\\\n        return MY_URL\\\\n    }\\\\n\\\\n    getResCode = function() {\\\\n        return indexHtml\\\\n    }\\\\n\\\\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({}, MY_RULE)\\\\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'].find((vv) => v.url.startsWith(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                MY__RULE.params = v.extra || {}\\\\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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\\\\\"[]\\\\\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + v.url.slice(reIndex + 4)\\\\n                return v\\\\n            } else {\\\\n                return v\\\\n            }\\\\n            v.extra = {\\\\n                url: v.url,\\\\n                RULE: MY__RULE\\\\n            }\\\\n            v.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\\\n            if (v.extra.RULE.url.includes('#immersiveTheme#')) v.url += '&#immersiveTheme#'\\\\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(/^(.*?)(?:==>(.*))?$/)\\\\n    findRule = findRule.split(';')\\\\n    parseDomForArray(indexHtml, 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) {\\\\n                    return ''\\\\n                }\\\\n            }),\\\\n            res = {\\\\n                title: title,\\\\n                url: url,\\\\n                desc: desc,\\\\n                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){MY_RULE.pages=' + JSON.stringify(MY_RULE.pages) + '||\\\\\\\"[]\\\\\\\";MY_RULE.pageList=JSON.parse(MY_RULE.pages);}' + res.url.slice(reIndex + 4)\\\\n            } else if (detailFindRule) {\\\\n                res.extra = {\\\\n                    url: url,\\\\n                    RULE: Object.assign({}, MY_RULE, {\\\\n                        detail_find_rule: detailFindRule\\\\n                    })\\\\n                }\\\\n                res.url = 'hiker://page/detailLoad?rule=' + getItem('myCollection')\\\\n                if (res.extra.RULE.url.includes('#immersiveTheme#')) res.url += '&#immersiveTheme#'\\\\n            }\\\\n        }\\\\n        myCollection_el.push(res)\\\\n    })\\\\n    setResult(myCollection_el)\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"工具集\\\",\\\"path\\\":\\\"utility\\\",\\\"rule\\\":\\\"$.exports = {\\\\n    dataLoad: function(showAll) {\\\\n        //检查间隔，默认一天\\\\n        let interval = parseInt(readFile('updateInterval') || '1'),\\\\n            time = parseInt(readFile('updateTime')) || 0,\\\\n            now = new Date().getTime(),\\\\n            data = []\\\\n        if (time == 0 || interval > 0 && now - time > 1000 * 60 * 60 * 24 * interval) {\\\\n            // 获取远程数据\\\\n            let url = getItem('remoteUrl')\\\\n            try {\\\\n                let remoteData = fetch(url)\\\\n                if (url.startsWith('hiker://page/'))\\\\n                    remoteData = JSON.parse(remoteData).rule\\\\n                data = JSON.parse(remoteData)\\\\n            } catch (e) {}\\\\n            if(data.length == 0) {\\\\n                data = JSON.parse(readFile('dataCache') || '[]')\\\\n                log('没有获取到更新数据')\\\\n            } else {\\\\n                data = data.filter((v) => { return v.title != getItem('myCollection') && !v.author.includes('轻合集生成器') })\\\\n                saveFile('dataCache', JSON.stringify(data))\\\\n                saveFile('updateTime', now.toString())\\\\n                log('更新数据已写入本地')\\\\n            }\\\\n        } else {\\\\n            data = JSON.parse(readFile('dataCache') || '[]')\\\\n        }\\\\n        // 写入自定义数据\\\\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    runCode: function(rule) {\\\\n        try {\\\\n            let [input, code] = rule.split('.js:')\\\\n            return code ? eval(code) : rule\\\\n        } catch (e) { return rule }\\\\n    },\\\\n    urlParse: function(url, headers, pageNum, func) {\\\\n        url = url.split(';').map((v) => v.replace(/；；/g, ';'))\\\\n        if (func) func(url)\\\\n        url[0] = url[0].replace(/fypage(?:@(-?\\\\\\\\d+)@)?(?:\\\\\\\\*(\\\\\\\\d+)@)?/, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\\\n        url[0] = /^([\\\\\\\\s\\\\\\\\S]*?)(?:\\\\\\\\[firstPage=([\\\\\\\\s\\\\\\\\S]*?)\\\\\\\\])?$/.exec(url[0])\\\\n        url[0] = runCode(url[0][2] && pageNum == 1 ? url[0][2] : url[0][1])\\\\n        let options = { headers: headers, method: url[1] }\\\\n        // post方法时转换参数\\\\n        if (/^post$/i.test(options['method'])) {\\\\n            let [oriUrl, body] = url[0].split('?')\\\\n            url[0] = oriUrl.replace(/？？/g, '?')\\\\n            if (body.startsWith('JsonBody=')) body = body.slice(9)\\\\n            options['body'] = body\\\\n        }\\\\n        if (url[2]) options.headers['Content-Type'] = 'text/plain;charst=' + url[2]\\\\n        if (url[3]) url[3].match(/{(.*)}/)[1].split('&&').forEach((v) => {\\\\n            let [key, value] = v.split('@')\\\\n            options.headers[key] = runCode(value)\\\\n        })\\\\n        // 添加全局UA\\\\n        if (!options.headers['User-Agent']) {\\\\n            if (MY_RULE.ua == 'pc')\\\\n                options.headers['User-Agent'] = PC_UA\\\\n            else if (MY_RULE.ua == 'mobile')\\\\n                options.headers['User-Agent'] = MOBILE_UA\\\\n        }\\\\n        return { MY_URL: url[0], MY_URL_Options: options }\\\\n    }\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"icon_2_round\\\",\\\"name\\\":\\\"设置\\\",\\\"path\\\":\\\"Config\\\",\\\"rule\\\":\\\"js:\\\\naddListener('onClose', 'clearVar(\\\\\\\"myCollection-sortFlag\\\\\\\");refreshPage()')\\\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\\\nconst { dataLoad } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\\\nlet data = dataLoad(true),\\\\n    el = [{\\\\n        title: '清除缓存,立即更新 <small> （基于远程仓库,不要频繁点击）',\\\\n        url: $().lazyRule(() => {\\\\n            deleteFile('updateTime')\\\\n            back(false)\\\\n            return 'toast://已更新'\\\\n        }),\\\\n        img: 'hiker://images/icon1',\\\\n        col_type: 'avatar'\\\\n    }],\\\\n    searchThd = readFile('searchThd') || '5',\\\\n    updateInterval = readFile('updateInterval') || '1',\\\\n    newWindow = readFile('newWindow'),\\\\n    editMode = getVar('myCollection-editMode', '启用/禁用')\\\\n\\\\nel.push({\\\\n    title: '  🔍 搜索模式: ' + (searchThd == 0 ? '列' : '聚' + searchThd) + '  ',\\\\n    url: $(['列表搜索', '聚合搜索'], 1).select((searchThd) => {\\\\n        if (input == '列表搜索') {\\\\n            saveFile('searchThd', '0')\\\\n            refreshPage()\\\\n        } else {\\\\n            if (searchThd == 0) searchThd = 5\\\\n            return $(searchThd, '输入搜索线程，最好不要超过16').input(() => {\\\\n                saveFile('searchThd', input)\\\\n                refreshPage()\\\\n            })\\\\n        }\\\\n    }, searchThd),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '  💡 更新频率: ' + (updateInterval < 1 ? '手动' : updateInterval + '天') + '  ',\\\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新').input(() => {\\\\n        saveFile('updateInterval', input)\\\\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: '““””<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' }, { col_type: 'big_blank_block' });\\\\n['启用/禁用', '重新排序', '更改图标', '导入海阔'].forEach((v) => {\\\\n    el.push({\\\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\\\n            putVar('myCollection-editMode', v)\\\\n            refreshPage(false)\\\\n            return 'hiker://empty'\\\\n        }, v),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n})\\\\nel.push({\\\\n    title: '恢复出厂数据',\\\\n    url: $('确定要恢复出厂，清楚自定义数据吗？').confirm(() => {\\\\n        deleteFile('customData')\\\\n        refreshPage(false)\\\\n        return 'toast://已恢复出厂数据'\\\\n    }),\\\\n    col_type: 'scroll_button'\\\\n})\\\\n\\\\nJSON.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((rule) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]'),\\\\n                    index = rules.findIndex((v) => v.title == rule.title)\\\\n                rules[index].visible = !rules[index].visible\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, v)\\\\n            break\\\\n        case '重新排序':\\\\n            let sortFlag = parseInt(getVar('myCollection-sortFlag', '-1'))\\\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\\\n            if (sortFlag == -1)\\\\n                d.url = $('#noLoading#').lazyRule((i) => {\\\\n                    putVar('myCollection-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                    putVar('myCollection-sortFlag', '-1')\\\\n                    refreshPage(false)\\\\n                    return 'hiker://empty'\\\\n                }, sortFlag, i)\\\\n            break\\\\n        case '更改图标':\\\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((rule) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]'),\\\\n                    index = rules.findIndex((v) => v.title == rule.title)\\\\n                if (input)\\\\n                    rules[index].icon = input\\\\n                else\\\\n                    delete rules[index].icon\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, v)\\\\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\\\":\\\"reset\\\",\\\"rule\\\":\\\"function common() {\\\\n    let rCache = {};\\\\n    require = 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    }\\\\n    requireCache = function(param0, param1, param2, param3, param4, param5) {\\\\n        if (!param0 || rCache[param0] != null) {\\\\n            return\\\\n        }\\\\n        //log(param0)\\\\n        param3 = param3 || 0;\\\\n        param4 = MY_TICKET;\\\\n        param5 = eval;\\\\n        return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5);\\\\n    }\\\\n    rc = requireCache;\\\\n\\\\n}\\\\n\\\\nlet resetter = {\\\\n    home: function() {\\\\n        common();\\\\n    },\\\\n    search: function() {\\\\n        common();\\\\n    },\\\\n    c: function() {\\\\n        common();\\\\n    },\\\\n    detail: function() {\\\\n        common();\\\\n        let _pre = MY_RULE.preRule;\\\\n        let _myc = getItem('myCollection')\\\\n        //给最新章节规则注入预处理代码\\\\n        setLastChapterRule = function(param0) {\\\\n            if (!param0) {\\\\n                return\\\\n            }\\\\n            if (param0.startsWith(\\\\\\\"js:\\\\\\\") && MY_RULE.preRule) {\\\\n                let inject = \\\\\\\"let _r = fetch(\\\\\\\\\\\\\\\"hiker://page/reset?rule=\\\\\\\" + _myc + \\\\\\\"\\\\\\\\\\\\\\\");\\\\\\\\n\\\\\\\" +\\\\n                    \\\\\\\"eval(JSON.parse(_r).rule).c();\\\\\\\\n\\\\\\\" +\\\\n                    \\\\\\\"eval(unescape('\\\\\\\" + escape(_pre) + \\\\\\\"'));\\\\\\\\n\\\\\\\" +\\\\n                    \\\\\\\"let _cfg = getMyVar('initConfig', '{}');\\\\\\\\nif (_cfg && _cfg.length > 0) {\\\\\\\\nconfig = JSON.parse(_cfg);\\\\\\\\n}\\\\\\\\n\\\\\\\" +\\\\n                    \\\\\\\"eval(unescape('\\\\\\\" + escape(param0.slice(3)) + \\\\\\\"'));\\\\\\\";\\\\n                param0 = \\\\\\\"js:\\\\\\\\n\\\\\\\" + inject\\\\n            }\\\\n            log(param0)\\\\n            method_setLastChapterRule.invoke(javaContext, param0);\\\\n        }\\\\n    }\\\\n}\\\\n\\\\nresetter\\\"},{\\\"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}\\\"},{\\\"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}\\\"}]\"}","picUrl":"https://lanmeiguojiang.com/tubiao/08/72.png","title":"热舞.dm"}
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!