API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：MyFieldᴰⁿ

xiaomianao666
Dec 6th, 2021
96
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 310.33 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥MyFieldᴰⁿ@@{"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:\\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, { name: RULE.title })\\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://page/singleSearch?keyword=\\\"+input+\\\"&page=fypage\\\"',\\n        extra: { rule: getItem('myCollection'), RULE: RULE },\\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\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nvar { MY_URL, MY_URL_Options } = 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// 正文解析\\nif (pageNum == 1) eval(MY_RULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    function getUrl() {\\n        return MY_URL\\n    }\\n\\n    function getResCode() {\\n        return indexHtml\\n    }\\n\\n    function setResult(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, params] = v.url.split('#')[0].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?' + (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                v.url = v.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n                return v\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) { return v }\\n            v.extra = { url: v.url, RULE: MY__RULE, pageTitle: v.title }\\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) { return '' }\\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                res.url = res.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title }\\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}\\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\\nconst { runCode, urlParse } = $.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 { MY_URL, MY_URL_Options } = 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)\\nsetLastChapterRule(MY_RULE.last_chapter_rule)\\nMY_PARAMS = MY_RULE.params\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    function getUrl() {\\n        return MY_URL\\n    }\\n\\n    function getResCode() {\\n        return indexHtml\\n    }\\n\\n    function setResult(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, params] = v.url.split('#')[0].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?' + (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                v.url = v.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n                return v\\n            } else { return v }\\n            v.extra = { url: v.url, RULE: MY__RULE }\\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) { return '' }\\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                res.url = res.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n            } else if (detailFindRule) {\\n                res.extra = { url: url, RULE: Object.assign({}, MY_RULE, { detail_find_rule: detailFindRule }) }\\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}\\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\":\"movie_1_vertical_pic\",\"name\":\"单搜\",\"path\":\"singleSearch\",\"rule\":\"js:\\nlet myCollection_el = [],\\n    RULE = MY_PARAMS.RULE,\\n    keyword = getParam('keyword'),\\n    pageNum = parseInt(getParam('page'))\\n\\n// 处理MY_URL和MY_RULE\\nMY_TYPE = 'search'\\nMY_RULE.ua = RULE.ua\\nMY_RULE.title = RULE.title\\nMY_RULE.col_type = RULE.col_type\\nMY_RULE.detail_col_type = ['', '*'].includes(RULE.sdetail_find_rule) ? RULE.detail_col_type : RULE.sdetail_col_type\\nMY_RULE.find_rule = RULE.searchFind\\nMY_RULE.detail_find_rule = ['', '*'].includes(RULE.sdetail_find_rule) ? RULE.detail_find_rule : RULE.sdetail_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\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nvar { MY_URL, MY_URL_Options } = urlParse(RULE.search_url, {}, pageNum, (url) => {\\n    url[0] = url[0].replace(url[0].includes('%%') ? /%%/g : /\\\\*\\\\*/g, encodeStr(keyword, url[2]))\\n}),\\n    indexHtml = fetch(MY_URL, MY_URL_Options)\\nMY_RULE.url = MY_URL\\nMY_RULE.urlHeaders = MY_URL_Options.headers\\n// 正文解析\\nif (pageNum == 1) setPageTitle('“' + keyword + '”的搜索结果')\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    function getUrl() {\\n        return MY_URL\\n    }\\n\\n    function getResCode() {\\n        return indexHtml\\n    }\\n\\n    function setResult(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                subTitle = v.title\\n            v.title += '““””<br>' + (RULE.title.fontcolor('#12b668') + ' ▪ ' + (v.desc || '').fontcolor('#666666')).small()\\n            v.desc = v.content || ''\\n            if(!v.img && !v.pic_url) v.col_type = 'text_1'\\n            delete v.content\\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, params] = v.url.split('#')[0].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?' + (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                v.url = v.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n                return v\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) { return v }\\n            v.extra = { url: v.url, RULE: MY__RULE, pageTitle: subTitle }\\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, url, desc, content, img] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 4) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 1) v = runCode(v)\\n                    return v\\n                } catch (e) { return '' }\\n            }),\\n            res = {\\n                title: title + '““””<br>' + (RULE.title.fontcolor('#12b668') + ' ▪ ' + desc.fontcolor('#666666')).small(),\\n                url: url,\\n                desc: content,\\n                img: img\\n            }\\n        if(!res.img) res.col_type = 'text_1'\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                res.url = res.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title }\\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}\\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\"}],\"params\":\"{\\\"RULE\\\":{\\\"area_name\\\":\\\"\\\",\\\"area_url\\\":\\\"\\\",\\\"author\\\":\\\"断念\\\",\\\"class_name\\\":\\\"\\\",\\\"class_url\\\":\\\"\\\",\\\"col_type\\\":\\\"text_center_1\\\",\\\"detail_col_type\\\":\\\"movie_1\\\",\\\"detail_find_rule\\\":\\\"\\\",\\\"find_rule\\\":\\\"js:\\\\nthis.d = [];\\\\n\\\\nconst jxItem = $.require(\\\\\\\"hiker://page/jxItem\\\\\\\"),\\\\n    Route = $.require(\\\\\\\"hiker://page/Route\\\\\\\");\\\\n\\\\naddListener('onRefresh', $.toString(() => {\\\\n    switch (getVar('kqjxcs', '0')) {\\\\n        case '0':\\\\n            putVar('kqjxcs', 1);\\\\n            break;\\\\n        case '1':\\\\n            putVar('kqjxcs', 2);\\\\n            break;\\\\n        default:\\\\n            putVar('kqjxcs', 0);\\\\n            break;\\\\n    }\\\\n}));\\\\n\\\\nif (getVar('kqjxcs') == 2) {\\\\n    d.push({\\\\n        title: '‘‘’’<span style=\\\\\\\"color:#FACC2E\\\\\\\">解析测试',\\\\n        url: $().lazyRule(() => {\\\\n            var vipUrl = getVar('pluginLink');\\\\n            if (vipUrl.substr(0, 4) == 'http') {\\\\n                eval('var Config =' + fetch(getVar('oldConfig')));\\\\n                eval(fetch(Config.cj));\\\\n                return aytmParse(vipUrl);\\\\n            } else {\\\\n                return 'toast://输入框未填Url或者无效Url';\\\\n            }\\\\n        }),\\\\n        col_type: 'text_center_1',\\\\n    });\\\\n}\\\\n\\\\nvar jxNewV = getVar('jxNewV', ''),\\\\n    jxOldV = getVar('jxOldV');\\\\nvar versionTips = jxNewV == '' ? 'Version ' + jxOldV : '‘‘' + jxNewV + '\\\\\\\\n先更新小程序然后点击更新脚本依赖’’';\\\\nd.push({\\\\n    title: '‘‘’’<big><big><span style=\\\\\\\"color:#0C0000\\\\\\\">MyParseS',\\\\n    desc: versionTips,\\\\n    url: !getVar('kqjxcs') ? 'toast://这是标题' : Route.szParse,\\\\n    extra: {\\\\n        newWindow: true,\\\\n        lineVisible: false\\\\n    },\\\\n    col_type: 'text_center_1'\\\\n});\\\\n\\\\nfunction czGuide() {\\\\n    return \\\\\\\"https://docs.qq.com/doc/DVXNGVGdLREFPY3Zz\\\\\\\"\\\\n}\\\\n\\\\njxItem.lqFile();\\\\n\\\\nRoute.addLanJie(d);\\\",\\\"group\\\":\\\"①推荐\\\",\\\"icon\\\":\\\"https://static01.imgkr.com/temp/238137efb61645879687a8503f34d893.png\\\",\\\"last_chapter_rule\\\":\\\"\\\",\\\"pageList\\\":[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Parse_Dn.html\\\",\\\"path\\\":\\\"Parse_Dn.html\\\",\\\"rule\\\":\\\"<!DOCTYPE html>\\\\n<html>\\\\n<head>\\\\n    <meta charset=\\\\\\\"utf-8\\\\\\\">\\\\n    <meta name=\\\\\\\"viewport\\\\\\\" content=\\\\\\\"width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no\\\\\\\" />\\\\n    <script src=\\\\\\\"https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.min.js\\\\\\\"></script>\\\\n    <script src=\\\\\\\"https://code.jquery.com/jquery-2.1.4.min.js\\\\\\\"></script>\\\\n    <!--\\\\n    <script src=\\\\\\\"http://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js\\\\\\\"></script>\\\\n    <script src=\\\\\\\"http://apps.bdimg.com/libs/vue/1.0.14/vue.js\\\\\\\"></script>\\\\n    -->\\\\n    <title>Parse_Dn</title>\\\\n    <style type=text/css>\\\\n        html, body {\\\\n            height: auto;\\\\n            overflow: hidden;\\\\n        }\\\\n        body {\\\\n            margin: 0 5px 0 5px;\\\\n            padding: 0 0px 0 0px;\\\\n            //background: #F9F0DA;\\\\n            font-weight: 0;\\\\n            font-family: \\\\\\\"Microsoft YaHei\\\\\\\",\\\\\\\"宋体\\\\\\\",\\\\\\\"Segoe UI\\\\\\\", \\\\\\\"Lucida Grande\\\\\\\", Helvetica, Arial,sans-serif, FreeSans, Arimo;\\\\n        }\\\\n        #div2{\\\\n           margin-top:35px;\\\\n        }\\\\n        /*输入框父元素*/\\\\n        div.box {\\\\n            height: 53px;\\\\n            line-height: 20px;\\\\n            position: relative;\\\\n        }\\\\n        /*输入框尺寸*/\\\\n        form {\\\\n            background: transparent;\\\\n            position: relative;\\\\n            width: 92%;\\\\n        }\\\\n        input, label, .lieb button {\\\\n            border: none;\\\\n            outline: none;\\\\n        }\\\\n        /*字体位置*/\\\\n        input {\\\\n            width: 77%;\\\\n            height: 32px;\\\\n            padding-left: 66px;\\\\n            padding-right: 30px;\\\\n        }\\\\n        label {\\\\n            text-align:center;\\\\n            line-height: 43px;\\\\n            height: 40px;\\\\n            width: 60px;\\\\n            cursor: pointer;\\\\n            position: absolute;\\\\n        }\\\\n        /*小框*/\\\\n        .bar label {\\\\n            background: #D06B6C;\\\\n            border-radius: 555 555px 555px 555;\\\\n            width: 60px;\\\\n            font-size: 13px;\\\\n            color: #F9F0DA;\\\\n            top: 0;\\\\n            left: 3px;\\\\n        }\\\\n        /*输入框样式*/\\\\n        .bar input {\\\\n            background: #F9F0DA;\\\\n            border: 3px solid #D06B6C;\\\\n            border-radius: 4px;\\\\n        }\\\\n        /*列表*/\\\\n        .lieb button {\\\\n            text-align:center;\\\\n            line-height:40px;\\\\n            height: 40px;\\\\n            width: 27px;\\\\n            cursor: pointer;\\\\n            position: absolute;\\\\n        }\\\\n        /*列表*/\\\\n        .lieb button{\\\\n            border-radius: 4px;\\\\n            background: #D06B6C;\\\\n            font-size: 13px;\\\\n            color: #F9F0DA;\\\\n            top: 0;\\\\n            right: 0px;\\\\n        }\\\\n        /*头像*/\\\\n        .round_icon{\\\\n            width: 40px;\\\\n            height: 40px;\\\\n            display: flex;\\\\n            border-radius: 50%;\\\\n            align-items: center;\\\\n            justify-content: center;\\\\n            overflow: hidden;\\\\n        }\\\\n\\\\n        .jx-ul, .cj-ul {\\\\n            z-index: 999;\\\\n            position: fixed;\\\\n            width: 77%;\\\\n           // left: 10%;\\\\n        }\\\\n        .jx-ul, .cj-ul {\\\\n            display: none;\\\\n        }\\\\n        .jx-ul {\\\\n            top: 2%;\\\\n        }\\\\n        .cj-ul {\\\\n            top: 30%;\\\\n        }\\\\n        li {\\\\n            height: 35px;\\\\n            border: 1px solid #01bfda;\\\\n            border-radius: 6px;\\\\n            background: rgba(0, 0, 0, 0.8);\\\\n            color: white;\\\\n            line-height: 35px;\\\\n            text-align: center;\\\\n            font-size: 16px;\\\\n            white-space: nowrap;\\\\n            overflow: hidden;\\\\n            text-overflow: ellipsis;\\\\n        }\\\\n        li {\\\\n            list-style: none;\\\\n        }\\\\n        li:hover {\\\\n            cursor: pointer;\\\\n            background: rgba(139, 131, 120, 0.9);\\\\n        }\\\\n        li[check=\\\\\\\"true\\\\\\\"] {\\\\n            background: rgba(139, 0, 0, 0.9);\\\\n        }\\\\n\\\\n    </style>\\\\n</head>\\\\n\\\\n<body>\\\\n    <div class=\\\\\\\"fung\\\\\\\">\\\\n        <a style=\\\\\\\"float:left;\\\\\\\">\\\\n            <button  style=\\\\\\\"border: none;border-radius:10px;background: #c5464a;width: 80px; font-size: 18px;color: #F9F0DA;\\\\\\\" onclick=\\\\\\\"cancel();\\\\\\\">关 闭</button>\\\\n        </a>\\\\n        <a style=\\\\\\\"float:right\\\\\\\">\\\\n            <button style=\\\\\\\"border: none;border-radius:10px;background: #068006;width: 80px; font-size: 18px;color: #F9F0DA;\\\\\\\"onclick=\\\\\\\"clickme('配 置 已 保 存 ！', 1000, '开');\\\\\\\">保 存</button> \\\\n        </a>\\\\n    </div>\\\\n    <br>\\\\n    <div id=\\\\\\\"div2\\\\\\\"></div>\\\\n    <div>\\\\n        <a style=\\\\\\\"float:left;margin-top:5px;\\\\\\\" onclick=\\\\\\\"openDnPage()\\\\\\\">\\\\n            <img src=\\\\\\\"https://s3.ax1x.com/2021/02/22/y7wb9O.jpg\\\\\\\" class=\\\\\\\"round_icon\\\\\\\"  alt=\\\\\\\"\\\\\\\">\\\\n        </a>\\\\n        <span style=\\\\\\\"line-height:60px;font-size:18px;color: grey;\\\\\\\">&nbsp;&nbsp;断&nbsp;念</span>\\\\n        <a style=\\\\\\\"float:right;margin-top:5px;\\\\\\\">\\\\n            <button  style=\\\\\\\"border: none;border-radius:10px;background: #05BFC5;width: 185px;height:40px; font-size: 18px;color: #F9F0DA;\\\\\\\" onclick=\\\\\\\"clickme('配 置 已 保 存 ！', 1000, '关');\\\\\\\">保存设置并关闭界面</button>\\\\n        </a>\\\\n    </div>\\\\n    <div class=\\\\\\\"zj-div\\\\\\\">\\\\n        <ul class=\\\\\\\"jx-ul\\\\\\\" style=\\\\\\\"height:444px;overflow-y:auto;\\\\\\\">\\\\n            <li class=\\\\\\\"myChoice\\\\\\\" style=\\\\\\\"z-index:9999;position: fixed;width:76.5%;color:red;\\\\\\\"></li>\\\\n            <li class=\\\\\\\"useless\\\\\\\"></li>\\\\n            <li class=\\\\\\\"xlList\\\\\\\" v-for=\\\\\\\"item in jxData\\\\\\\">{{item}}</li>\\\\n        </ul>\\\\n        <ul class=\\\\\\\"cj-ul\\\\\\\">\\\\n            <li style=\\\\\\\"background:grey;\\\\\\\">请选择插件</li>\\\\n            <li v-for=\\\\\\\"item in cjData\\\\\\\">{{item}}</li>\\\\n        </ul>\\\\n    </div>\\\\n</body>\\\\n<script>\\\\n    var settings = {\\\\n        qy: 'yun1717',\\\\n        yk: 'yun1717',\\\\n        tx: 'yun1717',\\\\n        mg: 'yun1717',\\\\n        bl: 'yun1717',\\\\n        oth: 'yun1717',\\\\n        qju: '',\\\\n        cj: 'hiker://files/cache/Parse_Dn.js'\\\\n    };\\\\n    eval(fy_bridge_app.getInternalJs());\\\\n    \\\\n    var oldRoute = \\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\";\\\\n    var mySet = fy_bridge_app.fetch(oldRoute);\\\\n    \\\\n    var newRoute = \\\\\\\"hiker://files/rules/DuanNian/MyParse.json\\\\\\\";\\\\n    var newConfig = fy_bridge_app.fetch(newRoute);\\\\n    var mySelect = [];\\\\n    if(newConfig != \\\\\\\"\\\\\\\"){\\\\n        eval(\\\\\\\"newConfig =\\\\\\\" + newConfig + \\\\\\\";\\\\\\\");\\\\n        settings = newConfig.settings;\\\\n        var ycTitle = ['defaultParse', 'maoss', 'CityIP', 'cacheM3u8', 'pcUA', 'parseLc', 'gparse', 'nparse'];\\\\n        for(var i = 0; i < newConfig.title.length; i++){\\\\n            var Titles = newConfig.title[i];\\\\n            if(ycTitle.includes(Titles) == false){\\\\n                mySelect.push(Titles);\\\\n            }\\\\n        }\\\\n    }\\\\n    var sfRefresh = settings.cj;\\\\n    function Did(id){\\\\n        return document.getElementById(id);\\\\n    }\\\\n    \\\\n    if(mySet == ''){\\\\n        Did(\\\\\\\"div2\\\\\\\").insertAdjacentHTML('afterBegin','\\\\\\\\\\\\n<h4>提示：<br>①注意插件选项，没有手动导入插件的话不用动它。如设置不当会导致规则无法使用，<br>解决办法：视界打开更多设置→文件管理→点cache→长按MyParseSet.json删除掉；<br>②全局设置如果选择了非默认那么全部的解析会使用这一设置，不想这样的话请填入默认；<br>③绿色保存按钮仅仅保存配置不会关闭设置页面，配置后想保存并关闭设置页面的话请点蓝色按钮；<br>④阅读完提示点关闭加载完整设置页面，如出问题无法自行解决点图片进入论坛向我反馈。<br></h4>');\\\\n    }\\\\n    \\\\n    var boxData = [\\\\n        {\\\\n            title: \\\\\\\"奇 奇\\\\\\\",\\\\n            id: \\\\\\\"qy\\\\\\\",\\\\n            value: settings.qy,\\\\n        }, {\\\\n            title: \\\\\\\"酷 酷\\\\\\\",\\\\n            id: \\\\\\\"yk\\\\\\\",\\\\n            value: settings.yk,\\\\n        }, {\\\\n            title: \\\\\\\"腾 腾\\\\\\\",\\\\n            id: \\\\\\\"tx\\\\\\\",\\\\n            value: settings.tx,\\\\n        }, {\\\\n            title: \\\\\\\"果 果\\\\\\\",\\\\n            id: \\\\\\\"mg\\\\\\\",\\\\n            value: settings.mg,\\\\n        }, {\\\\n            title: \\\\\\\"哩 哩\\\\\\\",\\\\n            id: \\\\\\\"bl\\\\\\\",\\\\n            value: settings.bl,\\\\n        }, {\\\\n            title: \\\\\\\"其 他\\\\\\\",\\\\n            id: \\\\\\\"oth\\\\\\\",\\\\n            value: settings.oth,\\\\n        }, {\\\\n            title: \\\\\\\"全 局\\\\\\\",\\\\n            id: \\\\\\\"qju\\\\\\\",\\\\n            value: settings.qju,\\\\n        }, {\\\\n            title: \\\\\\\"插 件\\\\\\\",\\\\n            id: \\\\\\\"cj\\\\\\\",\\\\n            value: settings.cj,\\\\n        }\\\\n    ];\\\\n\\\\n    var inputBox = \\\\\\\"\\\\\\\";\\\\n    for(let i = 0; i < boxData.length; i++){\\\\n        let b = boxData[i];\\\\n        inputBox += '<div class=\\\\\\\"box bar\\\\\\\">\\\\\\\\\\\\n            <form>\\\\\\\\\\\\n                <label type=\\\\\\\"submit\\\\\\\">' + b.title + '</label>\\\\\\\\\\\\n                <input type=\\\\\\\"text\\\\\\\" placeholder=\\\\\\\"输入解析名或者URL......\\\\\\\" value=\\\\\\\"' + b.value + '\\\\\\\" id=\\\\\\\"' + b.id + '\\\\\\\">\\\\\\\\\\\\n            </form>\\\\\\\\\\\\n            <div class=\\\\\\\"lieb\\\\\\\">\\\\\\\\\\\\n                <button id=\\\\\\\"' + b.id + 'Select\\\\\\\">☰</button>\\\\\\\\\\\\n            </div>\\\\\\\\\\\\n        </div>';\\\\n    }\\\\n    Did(\\\\\\\"div2\\\\\\\").insertAdjacentHTML('afterend', inputBox);\\\\n    Did(\\\\\\\"cj\\\\\\\").placeholder = \\\\\\\"输入插件地址......\\\\\\\";\\\\n    Did(\\\\\\\"qju\\\\\\\").placeholder = \\\\\\\"此项建议留空或者填默认两个字\\\\\\\";\\\\n    \\\\n    new Vue({\\\\n        el: \\\\\\\".zj-div\\\\\\\",\\\\n        data: {\\\\n            jxData: mySelect,\\\\n            cjData: [\\\\\\\"hiker://files/cache/Parse_Dn.js\\\\\\\", \\\\\\\"hiker://files/rules/dzHouse/js/srcauto.js\\\\\\\", \\\\\\\"hiker://files/rules/js/Parse-V2_Dn.js\\\\\\\"]\\\\n        }\\\\n    });\\\\n\\\\n    $(document).ready(function() {\\\\n        var len = $('.jx-ul').children('li').length;\\\\n        var len2 = $('.cj-ul').children('li').length;\\\\n        $('.lieb button').click(function(e) {\\\\n            if($('.lieb button').text().includes('━')){\\\\n                $('.lieb button').css('background', '');\\\\n                $('.lieb button').text('☰');\\\\n            }else{\\\\n                $(this).text('━');\\\\n                $(this).css('background', 'red');\\\\n            }\\\\n            $('li').attr('check', 'false');\\\\n            var inputid = \\\\\\\"#\\\\\\\" + this.id.split(\\\\\\\"Select\\\\\\\")[0];\\\\n            var arr = $(inputid).val().split(',');\\\\n            arr = arr[0] == '' ? [] : arr;\\\\n            $('.myChoice').text(arr);\\\\n            if (inputid !== '#cj' && $('.cj-ul').css('display')=='none') {\\\\n                $('.jx-ul').slideToggle();\\\\n                e.stopPropagation();\\\\n                for (let i = 1; i < len; i++) {\\\\n                    var jxList = $('.jx-ul li:not(.myChoice)').eq(i);\\\\n                    if (arr.includes(jxList.text())) {\\\\n                        jxList.attr('check', 'true');\\\\n                    }\\\\n                    jxList.unbind('click').click(function(e) {\\\\n                        e.stopPropagation();\\\\n                        if ($(this).attr('check') !== \\\\\\\"true\\\\\\\") {\\\\n                            $(this).attr('check', 'true');\\\\n                            arr.unshift($(this).text());\\\\n                            $(inputid).val(arr);\\\\n                            $('.myChoice').text(arr);\\\\n                        } else {\\\\n                            $(this).attr('check', 'false');\\\\n                            for (var a = 0; a < arr.length; a++) {\\\\n                                if (arr[a] == $(this).text()) {\\\\n                                    arr.splice(a, 1);\\\\n                                    $(inputid).val(arr);\\\\n                                    $('.myChoice').text(arr);\\\\n                                }\\\\n                            }\\\\n                        }\\\\n                    })\\\\n                }\\\\n            } else if($('.jx-ul').css('display')=='none'){\\\\n                $('.cj-ul').slideToggle();\\\\n                e.stopPropagation();\\\\n                for (let i = 0; i < len2; i++) {\\\\n                    var cjList = $('.cj-ul li').eq(i);\\\\n                    if ($(inputid).val() == cjList.text()) {\\\\n                        cjList.attr('check', 'true');\\\\n                    }\\\\n                    cjList.unbind('click').click(function() {\\\\n                        if (i !== 0) {\\\\n                            $(inputid).val($(this).text());\\\\n                            $(this).attr('check', 'true');\\\\n                            $(this).siblings().attr('check', 'false');\\\\n                        }\\\\n                    })\\\\n                }\\\\n            }\\\\n        });\\\\n        $(document).not($('.xlList')).click(function(e) {\\\\n            $('.jx-ul').slideUp();\\\\n            $('.cj-ul').slideUp();\\\\n            $('.lieb button').text('☰');\\\\n            $('.lieb button').css('background', '');\\\\n        })\\\\n        $('label').dblclick(function(){\\\\n            let inputid = '#' + $(this).next().attr('id');\\\\n            $(inputid).val('');\\\\n        })\\\\n    })\\\\n    \\\\n    function Toast(msg,duration){  \\\\n        duration=isNaN(duration)?2000:duration;  \\\\n        var m = document.createElement('div');  \\\\n        m.innerHTML = msg;  \\\\n        m.style.cssText=\\\\\\\"width:45%; min-width:150px; background:#311; opacity:0.6; height:auto;min-height: 45px; color:#fff; line-height:45px; text-align:center; border-radius:10px; position:fixed; top:60%; left:26%; z-index:999999;\\\\\\\";  \\\\n        document.body.appendChild(m);  \\\\n        setTimeout(function() {  \\\\n            var d = 0.5;  \\\\n            m.style.webkitTransition = '-webkit-transform ' + d + 's ease-in, opacity ' + d + 's ease-in';  \\\\n            m.style.opacity = '0';  \\\\n            setTimeout(function() { document.body.removeChild(m) }, d * 1000);  \\\\n        }, duration);  \\\\n    }  \\\\n\\\\n    function openDnPage(){\\\\n        fba.open(JSON.stringify({\\\\n            rule: \\\\\\\"=^_^=\\\\\\\",\\\\n            title: \\\\\\\"管理解析\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=编辑#noHistory#\\\\\\\",\\\\n            group: \\\\\\\"\\\\\\\",\\\\n            col_type: \\\\\\\"\\\\\\\",\\\\n            //findRule: \\\\\\\"js:this.d=[];$.require(\\\\\\\\\\\\\\\"hiker://page/Parse_Dn.js?rule=MyFieldᴰⁿ\\\\\\\\\\\\\\\").edit();setResult(d);\\\\\\\",\\\\n            preRule: \\\\\\\"\\\\\\\",\\\\n            extra: {}\\\\n        }));\\\\n    }\\\\n    function cancel(){\\\\n        if(mySet==''){\\\\n            fy_bridge_app.writeFile(oldRoute, JSON.stringify(settings, null, 4));\\\\n            fy_bridge_app.refreshPage(true);\\\\n        }else{\\\\n            fy_bridge_app.back(false);\\\\n        }\\\\n    }\\\\n    function clickme(msg,duration,title){\\\\n        for(let i = 0; i < boxData.length; i++){\\\\n            let id = boxData[i].id;\\\\n            settings[id] = Did(id).value;\\\\n            if(settings.qju == ''){\\\\n                settings.qju = '默认';\\\\n            }\\\\n        }\\\\n        if (mySelect[0] != undefined) {\\\\n            eval('var bcConfig=' + fy_bridge_app.fetch(newRoute));\\\\n            Object.assign(bcConfig.settings, settings);\\\\n            fy_bridge_app.writeFile(newRoute, $$$.stringify(bcConfig));\\\\n        }\\\\n        fy_bridge_app.writeFile(oldRoute, $$$.stringify(settings));\\\\n            \\\\n        Toast(msg,duration);\\\\n        if(title==\\\\\\\"关\\\\\\\"){\\\\n            if(sfRefresh != Did(\\\\\\\"cj\\\\\\\").value){\\\\n                fy_bridge_app.back();\\\\n            }else{\\\\n                fy_bridge_app.back(false);\\\\n            }\\\\n        }else{\\\\n            fy_bridge_app.refreshPage(true);\\\\n        }\\\\n    }\\\\n\\\\n</script>   \\\\n</html>\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Parse_Dn.js\\\",\\\"path\\\":\\\"Parse_Dn.js\\\",\\\"rule\\\":\\\"//============免嗅调用============\\\\n//－－－=^_^=\\\\n\\\\nvar version = \\\\\\\"3.5.1\\\\\\\";\\\\nvar updateDate = '2021/10/30/22:22';\\\\nvar _mySet = {\\\\n    qju: '默认',\\\\n    cjcache: 'hiker://files/cache/Parse_Dn.js',\\\\n    x5cache: 'hiker://files/cache/Parse_Dn.html',\\\\n    oldConfig: 'hiker://files/cache/MyParseSet.json',\\\\n    ckLink: 'https://code.aliyun.com/AI957/Hiker/raw/master/v/',\\\\n    cj: 'https://code.aliyun.com/AI957/Hiker/raw/master/v/CloudParse-V2_Dn.js',\\\\n    x5Url: 'https://code.aliyun.com/AI957/Hiker/raw/master/v/Parse_Dn.html',\\\\n    parseRoute: 'hiker://files/rules/DuanNian/MyParse.json',\\\\n    x5Route: 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/Parse_Dn.html'\\\\n};\\\\nvar MyParseS = {};\\\\nvar mySet = _mySet;\\\\nif (fileExist(_mySet.parseRoute)) {\\\\n    eval('var parseFile =' + fetch(_mySet.parseRoute));\\\\n    MyParseS = parseFile.codes;\\\\n    mySet = parseFile.settings;\\\\n}\\\\n\\\\nvar parseTitle = [\\\\n    \\\\\\\"yun1717\\\\\\\",\\\\n    \\\\\\\"PanGu\\\\\\\",\\\\n    \\\\\\\"FuXing\\\\\\\",\\\\n    \\\\\\\"https://jxx.smys8.cn/index.php?url=\\\\\\\",\\\\n    \\\\\\\"https://okjx.cc/?url=\\\\\\\",\\\\n    \\\\\\\"https://jx.m3u8.tv/jiexi/?url=\\\\\\\",\\\\n    \\\\\\\"https://sb.5gseo.net/?url=\\\\\\\"\\\\n];\\\\n\\\\n//－－－=^_^=\\\\n\\\\n//接口设置.\\\\n\\\\nvar setUrl = \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noRecordHistory#\\\\\\\";\\\\nvar set_switch = setUrl;\\\\nvar lazy = `eval('var config =' + fetch(getVar('oldConfig')));eval(fetch(config.cj));aytmParse(input)`;\\\\n\\\\n//var parwix = `var yurl='https://daili.mayixiongdi.cn/?url=';Referer': 'https://www.mayixiongdi.cn/ys?id=';'https://daili.mayixiongdi.cn/api.php', 'Referer':'https://daili.mayixiongdi.cn';\\\\n// 全民https://pcvideoaliyun.tianshangrenjian.mgtv.com.88wuma.com/?url=\\\\n\\\\n//－－－备 用－－－\\\\n/*\\\\n * 影视工场： https://ysgc.cc/\\\\n * 江湖: 555电影 https://www.555dy2.com/phone.html ｜ 17看 http://17kanyy.cn/ http://jhjiexi.30vr.cn/?url= ｜ http://api.maizimall.com/index.php?url=\\\\n * 江湖: http://www.tianshuyun.net/index.php/vod/play/id/448377/sid/1/nid/1.html\\\\n * 江湖2: http://98hyk.cn/index.php/vod/play/id/72841/sid/1/nid/1.html\\\\n * 人人迷: https://vip.susou.tv/player/?url= ｜ https://www.momdm.cc/\\\\n * \\\\n * wuigen: https://www.5igen.com/dmplayer/player/?url=\\\\n * 干饭(人人迷): https://jx.zui.cm/?url=\\\\n * https://2.66movie.top/player/?url=\\\\n * \\\\n */\\\\n\\\\n\\\\nvar tools = {\\\\n    MD5: function(data) {\\\\n        eval(getCryptoJS());\\\\n        return CryptoJS.MD5(data).toString(CryptoJS.enc.Hex);\\\\n    },\\\\n    AES: function(text, key, iv, isEncrypt) {\\\\n        eval(getCryptoJS());\\\\n        var key = CryptoJS.enc.Utf8.parse(key);\\\\n        var iv = CryptoJS.enc.Utf8.parse(iv);\\\\n        if (isEncrypt) {\\\\n            return CryptoJS.AES.encrypt(text, key, {\\\\n                iv: iv,\\\\n                mode: CryptoJS.mode.CBC,\\\\n                padding: CryptoJS.pad.Pkcs7\\\\n            }).toString();\\\\n        };\\\\n        return CryptoJS.AES.decrypt(text, key, {\\\\n            iv: iv,\\\\n            padding: CryptoJS.pad.Pkcs7\\\\n        }).toString(CryptoJS.enc.Utf8);\\\\n    },\\\\n    //ascii\\\\n    nextCharacter: function(asciiValue, k) {\\\\n        var s = asciiValue;\\\\n        return String.fromCharCode(s + k);\\\\n    },\\\\n    //凯撒\\\\n    caesarCipher: function(stringValue, k) {\\\\n        var newString = \\\\\\\"\\\\\\\";\\\\n        for (var i = 0; i < stringValue.length; i++) {\\\\n            newString += this.nextCharacter(stringValue[i].charCodeAt(), k);\\\\n        }\\\\n        return newString;\\\\n    },\\\\n    nowDate: function() {\\\\n        var date1 = new Date();\\\\n        var dateStr = \\\\\\\"\\\\\\\";\\\\n        if (date1) {\\\\n            dateStr = date1.getFullYear();\\\\n            var month = date1.getMonth() + 1;\\\\n            var day = date1.getDate();\\\\n            if (month < 10) {\\\\n                dateStr += \\\\\\\"-0\\\\\\\" + month;\\\\n            } else {\\\\n                dateStr += \\\\\\\"-\\\\\\\" + month;\\\\n            }\\\\n            if (day < 10) {\\\\n                dateStr += \\\\\\\"-0\\\\\\\" + day;\\\\n            } else {\\\\n                dateStr += \\\\\\\"-\\\\\\\" + day;\\\\n            }\\\\n        }\\\\n        return dateStr;\\\\n    },\\\\n    toJSON: function(json) {\\\\n        return JSON.stringify(json, (key, value) => {\\\\n            if (typeof value == 'function') {\\\\n                return value.toString();\\\\n            } else {\\\\n                return value;\\\\n            }\\\\n        }, 4);\\\\n    },\\\\n    toVNum: function(a) {\\\\n        var a = a.toString();\\\\n        var c = a.split('.');\\\\n        var num_place = [\\\\\\\"\\\\\\\", \\\\\\\"0\\\\\\\", \\\\\\\"00\\\\\\\", \\\\\\\"000\\\\\\\", \\\\\\\"0000\\\\\\\"],\\\\n            r = num_place.reverse();\\\\n        for (var i = 0; i < c.length; i++) {\\\\n            var len = c[i].length;\\\\n            c[i] = r[len] + c[i];\\\\n        }\\\\n        var res = c.join('');\\\\n        return res;\\\\n    },\\\\n    cprVersion: function(a, b) {\\\\n        var _a = parseInt(this.toVNum(a)),\\\\n            _b = parseInt(this.toVNum(b));\\\\n        b = isNaN(_b) ? version : b;\\\\n        if (_a > _b) {\\\\n            putVar('jxNewV', '有新版本: ' + a);\\\\n        } else {\\\\n            clearVar('jxNewV');\\\\n        }\\\\n        putVar('jxOldV', b);\\\\n    }\\\\n};\\\\n\\\\nif (getVar(\\\\\\\"jxOldV\\\\\\\", \\\\\\\"0\\\\\\\") != version) {\\\\n    putVar('cjCache', _mySet.cjcache);\\\\n    putVar('x5Cache', _mySet.x5Cache);\\\\n    putVar('oldConfig', _mySet.oldConfig);\\\\n    putVar('parseRoute', _mySet.parseRoute);\\\\n    let mayck = 'https://gitee.com/Duan-Nian/Dn/raw/master/hikerview/';\\\\n    let jxNewV = fetch(mayck + 'ParseVersion.txt'),\\\\n        jxOldV = (fetch(_mySet.cjcache).split('version = \\\\\\\"')[1] + '').split('\\\\\\\"')[0];\\\\n    tools.cprVersion(jxNewV, jxOldV);\\\\n    writeFile('hiker://files/cache/x5ParseLanJie.txt', fetch(mayck + 'x5ParseLanJie.txt'));\\\\n}\\\\n\\\\nvar ParseS = {};\\\\nvar originalParseS = {\\\\n    //updateDate: updateDate,\\\\n    CityIP: 'http://pv.sohu.com/cityjson',\\\\n    pcUA: 'User-Agent@Mozilla/5.0 (Windows NT 10.0\\\\\\\\；\\\\\\\\； WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36',\\\\n    cacheM3u8: function(vUrl, ref) {\\\\n        try {\\\\n            var m3u8 = fetch(vUrl, {});\\\\n            writeFile('hiker://files/cache/videos.m3u8', m3u8);\\\\n        } catch (e) {}\\\\n        return 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/videos.m3u8#';\\\\n    },\\\\n    defaultParse: function(url) {\\\\n        return url;\\\\n    },\\\\n    maoss: function(jxurl, ref, key) {\\\\n        try {\\\\n            var getVideoInfo = function(text) {\\\\n                return tools.AES(text, key, iv);\\\\n            };\\\\n            if (ref) {\\\\n                var html = request(jxurl, {\\\\n                    headers: {\\\\n                        'Referer': ref\\\\n                    }\\\\n                });\\\\n            } else {\\\\n                var html = request(jxurl);\\\\n            }\\\\n            if (html.indexOf('&btwaf=') != -1) {\\\\n                html = request(jxurl + '&btwaf' + html.match(/&btwaf(.*?)\\\\\\\"/)[1], {\\\\n                    headers: {\\\\n                        'Referer': ref\\\\n                    }\\\\n                })\\\\n            }\\\\n            var iv = html.split('bt_token = \\\\\\\"')[1].split('\\\\\\\"')[0];\\\\n            eval(html.match(/var config = {[\\\\\\\\s\\\\\\\\S]*?}/)[0] + '');\\\\n            if (config.url.slice(0, 4) != 'http') {\\\\n                config.url = decodeURIComponent(tools.AES(config.url, \\\\\\\"dvyYRQlnPRCMdQSe\\\\\\\", iv));\\\\n            }\\\\n            return config.url;\\\\n        } catch (e) {\\\\n            return '';\\\\n        }\\\\n    },\\\\n    LLQ: function(jxurl) {\\\\n        try {\\\\n            var api = jxurl.split('?url=')[0] + \\\\\\\"api.php\\\\\\\";\\\\n            var b64id = base64Encode(jxurl.split('url=')[1]);\\\\n            var parseid = tools.caesarCipher(b64id, -1);\\\\n            var json = JSON.parse(request(api, {\\\\n                headers: {\\\\n                    'Referer': jxurl\\\\n                },\\\\n                method: 'POST',\\\\n                body: 'url=' + parseid\\\\n            }));\\\\n            url = (json.code == 200 ? base64Decode(tools.caesarCipher(json.url, -1)) : '');\\\\n            return url;\\\\n        } catch (e) {\\\\n            return '';\\\\n        }\\\\n    },\\\\n    PanGu: function(vipUrl, data) {\\\\n        /*var ref = 'https://www.pangujiexi.com/';\\\\n        var parse = 'https://panguapi.ntryjd.net/jiexi/?url=' + vipUrl;\\\\n        var api = 'https://panguapi.ntryjd.net/jiexi/api.php';\\\\n        */\\\\n        //var ref = 'https://xmystv.com/';\\\\n        //var parse = 'https://www.99kpw.com/pangu/index.php?url=' + tailUrl;\\\\n        //var api = 'https://www.99kpw.com/pangu/api.php';\\\\n        var parse = \\\\\\\"https://www.pangujiexi.com/pangu/?url=\\\\\\\" + vipUrl;\\\\n        var api = \\\\\\\"https://panguapi.ntryjd.net/pangu2021/api.php\\\\\\\";\\\\n        if (data) {\\\\n            ref = data[0];\\\\n            parse = data[1];\\\\n            api = data[2];\\\\n        }\\\\n        var Time = (Math.floor(new Date().getTime() / 1000) * 1).toString();\\\\n        var json = request(api, {\\\\n            headers: {\\\\n                \\\\\\\"Referer\\\\\\\": parse\\\\n            },\\\\n            body: \\\\\\\"url=\\\\\\\" + vipUrl + \\\\\\\"&referer=\\\\\\\" + base64Encode(parse) + \\\\\\\"&ref=1&time=\\\\\\\" + Time + \\\\\\\"&type=&other=\\\\\\\" + base64Encode(vipUrl) + \\\\\\\"&ios=0\\\\\\\",\\\\n            method: \\\\\\\"POST\\\\\\\"\\\\n        });\\\\n        var url = json[0] == \\\\\\\"{\\\\\\\" ? JSON.parse(json).url : \\\\\\\"\\\\\\\";\\\\n        return url;\\\\n    },\\\\n    yun1717: function(vipUrl) {\\\\n        var isyk = vipUrl.indexOf('youku');\\\\n        var ref = \\\\\\\"https://www.1717yun.com/jx/ty.php?url=\\\\\\\" + vipUrl;\\\\n        var parse = \\\\\\\"https://1717yun.com.zh188.net/0828/?url=\\\\\\\" + vipUrl;\\\\n        var api = \\\\\\\"https://1717yun.com.zh188.net/1004/..index..php\\\\\\\";\\\\n        return isyk == -1 ? this.PanGu(vipUrl, [ref, parse, api]) : this.PanGu(vipUrl, [ref + ',vip:', parse + ',vip:', api]);\\\\n    },\\\\n    FuXing: function(vipUrl) {\\\\n        try {\\\\n            //if(vipUrl.indexOf('v.youku')!=-1){\\\\n            //    vipUrl = (JSON.parse(request(vipUrl, {redirect:false, withHeaders:true})).headers.location + '').replace(/\\\\\\\\?.*/,'');\\\\n            //}\\\\n            var ref = 'https://jx.xuetuiguang.cn/jiexi/?url=' + vipUrl;\\\\n            var parse = ref;\\\\n            var api = 'https://jx.xuetuiguang.cn/jiexi/apiu_fx.php';\\\\n            return this.PanGu(vipUrl, [ref, parse, api]);\\\\n        } catch (e) {\\\\n            return '';\\\\n        }\\\\n    },\\\\n};\\\\n\\\\nObject.assign(ParseS, originalParseS, MyParseS);\\\\n//覆盖顺序，第三个覆盖第二个然后覆盖第一个\\\\n\\\\n\\\\nfunction aytmParse(vipUrl) {\\\\n    this.request = function(param0, param1, param2) {\\\\n        param1 = param1 == undefined ? {} : param1;\\\\n        param1.timeout = 2500;\\\\n        param2 = MY_RULE;\\\\n        var retStr = method_request.invoke(javaContext, param0, param1, param2);\\\\n        return retStr == null ? retStr : retStr + \\\\\\\"\\\\\\\";\\\\n    };\\\\n    this.fetch = function(param0, param1, param2) {\\\\n        param1 = param1 == undefined ? {} : param1;\\\\n        param1.headers = param1.headers == undefined ? {} : param1.headers;\\\\n        param1.headers['User-Agent'] = PC_UA;\\\\n        param1.timeout = 2500;\\\\n        param2 = MY_RULE;\\\\n        var retStr = method_fetch.invoke(javaContext, param0, param1, param2);\\\\n        return retStr == null ? retStr : retStr + \\\\\\\"\\\\\\\";\\\\n    };\\\\n    var host = vipUrl.match(/\\\\\\\\.(.*?)\\\\\\\\//);\\\\n    host = host == null ? null : host[1];\\\\n    var noUrl = \\\\\\\"toast://接收到的链接为: \\\\\\\";\\\\n    switch (mySet.qju) {\\\\n        case \\\\\\\"\\\\\\\":\\\\n        case \\\\\\\"默认\\\\\\\":\\\\n            switch (host) {\\\\n                case \\\\\\\"qq.com\\\\\\\":\\\\n                    str = mySet.tx;\\\\n                    break;\\\\n                case \\\\\\\"iqiyi.com\\\\\\\":\\\\n                    str = mySet.qy;\\\\n                    break;\\\\n                case \\\\\\\"youku.com\\\\\\\":\\\\n                    str = mySet.yk;\\\\n                    break;\\\\n                case \\\\\\\"mgtv.com\\\\\\\":\\\\n                    str = mySet.mg;\\\\n                    break;\\\\n                case \\\\\\\"bilibili.com\\\\\\\":\\\\n                    str = mySet.bl;\\\\n                    break;\\\\n                default:\\\\n                    str = host == null ? noUrl : mySet.oth;\\\\n                    break;\\\\n            }\\\\n            break;\\\\n        default:\\\\n            str = host == null ? noUrl : mySet.qju;\\\\n            break;\\\\n    }\\\\n    let myChoice = str.split(',');\\\\n    let len = myChoice.length;\\\\n    for (let i = 0; i < len; i++) {\\\\n        let name = myChoice[i];\\\\n        if (typeof ParseS[name] == 'function') {\\\\n            let url = ParseS[name](vipUrl);\\\\n            if (i != len - 1 && !/m3u8|mp4|http/.test(url)) {\\\\n                continue;\\\\n            }\\\\n            if (url[0] == '/') {\\\\n                url = 'https:' + url\\\\n            }\\\\n            if (url.indexOf('=http') != -1) {\\\\n                url = url.indexOf('&url=') > -1 ? url : 'http' + decodeURIComponent(url.split('=http')[1]);\\\\n            }\\\\n            /*if(url.match(/mgtv.com/g)=='mgtv.com'){\\\\n                url = url + ';{Referer@https://www.mgtv.com}';\\\\n            } else */\\\\n            if (url.indexOf('.flv') != -1) {\\\\n                url = url + ';{User-Agent@app&&Referer@' + vipUrl + '}';\\\\n            }\\\\n            if (url == '' || url == vipUrl) {\\\\n                return vipUrl;\\\\n            } else {\\\\n                return url + '#isVideo=true#';\\\\n            }\\\\n        } else if (typeof ParseS[name] == 'string') {\\\\n            return ParseS.defaultParse(ParseS[name] + vipUrl);\\\\n        } else {\\\\n            return name.substr(0, 4) == \\\\\\\"http\\\\\\\" || host == null ? name + vipUrl : \\\\\\\"toast://\\\\\\\" + name + \\\\\\\" 不是直链也不是免嗅\\\\\\\";\\\\n        }\\\\n    }\\\\n};\\\\n\\\\nvar playParse = {\\\\n    player_xx: function(jurl, Label) {\\\\n        return $(jurl).lazyRule((k) => {\\\\n            var jsUrl = JSON.parse(fetch(getVar('oldConfig'))).cj;\\\\n            var Label = k;\\\\n            var fa = ['letv', 'pptv', 'qq', 'youku', 'qiyi', 'iqiyi', 'mgtv', 'bilibili', 'sohu', 'migu', 'm1905', 'vip'];\\\\n            var html = parseDom(request(input), Label);\\\\n            eval(html.replace(/player_.*?={/, 'pdata={'));\\\\n            eval(fetch(jsUrl));\\\\n            if (pdata.url.substr(0, 8).match(/JT..JT../)) {\\\\n                pdata.url = base64Decode(pdata.url);\\\\n            }\\\\n            if (pdata.url.substr(0, 8).match(/%..%../)) {\\\\n                pdata.url = unescape(pdata.url);\\\\n            }\\\\n            if (fa.includes(pdata.from) == true) {\\\\n                return aytmParse(pdata.url);\\\\n            } else {\\\\n                return pdata.url + '#isVideo=true#';\\\\n            }\\\\n        }, Label)\\\\n    }\\\\n};\\\\n\\\\nfunction setParse() {\\\\n    $.require(\\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ\\\\\\\").setParse();\\\\n}\\\\n\\\\nfunction mzPopup() {\\\\n    if (getVar(\\\\\\\"ijk-tx\\\\\\\", \\\\\\\"\\\\\\\") == \\\\\\\"1\\\\\\\") {\\\\n        setItem(\\\\\\\"tixing\\\\\\\", \\\\\\\"1\\\\\\\")\\\\n        clearVar(\\\\\\\"ijk-tx\\\\\\\")\\\\n    }\\\\n    return confirm({\\\\n        title: '免责声明',\\\\n        content: '本程序不提供视频解析服务\\\\\\\\n所有内容均从用户分享中收集\\\\\\\\n仅供测试和学习交流\\\\\\\\n\\\\\\\\n确定即认可，不再提醒',\\\\n        confirm: $.toString(() => {\\\\n            putVar(\\\\\\\"ijk-tx\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage(false);\\\\n            return \\\\\\\"toast://您点击了确认\\\\\\\"\\\\n        })\\\\n    })\\\\n}\\\\nif (getItem(\\\\\\\"tixing\\\\\\\", \\\\\\\"\\\\\\\") == \\\\\\\"\\\\\\\") {\\\\n    mzPopup();\\\\n}\\\\n\\\\n//===========解析代码结束===========\\\\n\\\\nfunction saveButton(content) {\\\\n    var data = content.split('★★★');\\\\n    if (data.length == 2) {\\\\n        var _dt = parsePaste(data[0]);\\\\n        content = _dt.substr(0, 6) != 'error:' ? _dt : '';\\\\n    }\\\\n    data = content.split('★');\\\\n    var type = data[0];\\\\n    var arrList = [];\\\\n    var objCode = {};\\\\n    if (data.length > 2 && data[0] != '直链') {\\\\n        var objKey = data[1];\\\\n        var objValue = data[2];\\\\n        if (type == 'MyParseS') {\\\\n            objValue = base64Decode(objValue);\\\\n        }\\\\n        if (objValue.split('function').length > 1) {\\\\n            eval('objValue=' + objValue);\\\\n        }\\\\n        arrList.splice(0, 0, objKey);\\\\n        objCode[objKey] = objValue;\\\\n\\\\n    } else if (type == '直链') {\\\\n        arrList = data;\\\\n        arrList.splice(0, 1);\\\\n    } else {\\\\n        arrList = null;\\\\n    }\\\\n    if (arrList != null) {\\\\n        var parseRoute = getVar('parseRoute');\\\\n        eval('var json =' + fetch(parseRoute));\\\\n        arrList = arrList.concat(json.title);\\\\n        json.title = Array.from(new Set(arrList));\\\\n        Object.assign(json.codes, objCode);\\\\n        if (type == '测试') {\\\\n            eval('var config =' + fetch(getVar('oldConfig')));\\\\n            eval(fetch(config.cj));\\\\n            if (typeof ParseS[data[1]] == \\\\\\\"function\\\\\\\") {\\\\n                return ParseS[data[1]](data[2]);\\\\n            } else {\\\\n                return ParseS.defaultParse(ParseS[data[1]] + data[2]);\\\\n            }\\\\n        } else {\\\\n            writeFile(parseRoute, $.stringify(json));\\\\n            return \\\\\\\"toast://已保存内容\\\\\\\";\\\\n        }\\\\n    } else {\\\\n        return \\\\\\\"toast://无法识别这个内容呢\\\\\\\"\\\\n    }\\\\n}\\\\n\\\\nif (getItem('updateDate') != updateDate) {\\\\n    var functionCode = saveButton + '';\\\\n    writeFile('hiker://files/cache/plscParse.html', fetch(_mySet.ckLink + 'plscParse.html'));\\\\n    setItem('myFunction', functionCode);\\\\n    setItem('updateDate', updateDate);\\\\n}\\\\nvar bjItem = {\\\\n    hfPlugin: function(parseRoute) {\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\n            if (fileExist(k) == true) {\\\\n                var cjcache = getVar('cjCache');\\\\n                eval('var json =' + fetch(k));\\\\n                json.settings.cj = cjcache;\\\\n                writeFile(k, $.stringify(json));\\\\n                var oldRoute = getVar('oldConfig');\\\\n                var oldConfig = json.settings;\\\\n                oldConfig.cj = cjcache;\\\\n                writeFile(oldRoute, $.stringify(oldConfig));\\\\n                refreshPage(false);\\\\n                return 'toast://恢复成功';\\\\n            } else {\\\\n                return 'toast://需要先拉取列表'\\\\n            }\\\\n        }, parseRoute)\\\\n    },\\\\n    pullCode: function(k) {\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\n            var pullMode = k[0];\\\\n            var parseRoute = k[1];\\\\n            var parseFile = fetch(parseRoute);\\\\n            if (!parseFile) {\\\\n                var settings = fetch(getVar('oldConfig'));\\\\n                settings = settings == '' ? {} : JSON.parse(settings);\\\\n                var json = {};\\\\n                json.settings = settings;\\\\n                json.title = [];\\\\n                json.codes = {};\\\\n            } else {\\\\n                eval('var json =' + parseFile);\\\\n            }\\\\n            var tishi = 'toast://抱歉!无法识别这个内容呢╯﹏╰';\\\\n            var cjLink = getVar('pluginLink');\\\\n            var Contents = cjLink == 'Q神' ? pullMode + '★' + fetch('hiker://files/jiexi/jiexi.txt') : cjLink;\\\\n            try {\\\\n                var yPaste = parsePaste(Contents).split('@base64://');\\\\n                if (yPaste.length == 2) {\\\\n                    Contents = base64Decode(yPaste[1]);\\\\n                } else if (cjLink.substr(0, 5) == 'hiker' || cjLink.substr(0, 4) == 'http') {\\\\n                    Contents = fetch(cjLink);\\\\n                }\\\\n                var jcKL = Contents.split('★');\\\\n                var isKL = jcKL[0];\\\\n                if (jcKL.length == 2) {\\\\n                    isKL = isKL == '' ? pullMode : isKL;\\\\n                    Contents = jcKL[1].split('\\\\\\\\n');\\\\n                    if (Contents[0] == '') {\\\\n                        Contents.splice(0, 1)\\\\n                    }\\\\n                }\\\\n                var addTitle = [],\\\\n                    addCode = {};\\\\n                if (('' + Contents[0]).split('&&').length == 2) {\\\\n                    for (let i = 0; i < Contents.length; i++) {\\\\n                        let arr = Contents[i].split('&&');\\\\n                        let title = arr[0] + '(x5)',\\\\n                            url = arr[1];\\\\n                        if (pullMode == '免嗅') {\\\\n                            addTitle.push(title)\\\\n                            addCode[title] = url;\\\\n                        } else {\\\\n                            addTitle.push(url);\\\\n                        }\\\\n                    }\\\\n                } else if (isKL == '直链' && pullMode == '直链') {\\\\n                    addTitle = Contents;\\\\n                }\\\\n                if (addTitle[0] == undefined) {\\\\n                    eval(Contents);\\\\n                    if (typeof originalParseS == 'object') {\\\\n                        addCode = originalParseS;\\\\n                    } else {\\\\n                        addCode = ParseS;\\\\n                    }\\\\n                    var scObject = [\\\\\\\"parseLc\\\\\\\", \\\\\\\"gparse\\\\\\\", \\\\\\\"nparse\\\\\\\", \\\\\\\"Mao全网\\\\\\\", \\\\\\\"ds973\\\\\\\", \\\\\\\"parwix\\\\\\\", \\\\\\\"OJBK\\\\\\\", \\\\\\\"91解析\\\\\\\", \\\\\\\"人人迷\\\\\\\", \\\\\\\"江湖\\\\\\\", \\\\\\\"久播\\\\\\\", \\\\\\\"骚火\\\\\\\", \\\\\\\"LK解析\\\\\\\", \\\\\\\"小狼云\\\\\\\", \\\\\\\"九八看\\\\\\\", \\\\\\\"思云解析\\\\\\\", \\\\\\\"CityIP\\\\\\\", \\\\\\\"pcUA\\\\\\\", \\\\\\\"cacheM3u8\\\\\\\", \\\\\\\"defaultParse\\\\\\\", \\\\\\\"maoss\\\\\\\", \\\\\\\"LLQ\\\\\\\"];\\\\n                    for (var i = 0; i < scObject.length; i++) {\\\\n                        delete addCode[scObject[i]];\\\\n                    }\\\\n                    if (typeof parseTitle == 'object') {\\\\n                        addTitle = parseTitle;\\\\n                    } else {\\\\n                        addTitle = Object.keys(addCode);\\\\n                    }\\\\n                }\\\\n                var oldSL = json.title.length;\\\\n                var newTitle = json.title.concat(addTitle);\\\\n                json.title = Array.from(new Set(newTitle));\\\\n                if (pullMode == '免嗅') {\\\\n                    Object.assign(json.codes, addCode);\\\\n                }\\\\n                var newSL = json.title.length - oldSL;\\\\n                var coverSL = newTitle.length - json.title.length;\\\\n                coverSL = coverSL == 0 ? '' : ', 覆盖了' + coverSL + '个';\\\\n                //var newFile = tools.toJSON(json);//自定义stringify函数，带有转义字符\\\\n                var newFile = $.stringify(json); //JSON.parse会报错\\\\n                writeFile(parseRoute, newFile);\\\\n                refreshPage(false);\\\\n                return 'toast://总共导入了' + newSL + '个' + pullMode + '解析' + coverSL;\\\\n            } catch (e) {\\\\n                return tishi;\\\\n            }\\\\n        }, [k, _mySet.parseRoute])\\\\n    },\\\\n    pullScript: function(cj, x5) {\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\n            var cjFrom = 'hiker://page/Parse_Dn.js?rule=MyFieldᴰⁿ';\\\\n            var x5From = 'hiker://page/Parse_Dn.html?rule=MyFieldᴰⁿ';\\\\n            try {\\\\n                var cjFile = JSON.parse(fetch(cjFrom)).rule;\\\\n                cjFile = cjFile.split('解析代码结束')[0];\\\\n                var x5File = JSON.parse(fetch(x5From)).rule;\\\\n                writeFile(k[0], cjFile);\\\\n                writeFile(k[1], x5File);\\\\n                clearVar('jxOldV');\\\\n                refreshPage(false);\\\\n                return 'toast://更新成功';\\\\n            } catch (e) {\\\\n                return 'toast://未成功获取内容';\\\\n            }\\\\n        }, [cj, x5])\\\\n    },\\\\n    xlSelect: function(bianji, lbLength) {\\\\n        return \\\\\\\"select://\\\\\\\" + JSON.stringify({\\\\n            options: ['‘‘’’<span style=\\\\\\\"color:red\\\\\\\" title=\\\\\\\"删除||' + bianji + '\\\\\\\">删 除', '‘‘’’<span style=\\\\\\\"color:#F57474\\\\\\\" title=\\\\\\\"隐藏||' + bianji + '\\\\\\\">隐 藏', '‘‘’’<span style=\\\\\\\"color:#FF8000\\\\\\\" title=\\\\\\\"修改||' + bianji + '\\\\\\\">修 改', '‘‘’’<span style=\\\\\\\"color:#098AC1\\\\\\\" title=\\\\\\\"置顶||' + bianji + '0' + '\\\\\\\">置 顶', '‘‘’’<span style=\\\\\\\"color:#098AC1\\\\\\\" title=\\\\\\\"移动||' + bianji + '\\\\\\\">移 动', '‘‘’’<span style=\\\\\\\"color:#098AC1\\\\\\\" title=\\\\\\\"置底||' + bianji + lbLength + '\\\\\\\">置 底', '‘‘’’<span style=\\\\\\\"color:#04B431\\\\\\\" title=\\\\\\\"分享||' + bianji + '\\\\\\\">地板分享', '‘‘’’<span style=\\\\\\\"color:#04B431\\\\\\\" title=\\\\\\\"云分享||' + bianji + '\\\\\\\">云板分享'],\\\\n            col: '2',\\\\n            js: $.toString(() => {\\\\n                var parseRoute = getVar('parseRoute');\\\\n                eval('var json =' + fetch(parseRoute));\\\\n                var newInput = parseDomForHtml(input, 'span&&title').split('||');\\\\n                var type = newInput[0];\\\\n                var name = newInput[1];\\\\n                var num = newInput[2];\\\\n                var num2 = newInput[3];\\\\n                switch (type) {\\\\n                    case \\\\\\\"删除\\\\\\\":\\\\n                        return $(\\\\\\\"即将删除: \\\\\\\" + name).confirm((k) => {\\\\n                            var name = k[0];\\\\n                            var num = k[1];\\\\n                            var parseRoute = getVar('parseRoute');\\\\n                            eval('var json =' + fetch(parseRoute));\\\\n                            if (json.codes.hasOwnProperty(name)) {\\\\n                                delete json.codes[name];\\\\n                            }\\\\n                            json.title.splice(num, 1);\\\\n                            writeFile(parseRoute, $.stringify(json));\\\\n                            refreshPage(false);\\\\n                            return \\\\\\\"toast://已将〖\\\\\\\" + name + \\\\\\\"〗删除\\\\\\\";\\\\n                        }, [name, num]);\\\\n                        break;\\\\n                    case \\\\\\\"隐藏\\\\\\\":\\\\n                        return $(\\\\\\\"hiker://empty#noLoading#\\\\\\\").lazyRule((k) => {\\\\n                            var name = k[0];\\\\n                            var num = k[1];\\\\n                            var parseRoute = getVar('parseRoute');\\\\n                            eval('var json =' + fetch(parseRoute));\\\\n                            if (json.codes.hasOwnProperty(name)) {\\\\n                                json.title.splice(num, 1);\\\\n                                writeFile(parseRoute, $.stringify(json));\\\\n                                refreshPage(false);\\\\n                                return \\\\\\\"toast://已将〖\\\\\\\" + name + \\\\\\\"〗隐藏\\\\\\\";\\\\n                            } else {\\\\n                                return \\\\\\\"toast://可能是个网址, 您可选择删除\\\\\\\";\\\\n                            }\\\\n                        }, [name, num]);\\\\n                        break;\\\\n                    case \\\\\\\"修改\\\\\\\":\\\\n                        //if (json.codes[name]) {\\\\n                        var nCode = name;\\\\n                        var nName = \\\\\\\"这是名称\\\\\\\";\\\\n                        if (json.codes[name]) {\\\\n                            nCode = json.codes[name].toString();\\\\n                            nName = name;\\\\n                        }\\\\n                        return $(\\\\\\\"hiker://empty#noRecordHistory#\\\\\\\").rule((k) => {\\\\n                            var d = [];\\\\n                            eval(getItem('myFunction'));\\\\n                            var name = k[0];\\\\n                            var code = k[1];\\\\n                            d.push({\\\\n                                title: '保 存',\\\\n                                url: saveButton + \\\\\\\"saveButton(getVar('input_edit'));back();\\\\\\\",\\\\n                                col_type: \\\\\\\"input\\\\\\\",\\\\n                                desc: \\\\\\\"建议按默认的代码格式修改哦\\\\\\\",\\\\n                                extra: {\\\\n                                    onChange: \\\\\\\"putVar('input_edit', input)\\\\\\\",\\\\n                                    type: \\\\\\\"textarea\\\\\\\",\\\\n                                    height: \\\\\\\"-1\\\\\\\",\\\\n                                    titleVisible: false,\\\\n                                    defaultValue: '修改★' + name + '★' + code,\\\\n                                }\\\\n                            });\\\\n                            d.push({\\\\n                                title: '‘‘’’<small><span style=\\\\\\\"color:#6EB897\\\\\\\">格式为：操作类型★标题★function(){自定义内容}<br>请勿填入其他格式',\\\\n                                url: $('#noLoading#').lazyRule((saveButton) => {\\\\n                                    saveButton(getVar('input_edit'));\\\\n                                    back();\\\\n                                    return 'toast://已保存修改';\\\\n                                }, saveButton),\\\\n                                desc: '‘‘’’<big><big><span style=\\\\\\\"color:#298A08\\\\\\\">保 存',\\\\n                                col_type: 'text_center_1'\\\\n                            });\\\\n                            setResult(d);\\\\n                        }, [nName, nCode]) //[name, json.codes[name].toString()])\\\\n                        /*} else {\\\\n                            return \\\\\\\"toast://只有网址或者标题, 不支持修改\\\\\\\"\\\\n                        }*/\\\\n                        break;\\\\n                    case \\\\\\\"置顶\\\\\\\":\\\\n                    case \\\\\\\"置底\\\\\\\":\\\\n                        var item = json.title.splice(num, 1);\\\\n                        json.title.splice(num2, 0, item[0]);\\\\n                        writeFile(parseRoute, $.stringify(json));\\\\n                        refreshPage(false);\\\\n                        break;\\\\n                    case \\\\\\\"移动\\\\\\\":\\\\n                        return $('hiker://empty#noLoading#').lazyRule((k) => {\\\\n                            putVar('bianji', '移动#' + k);\\\\n                            refreshPage(false);\\\\n                            return input;\\\\n                        }, num);\\\\n                        break;\\\\n                    case \\\\\\\"分享\\\\\\\":\\\\n                    case \\\\\\\"云分享\\\\\\\":\\\\n                        if (json.codes[name]) {\\\\n                            var parseText = typeof json.codes[name] == 'function' ? $.stringify(json.codes[name]) : json.codes[name];\\\\n                            parseText = 'MyParseS★' + name + '★' + base64Encode(parseText);\\\\n                        } else {\\\\n                            var parseText = '直链★' + json.title[num];\\\\n                        }\\\\n                        if (type == '云分享' && parseText.substr(0, 8) == 'MyParseS') {\\\\n                            parseText = sharePaste(parseText);\\\\n                            return parseText.substr(0, 6) != 'error:' ? 'copy://' + parseText + '\\\\\\\\n★★★\\\\\\\\n' + 'MyParseS：' + name : 'toast://分享失败!!云剪贴板可能挂了';\\\\n                        } else {\\\\n                            return 'copy://' + parseText;\\\\n                        }\\\\n                    default:\\\\n                        return 'toast://暂不支持';\\\\n                        break;\\\\n                } //switch的\\\\n            }) //String的\\\\n        }) //stringify的\\\\n    },\\\\n    xjParse: function() {\\\\n        return $(\\\\\\\"hiker://empty#noRecordHistory#\\\\\\\").rule(() => {\\\\n            var d = [];\\\\n            eval(getItem('myFunction'));\\\\n            d.push({\\\\n                title: '保 存',\\\\n                url: saveButton + \\\\\\\"saveButton(input);back();clearVar('input_add')\\\\\\\",\\\\n                col_type: \\\\\\\"input\\\\\\\",\\\\n                desc: \\\\\\\"输入正确格式内容\\\\\\\",\\\\n                extra: {\\\\n                    onChange: 'putVar(\\\\\\\"input_add\\\\\\\", input)',\\\\n                    type: \\\\\\\"textarea\\\\\\\",\\\\n                    height: \\\\\\\"-1\\\\\\\",\\\\n                    titleVisible: false,\\\\n                    defaultValue: getVar('input_add'),\\\\n                }\\\\n            });\\\\n            d.push({\\\\n                title: '‘‘’’<small><span style=\\\\\\\"color:#6EB897\\\\\\\">按描述诉格式输入, 请勿填入其他格式<br>本地口令: 操作类型★名称★代码<br>云口令: 链接★★★名称; 纯网址: 直链★url1★url2',\\\\n                desc: '‘‘’’<big><big><span style=\\\\\\\"color:#298A08\\\\\\\">保 存',\\\\n                url: $('noLoading').lazyRule((saveButton) => {\\\\n                    return saveButton(getVar('input_add'));\\\\n                }, saveButton),\\\\n                col_type: 'text_center_1'\\\\n            });\\\\n            setResult(d);\\\\n        })\\\\n    },\\\\n    ydParse: function(BJmode, i) {\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\n            var A = k[0].split('#')[1];\\\\n            var B = k[1];\\\\n            var parseRoute = getVar('parseRoute');\\\\n            eval('var json =' + fetch(parseRoute));\\\\n            var item = json.title.splice(A, 1); // 1: 标记开始位置，2: 删除到哪个位置\\\\n            json.title.splice(B, 0, item[0]); // 1: 同上，2: 0表示不删除，3: 添加对象\\\\n            writeFile(parseRoute, $.stringify(json));\\\\n            clearVar('bianji');\\\\n            refreshPage(false);\\\\n            return 'hiker://empty';\\\\n        }, [BJmode, i])\\\\n    },\\\\n    plscParse: function() {\\\\n        return $('hiker://empty#noRecordHistory#').rule(() => {\\\\n            var d = [];\\\\n            d.push({\\\\n                title: '批量删除解析',\\\\n                desc: 'auto&&float',\\\\n                url: 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/plscParse.html',\\\\n                col_type: 'x5_webview_single'\\\\n            })\\\\n            setResult(d);\\\\n        })\\\\n    }\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"调用路由\\\",\\\"path\\\":\\\"Route\\\",\\\"rule\\\":\\\"js:\\\\nconst d = [];\\\\nconst data = {};\\\\n\\\\nif (!getVar('jxOldV')) {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/Parse_Dn.js\\\\\\\")).rule);\\\\n}\\\\n\\\\ndata.oldConfig = \\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\";\\\\ndata.cjRoute = \\\\\\\"hiker://files/cache/Parse_Dn.js\\\\\\\";\\\\ndata.x5Route = \\\\\\\"file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/Parse_Dn.html\\\\\\\";\\\\n\\\\ndata.jxLazy = \\\\\\\"eval('var config =' + fetch('\\\\\\\" + data.oldConfig + \\\\\\\"'));eval(fetch(config.cj));aytmParse(input)\\\\\\\";\\\\n\\\\ndata.szParse = \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noHistory#\\\\\\\";\\\\n\\\\ndata.addLanJie = function(d) {\\\\n    let lanjie = ['baidu.*.png', '.jpg', 'baidu.', 'cnzz.', 'dykj\\\\\\\\.'];\\\\n    eval('var ylanjie =' + fetch('hiker://files/cache/x5ParseLanJie.txt'));\\\\n    lanjie = typeof(ylanjie) == 'object' ? ylanjie : lanjie;\\\\n    for (let i = 0; i < d.length; i++) {\\\\n        let durl = d[i].url;\\\\n        if (durl != undefined && /lazyRule/.test(durl) && /aytmParse|defaultParse/.test(durl)) {\\\\n            d[i].extra = d[i].extra == undefined ? {} : d[i].extra;\\\\n            d[i].extra.blockRules = lanjie;\\\\n        }\\\\n    }\\\\n    setResult(d);\\\\n}\\\\ndata.x5Parse = function(Url) {\\\\n    return $(Url).lazyRule(() => {\\\\n        eval('var ParseS =' + fetch('hiker://files/rules/DuanNian/MyParse.json'));\\\\n        return ParseS.codes.defaultParse(input);\\\\n    })\\\\n}\\\\ndata.setParse = function() {\\\\n    var d = [];\\\\n    d.push({\\\\n        desc: 'auto',\\\\n        url: this.x5Route,\\\\n        col_type: 'x5_webview_single'\\\\n    });\\\\n    var jxNewV = getVar('jxNewV', ''),\\\\n        jxOldV = getVar('jxOldV');\\\\n    var versionTips = jxNewV == '' ? '‘‘' : '‘‘' + jxNewV;\\\\n    var pics = [\\\\n        'https://tva1.sinaimg.cn/large/9bd9b167gy1fwri56wjhqj21hc0u0arr.jpg',\\\\n        'https://cdn.seovx.com/img/seovx-20-10%20(92).jpg',\\\\n        'https://cdn.seovx.com/img/mom2018%20(207).jpg',\\\\n        'https://tva4.sinaimg.cn/large/9bd9b167gy1fwrh5xoltdj21hc0u0tax.jpg',\\\\n        'https://tva1.sinaimg.cn/large/005BYqpggy1fwreyu4nl6j31hc0u0ahr.jpg',\\\\n        'https://s3.bmp.ovh/imgs/2021/10/d7e60b990742093d.jpeg',\\\\n        'https://s3.bmp.ovh/imgs/2021/10/91ad6d6538bf8689.jpg',\\\\n        'https://tva1.sinaimg.cn/large/005BYqpggy1fwresl5pmlj31hc0xcwka.jpg',\\\\n        'https://tva3.sinaimg.cn/large/005BYqpggy1fwrgjdk74oj31hc0u0dqn.jpg',\\\\n        'https://cdn.seovx.com/img/mom2018%20(320).jpg',\\\\n        'https://cdn.seovx.com/img/mom2018%20(803).jpg'\\\\n    ];\\\\n    d.push({\\\\n        img: pics[Math.floor(Math.random() * 10)],\\\\n        title: versionTips + '’’<small><span style=\\\\\\\"color:#6EB897\\\\\\\"><br>　　点击上方头像进入编辑<br>点此进入论坛帖子列表',\\\\n        desc: '当前版本: ' + jxOldV,\\\\n        url: 'https://haikuoshijie.cn/user/1958',\\\\n        col_type: 'movie_1'\\\\n    });\\\\n    setResult(d);\\\\n}\\\\n\\\\nswitch (getParam(\\\\\\\"type\\\\\\\")) {\\\\n    case \\\\\\\"设置\\\\\\\":\\\\n        data.setParse();\\\\n        break;\\\\n    case \\\\\\\"编辑\\\\\\\":\\\\n        $.require(\\\\\\\"hiker://page/jxItem?rule=MyFieldᴰⁿ\\\\\\\").jxList();\\\\n        setResult(d);\\\\n        break;\\\\n    default:\\\\n        $.exports = data;\\\\n        break;\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"解析项主界面\\\",\\\"path\\\":\\\"jxItem\\\",\\\"rule\\\":\\\"var _0xod2='jsjiami.com.v6',_0x4690=[_0xod2,'fFLDs8O1Ig==','VwzCn8K/wo4=','w5DCqMOvJcK3','w7U5CsOV','w7TCtcOvN8KT','w7bDo8OuUiA=','Rm1Ow65u','MExUw6TCpA==','5a+W5Ya155iU6ZO5','DcK4KcKJw5wrDcOl','5a6B5Yao5YSI5ZSg','w4zCvMOGMsKgw7Y=','w4QEw4Qwfg==','FEDDnRk+','V8Kxf0ow','KzDDp8O+w5w=','DMKcwr/ChsKW','HMKXARXCpQ==','w609w78Gfw==','wrR/BcKOKDrDvR9+wp8vaFYCfsKMwpszBRTCoWrDsGExdsKCw6VWwpQn','WsKff8Kxwp4=','w6bCrMK0Gw==','Vyp1w4pJ','w7IGCsONHQ==','YMKrZHQy','TMKzB8Odw67Ck8KYOQ==','w43DjxZoM2peMcKEEg==','HFLDuTAJ','SsKAXUsa','TCTCg8KgwrM=','WsKhwqd3woo=','A1ZMw5fCtg==','wqHDkRrDn2nDtV/DnQ==','czNew4RNbBjDmA==','GHZqw6LCh8KUJghR','w4vDpU0q','IFM6wqQi','IcKRbQ==','by9cw40=','woZJwojChcKb','w5fDoC95Ig==','VDjCncKqwp8=','e8KbY8KAwpTDjF/Dt20f','w5fDuVAn','wqHDkQXDmw==','w43Dj8OpZz99w60Xw5fCqw==','N8KJYsKJw6DDssKq','Zixzw4xg','wq0Tw6LCjcK4CDYXwpjCqsOpQFI=','wrFQPRw=','4oKl4oKi4oKc4oCSUHzDthnCmeetvueQveikheadgw==','w5LCk8KXGxk=','MsOQw5jCqVo=','wqQDw5Yyw47CkwHCr1rCo3J8wqA=','EcOEw6XCo3k=','wpRofBnClGhm','U8KteE4=','KcOnw7jCiUBAw77CjMK9K2Bdw6Zvw53Dsx1fwo8gIsODw4TDgMOpw4HDmQfCiGnDhQFvX8Ky','U8KpTFY2','VMKgJMOZ','w63DlDsQw4M=','EjbDk8O7w4kFwrTCicOew5Q=','b8OHbsKEwqjDhlY=','GMKnBMKBw7E=','C8KIwqBADA==','w6zDg8OdwrNrw7TChiM=','wr3Dl8Kmw41cw4x6wpAfHg==','wpZASBTChA==','wr7DiMKGIsOW','Ww5pw7TDqg==','cXzCpm3Crw==','Z8KDSsKVwqg=','wo55XR4=','4oKs4oKB4oO84oGddlsdwqEd5pKK5Lyo5o2u5b++','w7hqwpjDjSg=','w5cjFcOJBw==','MCXDpcO6w6o=','wp55HsKqbg==','K8O8w6XClw==','QVJOw7Y=','4oGM4oCi4oGX4oORe2TDpBpxWMO/w7XCi8OWw5fDssKcO8OcwqPCmsOMGcOfVCXDpsO5w6Z/w5RK','T8KZbsKEwro=','AWXDvCk0Yz3Cpg==','aQTCgcKDwpE=','w6AfOMO7Fg==','w4/DtUY2AMO+V1HDtVbChzPCqg==','w6/CvcKqERg2w5Y=','w5DCuMOaJsKx','FcKkLsKAw61+RsKvRUobYWvCgBjCgmlfIBXCnlXDjHI=','ZMONAiLCisKMwr3CnCIMUcOsw4FpwpE=','CMOFw4XCvEQ=','QE1fw5Np','HmB0WsO3','w6HCrS99wq4=','asKOQmMi','J2x6w6rChA==','w6rCgS5OwpM=','w6kKwq7ChcOVF2IFw5nCs8KoY1U=','4oKC4oKU4oGP4oO5wqfDkB3Cp8KaSsOgwqHCsjHCuMKWw6sbwrTCiwjCtUPCgWF3TlgmwopNaSrDmAwYw6zmlrfCt+W4mMKu6KSJMeadhg==','FibDh8Ojw4UFwqPCjsOaw4VIw7fDvg==','w6bDjMOswrF0w7o=','56S25Yiew7c=','4oCB4oCP4oO34oC7w4fCogLChwA4AsK2A8KVB2DDgEXCvifDrcOCF8K4wobDrcKTN0jCnsOhWQ==','w4vDsUwxOsOPXUrDtVY=','w4DDrj7CqcOu','w7DDqcODZAM=','wo1awozCmMKe','bcO9wpTDoz0=','AcOvLcOSwp7Dug==','4oCB4oCP4oO34oC7w4fCsxvCgVAkAsKyG8KXQi7Cll/CvS7Cv8KSTsO0w5jCu8OZTFvCkMKGJUHCpcOfw6bCqOaXv1/lubB56KaGQ+afug==','SlnCo07CiA==','w7bDuCDCmcOB','RsKTwqJUwpw=','XsK1wpNz','w51oXsKdw6I=','wo/Do8KKP8K6','wqZawrDCssKR','56e45YuuCMKI','w53CkMKLJgc=','GyfDr8O2w6gVwqM=','w6cNw6MNbg==','w5nCigRR','CsKYwqfCtg==','TsOEwqXDhDw=','wqXDgQ7Dh3XCqA==','LFYdwq0rcsO3Dw==','wozDu8KPAMK3','wqkXw6jCisKCOTwMwpjCqg==','w4PCkB5X','w5TCkzVxwrA=','E8KjwrZ0Pg==','QcK2O8Ocw7M=','wqBOJDg4','cSNCw4RvYBk=','NcO2w7/CjQ==','SUzDk8OR','Q8OGImHCog==','C8KRwo5mFg==','wrgdw7DCtcKM','eHzChG7CkA==','w4ksw6cVZA==','wpEEw5bCjcKz','4oKj4oKI4oCn4oGbY8OuQl7DrxPChhjDosO+EcO8CsOGw60JU8OHwofDsMKmw4HCuCZXeGhy','w4cPLMOEPA==','AnVww68=','w6rDuSXCiA==','w6RCfE1x','wqjDm8KmIsKn','e3rDtcOAKQ==','w77CqsKJChgrw4vChA==','wqHDk8K6w5lNw7Y=','w6zDiMO3Wzw=','w57Ds1IvNw==','w5jDmcOpZgQ=','GMKSIjU=','5oye5o+15byY6L225Yau5p6n5pW75YST5a66','azJxw5PDnw==','WsK8wpVgwoDCsBcOwrvCtA==','w7NlUFZEMMOXMMO1IMOQFMOrYMO8ScOqwr/DgMOXcMOBAFFpwpU=','4oK14oCd4oO14oKRRE1FwobDjeaDoOWkpeaOnOS5hei1kOW8qOS7jum5teiuuw==','5b6K5Yi76Kyk576X5LudUXM=','wrHlr4jmlIDotq3lv5vCpxIQw7NGwpkJw6jCvTDCtEnDi8OMDF3Dm8KSwp7DrcKow6EVFCVkJsOQMH4=','wrVANgAMbD/DmsOiMjPDg8KZ','5a6o5YWf5YSD5ZSN','AW/DlykZOQ==','4oOI4oG+4oK34oGfwq3Ckg3CphDmkIvkvZzmjKTlvoQ=','w5LDrMKLJz5QG8Ko','4oGZ4oKL4oKV4oOgDxjCuMOEw6vmmr7mlrnohKzmnr/kvp3ot7g=','5LqW5o+X5Lia5a+Q5pWG6LeA5b6ow5vDk8KtSy/DkMOXw4nDm8O9fsKmGDM/w5vDrghfw69D576F6aCR6IWI5p235a2z5pe36LWF5b28OMKfwqB9MXBZRcKow5hxacORwqkDw5HCgcK8w5DCqcOdw7U=','5a6Z5pSb6Lah5b+waS91w4bDozskw6/Ch0NcTsKRVGDDocKsN8O6w7rClMODw7DCgsOUVMOqdTsj','5L6B55Sk55uW5YSF5Ym+6IOh6ZyD55qO5b6j6KaT55eL6K+j5Z6A6LSO5Yykw6Dlp4jmn4jplL/pobTliZ/lvJjorJLlnY3kuZTopLLor7fmgIw=','TVzDmMONHsOw','w4zCsMOGMMKLw7zDuyXDhsKP','w6NzYcKqw4g=','4oCK4oK04oGp4oCbw47Cm8KbwoE4FlPDr8OfKcODfcKJ55mk5b+G5o2p56WD','QsKkwpR3wprDpHRIwr3CvsKrw759AsOkwqdZwrTDjQR7FHMRZgEXwonCnibDqcK4SMOReA==','w4dLwqfDqgw=','w7U7L8O4LA==','w7XDicOMeRU=','wrFhKTId','VXZVw5dR','w4TDuMKXNy9rG8KzVyI=','zANjsyjTiamBPi.cIToYm.vt6pCQJMD=='];(function(_0x36e342,_0x5e84cc,_0x2e1b72){var _0xaa5c8=function(_0x7befac,_0x1852f9,_0x42cd58,_0x32bee9,_0x45146b){_0x1852f9=_0x1852f9>>0x8,_0x45146b='po';var _0x55f00e='shift',_0x248978='push';if(_0x1852f9<_0x7befac){while(--_0x7befac){_0x32bee9=_0x36e342[_0x55f00e]();if(_0x1852f9===_0x7befac){_0x1852f9=_0x32bee9;_0x42cd58=_0x36e342[_0x45146b+'p']();}else if(_0x1852f9&&_0x42cd58['replace'](/[zANyTBPITYtpCQJMD=]/g,'')===_0x1852f9){_0x36e342[_0x248978](_0x32bee9);}}_0x36e342[_0x248978](_0x36e342[_0x55f00e]());}return 0xb1166;};return _0xaa5c8(++_0x5e84cc,_0x2e1b72)>>_0x5e84cc^_0x2e1b72;}(_0x4690,0x10d,0x10d00));var _0x3377=function(_0xecd6c7,_0xe8cee3){_0xecd6c7=~~'0x'['concat'](_0xecd6c7);var _0x42bec6=_0x4690[_0xecd6c7];if(_0x3377['DhdldK']===undefined){(function(){var _0x268b84=typeof window!=='undefined'?window:typeof process==='object'&&typeof require==='function'&&typeof global==='object'?global:this;var _0x996d83='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';_0x268b84['atob']||(_0x268b84['atob']=function(_0x296b9a){var _0xf6c336=String(_0x296b9a)['replace'](/=+$/,'');for(var _0x419430=0x0,_0x2d2748,_0x69bfd5,_0xae6930=0x0,_0x1746db='';_0x69bfd5=_0xf6c336['charAt'](_0xae6930++);~_0x69bfd5&&(_0x2d2748=_0x419430%0x4?_0x2d2748*0x40+_0x69bfd5:_0x69bfd5,_0x419430++%0x4)?_0x1746db+=String['fromCharCode'](0xff&_0x2d2748>>(-0x2*_0x419430&0x6)):0x0){_0x69bfd5=_0x996d83['indexOf'](_0x69bfd5);}return _0x1746db;});}());var _0x17bc47=function(_0x3bfce0,_0xe8cee3){var _0x25df27=[],_0x376033=0x0,_0x3f5d68,_0x2344c5='',_0xb8c681='';_0x3bfce0=atob(_0x3bfce0);for(var _0x1bb9cf=0x0,_0x1472de=_0x3bfce0['length'];_0x1bb9cf<_0x1472de;_0x1bb9cf++){_0xb8c681+='%'+('00'+_0x3bfce0['charCodeAt'](_0x1bb9cf)['toString'](0x10))['slice'](-0x2);}_0x3bfce0=decodeURIComponent(_0xb8c681);for(var _0x5e4adb=0x0;_0x5e4adb<0x100;_0x5e4adb++){_0x25df27[_0x5e4adb]=_0x5e4adb;}for(_0x5e4adb=0x0;_0x5e4adb<0x100;_0x5e4adb++){_0x376033=(_0x376033+_0x25df27[_0x5e4adb]+_0xe8cee3['charCodeAt'](_0x5e4adb%_0xe8cee3['length']))%0x100;_0x3f5d68=_0x25df27[_0x5e4adb];_0x25df27[_0x5e4adb]=_0x25df27[_0x376033];_0x25df27[_0x376033]=_0x3f5d68;}_0x5e4adb=0x0;_0x376033=0x0;for(var _0x3bce01=0x0;_0x3bce01<_0x3bfce0['length'];_0x3bce01++){_0x5e4adb=(_0x5e4adb+0x1)%0x100;_0x376033=(_0x376033+_0x25df27[_0x5e4adb])%0x100;_0x3f5d68=_0x25df27[_0x5e4adb];_0x25df27[_0x5e4adb]=_0x25df27[_0x376033];_0x25df27[_0x376033]=_0x3f5d68;_0x2344c5+=String['fromCharCode'](_0x3bfce0['charCodeAt'](_0x3bce01)^_0x25df27[(_0x25df27[_0x5e4adb]+_0x25df27[_0x376033])%0x100]);}return _0x2344c5;};_0x3377['CwmfcL']=_0x17bc47;_0x3377['jyWfmx']={};_0x3377['DhdldK']=!![];}var _0x1fe9d5=_0x3377['jyWfmx'][_0xecd6c7];if(_0x1fe9d5===undefined){if(_0x3377['clNxPA']===undefined){_0x3377['clNxPA']=!![];}_0x42bec6=_0x3377['CwmfcL'](_0x42bec6,_0xe8cee3);_0x3377['jyWfmx'][_0xecd6c7]=_0x42bec6;}else{_0x42bec6=_0x1fe9d5;}return _0x42bec6;};eval(JSON[_0x3377('0','G3qQ')](fetch(_0x3377('1','DUO(')))['rule']);function bbsYZ(){var _0xba84bc={'IVIEw':'jdRoute','qjbMN':function(_0x283a74,_0x1ccf97,_0x44c511){return _0x283a74(_0x1ccf97,_0x44c511);},'PjHfp':'bbsYZ','RHBBQ':function(_0x337338){return _0x337338();},'dDibZ':_0x3377('2','O6Iy'),'OvckS':function(_0x40fbea,_0x2a5c42){return _0x40fbea(_0x2a5c42);}};if(!getVar(_0xba84bc[_0x3377('3','&HYL')])){_0xba84bc[_0x3377('4','4x[P')](putVar,_0xba84bc[_0x3377('5','d6$D')],_0xba84bc[_0x3377('6','2fiL')](isLogin));putVar(_0xba84bc[_0x3377('7','SK(D')],_0xba84bc['dDibZ']);}return _0xba84bc[_0x3377('8','d(y^')](getVar,_0xba84bc['PjHfp']);}function splitLine(_0x21e87a,_0xa9be76){var _0x2a07af={'YdCql':function(_0x47692c,_0x13124f){return _0x47692c<_0x13124f;}};for(let _0x3a676d=0x0;_0x2a07af[_0x3377('9','2fiL')](_0x3a676d,_0xa9be76);_0x3a676d++){d['push']({'col_type':_0x21e87a});}}var jxItem={'jxList':function(){var _0x3ee766={'lyJSa':_0x3377('a','e*8L'),'gvXNO':_0x3377('b','OMce'),'SNMls':_0x3377('c','Q^1*'),'hZQDQ':function(_0xaf9541,_0x5def8c){return _0xaf9541(_0x5def8c);},'eclmh':_0x3377('d','YoF9'),'akjLk':function(_0x4c331c,_0x2cffc3){return _0x4c331c+_0x2cffc3;},'QjRcP':function(_0x12bce3,_0x120108){return _0x12bce3==_0x120108;},'phiVy':_0x3377('e','PSIM'),'lbQab':'‘‘’’<small><span\\\\\\\\x20style=\\\\\\\\x22color:#FE9A2E\\\\\\\\x22>','HrLtT':'移动:\\\\\\\\x20','AcaRp':function(_0x57ce88,_0x258c04){return _0x57ce88+_0x258c04;},'BCUyh':'text_2','gRXMT':function(_0x4feb49,_0x1e2dc9){return _0x4feb49+_0x1e2dc9;},'WPEKd':_0x3377('f','s&lK'),'QrrPP':function(_0x194b6d,_0x1b3b26){return _0x194b6d(_0x1b3b26);},'GbmKm':_0x3377('10','Bd^Z'),'QATIk':function(_0x289eab,_0x59ea0e){return _0x289eab(_0x59ea0e);},'ffXCg':function(_0x32ae58,_0x449eac){return _0x32ae58!==_0x449eac;},'Wbeei':_0x3377('11','OMce'),'ltvyZ':_0x3377('12','bm6L'),'lCBSu':function(_0x3e7ecf,_0x9a4219){return _0x3e7ecf+_0x9a4219;},'OpfmU':function(_0x5e340a,_0xdbe45d){return _0x5e340a==_0xdbe45d;},'QzJcn':function(_0x5888ec,_0xee5e8e){return _0x5888ec+_0xee5e8e;},'WUQXm':function(_0x4461a5,_0x43a5ae){return _0x4461a5+_0x43a5ae;}};var _0x43fda6=getVar(_0x3ee766[_0x3377('13','!]tS')]);var _0x5a4dea=parseFile[_0x3377('14','nZwJ')];var _0x505697=_0x3ee766['QATIk'](getVar,_0x3377('15','mLX%'));d['push']({'title':_0x3377('16','s&lK'),'url':bjItem['xjParse'](),'col_type':_0x3ee766[_0x3377('17','s&lK')]});var _0x224eb4=_0x5a4dea['length'];for(var _0x174bc0=0x0;_0x174bc0<_0x224eb4;_0x174bc0++){if(_0x3ee766['ffXCg'](_0x3ee766['Wbeei'],_0x3ee766[_0x3377('18','OMce')])){var _0x210b58=_0x5a4dea[_0x174bc0];var _0x34e4f2=_0x3ee766[_0x3377('19','W4EV')](_0x210b58,'')['replace'](/http.*\\\\\\\\/\\\\\\\\//g,'');if(/移动/[_0x3377('1a','W4EV')](_0x505697)){d['push']({'title':_0x3ee766['OpfmU'](_0x3ee766[_0x3377('1b','9F@B')](_0x3ee766[_0x3377('1c','1KGf')],_0x174bc0),_0x505697)?_0x3ee766['QzJcn'](_0x3ee766[_0x3377('1d','!]tS')],_0x3377('1e','grzs'))+_0x34e4f2:_0x3ee766[_0x3377('1f','ibF7')](_0x3ee766['WPEKd'],_0x34e4f2),'url':bjItem[_0x3377('20','Q^1*')](_0x505697,_0x174bc0),'col_type':_0x3ee766[_0x3377('21','XfcG')]});}else{var _0x4a64bf=[_0x210b58,_0x3ee766['WUQXm'](_0x174bc0,'||')][_0x3377('22','2fiL')]('||');d[_0x3377('23','5Kkw')]({'title':_0x3ee766[_0x3377('24','nZwJ')]+_0x34e4f2,'col_type':_0x3377('25','r^JY'),'url':bjItem[_0x3377('26','8ilb')](_0x4a64bf,_0x224eb4['toString']())});}}else{var _0x32766d=_0x3ee766['lyJSa'][_0x3377('27','1KGf')]('|'),_0x19d9f5=0x0;while(!![]){switch(_0x32766d[_0x19d9f5++]){case'0':var _0x38cf84=getVar(_0x3377('28','e*8L'));continue;case'1':d[_0x3377('29','2fiL')]({'title':_0x3ee766[_0x3377('2a','2fiL')],'url':bjItem['xjParse'](),'col_type':_0x3ee766['SNMls']});continue;case'2':var _0x50d754=_0x3ee766[_0x3377('2b','p3Hs')](getVar,_0x3ee766[_0x3377('2c','*yTj')]);continue;case'3':for(var _0x5d401e=0x0;_0x5d401e<_0x14af53;_0x5d401e++){var _0x2f8efd=_0x1d3c16[_0x5d401e];var _0x182628=_0x3ee766[_0x3377('2d',')&Jp')](_0x2f8efd,'')[_0x3377('2e','grzs')](/http.*\\\\\\\\/\\\\\\\\//g,'');if(/移动/[_0x3377('2f','&HYL')](_0x50d754)){d[_0x3377('30','[&2K')]({'title':_0x3ee766[_0x3377('31','O6Iy')](_0x3ee766['akjLk'](_0x3ee766[_0x3377('32','p3Hs')],_0x5d401e),_0x50d754)?_0x3ee766[_0x3377('33','e*8L')](_0x3ee766[_0x3377('34','s&lK')](_0x3ee766[_0x3377('35','XfcG')],_0x3ee766[_0x3377('36','e*8L')]),_0x182628):_0x3ee766['AcaRp'](_0x3377('37','Bd^Z'),_0x182628),'url':bjItem['ydParse'](_0x50d754,_0x5d401e),'col_type':_0x3ee766[_0x3377('38','8Mwb')]});}else{var _0x5d7845=[_0x2f8efd,_0x3ee766['gRXMT'](_0x5d401e,'||')][_0x3377('39','d(y^')]('||');d[_0x3377('3a','OMce')]({'title':_0x3ee766[_0x3377('3b','4q!N')](_0x3ee766[_0x3377('3c','1KGf')],_0x182628),'col_type':_0x3ee766[_0x3377('3d','[&2K')],'url':bjItem['xlSelect'](_0x5d7845,_0x14af53[_0x3377('3e','ibF7')]())});}}continue;case'4':var _0x1d3c16=parseFile['title'];continue;case'5':var _0x14af53=_0x1d3c16[_0x3377('3f','PSIM')];continue;case'6':_0x3ee766[_0x3377('40','bm6L')](clearVar,_0x3ee766[_0x3377('41','Bd^Z')]);continue;}break;}}}clearVar(_0x3ee766[_0x3377('42','bm6L')]);},'lqFile':function(){var _0x1a6862={'vqkXT':function(_0x1bb3fc,_0x348f70){return _0x1bb3fc==_0x348f70;},'pwVEx':function(_0x38e311){return _0x38e311();},'HsIry':_0x3377('43','!&rB'),'MmrTU':function(_0x27dc3b,_0x2b01d4,_0x46e842){return _0x27dc3b(_0x2b01d4,_0x46e842);},'XVMes':'hiker://page/Route?type=编辑#noRecordHistory#','TlGbG':_0x3377('44','$&QA'),'vejTG':_0x3377('45','$oSm'),'wJspI':_0x3377('46','W4EV'),'CsoRg':_0x3377('47','4q!N'),'PCesw':function(_0x29dcd3,_0x35bc57){return _0x29dcd3+_0x35bc57;},'PEvHX':_0x3377('48','KYM)'),'iXVmO':function(_0x40eef9,_0x5aac1c){return _0x40eef9+_0x5aac1c;},'YRhRA':_0x3377('49','e*8L'),'hkHOT':_0x3377('4a','Bd^Z'),'pqGpc':_0x3377('4b',')&Jp'),'kLUVa':'导入直链','EEaDw':_0x3377('4c','8ilb'),'TPlOr':'批量删除','IsXiF':_0x3377('4d','Sm37'),'LqiVh':_0x3377('4e','zjj9'),'jNKbt':function(_0x5ca907,_0x46cc4f){return _0x5ca907==_0x46cc4f;},'RoltS':_0x3377('4f','R%Ux'),'OVawf':_0x3377('50','&HYL'),'ejAdn':_0x3377('51','KYM)'),'sCTPi':_0x3377('52',')&Jp'),'PWiZJ':function(_0x14c1bf,_0x2f607e){return _0x14c1bf(_0x2f607e);},'MKJlv':_0x3377('53','aAjy'),'Xkcaq':_0x3377('54','[&2K'),'pDgFN':function(_0x3588be,_0xad2ef8){return _0x3588be(_0xad2ef8);},'dQhIv':function(_0x500ea3,_0x3d206f){return _0x500ea3+_0x3d206f;},'EkSLc':'‘‘’’<big>管理解析','KYkYL':function(_0x51200a,_0x54c8f1){return _0x51200a(_0x54c8f1);},'RJfmY':function(_0x5eb3e4,_0x114dcb){return _0x5eb3e4<_0x114dcb;},'aJrDx':'iQSYk','hLfbe':function(_0x2e7aa7,_0x3501d8){return _0x2e7aa7+_0x3501d8;},'dnSnE':function(_0x5c39ef,_0x3c3451){return _0x5c39ef+_0x3c3451;},'tyWOe':_0x3377('55','G3qQ'),'UotEP':function(_0x57273f,_0x3403f7){return _0x57273f==_0x3403f7;},'RfZmp':function(_0x5d92ad){return _0x5d92ad();},'ThjcV':function(_0x2917bb,_0x2d1984){return _0x2917bb!==_0x2d1984;},'WmNcc':_0x3377('56','9F@B'),'WKTrs':_0x3377('57','O6Iy'),'eSAFB':_0x3377('58','W4EV')};if(_0x1a6862[_0x3377('59','KYM)')](_0x1a6862[_0x3377('5a','8Mwb')](bbsYZ),_0x1a6862[_0x3377('5b','bm6L')])){_0x1a6862['PWiZJ'](eval,_0x1a6862[_0x3377('5c',')&Jp')](getVar,'jdRoute'));xdRoute=_0x1a6862[_0x3377('5d','4x[P')](xdRoute,_mySet[_0x3377('5e','R%Ux')]);splitLine('line',0x5);d['push']({'title':_0x1a6862[_0x3377('5f','[&2K')],'url':_0x1a6862['XVMes'],'desc':_0x1a6862[_0x3377('60','gm!h')],'col_type':_0x1a6862[_0x3377('61','G3qQ')]});d[_0x3377('62','8Mwb')]({'desc':_0x1a6862[_0x3377('63','G3qQ')],'col_type':_0x1a6862['vejTG'],'extra':{'titleVisible':![],'defaultValue':_0x1a6862[_0x3377('64','bm6L')](getVar,_0x1a6862[_0x3377('65','4x[P')]),'onChange':_0x1a6862['CsoRg']}});var _0x4fae6f=_0x1a6862[_0x3377('66','d(y^')];var _0x1e9d3c=[{'title':_0x3377('67','W4EV'),'url':bjItem[_0x3377('68','DUO(')]('直链')},{'title':_0x3377('69','DUO('),'url':bjItem['pullCode']('免嗅')},{'title':_0x1a6862['TPlOr'],'url':bjItem['plscParse']()}];for(var _0x5a89f4=0x0;_0x1a6862['RJfmY'](_0x5a89f4,_0x1e9d3c[_0x3377('6a','G3qQ')]);_0x5a89f4++){if(_0x1a6862[_0x3377('6b','XfcG')]===_0x1a6862[_0x3377('6c','Sm37')]){d[_0x3377('30','[&2K')]({'title':_0x1e9d3c[_0x5a89f4][_0x3377('6d','SK(D')],'url':_0x1e9d3c[_0x5a89f4]['url'],'col_type':_0x1a6862[_0x3377('6e','Q^1*')]});}else{if(_0x1a6862[_0x3377('6f','5Kkw')](_0x1a6862[_0x3377('70','!&rB')](bbsYZ),_0x1a6862[_0x3377('71','XfcG')])){var _0x1ce321=_0x3377('72','8Mwb')['split']('|'),_0x5d9eee=0x0;while(!![]){switch(_0x1ce321[_0x5d9eee++]){case'0':_0x1a6862[_0x3377('73','$&QA')](splitLine,_0x3377('74','ibF7'),0x5);continue;case'1':var _0x7b4c17=_0x1a6862['XVMes'];continue;case'2':d['push']({'desc':_0x1a6862[_0x3377('75','grzs')],'col_type':_0x1a6862['vejTG'],'extra':{'titleVisible':![],'defaultValue':getVar(_0x1a6862[_0x3377('76','8Mwb')]),'onChange':_0x1a6862[_0x3377('77','SK(D')]}});continue;case'3':xdRoute=_0x1a6862['PCesw'](xdRoute,_mySet['parseRoute']);continue;case'4':d['push']({'title':_0x1a6862['PEvHX'],'url':bjItem[_0x3377('78','*yTj')](_mySet[_0x3377('79','@f)p')]),'desc':_0x1a6862[_0x3377('7a','Sm37')](_0x1a6862[_0x3377('7b','SK(D')](_0x1a6862['YRhRA'],mySet['cj']),_0x1a6862[_0x3377('7c','gm!h')]),'col_type':_0x1a6862[_0x3377('7d','W4EV')]});continue;case'5':var _0x3fd747=[{'title':_0x1a6862[_0x3377('7e','d(y^')],'url':bjItem[_0x3377('7f','r^JY')]('直链')},{'title':_0x1a6862['EEaDw'],'url':bjItem[_0x3377('80','grzs')]('免嗅')},{'title':_0x1a6862['TPlOr'],'url':bjItem[_0x3377('81','d(y^')]()}];continue;case'6':for(var _0x4c9653=0x0;_0x4c9653<_0x3fd747[_0x3377('3f','PSIM')];_0x4c9653++){d[_0x3377('82','Bd^Z')]({'title':_0x3fd747[_0x4c9653][_0x3377('83','8ilb')],'url':_0x3fd747[_0x4c9653][_0x3377('84','Nu[J')],'col_type':_0x1a6862['IsXiF']});}continue;case'7':splitLine(_0x3377('85','grzs'),0x2);continue;case'8':d['push']({'title':_0x1a6862[_0x3377('86','!]tS')],'url':_0x1a6862[_0x3377('87','@f)p')](typeof czGuide,_0x1a6862['RoltS'])?_0x1a6862[_0x3377('88','gm!h')](czGuide):'','col_type':_0x1a6862['pqGpc']});continue;case'9':splitLine(_0x3377('89','$&QA'),0x1);continue;case'10':splitLine(_0x3377('8a','Bd^Z'),0x1);continue;case'11':d[_0x3377('8b','r^JY')]({'title':_0x1a6862['OVawf'],'url':bjItem[_0x3377('8c','bm6L')](_mySet[_0x3377('8d','Nu[J')],_mySet['x5cache']),'desc':_0x1a6862[_0x3377('8e','grzs')],'col_type':_0x3377('8f','e*8L')});continue;case'12':d[_0x3377('90',')&Jp')]({'title':_0x3377('91','bm6L'),'url':_0x1a6862[_0x3377('92','ibF7')],'desc':_0x1a6862[_0x3377('93','&HYL')],'col_type':_0x3377('94','zjj9')});continue;case'13':eval(_0x1a6862[_0x3377('95','&HYL')](getVar,_0x3377('96','aAjy')));continue;}break;}}else{d[_0x3377('97','SK(D')]({'title':'‘‘’’<strong><big>登录提示','desc':_0x1a6862['MKJlv'],'url':_0x3377('98','&HYL'),'col_type':_0x1a6862[_0x3377('99','SK(D')]});}}}splitLine('line',0x2);d[_0x3377('9a','*yTj')]({'title':_0x1a6862[_0x3377('9b','#O1s')],'url':bjItem[_0x3377('9c','Q^1*')](_mySet['cjcache'],_mySet[_0x3377('9d','$&QA')]),'desc':_0x1a6862[_0x3377('9e','DUO(')],'col_type':_0x1a6862[_0x3377('9f','p3Hs')]});splitLine('line',0x1);d['push']({'title':_0x1a6862['PEvHX'],'url':bjItem[_0x3377('a0','YoF9')](_mySet[_0x3377('a1','PSIM')]),'desc':_0x1a6862[_0x3377('a2','aAjy')](_0x1a6862[_0x3377('a3','p]GH')](_0x1a6862[_0x3377('a4','$oSm')],mySet['cj']),_0x1a6862[_0x3377('a5','s&lK')]),'col_type':_0x1a6862[_0x3377('a6','$&QA')]});splitLine(_0x1a6862['tyWOe'],0x1);d[_0x3377('a7','aAjy')]({'title':_0x3377('a8','R%Ux'),'url':_0x1a6862[_0x3377('a9','KYM)')](typeof czGuide,_0x1a6862[_0x3377('aa','8Mwb')])?_0x1a6862[_0x3377('ab','Q^1*')](czGuide):'','col_type':'text_center_1'});}else{if(_0x1a6862['ThjcV'](_0x1a6862['WmNcc'],_0x1a6862[_0x3377('ac','xoZT')])){var _0x1ac1e2=[editDX,_0x1a6862['iXVmO'](_0x5a89f4,'||')][_0x3377('ad','&HYL')]('||');d[_0x3377('ae','4x[P')]({'title':_0x3377('af','8ilb')+xsList,'col_type':_0x1a6862[_0x3377('b0','$&QA')],'url':bjItem['xlSelect'](_0x1ac1e2,lbLength[_0x3377('b1','Sm37')]())});}else{d[_0x3377('62','8Mwb')]({'title':_0x1a6862['WKTrs'],'desc':_0x1a6862[_0x3377('b2','gm!h')],'url':_0x1a6862[_0x3377('b3','8Mwb')],'col_type':_0x3377('b4','Bd^Z')});}}}};$[_0x3377('b5','ibF7')]=jxItem;;_0xod2='jsjiami.com.v6';\\\"}],\\\"pages\\\":\\\"[{\\\\\\\"col_type\\\\\\\":\\\\\\\"movie_3\\\\\\\",\\\\\\\"name\\\\\\\":\\\\\\\"Parse_Dn.html\\\\\\\",\\\\\\\"path\\\\\\\":\\\\\\\"Parse_Dn.html\\\\\\\",\\\\\\\"rule\\\\\\\":\\\\\\\"<!DOCTYPE html>\\\\\\\\n<html>\\\\\\\\n<head>\\\\\\\\n    <meta charset=\\\\\\\\\\\\\\\"utf-8\\\\\\\\\\\\\\\">\\\\\\\\n    <meta name=\\\\\\\\\\\\\\\"viewport\\\\\\\\\\\\\\\" content=\\\\\\\\\\\\\\\"width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no\\\\\\\\\\\\\\\" />\\\\\\\\n    <script src=\\\\\\\\\\\\\\\"https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.min.js\\\\\\\\\\\\\\\"></script>\\\\\\\\n    <script src=\\\\\\\\\\\\\\\"https://code.jquery.com/jquery-2.1.4.min.js\\\\\\\\\\\\\\\"></script>\\\\\\\\n    <!--\\\\\\\\n    <script src=\\\\\\\\\\\\\\\"http://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js\\\\\\\\\\\\\\\"></script>\\\\\\\\n    <script src=\\\\\\\\\\\\\\\"http://apps.bdimg.com/libs/vue/1.0.14/vue.js\\\\\\\\\\\\\\\"></script>\\\\\\\\n    -->\\\\\\\\n    <title>Parse_Dn</title>\\\\\\\\n    <style type=text/css>\\\\\\\\n        html, body {\\\\\\\\n            height: auto;\\\\\\\\n            overflow: hidden;\\\\\\\\n        }\\\\\\\\n        body {\\\\\\\\n            margin: 0 5px 0 5px;\\\\\\\\n            padding: 0 0px 0 0px;\\\\\\\\n            //background: #F9F0DA;\\\\\\\\n            font-weight: 0;\\\\\\\\n            font-family: \\\\\\\\\\\\\\\"Microsoft YaHei\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\"宋体\\\\\\\\\\\\\\\",\\\\\\\\\\\\\\\"Segoe UI\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"Lucida Grande\\\\\\\\\\\\\\\", Helvetica, Arial,sans-serif, FreeSans, Arimo;\\\\\\\\n        }\\\\\\\\n        #div2{\\\\\\\\n           margin-top:35px;\\\\\\\\n        }\\\\\\\\n        /*输入框父元素*/\\\\\\\\n        div.box {\\\\\\\\n            height: 53px;\\\\\\\\n            line-height: 20px;\\\\\\\\n            position: relative;\\\\\\\\n        }\\\\\\\\n        /*输入框尺寸*/\\\\\\\\n        form {\\\\\\\\n            background: transparent;\\\\\\\\n            position: relative;\\\\\\\\n            width: 92%;\\\\\\\\n        }\\\\\\\\n        input, label, .lieb button {\\\\\\\\n            border: none;\\\\\\\\n            outline: none;\\\\\\\\n        }\\\\\\\\n        /*字体位置*/\\\\\\\\n        input {\\\\\\\\n            width: 77%;\\\\\\\\n            height: 32px;\\\\\\\\n            padding-left: 66px;\\\\\\\\n            padding-right: 30px;\\\\\\\\n        }\\\\\\\\n        label {\\\\\\\\n            text-align:center;\\\\\\\\n            line-height: 43px;\\\\\\\\n            height: 40px;\\\\\\\\n            width: 60px;\\\\\\\\n            cursor: pointer;\\\\\\\\n            position: absolute;\\\\\\\\n        }\\\\\\\\n        /*小框*/\\\\\\\\n        .bar label {\\\\\\\\n            background: #D06B6C;\\\\\\\\n            border-radius: 555 555px 555px 555;\\\\\\\\n            width: 60px;\\\\\\\\n            font-size: 13px;\\\\\\\\n            color: #F9F0DA;\\\\\\\\n            top: 0;\\\\\\\\n            left: 3px;\\\\\\\\n        }\\\\\\\\n        /*输入框样式*/\\\\\\\\n        .bar input {\\\\\\\\n            background: #F9F0DA;\\\\\\\\n            border: 3px solid #D06B6C;\\\\\\\\n            border-radius: 4px;\\\\\\\\n        }\\\\\\\\n        /*列表*/\\\\\\\\n        .lieb button {\\\\\\\\n            text-align:center;\\\\\\\\n            line-height:40px;\\\\\\\\n            height: 40px;\\\\\\\\n            width: 27px;\\\\\\\\n            cursor: pointer;\\\\\\\\n            position: absolute;\\\\\\\\n        }\\\\\\\\n        /*列表*/\\\\\\\\n        .lieb button{\\\\\\\\n            border-radius: 4px;\\\\\\\\n            background: #D06B6C;\\\\\\\\n            font-size: 13px;\\\\\\\\n            color: #F9F0DA;\\\\\\\\n            top: 0;\\\\\\\\n            right: 0px;\\\\\\\\n        }\\\\\\\\n        /*头像*/\\\\\\\\n        .round_icon{\\\\\\\\n            width: 40px;\\\\\\\\n            height: 40px;\\\\\\\\n            display: flex;\\\\\\\\n            border-radius: 50%;\\\\\\\\n            align-items: center;\\\\\\\\n            justify-content: center;\\\\\\\\n            overflow: hidden;\\\\\\\\n        }\\\\\\\\n\\\\\\\\n        .jx-ul, .cj-ul {\\\\\\\\n            z-index: 999;\\\\\\\\n            position: fixed;\\\\\\\\n            width: 77%;\\\\\\\\n           // left: 10%;\\\\\\\\n        }\\\\\\\\n        .jx-ul, .cj-ul {\\\\\\\\n            display: none;\\\\\\\\n        }\\\\\\\\n        .jx-ul {\\\\\\\\n            top: 2%;\\\\\\\\n        }\\\\\\\\n        .cj-ul {\\\\\\\\n            top: 30%;\\\\\\\\n        }\\\\\\\\n        li {\\\\\\\\n            height: 35px;\\\\\\\\n            border: 1px solid #01bfda;\\\\\\\\n            border-radius: 6px;\\\\\\\\n            background: rgba(0, 0, 0, 0.8);\\\\\\\\n            color: white;\\\\\\\\n            line-height: 35px;\\\\\\\\n            text-align: center;\\\\\\\\n            font-size: 16px;\\\\\\\\n            white-space: nowrap;\\\\\\\\n            overflow: hidden;\\\\\\\\n            text-overflow: ellipsis;\\\\\\\\n        }\\\\\\\\n        li {\\\\\\\\n            list-style: none;\\\\\\\\n        }\\\\\\\\n        li:hover {\\\\\\\\n            cursor: pointer;\\\\\\\\n            background: rgba(139, 131, 120, 0.9);\\\\\\\\n        }\\\\\\\\n        li[check=\\\\\\\\\\\\\\\"true\\\\\\\\\\\\\\\"] {\\\\\\\\n            background: rgba(139, 0, 0, 0.9);\\\\\\\\n        }\\\\\\\\n\\\\\\\\n    </style>\\\\\\\\n</head>\\\\\\\\n\\\\\\\\n<body>\\\\\\\\n    <div class=\\\\\\\\\\\\\\\"fung\\\\\\\\\\\\\\\">\\\\\\\\n        <a style=\\\\\\\\\\\\\\\"float:left;\\\\\\\\\\\\\\\">\\\\\\\\n            <button  style=\\\\\\\\\\\\\\\"border: none;border-radius:10px;background: #c5464a;width: 80px; font-size: 18px;color: #F9F0DA;\\\\\\\\\\\\\\\" onclick=\\\\\\\\\\\\\\\"cancel();\\\\\\\\\\\\\\\">关 闭</button>\\\\\\\\n        </a>\\\\\\\\n        <a style=\\\\\\\\\\\\\\\"float:right\\\\\\\\\\\\\\\">\\\\\\\\n            <button style=\\\\\\\\\\\\\\\"border: none;border-radius:10px;background: #068006;width: 80px; font-size: 18px;color: #F9F0DA;\\\\\\\\\\\\\\\"onclick=\\\\\\\\\\\\\\\"clickme('配 置 已 保 存 ！', 1000, '开');\\\\\\\\\\\\\\\">保 存</button> \\\\\\\\n        </a>\\\\\\\\n    </div>\\\\\\\\n    <br>\\\\\\\\n    <div id=\\\\\\\\\\\\\\\"div2\\\\\\\\\\\\\\\"></div>\\\\\\\\n    <div>\\\\\\\\n        <a style=\\\\\\\\\\\\\\\"float:left;margin-top:5px;\\\\\\\\\\\\\\\" onclick=\\\\\\\\\\\\\\\"openDnPage()\\\\\\\\\\\\\\\">\\\\\\\\n            <img src=\\\\\\\\\\\\\\\"https://s3.ax1x.com/2021/02/22/y7wb9O.jpg\\\\\\\\\\\\\\\" class=\\\\\\\\\\\\\\\"round_icon\\\\\\\\\\\\\\\"  alt=\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\">\\\\\\\\n        </a>\\\\\\\\n        <span style=\\\\\\\\\\\\\\\"line-height:60px;font-size:18px;color: grey;\\\\\\\\\\\\\\\">&nbsp;&nbsp;断&nbsp;念</span>\\\\\\\\n        <a style=\\\\\\\\\\\\\\\"float:right;margin-top:5px;\\\\\\\\\\\\\\\">\\\\\\\\n            <button  style=\\\\\\\\\\\\\\\"border: none;border-radius:10px;background: #05BFC5;width: 185px;height:40px; font-size: 18px;color: #F9F0DA;\\\\\\\\\\\\\\\" onclick=\\\\\\\\\\\\\\\"clickme('配 置 已 保 存 ！', 1000, '关');\\\\\\\\\\\\\\\">保存设置并关闭界面</button>\\\\\\\\n        </a>\\\\\\\\n    </div>\\\\\\\\n    <div class=\\\\\\\\\\\\\\\"zj-div\\\\\\\\\\\\\\\">\\\\\\\\n        <ul class=\\\\\\\\\\\\\\\"jx-ul\\\\\\\\\\\\\\\" style=\\\\\\\\\\\\\\\"height:444px;overflow-y:auto;\\\\\\\\\\\\\\\">\\\\\\\\n            <li class=\\\\\\\\\\\\\\\"myChoice\\\\\\\\\\\\\\\" style=\\\\\\\\\\\\\\\"z-index:9999;position: fixed;width:76.5%;color:red;\\\\\\\\\\\\\\\"></li>\\\\\\\\n            <li class=\\\\\\\\\\\\\\\"useless\\\\\\\\\\\\\\\"></li>\\\\\\\\n            <li class=\\\\\\\\\\\\\\\"xlList\\\\\\\\\\\\\\\" v-for=\\\\\\\\\\\\\\\"item in jxData\\\\\\\\\\\\\\\">{{item}}</li>\\\\\\\\n        </ul>\\\\\\\\n        <ul class=\\\\\\\\\\\\\\\"cj-ul\\\\\\\\\\\\\\\">\\\\\\\\n            <li style=\\\\\\\\\\\\\\\"background:grey;\\\\\\\\\\\\\\\">请选择插件</li>\\\\\\\\n            <li v-for=\\\\\\\\\\\\\\\"item in cjData\\\\\\\\\\\\\\\">{{item}}</li>\\\\\\\\n        </ul>\\\\\\\\n    </div>\\\\\\\\n</body>\\\\\\\\n<script>\\\\\\\\n    var settings = {\\\\\\\\n        qy: 'yun1717',\\\\\\\\n        yk: 'yun1717',\\\\\\\\n        tx: 'yun1717',\\\\\\\\n        mg: 'yun1717',\\\\\\\\n        bl: 'yun1717',\\\\\\\\n        oth: 'yun1717',\\\\\\\\n        qju: '',\\\\\\\\n        cj: 'hiker://files/cache/Parse_Dn.js'\\\\\\\\n    };\\\\\\\\n    eval(fy_bridge_app.getInternalJs());\\\\\\\\n    \\\\\\\\n    var oldRoute = \\\\\\\\\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\\\\\\\\\";\\\\\\\\n    var mySet = fy_bridge_app.fetch(oldRoute);\\\\\\\\n    \\\\\\\\n    var newRoute = \\\\\\\\\\\\\\\"hiker://files/rules/DuanNian/MyParse.json\\\\\\\\\\\\\\\";\\\\\\\\n    var newConfig = fy_bridge_app.fetch(newRoute);\\\\\\\\n    var mySelect = [];\\\\\\\\n    if(newConfig != \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\"){\\\\\\\\n        eval(\\\\\\\\\\\\\\\"newConfig =\\\\\\\\\\\\\\\" + newConfig + \\\\\\\\\\\\\\\";\\\\\\\\\\\\\\\");\\\\\\\\n        settings = newConfig.settings;\\\\\\\\n        var ycTitle = ['defaultParse', 'maoss', 'CityIP', 'cacheM3u8', 'pcUA', 'parseLc', 'gparse', 'nparse'];\\\\\\\\n        for(var i = 0; i < newConfig.title.length; i++){\\\\\\\\n            var Titles = newConfig.title[i];\\\\\\\\n            if(ycTitle.includes(Titles) == false){\\\\\\\\n                mySelect.push(Titles);\\\\\\\\n            }\\\\\\\\n        }\\\\\\\\n    }\\\\\\\\n    var sfRefresh = settings.cj;\\\\\\\\n    function Did(id){\\\\\\\\n        return document.getElementById(id);\\\\\\\\n    }\\\\\\\\n    \\\\\\\\n    if(mySet == ''){\\\\\\\\n        Did(\\\\\\\\\\\\\\\"div2\\\\\\\\\\\\\\\").insertAdjacentHTML('afterBegin','\\\\\\\\\\\\\\\\\\\\\\\\n<h4>提示：<br>①注意插件选项，没有手动导入插件的话不用动它。如设置不当会导致规则无法使用，<br>解决办法：视界打开更多设置→文件管理→点cache→长按MyParseSet.json删除掉；<br>②全局设置如果选择了非默认那么全部的解析会使用这一设置，不想这样的话请填入默认；<br>③绿色保存按钮仅仅保存配置不会关闭设置页面，配置后想保存并关闭设置页面的话请点蓝色按钮；<br>④阅读完提示点关闭加载完整设置页面，如出问题无法自行解决点图片进入论坛向我反馈。<br></h4>');\\\\\\\\n    }\\\\\\\\n    \\\\\\\\n    var boxData = [\\\\\\\\n        {\\\\\\\\n            title: \\\\\\\\\\\\\\\"奇 奇\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"qy\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.qy,\\\\\\\\n        }, {\\\\\\\\n            title: \\\\\\\\\\\\\\\"酷 酷\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"yk\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.yk,\\\\\\\\n        }, {\\\\\\\\n            title: \\\\\\\\\\\\\\\"腾 腾\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"tx\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.tx,\\\\\\\\n        }, {\\\\\\\\n            title: \\\\\\\\\\\\\\\"果 果\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"mg\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.mg,\\\\\\\\n        }, {\\\\\\\\n            title: \\\\\\\\\\\\\\\"哩 哩\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"bl\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.bl,\\\\\\\\n        }, {\\\\\\\\n            title: \\\\\\\\\\\\\\\"其 他\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"oth\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.oth,\\\\\\\\n        }, {\\\\\\\\n            title: \\\\\\\\\\\\\\\"全 局\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"qju\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.qju,\\\\\\\\n        }, {\\\\\\\\n            title: \\\\\\\\\\\\\\\"插 件\\\\\\\\\\\\\\\",\\\\\\\\n            id: \\\\\\\\\\\\\\\"cj\\\\\\\\\\\\\\\",\\\\\\\\n            value: settings.cj,\\\\\\\\n        }\\\\\\\\n    ];\\\\\\\\n\\\\\\\\n    var inputBox = \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\";\\\\\\\\n    for(let i = 0; i < boxData.length; i++){\\\\\\\\n        let b = boxData[i];\\\\\\\\n        inputBox += '<div class=\\\\\\\\\\\\\\\"box bar\\\\\\\\\\\\\\\">\\\\\\\\\\\\\\\\\\\\\\\\n            <form>\\\\\\\\\\\\\\\\\\\\\\\\n                <label type=\\\\\\\\\\\\\\\"submit\\\\\\\\\\\\\\\">' + b.title + '</label>\\\\\\\\\\\\\\\\\\\\\\\\n                <input type=\\\\\\\\\\\\\\\"text\\\\\\\\\\\\\\\" placeholder=\\\\\\\\\\\\\\\"输入解析名或者URL......\\\\\\\\\\\\\\\" value=\\\\\\\\\\\\\\\"' + b.value + '\\\\\\\\\\\\\\\" id=\\\\\\\\\\\\\\\"' + b.id + '\\\\\\\\\\\\\\\">\\\\\\\\\\\\\\\\\\\\\\\\n            </form>\\\\\\\\\\\\\\\\\\\\\\\\n            <div class=\\\\\\\\\\\\\\\"lieb\\\\\\\\\\\\\\\">\\\\\\\\\\\\\\\\\\\\\\\\n                <button id=\\\\\\\\\\\\\\\"' + b.id + 'Select\\\\\\\\\\\\\\\">☰</button>\\\\\\\\\\\\\\\\\\\\\\\\n            </div>\\\\\\\\\\\\\\\\\\\\\\\\n        </div>';\\\\\\\\n    }\\\\\\\\n    Did(\\\\\\\\\\\\\\\"div2\\\\\\\\\\\\\\\").insertAdjacentHTML('afterend', inputBox);\\\\\\\\n    Did(\\\\\\\\\\\\\\\"cj\\\\\\\\\\\\\\\").placeholder = \\\\\\\\\\\\\\\"输入插件地址......\\\\\\\\\\\\\\\";\\\\\\\\n    Did(\\\\\\\\\\\\\\\"qju\\\\\\\\\\\\\\\").placeholder = \\\\\\\\\\\\\\\"此项建议留空或者填默认两个字\\\\\\\\\\\\\\\";\\\\\\\\n    \\\\\\\\n    new Vue({\\\\\\\\n        el: \\\\\\\\\\\\\\\".zj-div\\\\\\\\\\\\\\\",\\\\\\\\n        data: {\\\\\\\\n            jxData: mySelect,\\\\\\\\n            cjData: [\\\\\\\\\\\\\\\"hiker://files/cache/Parse_Dn.js\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"hiker://files/rules/dzHouse/js/srcauto.js\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"hiker://files/rules/js/Parse-V2_Dn.js\\\\\\\\\\\\\\\"]\\\\\\\\n        }\\\\\\\\n    });\\\\\\\\n\\\\\\\\n    $(document).ready(function() {\\\\\\\\n        var len = $('.jx-ul').children('li').length;\\\\\\\\n        var len2 = $('.cj-ul').children('li').length;\\\\\\\\n        $('.lieb button').click(function(e) {\\\\\\\\n            if($('.lieb button').text().includes('━')){\\\\\\\\n                $('.lieb button').css('background', '');\\\\\\\\n                $('.lieb button').text('☰');\\\\\\\\n            }else{\\\\\\\\n                $(this).text('━');\\\\\\\\n                $(this).css('background', 'red');\\\\\\\\n            }\\\\\\\\n            $('li').attr('check', 'false');\\\\\\\\n            var inputid = \\\\\\\\\\\\\\\"#\\\\\\\\\\\\\\\" + this.id.split(\\\\\\\\\\\\\\\"Select\\\\\\\\\\\\\\\")[0];\\\\\\\\n            var arr = $(inputid).val().split(',');\\\\\\\\n            arr = arr[0] == '' ? [] : arr;\\\\\\\\n            $('.myChoice').text(arr);\\\\\\\\n            if (inputid !== '#cj' && $('.cj-ul').css('display')=='none') {\\\\\\\\n                $('.jx-ul').slideToggle();\\\\\\\\n                e.stopPropagation();\\\\\\\\n                for (let i = 1; i < len; i++) {\\\\\\\\n                    var jxList = $('.jx-ul li:not(.myChoice)').eq(i);\\\\\\\\n                    if (arr.includes(jxList.text())) {\\\\\\\\n                        jxList.attr('check', 'true');\\\\\\\\n                    }\\\\\\\\n                    jxList.unbind('click').click(function(e) {\\\\\\\\n                        e.stopPropagation();\\\\\\\\n                        if ($(this).attr('check') !== \\\\\\\\\\\\\\\"true\\\\\\\\\\\\\\\") {\\\\\\\\n                            $(this).attr('check', 'true');\\\\\\\\n                            arr.unshift($(this).text());\\\\\\\\n                            $(inputid).val(arr);\\\\\\\\n                            $('.myChoice').text(arr);\\\\\\\\n                        } else {\\\\\\\\n                            $(this).attr('check', 'false');\\\\\\\\n                            for (var a = 0; a < arr.length; a++) {\\\\\\\\n                                if (arr[a] == $(this).text()) {\\\\\\\\n                                    arr.splice(a, 1);\\\\\\\\n                                    $(inputid).val(arr);\\\\\\\\n                                    $('.myChoice').text(arr);\\\\\\\\n                                }\\\\\\\\n                            }\\\\\\\\n                        }\\\\\\\\n                    })\\\\\\\\n                }\\\\\\\\n            } else if($('.jx-ul').css('display')=='none'){\\\\\\\\n                $('.cj-ul').slideToggle();\\\\\\\\n                e.stopPropagation();\\\\\\\\n                for (let i = 0; i < len2; i++) {\\\\\\\\n                    var cjList = $('.cj-ul li').eq(i);\\\\\\\\n                    if ($(inputid).val() == cjList.text()) {\\\\\\\\n                        cjList.attr('check', 'true');\\\\\\\\n                    }\\\\\\\\n                    cjList.unbind('click').click(function() {\\\\\\\\n                        if (i !== 0) {\\\\\\\\n                            $(inputid).val($(this).text());\\\\\\\\n                            $(this).attr('check', 'true');\\\\\\\\n                            $(this).siblings().attr('check', 'false');\\\\\\\\n                        }\\\\\\\\n                    })\\\\\\\\n                }\\\\\\\\n            }\\\\\\\\n        });\\\\\\\\n        $(document).not($('.xlList')).click(function(e) {\\\\\\\\n            $('.jx-ul').slideUp();\\\\\\\\n            $('.cj-ul').slideUp();\\\\\\\\n            $('.lieb button').text('☰');\\\\\\\\n            $('.lieb button').css('background', '');\\\\\\\\n        })\\\\\\\\n        $('label').dblclick(function(){\\\\\\\\n            let inputid = '#' + $(this).next().attr('id');\\\\\\\\n            $(inputid).val('');\\\\\\\\n        })\\\\\\\\n    })\\\\\\\\n    \\\\\\\\n    function Toast(msg,duration){  \\\\\\\\n        duration=isNaN(duration)?2000:duration;  \\\\\\\\n        var m = document.createElement('div');  \\\\\\\\n        m.innerHTML = msg;  \\\\\\\\n        m.style.cssText=\\\\\\\\\\\\\\\"width:45%; min-width:150px; background:#311; opacity:0.6; height:auto;min-height: 45px; color:#fff; line-height:45px; text-align:center; border-radius:10px; position:fixed; top:60%; left:26%; z-index:999999;\\\\\\\\\\\\\\\";  \\\\\\\\n        document.body.appendChild(m);  \\\\\\\\n        setTimeout(function() {  \\\\\\\\n            var d = 0.5;  \\\\\\\\n            m.style.webkitTransition = '-webkit-transform ' + d + 's ease-in, opacity ' + d + 's ease-in';  \\\\\\\\n            m.style.opacity = '0';  \\\\\\\\n            setTimeout(function() { document.body.removeChild(m) }, d * 1000);  \\\\\\\\n        }, duration);  \\\\\\\\n    }  \\\\\\\\n\\\\\\\\n    function openDnPage(){\\\\\\\\n        fba.open(JSON.stringify({\\\\\\\\n            rule: \\\\\\\\\\\\\\\"=^_^=\\\\\\\\\\\\\\\",\\\\\\\\n            title: \\\\\\\\\\\\\\\"管理解析\\\\\\\\\\\\\\\",\\\\\\\\n            url: \\\\\\\\\\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=编辑#noHistory#\\\\\\\\\\\\\\\",\\\\\\\\n            group: \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\",\\\\\\\\n            col_type: \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\",\\\\\\\\n            //findRule: \\\\\\\\\\\\\\\"js:this.d=[];$.require(\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"hiker://page/Parse_Dn.js?rule=MyFieldᴰⁿ\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\").edit();setResult(d);\\\\\\\\\\\\\\\",\\\\\\\\n            preRule: \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\",\\\\\\\\n            extra: {}\\\\\\\\n        }));\\\\\\\\n    }\\\\\\\\n    function cancel(){\\\\\\\\n        if(mySet==''){\\\\\\\\n            fy_bridge_app.writeFile(oldRoute, JSON.stringify(settings, null, 4));\\\\\\\\n            fy_bridge_app.refreshPage(true);\\\\\\\\n        }else{\\\\\\\\n            fy_bridge_app.back(false);\\\\\\\\n        }\\\\\\\\n    }\\\\\\\\n    function clickme(msg,duration,title){\\\\\\\\n        for(let i = 0; i < boxData.length; i++){\\\\\\\\n            let id = boxData[i].id;\\\\\\\\n            settings[id] = Did(id).value;\\\\\\\\n            if(settings.qju == ''){\\\\\\\\n                settings.qju = '默认';\\\\\\\\n            }\\\\\\\\n        }\\\\\\\\n        if (mySelect[0] != undefined) {\\\\\\\\n            eval('var bcConfig=' + fy_bridge_app.fetch(newRoute));\\\\\\\\n            Object.assign(bcConfig.settings, settings);\\\\\\\\n            fy_bridge_app.writeFile(newRoute, $$$.stringify(bcConfig));\\\\\\\\n        }\\\\\\\\n        fy_bridge_app.writeFile(oldRoute, $$$.stringify(settings));\\\\\\\\n            \\\\\\\\n        Toast(msg,duration);\\\\\\\\n        if(title==\\\\\\\\\\\\\\\"关\\\\\\\\\\\\\\\"){\\\\\\\\n            if(sfRefresh != Did(\\\\\\\\\\\\\\\"cj\\\\\\\\\\\\\\\").value){\\\\\\\\n                fy_bridge_app.back();\\\\\\\\n            }else{\\\\\\\\n                fy_bridge_app.back(false);\\\\\\\\n            }\\\\\\\\n        }else{\\\\\\\\n            fy_bridge_app.refreshPage(true);\\\\\\\\n        }\\\\\\\\n    }\\\\\\\\n\\\\\\\\n</script>   \\\\\\\\n</html>\\\\\\\"},{\\\\\\\"col_type\\\\\\\":\\\\\\\"movie_3\\\\\\\",\\\\\\\"name\\\\\\\":\\\\\\\"Parse_Dn.js\\\\\\\",\\\\\\\"path\\\\\\\":\\\\\\\"Parse_Dn.js\\\\\\\",\\\\\\\"rule\\\\\\\":\\\\\\\"//============免嗅调用============\\\\\\\\n//－－－=^_^=\\\\\\\\n\\\\\\\\nvar version = \\\\\\\\\\\\\\\"3.5.1\\\\\\\\\\\\\\\";\\\\\\\\nvar updateDate = '2021/10/30/22:22';\\\\\\\\nvar _mySet = {\\\\\\\\n    qju: '默认',\\\\\\\\n    cjcache: 'hiker://files/cache/Parse_Dn.js',\\\\\\\\n    x5cache: 'hiker://files/cache/Parse_Dn.html',\\\\\\\\n    oldConfig: 'hiker://files/cache/MyParseSet.json',\\\\\\\\n    ckLink: 'https://code.aliyun.com/AI957/Hiker/raw/master/v/',\\\\\\\\n    cj: 'https://code.aliyun.com/AI957/Hiker/raw/master/v/CloudParse-V2_Dn.js',\\\\\\\\n    x5Url: 'https://code.aliyun.com/AI957/Hiker/raw/master/v/Parse_Dn.html',\\\\\\\\n    parseRoute: 'hiker://files/rules/DuanNian/MyParse.json',\\\\\\\\n    x5Route: 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/Parse_Dn.html'\\\\\\\\n};\\\\\\\\nvar MyParseS = {};\\\\\\\\nvar mySet = _mySet;\\\\\\\\nif (fileExist(_mySet.parseRoute)) {\\\\\\\\n    eval('var parseFile =' + fetch(_mySet.parseRoute));\\\\\\\\n    MyParseS = parseFile.codes;\\\\\\\\n    mySet = parseFile.settings;\\\\\\\\n}\\\\\\\\n\\\\\\\\nvar parseTitle = [\\\\\\\\n    \\\\\\\\\\\\\\\"yun1717\\\\\\\\\\\\\\\",\\\\\\\\n    \\\\\\\\\\\\\\\"PanGu\\\\\\\\\\\\\\\",\\\\\\\\n    \\\\\\\\\\\\\\\"FuXing\\\\\\\\\\\\\\\",\\\\\\\\n    \\\\\\\\\\\\\\\"https://jxx.smys8.cn/index.php?url=\\\\\\\\\\\\\\\",\\\\\\\\n    \\\\\\\\\\\\\\\"https://okjx.cc/?url=\\\\\\\\\\\\\\\",\\\\\\\\n    \\\\\\\\\\\\\\\"https://jx.m3u8.tv/jiexi/?url=\\\\\\\\\\\\\\\",\\\\\\\\n    \\\\\\\\\\\\\\\"https://sb.5gseo.net/?url=\\\\\\\\\\\\\\\"\\\\\\\\n];\\\\\\\\n\\\\\\\\n//－－－=^_^=\\\\\\\\n\\\\\\\\n//接口设置.\\\\\\\\n\\\\\\\\nvar setUrl = \\\\\\\\\\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noRecordHistory#\\\\\\\\\\\\\\\";\\\\\\\\nvar set_switch = setUrl;\\\\\\\\nvar lazy = `eval('var config =' + fetch(getVar('oldConfig')));eval(fetch(config.cj));aytmParse(input)`;\\\\\\\\n\\\\\\\\n//var parwix = `var yurl='https://daili.mayixiongdi.cn/?url=';Referer': 'https://www.mayixiongdi.cn/ys?id=';'https://daili.mayixiongdi.cn/api.php', 'Referer':'https://daili.mayixiongdi.cn';\\\\\\\\n// 全民https://pcvideoaliyun.tianshangrenjian.mgtv.com.88wuma.com/?url=\\\\\\\\n\\\\\\\\n//－－－备 用－－－\\\\\\\\n/*\\\\\\\\n * 影视工场： https://ysgc.cc/\\\\\\\\n * 江湖: 555电影 https://www.555dy2.com/phone.html ｜ 17看 http://17kanyy.cn/ http://jhjiexi.30vr.cn/?url= ｜ http://api.maizimall.com/index.php?url=\\\\\\\\n * 江湖: http://www.tianshuyun.net/index.php/vod/play/id/448377/sid/1/nid/1.html\\\\\\\\n * 江湖2: http://98hyk.cn/index.php/vod/play/id/72841/sid/1/nid/1.html\\\\\\\\n * 人人迷: https://vip.susou.tv/player/?url= ｜ https://www.momdm.cc/\\\\\\\\n * \\\\\\\\n * wuigen: https://www.5igen.com/dmplayer/player/?url=\\\\\\\\n * 干饭(人人迷): https://jx.zui.cm/?url=\\\\\\\\n * https://2.66movie.top/player/?url=\\\\\\\\n * \\\\\\\\n */\\\\\\\\n\\\\\\\\n\\\\\\\\nvar tools = {\\\\\\\\n    MD5: function(data) {\\\\\\\\n        eval(getCryptoJS());\\\\\\\\n        return CryptoJS.MD5(data).toString(CryptoJS.enc.Hex);\\\\\\\\n    },\\\\\\\\n    AES: function(text, key, iv, isEncrypt) {\\\\\\\\n        eval(getCryptoJS());\\\\\\\\n        var key = CryptoJS.enc.Utf8.parse(key);\\\\\\\\n        var iv = CryptoJS.enc.Utf8.parse(iv);\\\\\\\\n        if (isEncrypt) {\\\\\\\\n            return CryptoJS.AES.encrypt(text, key, {\\\\\\\\n                iv: iv,\\\\\\\\n                mode: CryptoJS.mode.CBC,\\\\\\\\n                padding: CryptoJS.pad.Pkcs7\\\\\\\\n            }).toString();\\\\\\\\n        };\\\\\\\\n        return CryptoJS.AES.decrypt(text, key, {\\\\\\\\n            iv: iv,\\\\\\\\n            padding: CryptoJS.pad.Pkcs7\\\\\\\\n        }).toString(CryptoJS.enc.Utf8);\\\\\\\\n    },\\\\\\\\n    //ascii\\\\\\\\n    nextCharacter: function(asciiValue, k) {\\\\\\\\n        var s = asciiValue;\\\\\\\\n        return String.fromCharCode(s + k);\\\\\\\\n    },\\\\\\\\n    //凯撒\\\\\\\\n    caesarCipher: function(stringValue, k) {\\\\\\\\n        var newString = \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\";\\\\\\\\n        for (var i = 0; i < stringValue.length; i++) {\\\\\\\\n            newString += this.nextCharacter(stringValue[i].charCodeAt(), k);\\\\\\\\n        }\\\\\\\\n        return newString;\\\\\\\\n    },\\\\\\\\n    nowDate: function() {\\\\\\\\n        var date1 = new Date();\\\\\\\\n        var dateStr = \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\";\\\\\\\\n        if (date1) {\\\\\\\\n            dateStr = date1.getFullYear();\\\\\\\\n            var month = date1.getMonth() + 1;\\\\\\\\n            var day = date1.getDate();\\\\\\\\n            if (month < 10) {\\\\\\\\n                dateStr += \\\\\\\\\\\\\\\"-0\\\\\\\\\\\\\\\" + month;\\\\\\\\n            } else {\\\\\\\\n                dateStr += \\\\\\\\\\\\\\\"-\\\\\\\\\\\\\\\" + month;\\\\\\\\n            }\\\\\\\\n            if (day < 10) {\\\\\\\\n                dateStr += \\\\\\\\\\\\\\\"-0\\\\\\\\\\\\\\\" + day;\\\\\\\\n            } else {\\\\\\\\n                dateStr += \\\\\\\\\\\\\\\"-\\\\\\\\\\\\\\\" + day;\\\\\\\\n            }\\\\\\\\n        }\\\\\\\\n        return dateStr;\\\\\\\\n    },\\\\\\\\n    toJSON: function(json) {\\\\\\\\n        return JSON.stringify(json, (key, value) => {\\\\\\\\n            if (typeof value == 'function') {\\\\\\\\n                return value.toString();\\\\\\\\n            } else {\\\\\\\\n                return value;\\\\\\\\n            }\\\\\\\\n        }, 4);\\\\\\\\n    },\\\\\\\\n    toVNum: function(a) {\\\\\\\\n        var a = a.toString();\\\\\\\\n        var c = a.split('.');\\\\\\\\n        var num_place = [\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"00\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"000\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"0000\\\\\\\\\\\\\\\"],\\\\\\\\n            r = num_place.reverse();\\\\\\\\n        for (var i = 0; i < c.length; i++) {\\\\\\\\n            var len = c[i].length;\\\\\\\\n            c[i] = r[len] + c[i];\\\\\\\\n        }\\\\\\\\n        var res = c.join('');\\\\\\\\n        return res;\\\\\\\\n    },\\\\\\\\n    cprVersion: function(a, b) {\\\\\\\\n        var _a = parseInt(this.toVNum(a)),\\\\\\\\n            _b = parseInt(this.toVNum(b));\\\\\\\\n        b = isNaN(_b) ? version : b;\\\\\\\\n        if (_a > _b) {\\\\\\\\n            putVar('jxNewV', '有新版本: ' + a);\\\\\\\\n        } else {\\\\\\\\n            clearVar('jxNewV');\\\\\\\\n        }\\\\\\\\n        putVar('jxOldV', b);\\\\\\\\n    }\\\\\\\\n};\\\\\\\\n\\\\\\\\nif (getVar(\\\\\\\\\\\\\\\"jxOldV\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\") != version) {\\\\\\\\n    putVar('cjCache', _mySet.cjcache);\\\\\\\\n    putVar('x5Cache', _mySet.x5Cache);\\\\\\\\n    putVar('oldConfig', _mySet.oldConfig);\\\\\\\\n    putVar('parseRoute', _mySet.parseRoute);\\\\\\\\n    let mayck = 'https://gitee.com/Duan-Nian/Dn/raw/master/hikerview/';\\\\\\\\n    let jxNewV = fetch(mayck + 'ParseVersion.txt'),\\\\\\\\n        jxOldV = (fetch(_mySet.cjcache).split('version = \\\\\\\\\\\\\\\"')[1] + '').split('\\\\\\\\\\\\\\\"')[0];\\\\\\\\n    tools.cprVersion(jxNewV, jxOldV);\\\\\\\\n    writeFile('hiker://files/cache/x5ParseLanJie.txt', fetch(mayck + 'x5ParseLanJie.txt'));\\\\\\\\n}\\\\\\\\n\\\\\\\\nvar ParseS = {};\\\\\\\\nvar originalParseS = {\\\\\\\\n    //updateDate: updateDate,\\\\\\\\n    CityIP: 'http://pv.sohu.com/cityjson',\\\\\\\\n    pcUA: 'User-Agent@Mozilla/5.0 (Windows NT 10.0\\\\\\\\\\\\\\\\；\\\\\\\\\\\\\\\\； WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36',\\\\\\\\n    cacheM3u8: function(vUrl, ref) {\\\\\\\\n        try {\\\\\\\\n            var m3u8 = fetch(vUrl, {});\\\\\\\\n            writeFile('hiker://files/cache/videos.m3u8', m3u8);\\\\\\\\n        } catch (e) {}\\\\\\\\n        return 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/videos.m3u8#';\\\\\\\\n    },\\\\\\\\n    defaultParse: function(url) {\\\\\\\\n        return url;\\\\\\\\n    },\\\\\\\\n    maoss: function(jxurl, ref, key) {\\\\\\\\n        try {\\\\\\\\n            var getVideoInfo = function(text) {\\\\\\\\n                return tools.AES(text, key, iv);\\\\\\\\n            };\\\\\\\\n            if (ref) {\\\\\\\\n                var html = request(jxurl, {\\\\\\\\n                    headers: {\\\\\\\\n                        'Referer': ref\\\\\\\\n                    }\\\\\\\\n                });\\\\\\\\n            } else {\\\\\\\\n                var html = request(jxurl);\\\\\\\\n            }\\\\\\\\n            if (html.indexOf('&btwaf=') != -1) {\\\\\\\\n                html = request(jxurl + '&btwaf' + html.match(/&btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], {\\\\\\\\n                    headers: {\\\\\\\\n                        'Referer': ref\\\\\\\\n                    }\\\\\\\\n                })\\\\\\\\n            }\\\\\\\\n            var iv = html.split('bt_token = \\\\\\\\\\\\\\\"')[1].split('\\\\\\\\\\\\\\\"')[0];\\\\\\\\n            eval(html.match(/var config = {[\\\\\\\\\\\\\\\\s\\\\\\\\\\\\\\\\S]*?}/)[0] + '');\\\\\\\\n            if (config.url.slice(0, 4) != 'http') {\\\\\\\\n                config.url = decodeURIComponent(tools.AES(config.url, \\\\\\\\\\\\\\\"dvyYRQlnPRCMdQSe\\\\\\\\\\\\\\\", iv));\\\\\\\\n            }\\\\\\\\n            return config.url;\\\\\\\\n        } catch (e) {\\\\\\\\n            return '';\\\\\\\\n        }\\\\\\\\n    },\\\\\\\\n    LLQ: function(jxurl) {\\\\\\\\n        try {\\\\\\\\n            var api = jxurl.split('?url=')[0] + \\\\\\\\\\\\\\\"api.php\\\\\\\\\\\\\\\";\\\\\\\\n            var b64id = base64Encode(jxurl.split('url=')[1]);\\\\\\\\n            var parseid = tools.caesarCipher(b64id, -1);\\\\\\\\n            var json = JSON.parse(request(api, {\\\\\\\\n                headers: {\\\\\\\\n                    'Referer': jxurl\\\\\\\\n                },\\\\\\\\n                method: 'POST',\\\\\\\\n                body: 'url=' + parseid\\\\\\\\n            }));\\\\\\\\n            url = (json.code == 200 ? base64Decode(tools.caesarCipher(json.url, -1)) : '');\\\\\\\\n            return url;\\\\\\\\n        } catch (e) {\\\\\\\\n            return '';\\\\\\\\n        }\\\\\\\\n    },\\\\\\\\n    PanGu: function(vipUrl, data) {\\\\\\\\n        /*var ref = 'https://www.pangujiexi.com/';\\\\\\\\n        var parse = 'https://panguapi.ntryjd.net/jiexi/?url=' + vipUrl;\\\\\\\\n        var api = 'https://panguapi.ntryjd.net/jiexi/api.php';\\\\\\\\n        */\\\\\\\\n        //var ref = 'https://xmystv.com/';\\\\\\\\n        //var parse = 'https://www.99kpw.com/pangu/index.php?url=' + tailUrl;\\\\\\\\n        //var api = 'https://www.99kpw.com/pangu/api.php';\\\\\\\\n        var parse = \\\\\\\\\\\\\\\"https://www.pangujiexi.com/pangu/?url=\\\\\\\\\\\\\\\" + vipUrl;\\\\\\\\n        var api = \\\\\\\\\\\\\\\"https://panguapi.ntryjd.net/pangu2021/api.php\\\\\\\\\\\\\\\";\\\\\\\\n        if (data) {\\\\\\\\n            ref = data[0];\\\\\\\\n            parse = data[1];\\\\\\\\n            api = data[2];\\\\\\\\n        }\\\\\\\\n        var Time = (Math.floor(new Date().getTime() / 1000) * 1).toString();\\\\\\\\n        var json = request(api, {\\\\\\\\n            headers: {\\\\\\\\n                \\\\\\\\\\\\\\\"Referer\\\\\\\\\\\\\\\": parse\\\\\\\\n            },\\\\\\\\n            body: \\\\\\\\\\\\\\\"url=\\\\\\\\\\\\\\\" + vipUrl + \\\\\\\\\\\\\\\"&referer=\\\\\\\\\\\\\\\" + base64Encode(parse) + \\\\\\\\\\\\\\\"&ref=1&time=\\\\\\\\\\\\\\\" + Time + \\\\\\\\\\\\\\\"&type=&other=\\\\\\\\\\\\\\\" + base64Encode(vipUrl) + \\\\\\\\\\\\\\\"&ios=0\\\\\\\\\\\\\\\",\\\\\\\\n            method: \\\\\\\\\\\\\\\"POST\\\\\\\\\\\\\\\"\\\\\\\\n        });\\\\\\\\n        var url = json[0] == \\\\\\\\\\\\\\\"{\\\\\\\\\\\\\\\" ? JSON.parse(json).url : \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\";\\\\\\\\n        return url;\\\\\\\\n    },\\\\\\\\n    yun1717: function(vipUrl) {\\\\\\\\n        var isyk = vipUrl.indexOf('youku');\\\\\\\\n        var ref = \\\\\\\\\\\\\\\"https://www.1717yun.com/jx/ty.php?url=\\\\\\\\\\\\\\\" + vipUrl;\\\\\\\\n        var parse = \\\\\\\\\\\\\\\"https://1717yun.com.zh188.net/0828/?url=\\\\\\\\\\\\\\\" + vipUrl;\\\\\\\\n        var api = \\\\\\\\\\\\\\\"https://1717yun.com.zh188.net/1004/..index..php\\\\\\\\\\\\\\\";\\\\\\\\n        return isyk == -1 ? this.PanGu(vipUrl, [ref, parse, api]) : this.PanGu(vipUrl, [ref + ',vip:', parse + ',vip:', api]);\\\\\\\\n    },\\\\\\\\n    FuXing: function(vipUrl) {\\\\\\\\n        try {\\\\\\\\n            //if(vipUrl.indexOf('v.youku')!=-1){\\\\\\\\n            //    vipUrl = (JSON.parse(request(vipUrl, {redirect:false, withHeaders:true})).headers.location + '').replace(/\\\\\\\\\\\\\\\\?.*/,'');\\\\\\\\n            //}\\\\\\\\n            var ref = 'https://jx.xuetuiguang.cn/jiexi/?url=' + vipUrl;\\\\\\\\n            var parse = ref;\\\\\\\\n            var api = 'https://jx.xuetuiguang.cn/jiexi/apiu_fx.php';\\\\\\\\n            return this.PanGu(vipUrl, [ref, parse, api]);\\\\\\\\n        } catch (e) {\\\\\\\\n            return '';\\\\\\\\n        }\\\\\\\\n    },\\\\\\\\n};\\\\\\\\n\\\\\\\\nObject.assign(ParseS, originalParseS, MyParseS);\\\\\\\\n//覆盖顺序，第三个覆盖第二个然后覆盖第一个\\\\\\\\n\\\\\\\\n\\\\\\\\nfunction aytmParse(vipUrl) {\\\\\\\\n    this.request = function(param0, param1, param2) {\\\\\\\\n        param1 = param1 == undefined ? {} : param1;\\\\\\\\n        param1.timeout = 2500;\\\\\\\\n        param2 = MY_RULE;\\\\\\\\n        var retStr = method_request.invoke(javaContext, param0, param1, param2);\\\\\\\\n        return retStr == null ? retStr : retStr + \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\";\\\\\\\\n    };\\\\\\\\n    this.fetch = function(param0, param1, param2) {\\\\\\\\n        param1 = param1 == undefined ? {} : param1;\\\\\\\\n        param1.headers = param1.headers == undefined ? {} : param1.headers;\\\\\\\\n        param1.headers['User-Agent'] = PC_UA;\\\\\\\\n        param1.timeout = 2500;\\\\\\\\n        param2 = MY_RULE;\\\\\\\\n        var retStr = method_fetch.invoke(javaContext, param0, param1, param2);\\\\\\\\n        return retStr == null ? retStr : retStr + \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\";\\\\\\\\n    };\\\\\\\\n    var host = vipUrl.match(/\\\\\\\\\\\\\\\\.(.*?)\\\\\\\\\\\\\\\\//);\\\\\\\\n    host = host == null ? null : host[1];\\\\\\\\n    var noUrl = \\\\\\\\\\\\\\\"toast://接收到的链接为: \\\\\\\\\\\\\\\";\\\\\\\\n    switch (mySet.qju) {\\\\\\\\n        case \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\":\\\\\\\\n        case \\\\\\\\\\\\\\\"默认\\\\\\\\\\\\\\\":\\\\\\\\n            switch (host) {\\\\\\\\n                case \\\\\\\\\\\\\\\"qq.com\\\\\\\\\\\\\\\":\\\\\\\\n                    str = mySet.tx;\\\\\\\\n                    break;\\\\\\\\n                case \\\\\\\\\\\\\\\"iqiyi.com\\\\\\\\\\\\\\\":\\\\\\\\n                    str = mySet.qy;\\\\\\\\n                    break;\\\\\\\\n                case \\\\\\\\\\\\\\\"youku.com\\\\\\\\\\\\\\\":\\\\\\\\n                    str = mySet.yk;\\\\\\\\n                    break;\\\\\\\\n                case \\\\\\\\\\\\\\\"mgtv.com\\\\\\\\\\\\\\\":\\\\\\\\n                    str = mySet.mg;\\\\\\\\n                    break;\\\\\\\\n                case \\\\\\\\\\\\\\\"bilibili.com\\\\\\\\\\\\\\\":\\\\\\\\n                    str = mySet.bl;\\\\\\\\n                    break;\\\\\\\\n                default:\\\\\\\\n                    str = host == null ? noUrl : mySet.oth;\\\\\\\\n                    break;\\\\\\\\n            }\\\\\\\\n            break;\\\\\\\\n        default:\\\\\\\\n            str = host == null ? noUrl : mySet.qju;\\\\\\\\n            break;\\\\\\\\n    }\\\\\\\\n    let myChoice = str.split(',');\\\\\\\\n    let len = myChoice.length;\\\\\\\\n    for (let i = 0; i < len; i++) {\\\\\\\\n        let name = myChoice[i];\\\\\\\\n        if (typeof ParseS[name] == 'function') {\\\\\\\\n            let url = ParseS[name](vipUrl);\\\\\\\\n            if (i != len - 1 && !/m3u8|mp4|http/.test(url)) {\\\\\\\\n                continue;\\\\\\\\n            }\\\\\\\\n            if (url[0] == '/') {\\\\\\\\n                url = 'https:' + url\\\\\\\\n            }\\\\\\\\n            if (url.indexOf('=http') != -1) {\\\\\\\\n                url = url.indexOf('&url=') > -1 ? url : 'http' + decodeURIComponent(url.split('=http')[1]);\\\\\\\\n            }\\\\\\\\n            /*if(url.match(/mgtv.com/g)=='mgtv.com'){\\\\\\\\n                url = url + ';{Referer@https://www.mgtv.com}';\\\\\\\\n            } else */\\\\\\\\n            if (url.indexOf('.flv') != -1) {\\\\\\\\n                url = url + ';{User-Agent@app&&Referer@' + vipUrl + '}';\\\\\\\\n            }\\\\\\\\n            if (url == '' || url == vipUrl) {\\\\\\\\n                return vipUrl;\\\\\\\\n            } else {\\\\\\\\n                return url + '#isVideo=true#';\\\\\\\\n            }\\\\\\\\n        } else if (typeof ParseS[name] == 'string') {\\\\\\\\n            return ParseS.defaultParse(ParseS[name] + vipUrl);\\\\\\\\n        } else {\\\\\\\\n            return name.substr(0, 4) == \\\\\\\\\\\\\\\"http\\\\\\\\\\\\\\\" || host == null ? name + vipUrl : \\\\\\\\\\\\\\\"toast://\\\\\\\\\\\\\\\" + name + \\\\\\\\\\\\\\\" 不是直链也不是免嗅\\\\\\\\\\\\\\\";\\\\\\\\n        }\\\\\\\\n    }\\\\\\\\n};\\\\\\\\n\\\\\\\\nvar playParse = {\\\\\\\\n    player_xx: function(jurl, Label) {\\\\\\\\n        return $(jurl).lazyRule((k) => {\\\\\\\\n            var jsUrl = JSON.parse(fetch(getVar('oldConfig'))).cj;\\\\\\\\n            var Label = k;\\\\\\\\n            var fa = ['letv', 'pptv', 'qq', 'youku', 'qiyi', 'iqiyi', 'mgtv', 'bilibili', 'sohu', 'migu', 'm1905', 'vip'];\\\\\\\\n            var html = parseDom(request(input), Label);\\\\\\\\n            eval(html.replace(/player_.*?={/, 'pdata={'));\\\\\\\\n            eval(fetch(jsUrl));\\\\\\\\n            if (pdata.url.substr(0, 8).match(/JT..JT../)) {\\\\\\\\n                pdata.url = base64Decode(pdata.url);\\\\\\\\n            }\\\\\\\\n            if (pdata.url.substr(0, 8).match(/%..%../)) {\\\\\\\\n                pdata.url = unescape(pdata.url);\\\\\\\\n            }\\\\\\\\n            if (fa.includes(pdata.from) == true) {\\\\\\\\n                return aytmParse(pdata.url);\\\\\\\\n            } else {\\\\\\\\n                return pdata.url + '#isVideo=true#';\\\\\\\\n            }\\\\\\\\n        }, Label)\\\\\\\\n    }\\\\\\\\n};\\\\\\\\n\\\\\\\\nfunction setParse() {\\\\\\\\n    $.require(\\\\\\\\\\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ\\\\\\\\\\\\\\\").setParse();\\\\\\\\n}\\\\\\\\n\\\\\\\\nfunction mzPopup() {\\\\\\\\n    if (getVar(\\\\\\\\\\\\\\\"ijk-tx\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\") == \\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\") {\\\\\\\\n        setItem(\\\\\\\\\\\\\\\"tixing\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\")\\\\\\\\n        clearVar(\\\\\\\\\\\\\\\"ijk-tx\\\\\\\\\\\\\\\")\\\\\\\\n    }\\\\\\\\n    return confirm({\\\\\\\\n        title: '免责声明',\\\\\\\\n        content: '本程序不提供视频解析服务\\\\\\\\\\\\\\\\n所有内容均从用户分享中收集\\\\\\\\\\\\\\\\n仅供测试和学习交流\\\\\\\\\\\\\\\\n\\\\\\\\\\\\\\\\n确定即认可，不再提醒',\\\\\\\\n        confirm: $.toString(() => {\\\\\\\\n            putVar(\\\\\\\\\\\\\\\"ijk-tx\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\");\\\\\\\\n            refreshPage(false);\\\\\\\\n            return \\\\\\\\\\\\\\\"toast://您点击了确认\\\\\\\\\\\\\\\"\\\\\\\\n        })\\\\\\\\n    })\\\\\\\\n}\\\\\\\\nif (getItem(\\\\\\\\\\\\\\\"tixing\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\") == \\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\") {\\\\\\\\n    mzPopup();\\\\\\\\n}\\\\\\\\n\\\\\\\\n//===========解析代码结束===========\\\\\\\\n\\\\\\\\nfunction saveButton(content) {\\\\\\\\n    var data = content.split('★★★');\\\\\\\\n    if (data.length == 2) {\\\\\\\\n        var _dt = parsePaste(data[0]);\\\\\\\\n        content = _dt.substr(0, 6) != 'error:' ? _dt : '';\\\\\\\\n    }\\\\\\\\n    data = content.split('★');\\\\\\\\n    var type = data[0];\\\\\\\\n    var arrList = [];\\\\\\\\n    var objCode = {};\\\\\\\\n    if (data.length > 2 && data[0] != '直链') {\\\\\\\\n        var objKey = data[1];\\\\\\\\n        var objValue = data[2];\\\\\\\\n        if (type == 'MyParseS') {\\\\\\\\n            objValue = base64Decode(objValue);\\\\\\\\n        }\\\\\\\\n        if (objValue.split('function').length > 1) {\\\\\\\\n            eval('objValue=' + objValue);\\\\\\\\n        }\\\\\\\\n        arrList.splice(0, 0, objKey);\\\\\\\\n        objCode[objKey] = objValue;\\\\\\\\n\\\\\\\\n    } else if (type == '直链') {\\\\\\\\n        arrList = data;\\\\\\\\n        arrList.splice(0, 1);\\\\\\\\n    } else {\\\\\\\\n        arrList = null;\\\\\\\\n    }\\\\\\\\n    if (arrList != null) {\\\\\\\\n        var parseRoute = getVar('parseRoute');\\\\\\\\n        eval('var json =' + fetch(parseRoute));\\\\\\\\n        arrList = arrList.concat(json.title);\\\\\\\\n        json.title = Array.from(new Set(arrList));\\\\\\\\n        Object.assign(json.codes, objCode);\\\\\\\\n        if (type == '测试') {\\\\\\\\n            eval('var config =' + fetch(getVar('oldConfig')));\\\\\\\\n            eval(fetch(config.cj));\\\\\\\\n            if (typeof ParseS[data[1]] == \\\\\\\\\\\\\\\"function\\\\\\\\\\\\\\\") {\\\\\\\\n                return ParseS[data[1]](data[2]);\\\\\\\\n            } else {\\\\\\\\n                return ParseS.defaultParse(ParseS[data[1]] + data[2]);\\\\\\\\n            }\\\\\\\\n        } else {\\\\\\\\n            writeFile(parseRoute, $.stringify(json));\\\\\\\\n            return \\\\\\\\\\\\\\\"toast://已保存内容\\\\\\\\\\\\\\\";\\\\\\\\n        }\\\\\\\\n    } else {\\\\\\\\n        return \\\\\\\\\\\\\\\"toast://无法识别这个内容呢\\\\\\\\\\\\\\\"\\\\\\\\n    }\\\\\\\\n}\\\\\\\\n\\\\\\\\nif (getItem('updateDate') != updateDate) {\\\\\\\\n    var functionCode = saveButton + '';\\\\\\\\n    writeFile('hiker://files/cache/plscParse.html', fetch(_mySet.ckLink + 'plscParse.html'));\\\\\\\\n    setItem('myFunction', functionCode);\\\\\\\\n    setItem('updateDate', updateDate);\\\\\\\\n}\\\\\\\\nvar bjItem = {\\\\\\\\n    hfPlugin: function(parseRoute) {\\\\\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\\\\\n            if (fileExist(k) == true) {\\\\\\\\n                var cjcache = getVar('cjCache');\\\\\\\\n                eval('var json =' + fetch(k));\\\\\\\\n                json.settings.cj = cjcache;\\\\\\\\n                writeFile(k, $.stringify(json));\\\\\\\\n                var oldRoute = getVar('oldConfig');\\\\\\\\n                var oldConfig = json.settings;\\\\\\\\n                oldConfig.cj = cjcache;\\\\\\\\n                writeFile(oldRoute, $.stringify(oldConfig));\\\\\\\\n                refreshPage(false);\\\\\\\\n                return 'toast://恢复成功';\\\\\\\\n            } else {\\\\\\\\n                return 'toast://需要先拉取列表'\\\\\\\\n            }\\\\\\\\n        }, parseRoute)\\\\\\\\n    },\\\\\\\\n    pullCode: function(k) {\\\\\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\\\\\n            var pullMode = k[0];\\\\\\\\n            var parseRoute = k[1];\\\\\\\\n            var parseFile = fetch(parseRoute);\\\\\\\\n            if (!parseFile) {\\\\\\\\n                var settings = fetch(getVar('oldConfig'));\\\\\\\\n                settings = settings == '' ? {} : JSON.parse(settings);\\\\\\\\n                var json = {};\\\\\\\\n                json.settings = settings;\\\\\\\\n                json.title = [];\\\\\\\\n                json.codes = {};\\\\\\\\n            } else {\\\\\\\\n                eval('var json =' + parseFile);\\\\\\\\n            }\\\\\\\\n            var tishi = 'toast://抱歉!无法识别这个内容呢╯﹏╰';\\\\\\\\n            var cjLink = getVar('pluginLink');\\\\\\\\n            var Contents = cjLink == 'Q神' ? pullMode + '★' + fetch('hiker://files/jiexi/jiexi.txt') : cjLink;\\\\\\\\n            try {\\\\\\\\n                var yPaste = parsePaste(Contents).split('@base64://');\\\\\\\\n                if (yPaste.length == 2) {\\\\\\\\n                    Contents = base64Decode(yPaste[1]);\\\\\\\\n                } else if (cjLink.substr(0, 5) == 'hiker' || cjLink.substr(0, 4) == 'http') {\\\\\\\\n                    Contents = fetch(cjLink);\\\\\\\\n                }\\\\\\\\n                var jcKL = Contents.split('★');\\\\\\\\n                var isKL = jcKL[0];\\\\\\\\n                if (jcKL.length == 2) {\\\\\\\\n                    isKL = isKL == '' ? pullMode : isKL;\\\\\\\\n                    Contents = jcKL[1].split('\\\\\\\\\\\\\\\\n');\\\\\\\\n                    if (Contents[0] == '') {\\\\\\\\n                        Contents.splice(0, 1)\\\\\\\\n                    }\\\\\\\\n                }\\\\\\\\n                var addTitle = [],\\\\\\\\n                    addCode = {};\\\\\\\\n                if (('' + Contents[0]).split('&&').length == 2) {\\\\\\\\n                    for (let i = 0; i < Contents.length; i++) {\\\\\\\\n                        let arr = Contents[i].split('&&');\\\\\\\\n                        let title = arr[0] + '(x5)',\\\\\\\\n                            url = arr[1];\\\\\\\\n                        if (pullMode == '免嗅') {\\\\\\\\n                            addTitle.push(title)\\\\\\\\n                            addCode[title] = url;\\\\\\\\n                        } else {\\\\\\\\n                            addTitle.push(url);\\\\\\\\n                        }\\\\\\\\n                    }\\\\\\\\n                } else if (isKL == '直链' && pullMode == '直链') {\\\\\\\\n                    addTitle = Contents;\\\\\\\\n                }\\\\\\\\n                if (addTitle[0] == undefined) {\\\\\\\\n                    eval(Contents);\\\\\\\\n                    if (typeof originalParseS == 'object') {\\\\\\\\n                        addCode = originalParseS;\\\\\\\\n                    } else {\\\\\\\\n                        addCode = ParseS;\\\\\\\\n                    }\\\\\\\\n                    var scObject = [\\\\\\\\\\\\\\\"parseLc\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"gparse\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"nparse\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"Mao全网\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"ds973\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"parwix\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"OJBK\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"91解析\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"人人迷\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"江湖\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"久播\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"骚火\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"LK解析\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"小狼云\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"九八看\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"思云解析\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"CityIP\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"pcUA\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"cacheM3u8\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"defaultParse\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"maoss\\\\\\\\\\\\\\\", \\\\\\\\\\\\\\\"LLQ\\\\\\\\\\\\\\\"];\\\\\\\\n                    for (var i = 0; i < scObject.length; i++) {\\\\\\\\n                        delete addCode[scObject[i]];\\\\\\\\n                    }\\\\\\\\n                    if (typeof parseTitle == 'object') {\\\\\\\\n                        addTitle = parseTitle;\\\\\\\\n                    } else {\\\\\\\\n                        addTitle = Object.keys(addCode);\\\\\\\\n                    }\\\\\\\\n                }\\\\\\\\n                var oldSL = json.title.length;\\\\\\\\n                var newTitle = json.title.concat(addTitle);\\\\\\\\n                json.title = Array.from(new Set(newTitle));\\\\\\\\n                if (pullMode == '免嗅') {\\\\\\\\n                    Object.assign(json.codes, addCode);\\\\\\\\n                }\\\\\\\\n                var newSL = json.title.length - oldSL;\\\\\\\\n                var coverSL = newTitle.length - json.title.length;\\\\\\\\n                coverSL = coverSL == 0 ? '' : ', 覆盖了' + coverSL + '个';\\\\\\\\n                //var newFile = tools.toJSON(json);//自定义stringify函数，带有转义字符\\\\\\\\n                var newFile = $.stringify(json); //JSON.parse会报错\\\\\\\\n                writeFile(parseRoute, newFile);\\\\\\\\n                refreshPage(false);\\\\\\\\n                return 'toast://总共导入了' + newSL + '个' + pullMode + '解析' + coverSL;\\\\\\\\n            } catch (e) {\\\\\\\\n                return tishi;\\\\\\\\n            }\\\\\\\\n        }, [k, _mySet.parseRoute])\\\\\\\\n    },\\\\\\\\n    pullScript: function(cj, x5) {\\\\\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\\\\\n            var cjFrom = 'hiker://page/Parse_Dn.js?rule=MyFieldᴰⁿ';\\\\\\\\n            var x5From = 'hiker://page/Parse_Dn.html?rule=MyFieldᴰⁿ';\\\\\\\\n            try {\\\\\\\\n                var cjFile = JSON.parse(fetch(cjFrom)).rule;\\\\\\\\n                cjFile = cjFile.split('解析代码结束')[0];\\\\\\\\n                var x5File = JSON.parse(fetch(x5From)).rule;\\\\\\\\n                writeFile(k[0], cjFile);\\\\\\\\n                writeFile(k[1], x5File);\\\\\\\\n                clearVar('jxOldV');\\\\\\\\n                refreshPage(false);\\\\\\\\n                return 'toast://更新成功';\\\\\\\\n            } catch (e) {\\\\\\\\n                return 'toast://未成功获取内容';\\\\\\\\n            }\\\\\\\\n        }, [cj, x5])\\\\\\\\n    },\\\\\\\\n    xlSelect: function(bianji, lbLength) {\\\\\\\\n        return \\\\\\\\\\\\\\\"select://\\\\\\\\\\\\\\\" + JSON.stringify({\\\\\\\\n            options: ['‘‘’’<span style=\\\\\\\\\\\\\\\"color:red\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"删除||' + bianji + '\\\\\\\\\\\\\\\">删 除', '‘‘’’<span style=\\\\\\\\\\\\\\\"color:#F57474\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"隐藏||' + bianji + '\\\\\\\\\\\\\\\">隐 藏', '‘‘’’<span style=\\\\\\\\\\\\\\\"color:#FF8000\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"修改||' + bianji + '\\\\\\\\\\\\\\\">修 改', '‘‘’’<span style=\\\\\\\\\\\\\\\"color:#098AC1\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"置顶||' + bianji + '0' + '\\\\\\\\\\\\\\\">置 顶', '‘‘’’<span style=\\\\\\\\\\\\\\\"color:#098AC1\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"移动||' + bianji + '\\\\\\\\\\\\\\\">移 动', '‘‘’’<span style=\\\\\\\\\\\\\\\"color:#098AC1\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"置底||' + bianji + lbLength + '\\\\\\\\\\\\\\\">置 底', '‘‘’’<span style=\\\\\\\\\\\\\\\"color:#04B431\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"分享||' + bianji + '\\\\\\\\\\\\\\\">地板分享', '‘‘’’<span style=\\\\\\\\\\\\\\\"color:#04B431\\\\\\\\\\\\\\\" title=\\\\\\\\\\\\\\\"云分享||' + bianji + '\\\\\\\\\\\\\\\">云板分享'],\\\\\\\\n            col: '2',\\\\\\\\n            js: $.toString(() => {\\\\\\\\n                var parseRoute = getVar('parseRoute');\\\\\\\\n                eval('var json =' + fetch(parseRoute));\\\\\\\\n                var newInput = parseDomForHtml(input, 'span&&title').split('||');\\\\\\\\n                var type = newInput[0];\\\\\\\\n                var name = newInput[1];\\\\\\\\n                var num = newInput[2];\\\\\\\\n                var num2 = newInput[3];\\\\\\\\n                switch (type) {\\\\\\\\n                    case \\\\\\\\\\\\\\\"删除\\\\\\\\\\\\\\\":\\\\\\\\n                        return $(\\\\\\\\\\\\\\\"即将删除: \\\\\\\\\\\\\\\" + name).confirm((k) => {\\\\\\\\n                            var name = k[0];\\\\\\\\n                            var num = k[1];\\\\\\\\n                            var parseRoute = getVar('parseRoute');\\\\\\\\n                            eval('var json =' + fetch(parseRoute));\\\\\\\\n                            if (json.codes.hasOwnProperty(name)) {\\\\\\\\n                                delete json.codes[name];\\\\\\\\n                            }\\\\\\\\n                            json.title.splice(num, 1);\\\\\\\\n                            writeFile(parseRoute, $.stringify(json));\\\\\\\\n                            refreshPage(false);\\\\\\\\n                            return \\\\\\\\\\\\\\\"toast://已将〖\\\\\\\\\\\\\\\" + name + \\\\\\\\\\\\\\\"〗删除\\\\\\\\\\\\\\\";\\\\\\\\n                        }, [name, num]);\\\\\\\\n                        break;\\\\\\\\n                    case \\\\\\\\\\\\\\\"隐藏\\\\\\\\\\\\\\\":\\\\\\\\n                        return $(\\\\\\\\\\\\\\\"hiker://empty#noLoading#\\\\\\\\\\\\\\\").lazyRule((k) => {\\\\\\\\n                            var name = k[0];\\\\\\\\n                            var num = k[1];\\\\\\\\n                            var parseRoute = getVar('parseRoute');\\\\\\\\n                            eval('var json =' + fetch(parseRoute));\\\\\\\\n                            if (json.codes.hasOwnProperty(name)) {\\\\\\\\n                                json.title.splice(num, 1);\\\\\\\\n                                writeFile(parseRoute, $.stringify(json));\\\\\\\\n                                refreshPage(false);\\\\\\\\n                                return \\\\\\\\\\\\\\\"toast://已将〖\\\\\\\\\\\\\\\" + name + \\\\\\\\\\\\\\\"〗隐藏\\\\\\\\\\\\\\\";\\\\\\\\n                            } else {\\\\\\\\n                                return \\\\\\\\\\\\\\\"toast://可能是个网址, 您可选择删除\\\\\\\\\\\\\\\";\\\\\\\\n                            }\\\\\\\\n                        }, [name, num]);\\\\\\\\n                        break;\\\\\\\\n                    case \\\\\\\\\\\\\\\"修改\\\\\\\\\\\\\\\":\\\\\\\\n                        //if (json.codes[name]) {\\\\\\\\n                        var nCode = name;\\\\\\\\n                        var nName = \\\\\\\\\\\\\\\"这是名称\\\\\\\\\\\\\\\";\\\\\\\\n                        if (json.codes[name]) {\\\\\\\\n                            nCode = json.codes[name].toString();\\\\\\\\n                            nName = name;\\\\\\\\n                        }\\\\\\\\n                        return $(\\\\\\\\\\\\\\\"hiker://empty#noRecordHistory#\\\\\\\\\\\\\\\").rule((k) => {\\\\\\\\n                            var d = [];\\\\\\\\n                            eval(getItem('myFunction'));\\\\\\\\n                            var name = k[0];\\\\\\\\n                            var code = k[1];\\\\\\\\n                            d.push({\\\\\\\\n                                title: '保 存',\\\\\\\\n                                url: saveButton + \\\\\\\\\\\\\\\"saveButton(getVar('input_edit'));back();\\\\\\\\\\\\\\\",\\\\\\\\n                                col_type: \\\\\\\\\\\\\\\"input\\\\\\\\\\\\\\\",\\\\\\\\n                                desc: \\\\\\\\\\\\\\\"建议按默认的代码格式修改哦\\\\\\\\\\\\\\\",\\\\\\\\n                                extra: {\\\\\\\\n                                    onChange: \\\\\\\\\\\\\\\"putVar('input_edit', input)\\\\\\\\\\\\\\\",\\\\\\\\n                                    type: \\\\\\\\\\\\\\\"textarea\\\\\\\\\\\\\\\",\\\\\\\\n                                    height: \\\\\\\\\\\\\\\"-1\\\\\\\\\\\\\\\",\\\\\\\\n                                    titleVisible: false,\\\\\\\\n                                    defaultValue: '修改★' + name + '★' + code,\\\\\\\\n                                }\\\\\\\\n                            });\\\\\\\\n                            d.push({\\\\\\\\n                                title: '‘‘’’<small><span style=\\\\\\\\\\\\\\\"color:#6EB897\\\\\\\\\\\\\\\">格式为：操作类型★标题★function(){自定义内容}<br>请勿填入其他格式',\\\\\\\\n                                url: $('#noLoading#').lazyRule((saveButton) => {\\\\\\\\n                                    saveButton(getVar('input_edit'));\\\\\\\\n                                    back();\\\\\\\\n                                    return 'toast://已保存修改';\\\\\\\\n                                }, saveButton),\\\\\\\\n                                desc: '‘‘’’<big><big><span style=\\\\\\\\\\\\\\\"color:#298A08\\\\\\\\\\\\\\\">保 存',\\\\\\\\n                                col_type: 'text_center_1'\\\\\\\\n                            });\\\\\\\\n                            setResult(d);\\\\\\\\n                        }, [nName, nCode]) //[name, json.codes[name].toString()])\\\\\\\\n                        /*} else {\\\\\\\\n                            return \\\\\\\\\\\\\\\"toast://只有网址或者标题, 不支持修改\\\\\\\\\\\\\\\"\\\\\\\\n                        }*/\\\\\\\\n                        break;\\\\\\\\n                    case \\\\\\\\\\\\\\\"置顶\\\\\\\\\\\\\\\":\\\\\\\\n                    case \\\\\\\\\\\\\\\"置底\\\\\\\\\\\\\\\":\\\\\\\\n                        var item = json.title.splice(num, 1);\\\\\\\\n                        json.title.splice(num2, 0, item[0]);\\\\\\\\n                        writeFile(parseRoute, $.stringify(json));\\\\\\\\n                        refreshPage(false);\\\\\\\\n                        break;\\\\\\\\n                    case \\\\\\\\\\\\\\\"移动\\\\\\\\\\\\\\\":\\\\\\\\n                        return $('hiker://empty#noLoading#').lazyRule((k) => {\\\\\\\\n                            putVar('bianji', '移动#' + k);\\\\\\\\n                            refreshPage(false);\\\\\\\\n                            return input;\\\\\\\\n                        }, num);\\\\\\\\n                        break;\\\\\\\\n                    case \\\\\\\\\\\\\\\"分享\\\\\\\\\\\\\\\":\\\\\\\\n                    case \\\\\\\\\\\\\\\"云分享\\\\\\\\\\\\\\\":\\\\\\\\n                        if (json.codes[name]) {\\\\\\\\n                            var parseText = typeof json.codes[name] == 'function' ? $.stringify(json.codes[name]) : json.codes[name];\\\\\\\\n                            parseText = 'MyParseS★' + name + '★' + base64Encode(parseText);\\\\\\\\n                        } else {\\\\\\\\n                            var parseText = '直链★' + json.title[num];\\\\\\\\n                        }\\\\\\\\n                        if (type == '云分享' && parseText.substr(0, 8) == 'MyParseS') {\\\\\\\\n                            parseText = sharePaste(parseText);\\\\\\\\n                            return parseText.substr(0, 6) != 'error:' ? 'copy://' + parseText + '\\\\\\\\\\\\\\\\n★★★\\\\\\\\\\\\\\\\n' + 'MyParseS：' + name : 'toast://分享失败!!云剪贴板可能挂了';\\\\\\\\n                        } else {\\\\\\\\n                            return 'copy://' + parseText;\\\\\\\\n                        }\\\\\\\\n                    default:\\\\\\\\n                        return 'toast://暂不支持';\\\\\\\\n                        break;\\\\\\\\n                } //switch的\\\\\\\\n            }) //String的\\\\\\\\n        }) //stringify的\\\\\\\\n    },\\\\\\\\n    xjParse: function() {\\\\\\\\n        return $(\\\\\\\\\\\\\\\"hiker://empty#noRecordHistory#\\\\\\\\\\\\\\\").rule(() => {\\\\\\\\n            var d = [];\\\\\\\\n            eval(getItem('myFunction'));\\\\\\\\n            d.push({\\\\\\\\n                title: '保 存',\\\\\\\\n                url: saveButton + \\\\\\\\\\\\\\\"saveButton(input);back();clearVar('input_add')\\\\\\\\\\\\\\\",\\\\\\\\n                col_type: \\\\\\\\\\\\\\\"input\\\\\\\\\\\\\\\",\\\\\\\\n                desc: \\\\\\\\\\\\\\\"输入正确格式内容\\\\\\\\\\\\\\\",\\\\\\\\n                extra: {\\\\\\\\n                    onChange: 'putVar(\\\\\\\\\\\\\\\"input_add\\\\\\\\\\\\\\\", input)',\\\\\\\\n                    type: \\\\\\\\\\\\\\\"textarea\\\\\\\\\\\\\\\",\\\\\\\\n                    height: \\\\\\\\\\\\\\\"-1\\\\\\\\\\\\\\\",\\\\\\\\n                    titleVisible: false,\\\\\\\\n                    defaultValue: getVar('input_add'),\\\\\\\\n                }\\\\\\\\n            });\\\\\\\\n            d.push({\\\\\\\\n                title: '‘‘’’<small><span style=\\\\\\\\\\\\\\\"color:#6EB897\\\\\\\\\\\\\\\">按描述诉格式输入, 请勿填入其他格式<br>本地口令: 操作类型★名称★代码<br>云口令: 链接★★★名称; 纯网址: 直链★url1★url2',\\\\\\\\n                desc: '‘‘’’<big><big><span style=\\\\\\\\\\\\\\\"color:#298A08\\\\\\\\\\\\\\\">保 存',\\\\\\\\n                url: $('noLoading').lazyRule((saveButton) => {\\\\\\\\n                    return saveButton(getVar('input_add'));\\\\\\\\n                }, saveButton),\\\\\\\\n                col_type: 'text_center_1'\\\\\\\\n            });\\\\\\\\n            setResult(d);\\\\\\\\n        })\\\\\\\\n    },\\\\\\\\n    ydParse: function(BJmode, i) {\\\\\\\\n        return $('#noLoading#').lazyRule((k) => {\\\\\\\\n            var A = k[0].split('#')[1];\\\\\\\\n            var B = k[1];\\\\\\\\n            var parseRoute = getVar('parseRoute');\\\\\\\\n            eval('var json =' + fetch(parseRoute));\\\\\\\\n            var item = json.title.splice(A, 1); // 1: 标记开始位置，2: 删除到哪个位置\\\\\\\\n            json.title.splice(B, 0, item[0]); // 1: 同上，2: 0表示不删除，3: 添加对象\\\\\\\\n            writeFile(parseRoute, $.stringify(json));\\\\\\\\n            clearVar('bianji');\\\\\\\\n            refreshPage(false);\\\\\\\\n            return 'hiker://empty';\\\\\\\\n        }, [BJmode, i])\\\\\\\\n    },\\\\\\\\n    plscParse: function() {\\\\\\\\n        return $('hiker://empty#noRecordHistory#').rule(() => {\\\\\\\\n            var d = [];\\\\\\\\n            d.push({\\\\\\\\n                title: '批量删除解析',\\\\\\\\n                desc: 'auto&&float',\\\\\\\\n                url: 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/plscParse.html',\\\\\\\\n                col_type: 'x5_webview_single'\\\\\\\\n            })\\\\\\\\n            setResult(d);\\\\\\\\n        })\\\\\\\\n    }\\\\\\\\n};\\\\\\\"},{\\\\\\\"col_type\\\\\\\":\\\\\\\"movie_3\\\\\\\",\\\\\\\"name\\\\\\\":\\\\\\\"调用路由\\\\\\\",\\\\\\\"path\\\\\\\":\\\\\\\"Route\\\\\\\",\\\\\\\"rule\\\\\\\":\\\\\\\"js:\\\\\\\\nconst d = [];\\\\\\\\nconst data = {};\\\\\\\\n\\\\\\\\nif (!getVar('jxOldV')) {\\\\\\\\n    eval(JSON.parse(fetch(\\\\\\\\\\\\\\\"hiker://page/Parse_Dn.js\\\\\\\\\\\\\\\")).rule);\\\\\\\\n}\\\\\\\\n\\\\\\\\ndata.oldConfig = \\\\\\\\\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\\\\\\\\\";\\\\\\\\ndata.cjRoute = \\\\\\\\\\\\\\\"hiker://files/cache/Parse_Dn.js\\\\\\\\\\\\\\\";\\\\\\\\ndata.x5Route = \\\\\\\\\\\\\\\"file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/Parse_Dn.html\\\\\\\\\\\\\\\";\\\\\\\\n\\\\\\\\ndata.jxLazy = \\\\\\\\\\\\\\\"eval('var config =' + fetch('\\\\\\\\\\\\\\\" + data.oldConfig + \\\\\\\\\\\\\\\"'));eval(fetch(config.cj));aytmParse(input)\\\\\\\\\\\\\\\";\\\\\\\\n\\\\\\\\ndata.szParse = \\\\\\\\\\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noHistory#\\\\\\\\\\\\\\\";\\\\\\\\n\\\\\\\\ndata.addLanJie = function(d) {\\\\\\\\n    let lanjie = ['baidu.*.png', '.jpg', 'baidu.', 'cnzz.', 'dykj\\\\\\\\\\\\\\\\.'];\\\\\\\\n    eval('var ylanjie =' + fetch('hiker://files/cache/x5ParseLanJie.txt'));\\\\\\\\n    lanjie = typeof(ylanjie) == 'object' ? ylanjie : lanjie;\\\\\\\\n    for (let i = 0; i < d.length; i++) {\\\\\\\\n        let durl = d[i].url;\\\\\\\\n        if (durl != undefined && /lazyRule/.test(durl) && /aytmParse|defaultParse/.test(durl)) {\\\\\\\\n            d[i].extra = d[i].extra == undefined ? {} : d[i].extra;\\\\\\\\n            d[i].extra.blockRules = lanjie;\\\\\\\\n        }\\\\\\\\n    }\\\\\\\\n    setResult(d);\\\\\\\\n}\\\\\\\\ndata.x5Parse = function(Url) {\\\\\\\\n    return $(Url).lazyRule(() => {\\\\\\\\n        eval('var ParseS =' + fetch('hiker://files/rules/DuanNian/MyParse.json'));\\\\\\\\n        return ParseS.codes.defaultParse(input);\\\\\\\\n    })\\\\\\\\n}\\\\\\\\ndata.setParse = function() {\\\\\\\\n    var d = [];\\\\\\\\n    d.push({\\\\\\\\n        desc: 'auto',\\\\\\\\n        url: this.x5Route,\\\\\\\\n        col_type: 'x5_webview_single'\\\\\\\\n    });\\\\\\\\n    var jxNewV = getVar('jxNewV', ''),\\\\\\\\n        jxOldV = getVar('jxOldV');\\\\\\\\n    var versionTips = jxNewV == '' ? '‘‘' : '‘‘' + jxNewV;\\\\\\\\n    var pics = [\\\\\\\\n        'https://tva1.sinaimg.cn/large/9bd9b167gy1fwri56wjhqj21hc0u0arr.jpg',\\\\\\\\n        'https://cdn.seovx.com/img/seovx-20-10%20(92).jpg',\\\\\\\\n        'https://cdn.seovx.com/img/mom2018%20(207).jpg',\\\\\\\\n        'https://tva4.sinaimg.cn/large/9bd9b167gy1fwrh5xoltdj21hc0u0tax.jpg',\\\\\\\\n        'https://tva1.sinaimg.cn/large/005BYqpggy1fwreyu4nl6j31hc0u0ahr.jpg',\\\\\\\\n        'https://s3.bmp.ovh/imgs/2021/10/d7e60b990742093d.jpeg',\\\\\\\\n        'https://s3.bmp.ovh/imgs/2021/10/91ad6d6538bf8689.jpg',\\\\\\\\n        'https://tva1.sinaimg.cn/large/005BYqpggy1fwresl5pmlj31hc0xcwka.jpg',\\\\\\\\n        'https://tva3.sinaimg.cn/large/005BYqpggy1fwrgjdk74oj31hc0u0dqn.jpg',\\\\\\\\n        'https://cdn.seovx.com/img/mom2018%20(320).jpg',\\\\\\\\n        'https://cdn.seovx.com/img/mom2018%20(803).jpg'\\\\\\\\n    ];\\\\\\\\n    d.push({\\\\\\\\n        img: pics[Math.floor(Math.random() * 10)],\\\\\\\\n        title: versionTips + '’’<small><span style=\\\\\\\\\\\\\\\"color:#6EB897\\\\\\\\\\\\\\\"><br>　　点击上方头像进入编辑<br>点此进入论坛帖子列表',\\\\\\\\n        desc: '当前版本: ' + jxOldV,\\\\\\\\n        url: 'https://haikuoshijie.cn/user/1958',\\\\\\\\n        col_type: 'movie_1'\\\\\\\\n    });\\\\\\\\n    setResult(d);\\\\\\\\n}\\\\\\\\n\\\\\\\\nswitch (getParam(\\\\\\\\\\\\\\\"type\\\\\\\\\\\\\\\")) {\\\\\\\\n    case \\\\\\\\\\\\\\\"设置\\\\\\\\\\\\\\\":\\\\\\\\n        data.setParse();\\\\\\\\n        break;\\\\\\\\n    case \\\\\\\\\\\\\\\"编辑\\\\\\\\\\\\\\\":\\\\\\\\n        $.require(\\\\\\\\\\\\\\\"hiker://page/jxItem?rule=MyFieldᴰⁿ\\\\\\\\\\\\\\\").jxList();\\\\\\\\n        setResult(d);\\\\\\\\n        break;\\\\\\\\n    default:\\\\\\\\n        $.exports = data;\\\\\\\\n        break;\\\\\\\\n}\\\\\\\"},{\\\\\\\"col_type\\\\\\\":\\\\\\\"movie_3\\\\\\\",\\\\\\\"name\\\\\\\":\\\\\\\"解析项主界面\\\\\\\",\\\\\\\"path\\\\\\\":\\\\\\\"jxItem\\\\\\\",\\\\\\\"rule\\\\\\\":\\\\\\\"var _0xod2='jsjiami.com.v6',_0x4690=[_0xod2,'fFLDs8O1Ig==','VwzCn8K/wo4=','w5DCqMOvJcK3','w7U5CsOV','w7TCtcOvN8KT','w7bDo8OuUiA=','Rm1Ow65u','MExUw6TCpA==','5a+W5Ya155iU6ZO5','DcK4KcKJw5wrDcOl','5a6B5Yao5YSI5ZSg','w4zCvMOGMsKgw7Y=','w4QEw4Qwfg==','FEDDnRk+','V8Kxf0ow','KzDDp8O+w5w=','DMKcwr/ChsKW','HMKXARXCpQ==','w609w78Gfw==','wrR/BcKOKDrDvR9+wp8vaFYCfsKMwpszBRTCoWrDsGExdsKCw6VWwpQn','WsKff8Kxwp4=','w6bCrMK0Gw==','Vyp1w4pJ','w7IGCsONHQ==','YMKrZHQy','TMKzB8Odw67Ck8KYOQ==','w43DjxZoM2peMcKEEg==','HFLDuTAJ','SsKAXUsa','TCTCg8KgwrM=','WsKhwqd3woo=','A1ZMw5fCtg==','wqHDkRrDn2nDtV/DnQ==','czNew4RNbBjDmA==','GHZqw6LCh8KUJghR','w4vDpU0q','IFM6wqQi','IcKRbQ==','by9cw40=','woZJwojChcKb','w5fDoC95Ig==','VDjCncKqwp8=','e8KbY8KAwpTDjF/Dt20f','w5fDuVAn','wqHDkQXDmw==','w43Dj8OpZz99w60Xw5fCqw==','N8KJYsKJw6DDssKq','Zixzw4xg','wq0Tw6LCjcK4CDYXwpjCqsOpQFI=','wrFQPRw=','4oKl4oKi4oKc4oCSUHzDthnCmeetvueQveikheadgw==','w5LCk8KXGxk=','MsOQw5jCqVo=','wqQDw5Yyw47CkwHCr1rCo3J8wqA=','EcOEw6XCo3k=','wpRofBnClGhm','U8KteE4=','KcOnw7jCiUBAw77CjMK9K2Bdw6Zvw53Dsx1fwo8gIsODw4TDgMOpw4HDmQfCiGnDhQFvX8Ky','U8KpTFY2','VMKgJMOZ','w63DlDsQw4M=','EjbDk8O7w4kFwrTCicOew5Q=','b8OHbsKEwqjDhlY=','GMKnBMKBw7E=','C8KIwqBADA==','w6zDg8OdwrNrw7TChiM=','wr3Dl8Kmw41cw4x6wpAfHg==','wpZASBTChA==','wr7DiMKGIsOW','Ww5pw7TDqg==','cXzCpm3Crw==','Z8KDSsKVwqg=','wo55XR4=','4oKs4oKB4oO84oGddlsdwqEd5pKK5Lyo5o2u5b++','w7hqwpjDjSg=','w5cjFcOJBw==','MCXDpcO6w6o=','wp55HsKqbg==','K8O8w6XClw==','QVJOw7Y=','4oGM4oCi4oGX4oORe2TDpBpxWMO/w7XCi8OWw5fDssKcO8OcwqPCmsOMGcOfVCXDpsO5w6Z/w5RK','T8KZbsKEwro=','AWXDvCk0Yz3Cpg==','aQTCgcKDwpE=','w6AfOMO7Fg==','w4/DtUY2AMO+V1HDtVbChzPCqg==','w6/CvcKqERg2w5Y=','w5DCuMOaJsKx','FcKkLsKAw61+RsKvRUobYWvCgBjCgmlfIBXCnlXDjHI=','ZMONAiLCisKMwr3CnCIMUcOsw4FpwpE=','CMOFw4XCvEQ=','QE1fw5Np','HmB0WsO3','w6HCrS99wq4=','asKOQmMi','J2x6w6rChA==','w6rCgS5OwpM=','w6kKwq7ChcOVF2IFw5nCs8KoY1U=','4oKC4oKU4oGP4oO5wqfDkB3Cp8KaSsOgwqHCsjHCuMKWw6sbwrTCiwjCtUPCgWF3TlgmwopNaSrDmAwYw6zmlrfCt+W4mMKu6KSJMeadhg==','FibDh8Ojw4UFwqPCjsOaw4VIw7fDvg==','w6bDjMOswrF0w7o=','56S25Yiew7c=','4oCB4oCP4oO34oC7w4fCogLChwA4AsK2A8KVB2DDgEXCvifDrcOCF8K4wobDrcKTN0jCnsOhWQ==','w4vDsUwxOsOPXUrDtVY=','w4DDrj7CqcOu','w7DDqcODZAM=','wo1awozCmMKe','bcO9wpTDoz0=','AcOvLcOSwp7Dug==','4oCB4oCP4oO34oC7w4fCsxvCgVAkAsKyG8KXQi7Cll/CvS7Cv8KSTsO0w5jCu8OZTFvCkMKGJUHCpcOfw6bCqOaXv1/lubB56KaGQ+afug==','SlnCo07CiA==','w7bDuCDCmcOB','RsKTwqJUwpw=','XsK1wpNz','w51oXsKdw6I=','wo/Do8KKP8K6','wqZawrDCssKR','56e45YuuCMKI','w53CkMKLJgc=','GyfDr8O2w6gVwqM=','w6cNw6MNbg==','w5nCigRR','CsKYwqfCtg==','TsOEwqXDhDw=','wqXDgQ7Dh3XCqA==','LFYdwq0rcsO3Dw==','wozDu8KPAMK3','wqkXw6jCisKCOTwMwpjCqg==','w4PCkB5X','w5TCkzVxwrA=','E8KjwrZ0Pg==','QcK2O8Ocw7M=','wqBOJDg4','cSNCw4RvYBk=','NcO2w7/CjQ==','SUzDk8OR','Q8OGImHCog==','C8KRwo5mFg==','wrgdw7DCtcKM','eHzChG7CkA==','w4ksw6cVZA==','wpEEw5bCjcKz','4oKj4oKI4oCn4oGbY8OuQl7DrxPChhjDosO+EcO8CsOGw60JU8OHwofDsMKmw4HCuCZXeGhy','w4cPLMOEPA==','AnVww68=','w6rDuSXCiA==','w6RCfE1x','wqjDm8KmIsKn','e3rDtcOAKQ==','w77CqsKJChgrw4vChA==','wqHDk8K6w5lNw7Y=','w6zDiMO3Wzw=','w57Ds1IvNw==','w5jDmcOpZgQ=','GMKSIjU=','5oye5o+15byY6L225Yau5p6n5pW75YST5a66','azJxw5PDnw==','WsK8wpVgwoDCsBcOwrvCtA==','w7NlUFZEMMOXMMO1IMOQFMOrYMO8ScOqwr/DgMOXcMOBAFFpwpU=','4oK14oCd4oO14oKRRE1FwobDjeaDoOWkpeaOnOS5hei1kOW8qOS7jum5teiuuw==','5b6K5Yi76Kyk576X5LudUXM=','wrHlr4jmlIDotq3lv5vCpxIQw7NGwpkJw6jCvTDCtEnDi8OMDF3Dm8KSwp7DrcKow6EVFCVkJsOQMH4=','wrVANgAMbD/DmsOiMjPDg8KZ','5a6o5YWf5YSD5ZSN','AW/DlykZOQ==','4oOI4oG+4oK34oGfwq3Ckg3CphDmkIvkvZzmjKTlvoQ=','w5LDrMKLJz5QG8Ko','4oGZ4oKL4oKV4oOgDxjCuMOEw6vmmr7mlrnohKzmnr/kvp3ot7g=','5LqW5o+X5Lia5a+Q5pWG6LeA5b6ow5vDk8KtSy/DkMOXw4nDm8O9fsKmGDM/w5vDrghfw69D576F6aCR6IWI5p235a2z5pe36LWF5b28OMKfwqB9MXBZRcKow5hxacORwqkDw5HCgcK8w5DCqcOdw7U=','5a6Z5pSb6Lah5b+waS91w4bDozskw6/Ch0NcTsKRVGDDocKsN8O6w7rClMODw7DCgsOUVMOqdTsj','5L6B55Sk55uW5YSF5Ym+6IOh6ZyD55qO5b6j6KaT55eL6K+j5Z6A6LSO5Yykw6Dlp4jmn4jplL/pobTliZ/lvJjorJLlnY3kuZTopLLor7fmgIw=','TVzDmMONHsOw','w4zCsMOGMMKLw7zDuyXDhsKP','w6NzYcKqw4g=','4oCK4oK04oGp4oCbw47Cm8KbwoE4FlPDr8OfKcODfcKJ55mk5b+G5o2p56WD','QsKkwpR3wprDpHRIwr3CvsKrw759AsOkwqdZwrTDjQR7FHMRZgEXwonCnibDqcK4SMOReA==','w4dLwqfDqgw=','w7U7L8O4LA==','w7XDicOMeRU=','wrFhKTId','VXZVw5dR','w4TDuMKXNy9rG8KzVyI=','zANjsyjTiamBPi.cIToYm.vt6pCQJMD=='];(function(_0x36e342,_0x5e84cc,_0x2e1b72){var _0xaa5c8=function(_0x7befac,_0x1852f9,_0x42cd58,_0x32bee9,_0x45146b){_0x1852f9=_0x1852f9>>0x8,_0x45146b='po';var _0x55f00e='shift',_0x248978='push';if(_0x1852f9<_0x7befac){while(--_0x7befac){_0x32bee9=_0x36e342[_0x55f00e]();if(_0x1852f9===_0x7befac){_0x1852f9=_0x32bee9;_0x42cd58=_0x36e342[_0x45146b+'p']();}else if(_0x1852f9&&_0x42cd58['replace'](/[zANyTBPITYtpCQJMD=]/g,'')===_0x1852f9){_0x36e342[_0x248978](_0x32bee9);}}_0x36e342[_0x248978](_0x36e342[_0x55f00e]());}return 0xb1166;};return _0xaa5c8(++_0x5e84cc,_0x2e1b72)>>_0x5e84cc^_0x2e1b72;}(_0x4690,0x10d,0x10d00));var _0x3377=function(_0xecd6c7,_0xe8cee3){_0xecd6c7=~~'0x'['concat'](_0xecd6c7);var _0x42bec6=_0x4690[_0xecd6c7];if(_0x3377['DhdldK']===undefined){(function(){var _0x268b84=typeof window!=='undefined'?window:typeof process==='object'&&typeof require==='function'&&typeof global==='object'?global:this;var _0x996d83='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';_0x268b84['atob']||(_0x268b84['atob']=function(_0x296b9a){var _0xf6c336=String(_0x296b9a)['replace'](/=+$/,'');for(var _0x419430=0x0,_0x2d2748,_0x69bfd5,_0xae6930=0x0,_0x1746db='';_0x69bfd5=_0xf6c336['charAt'](_0xae6930++);~_0x69bfd5&&(_0x2d2748=_0x419430%0x4?_0x2d2748*0x40+_0x69bfd5:_0x69bfd5,_0x419430++%0x4)?_0x1746db+=String['fromCharCode'](0xff&_0x2d2748>>(-0x2*_0x419430&0x6)):0x0){_0x69bfd5=_0x996d83['indexOf'](_0x69bfd5);}return _0x1746db;});}());var _0x17bc47=function(_0x3bfce0,_0xe8cee3){var _0x25df27=[],_0x376033=0x0,_0x3f5d68,_0x2344c5='',_0xb8c681='';_0x3bfce0=atob(_0x3bfce0);for(var _0x1bb9cf=0x0,_0x1472de=_0x3bfce0['length'];_0x1bb9cf<_0x1472de;_0x1bb9cf++){_0xb8c681+='%'+('00'+_0x3bfce0['charCodeAt'](_0x1bb9cf)['toString'](0x10))['slice'](-0x2);}_0x3bfce0=decodeURIComponent(_0xb8c681);for(var _0x5e4adb=0x0;_0x5e4adb<0x100;_0x5e4adb++){_0x25df27[_0x5e4adb]=_0x5e4adb;}for(_0x5e4adb=0x0;_0x5e4adb<0x100;_0x5e4adb++){_0x376033=(_0x376033+_0x25df27[_0x5e4adb]+_0xe8cee3['charCodeAt'](_0x5e4adb%_0xe8cee3['length']))%0x100;_0x3f5d68=_0x25df27[_0x5e4adb];_0x25df27[_0x5e4adb]=_0x25df27[_0x376033];_0x25df27[_0x376033]=_0x3f5d68;}_0x5e4adb=0x0;_0x376033=0x0;for(var _0x3bce01=0x0;_0x3bce01<_0x3bfce0['length'];_0x3bce01++){_0x5e4adb=(_0x5e4adb+0x1)%0x100;_0x376033=(_0x376033+_0x25df27[_0x5e4adb])%0x100;_0x3f5d68=_0x25df27[_0x5e4adb];_0x25df27[_0x5e4adb]=_0x25df27[_0x376033];_0x25df27[_0x376033]=_0x3f5d68;_0x2344c5+=String['fromCharCode'](_0x3bfce0['charCodeAt'](_0x3bce01)^_0x25df27[(_0x25df27[_0x5e4adb]+_0x25df27[_0x376033])%0x100]);}return _0x2344c5;};_0x3377['CwmfcL']=_0x17bc47;_0x3377['jyWfmx']={};_0x3377['DhdldK']=!![];}var _0x1fe9d5=_0x3377['jyWfmx'][_0xecd6c7];if(_0x1fe9d5===undefined){if(_0x3377['clNxPA']===undefined){_0x3377['clNxPA']=!![];}_0x42bec6=_0x3377['CwmfcL'](_0x42bec6,_0xe8cee3);_0x3377['jyWfmx'][_0xecd6c7]=_0x42bec6;}else{_0x42bec6=_0x1fe9d5;}return _0x42bec6;};eval(JSON[_0x3377('0','G3qQ')](fetch(_0x3377('1','DUO(')))['rule']);function bbsYZ(){var _0xba84bc={'IVIEw':'jdRoute','qjbMN':function(_0x283a74,_0x1ccf97,_0x44c511){return _0x283a74(_0x1ccf97,_0x44c511);},'PjHfp':'bbsYZ','RHBBQ':function(_0x337338){return _0x337338();},'dDibZ':_0x3377('2','O6Iy'),'OvckS':function(_0x40fbea,_0x2a5c42){return _0x40fbea(_0x2a5c42);}};if(!getVar(_0xba84bc[_0x3377('3','&HYL')])){_0xba84bc[_0x3377('4','4x[P')](putVar,_0xba84bc[_0x3377('5','d6$D')],_0xba84bc[_0x3377('6','2fiL')](isLogin));putVar(_0xba84bc[_0x3377('7','SK(D')],_0xba84bc['dDibZ']);}return _0xba84bc[_0x3377('8','d(y^')](getVar,_0xba84bc['PjHfp']);}function splitLine(_0x21e87a,_0xa9be76){var _0x2a07af={'YdCql':function(_0x47692c,_0x13124f){return _0x47692c<_0x13124f;}};for(let _0x3a676d=0x0;_0x2a07af[_0x3377('9','2fiL')](_0x3a676d,_0xa9be76);_0x3a676d++){d['push']({'col_type':_0x21e87a});}}var jxItem={'jxList':function(){var _0x3ee766={'lyJSa':_0x3377('a','e*8L'),'gvXNO':_0x3377('b','OMce'),'SNMls':_0x3377('c','Q^1*'),'hZQDQ':function(_0xaf9541,_0x5def8c){return _0xaf9541(_0x5def8c);},'eclmh':_0x3377('d','YoF9'),'akjLk':function(_0x4c331c,_0x2cffc3){return _0x4c331c+_0x2cffc3;},'QjRcP':function(_0x12bce3,_0x120108){return _0x12bce3==_0x120108;},'phiVy':_0x3377('e','PSIM'),'lbQab':'‘‘’’<small><span\\\\\\\\\\\\\\\\x20style=\\\\\\\\\\\\\\\\x22color:#FE9A2E\\\\\\\\\\\\\\\\x22>','HrLtT':'移动:\\\\\\\\\\\\\\\\x20','AcaRp':function(_0x57ce88,_0x258c04){return _0x57ce88+_0x258c04;},'BCUyh':'text_2','gRXMT':function(_0x4feb49,_0x1e2dc9){return _0x4feb49+_0x1e2dc9;},'WPEKd':_0x3377('f','s&lK'),'QrrPP':function(_0x194b6d,_0x1b3b26){return _0x194b6d(_0x1b3b26);},'GbmKm':_0x3377('10','Bd^Z'),'QATIk':function(_0x289eab,_0x59ea0e){return _0x289eab(_0x59ea0e);},'ffXCg':function(_0x32ae58,_0x449eac){return _0x32ae58!==_0x449eac;},'Wbeei':_0x3377('11','OMce'),'ltvyZ':_0x3377('12','bm6L'),'lCBSu':function(_0x3e7ecf,_0x9a4219){return _0x3e7ecf+_0x9a4219;},'OpfmU':function(_0x5e340a,_0xdbe45d){return _0x5e340a==_0xdbe45d;},'QzJcn':function(_0x5888ec,_0xee5e8e){return _0x5888ec+_0xee5e8e;},'WUQXm':function(_0x4461a5,_0x43a5ae){return _0x4461a5+_0x43a5ae;}};var _0x43fda6=getVar(_0x3ee766[_0x3377('13','!]tS')]);var _0x5a4dea=parseFile[_0x3377('14','nZwJ')];var _0x505697=_0x3ee766['QATIk'](getVar,_0x3377('15','mLX%'));d['push']({'title':_0x3377('16','s&lK'),'url':bjItem['xjParse'](),'col_type':_0x3ee766[_0x3377('17','s&lK')]});var _0x224eb4=_0x5a4dea['length'];for(var _0x174bc0=0x0;_0x174bc0<_0x224eb4;_0x174bc0++){if(_0x3ee766['ffXCg'](_0x3ee766['Wbeei'],_0x3ee766[_0x3377('18','OMce')])){var _0x210b58=_0x5a4dea[_0x174bc0];var _0x34e4f2=_0x3ee766[_0x3377('19','W4EV')](_0x210b58,'')['replace'](/http.*\\\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\//g,'');if(/移动/[_0x3377('1a','W4EV')](_0x505697)){d['push']({'title':_0x3ee766['OpfmU'](_0x3ee766[_0x3377('1b','9F@B')](_0x3ee766[_0x3377('1c','1KGf')],_0x174bc0),_0x505697)?_0x3ee766['QzJcn'](_0x3ee766[_0x3377('1d','!]tS')],_0x3377('1e','grzs'))+_0x34e4f2:_0x3ee766[_0x3377('1f','ibF7')](_0x3ee766['WPEKd'],_0x34e4f2),'url':bjItem[_0x3377('20','Q^1*')](_0x505697,_0x174bc0),'col_type':_0x3ee766[_0x3377('21','XfcG')]});}else{var _0x4a64bf=[_0x210b58,_0x3ee766['WUQXm'](_0x174bc0,'||')][_0x3377('22','2fiL')]('||');d[_0x3377('23','5Kkw')]({'title':_0x3ee766[_0x3377('24','nZwJ')]+_0x34e4f2,'col_type':_0x3377('25','r^JY'),'url':bjItem[_0x3377('26','8ilb')](_0x4a64bf,_0x224eb4['toString']())});}}else{var _0x32766d=_0x3ee766['lyJSa'][_0x3377('27','1KGf')]('|'),_0x19d9f5=0x0;while(!![]){switch(_0x32766d[_0x19d9f5++]){case'0':var _0x38cf84=getVar(_0x3377('28','e*8L'));continue;case'1':d[_0x3377('29','2fiL')]({'title':_0x3ee766[_0x3377('2a','2fiL')],'url':bjItem['xjParse'](),'col_type':_0x3ee766['SNMls']});continue;case'2':var _0x50d754=_0x3ee766[_0x3377('2b','p3Hs')](getVar,_0x3ee766[_0x3377('2c','*yTj')]);continue;case'3':for(var _0x5d401e=0x0;_0x5d401e<_0x14af53;_0x5d401e++){var _0x2f8efd=_0x1d3c16[_0x5d401e];var _0x182628=_0x3ee766[_0x3377('2d',')&Jp')](_0x2f8efd,'')[_0x3377('2e','grzs')](/http.*\\\\\\\\\\\\\\\\/\\\\\\\\\\\\\\\\//g,'');if(/移动/[_0x3377('2f','&HYL')](_0x50d754)){d[_0x3377('30','[&2K')]({'title':_0x3ee766[_0x3377('31','O6Iy')](_0x3ee766['akjLk'](_0x3ee766[_0x3377('32','p3Hs')],_0x5d401e),_0x50d754)?_0x3ee766[_0x3377('33','e*8L')](_0x3ee766[_0x3377('34','s&lK')](_0x3ee766[_0x3377('35','XfcG')],_0x3ee766[_0x3377('36','e*8L')]),_0x182628):_0x3ee766['AcaRp'](_0x3377('37','Bd^Z'),_0x182628),'url':bjItem['ydParse'](_0x50d754,_0x5d401e),'col_type':_0x3ee766[_0x3377('38','8Mwb')]});}else{var _0x5d7845=[_0x2f8efd,_0x3ee766['gRXMT'](_0x5d401e,'||')][_0x3377('39','d(y^')]('||');d[_0x3377('3a','OMce')]({'title':_0x3ee766[_0x3377('3b','4q!N')](_0x3ee766[_0x3377('3c','1KGf')],_0x182628),'col_type':_0x3ee766[_0x3377('3d','[&2K')],'url':bjItem['xlSelect'](_0x5d7845,_0x14af53[_0x3377('3e','ibF7')]())});}}continue;case'4':var _0x1d3c16=parseFile['title'];continue;case'5':var _0x14af53=_0x1d3c16[_0x3377('3f','PSIM')];continue;case'6':_0x3ee766[_0x3377('40','bm6L')](clearVar,_0x3ee766[_0x3377('41','Bd^Z')]);continue;}break;}}}clearVar(_0x3ee766[_0x3377('42','bm6L')]);},'lqFile':function(){var _0x1a6862={'vqkXT':function(_0x1bb3fc,_0x348f70){return _0x1bb3fc==_0x348f70;},'pwVEx':function(_0x38e311){return _0x38e311();},'HsIry':_0x3377('43','!&rB'),'MmrTU':function(_0x27dc3b,_0x2b01d4,_0x46e842){return _0x27dc3b(_0x2b01d4,_0x46e842);},'XVMes':'hiker://page/Route?type=编辑#noRecordHistory#','TlGbG':_0x3377('44','$&QA'),'vejTG':_0x3377('45','$oSm'),'wJspI':_0x3377('46','W4EV'),'CsoRg':_0x3377('47','4q!N'),'PCesw':function(_0x29dcd3,_0x35bc57){return _0x29dcd3+_0x35bc57;},'PEvHX':_0x3377('48','KYM)'),'iXVmO':function(_0x40eef9,_0x5aac1c){return _0x40eef9+_0x5aac1c;},'YRhRA':_0x3377('49','e*8L'),'hkHOT':_0x3377('4a','Bd^Z'),'pqGpc':_0x3377('4b',')&Jp'),'kLUVa':'导入直链','EEaDw':_0x3377('4c','8ilb'),'TPlOr':'批量删除','IsXiF':_0x3377('4d','Sm37'),'LqiVh':_0x3377('4e','zjj9'),'jNKbt':function(_0x5ca907,_0x46cc4f){return _0x5ca907==_0x46cc4f;},'RoltS':_0x3377('4f','R%Ux'),'OVawf':_0x3377('50','&HYL'),'ejAdn':_0x3377('51','KYM)'),'sCTPi':_0x3377('52',')&Jp'),'PWiZJ':function(_0x14c1bf,_0x2f607e){return _0x14c1bf(_0x2f607e);},'MKJlv':_0x3377('53','aAjy'),'Xkcaq':_0x3377('54','[&2K'),'pDgFN':function(_0x3588be,_0xad2ef8){return _0x3588be(_0xad2ef8);},'dQhIv':function(_0x500ea3,_0x3d206f){return _0x500ea3+_0x3d206f;},'EkSLc':'‘‘’’<big>管理解析','KYkYL':function(_0x51200a,_0x54c8f1){return _0x51200a(_0x54c8f1);},'RJfmY':function(_0x5eb3e4,_0x114dcb){return _0x5eb3e4<_0x114dcb;},'aJrDx':'iQSYk','hLfbe':function(_0x2e7aa7,_0x3501d8){return _0x2e7aa7+_0x3501d8;},'dnSnE':function(_0x5c39ef,_0x3c3451){return _0x5c39ef+_0x3c3451;},'tyWOe':_0x3377('55','G3qQ'),'UotEP':function(_0x57273f,_0x3403f7){return _0x57273f==_0x3403f7;},'RfZmp':function(_0x5d92ad){return _0x5d92ad();},'ThjcV':function(_0x2917bb,_0x2d1984){return _0x2917bb!==_0x2d1984;},'WmNcc':_0x3377('56','9F@B'),'WKTrs':_0x3377('57','O6Iy'),'eSAFB':_0x3377('58','W4EV')};if(_0x1a6862[_0x3377('59','KYM)')](_0x1a6862[_0x3377('5a','8Mwb')](bbsYZ),_0x1a6862[_0x3377('5b','bm6L')])){_0x1a6862['PWiZJ'](eval,_0x1a6862[_0x3377('5c',')&Jp')](getVar,'jdRoute'));xdRoute=_0x1a6862[_0x3377('5d','4x[P')](xdRoute,_mySet[_0x3377('5e','R%Ux')]);splitLine('line',0x5);d['push']({'title':_0x1a6862[_0x3377('5f','[&2K')],'url':_0x1a6862['XVMes'],'desc':_0x1a6862[_0x3377('60','gm!h')],'col_type':_0x1a6862[_0x3377('61','G3qQ')]});d[_0x3377('62','8Mwb')]({'desc':_0x1a6862[_0x3377('63','G3qQ')],'col_type':_0x1a6862['vejTG'],'extra':{'titleVisible':![],'defaultValue':_0x1a6862[_0x3377('64','bm6L')](getVar,_0x1a6862[_0x3377('65','4x[P')]),'onChange':_0x1a6862['CsoRg']}});var _0x4fae6f=_0x1a6862[_0x3377('66','d(y^')];var _0x1e9d3c=[{'title':_0x3377('67','W4EV'),'url':bjItem[_0x3377('68','DUO(')]('直链')},{'title':_0x3377('69','DUO('),'url':bjItem['pullCode']('免嗅')},{'title':_0x1a6862['TPlOr'],'url':bjItem['plscParse']()}];for(var _0x5a89f4=0x0;_0x1a6862['RJfmY'](_0x5a89f4,_0x1e9d3c[_0x3377('6a','G3qQ')]);_0x5a89f4++){if(_0x1a6862[_0x3377('6b','XfcG')]===_0x1a6862[_0x3377('6c','Sm37')]){d[_0x3377('30','[&2K')]({'title':_0x1e9d3c[_0x5a89f4][_0x3377('6d','SK(D')],'url':_0x1e9d3c[_0x5a89f4]['url'],'col_type':_0x1a6862[_0x3377('6e','Q^1*')]});}else{if(_0x1a6862[_0x3377('6f','5Kkw')](_0x1a6862[_0x3377('70','!&rB')](bbsYZ),_0x1a6862[_0x3377('71','XfcG')])){var _0x1ce321=_0x3377('72','8Mwb')['split']('|'),_0x5d9eee=0x0;while(!![]){switch(_0x1ce321[_0x5d9eee++]){case'0':_0x1a6862[_0x3377('73','$&QA')](splitLine,_0x3377('74','ibF7'),0x5);continue;case'1':var _0x7b4c17=_0x1a6862['XVMes'];continue;case'2':d['push']({'desc':_0x1a6862[_0x3377('75','grzs')],'col_type':_0x1a6862['vejTG'],'extra':{'titleVisible':![],'defaultValue':getVar(_0x1a6862[_0x3377('76','8Mwb')]),'onChange':_0x1a6862[_0x3377('77','SK(D')]}});continue;case'3':xdRoute=_0x1a6862['PCesw'](xdRoute,_mySet['parseRoute']);continue;case'4':d['push']({'title':_0x1a6862['PEvHX'],'url':bjItem[_0x3377('78','*yTj')](_mySet[_0x3377('79','@f)p')]),'desc':_0x1a6862[_0x3377('7a','Sm37')](_0x1a6862[_0x3377('7b','SK(D')](_0x1a6862['YRhRA'],mySet['cj']),_0x1a6862[_0x3377('7c','gm!h')]),'col_type':_0x1a6862[_0x3377('7d','W4EV')]});continue;case'5':var _0x3fd747=[{'title':_0x1a6862[_0x3377('7e','d(y^')],'url':bjItem[_0x3377('7f','r^JY')]('直链')},{'title':_0x1a6862['EEaDw'],'url':bjItem[_0x3377('80','grzs')]('免嗅')},{'title':_0x1a6862['TPlOr'],'url':bjItem[_0x3377('81','d(y^')]()}];continue;case'6':for(var _0x4c9653=0x0;_0x4c9653<_0x3fd747[_0x3377('3f','PSIM')];_0x4c9653++){d[_0x3377('82','Bd^Z')]({'title':_0x3fd747[_0x4c9653][_0x3377('83','8ilb')],'url':_0x3fd747[_0x4c9653][_0x3377('84','Nu[J')],'col_type':_0x1a6862['IsXiF']});}continue;case'7':splitLine(_0x3377('85','grzs'),0x2);continue;case'8':d['push']({'title':_0x1a6862[_0x3377('86','!]tS')],'url':_0x1a6862[_0x3377('87','@f)p')](typeof czGuide,_0x1a6862['RoltS'])?_0x1a6862[_0x3377('88','gm!h')](czGuide):'','col_type':_0x1a6862['pqGpc']});continue;case'9':splitLine(_0x3377('89','$&QA'),0x1);continue;case'10':splitLine(_0x3377('8a','Bd^Z'),0x1);continue;case'11':d[_0x3377('8b','r^JY')]({'title':_0x1a6862['OVawf'],'url':bjItem[_0x3377('8c','bm6L')](_mySet[_0x3377('8d','Nu[J')],_mySet['x5cache']),'desc':_0x1a6862[_0x3377('8e','grzs')],'col_type':_0x3377('8f','e*8L')});continue;case'12':d[_0x3377('90',')&Jp')]({'title':_0x3377('91','bm6L'),'url':_0x1a6862[_0x3377('92','ibF7')],'desc':_0x1a6862[_0x3377('93','&HYL')],'col_type':_0x3377('94','zjj9')});continue;case'13':eval(_0x1a6862[_0x3377('95','&HYL')](getVar,_0x3377('96','aAjy')));continue;}break;}}else{d[_0x3377('97','SK(D')]({'title':'‘‘’’<strong><big>登录提示','desc':_0x1a6862['MKJlv'],'url':_0x3377('98','&HYL'),'col_type':_0x1a6862[_0x3377('99','SK(D')]});}}}splitLine('line',0x2);d[_0x3377('9a','*yTj')]({'title':_0x1a6862[_0x3377('9b','#O1s')],'url':bjItem[_0x3377('9c','Q^1*')](_mySet['cjcache'],_mySet[_0x3377('9d','$&QA')]),'desc':_0x1a6862[_0x3377('9e','DUO(')],'col_type':_0x1a6862[_0x3377('9f','p3Hs')]});splitLine('line',0x1);d['push']({'title':_0x1a6862['PEvHX'],'url':bjItem[_0x3377('a0','YoF9')](_mySet[_0x3377('a1','PSIM')]),'desc':_0x1a6862[_0x3377('a2','aAjy')](_0x1a6862[_0x3377('a3','p]GH')](_0x1a6862[_0x3377('a4','$oSm')],mySet['cj']),_0x1a6862[_0x3377('a5','s&lK')]),'col_type':_0x1a6862[_0x3377('a6','$&QA')]});splitLine(_0x1a6862['tyWOe'],0x1);d[_0x3377('a7','aAjy')]({'title':_0x3377('a8','R%Ux'),'url':_0x1a6862[_0x3377('a9','KYM)')](typeof czGuide,_0x1a6862[_0x3377('aa','8Mwb')])?_0x1a6862[_0x3377('ab','Q^1*')](czGuide):'','col_type':'text_center_1'});}else{if(_0x1a6862['ThjcV'](_0x1a6862['WmNcc'],_0x1a6862[_0x3377('ac','xoZT')])){var _0x1ac1e2=[editDX,_0x1a6862['iXVmO'](_0x5a89f4,'||')][_0x3377('ad','&HYL')]('||');d[_0x3377('ae','4x[P')]({'title':_0x3377('af','8ilb')+xsList,'col_type':_0x1a6862[_0x3377('b0','$&QA')],'url':bjItem['xlSelect'](_0x1ac1e2,lbLength[_0x3377('b1','Sm37')]())});}else{d[_0x3377('62','8Mwb')]({'title':_0x1a6862['WKTrs'],'desc':_0x1a6862[_0x3377('b2','gm!h')],'url':_0x1a6862[_0x3377('b3','8Mwb')],'col_type':_0x3377('b4','Bd^Z')});}}}};$[_0x3377('b5','ibF7')]=jxItem;;_0xod2='jsjiami.com.v6';\\\\\\\"}]\\\",\\\"preRule\\\":\\\"\\\",\\\"sdetail_col_type\\\":\\\"movie_1\\\",\\\"sdetail_find_rule\\\":\\\"\\\",\\\"searchFind\\\":\\\"\\\",\\\"search_url\\\":\\\"\\\",\\\"sort_name\\\":\\\"\\\",\\\"sort_url\\\":\\\"\\\",\\\"title\\\":\\\"MyFieldᴰⁿ\\\",\\\"ua\\\":\\\"mobile\\\",\\\"url\\\":\\\"hiker://empty\\\",\\\"version\\\":5,\\\"visible\\\":true,\\\"year_name\\\":\\\"\\\",\\\"year_url\\\":\\\"\\\"}}\",\"saved\":false,\"title\":\"北城合集1206.北城\",\"version\":0,\"url\":\"hiker://page/indexLoad?#1#noHistory#\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\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, { name: RULE.title })\\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://page/singleSearch?keyword=\\\"+input+\\\"&page=fypage\\\"',\\n        extra: { rule: getItem('myCollection'), RULE: RULE },\\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\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\nvar { MY_URL, MY_URL_Options } = 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// 正文解析\\nif (pageNum == 1) eval(MY_RULE.preRule)\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    function getUrl() {\\n        return MY_URL\\n    }\\n\\n    function getResCode() {\\n        return indexHtml\\n    }\\n\\n    function setResult(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, params] = v.url.split('#')[0].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?' + (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                v.url = v.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n                return v\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) { return v }\\n            v.extra = { url: v.url, RULE: MY__RULE, pageTitle: v.title }\\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) { return '' }\\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                res.url = res.url.replace('.js:', '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\"' + MY_URL + '\\\";')\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title }\\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}\\n\",\"group\":\"➓轻合集\",\"ua\":\"mobile\",\"preRule\":\"setItem('myCollection', MY_RULE.title)\\nsetItem('remoteUrl', 'http://hiker.nokia.press/hikerule/rulelist.json?id=2966')\\n// \\n// 包裹错误\",\"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:\\\\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, { name: RULE.title })\\\\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://page/singleSearch?keyword=\\\\\\\"+input+\\\\\\\"&page=fypage\\\\\\\"',\\\\n        extra: { rule: getItem('myCollection'), RULE: RULE },\\\\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\\\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\\\nvar { MY_URL, MY_URL_Options } = 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// 正文解析\\\\nif (pageNum == 1) eval(MY_RULE.preRule)\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    function getUrl() {\\\\n        return MY_URL\\\\n    }\\\\n\\\\n    function getResCode() {\\\\n        return indexHtml\\\\n    }\\\\n\\\\n    function setResult(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, params] = v.url.split('#')[0].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?' + (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                v.url = v.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\\\\\"' + MY_URL + '\\\\\\\";')\\\\n                return v\\\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) { return v }\\\\n            v.extra = { url: v.url, RULE: MY__RULE, pageTitle: v.title }\\\\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) { return '' }\\\\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                res.url = res.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\\\\\"' + MY_URL + '\\\\\\\";')\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title }\\\\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}\\\\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\\\\nconst { runCode, urlParse } = $.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 { MY_URL, MY_URL_Options } = 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)\\\\nsetLastChapterRule(MY_RULE.last_chapter_rule)\\\\nMY_PARAMS = MY_RULE.params\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    function getUrl() {\\\\n        return MY_URL\\\\n    }\\\\n\\\\n    function getResCode() {\\\\n        return indexHtml\\\\n    }\\\\n\\\\n    function setResult(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, params] = v.url.split('#')[0].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?' + (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                v.url = v.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\\\\\"' + MY_URL + '\\\\\\\";')\\\\n                return v\\\\n            } else { return v }\\\\n            v.extra = { url: v.url, RULE: MY__RULE }\\\\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) { return '' }\\\\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                res.url = res.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\\\\\"' + MY_URL + '\\\\\\\";')\\\\n            } else if (detailFindRule) {\\\\n                res.extra = { url: url, RULE: Object.assign({}, MY_RULE, { detail_find_rule: detailFindRule }) }\\\\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}\\\\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\\\":\\\"movie_1_vertical_pic\\\",\\\"name\\\":\\\"单搜\\\",\\\"path\\\":\\\"singleSearch\\\",\\\"rule\\\":\\\"js:\\\\nlet myCollection_el = [],\\\\n    RULE = MY_PARAMS.RULE,\\\\n    keyword = getParam('keyword'),\\\\n    pageNum = parseInt(getParam('page'))\\\\n\\\\n// 处理MY_URL和MY_RULE\\\\nMY_TYPE = 'search'\\\\nMY_RULE.ua = RULE.ua\\\\nMY_RULE.title = RULE.title\\\\nMY_RULE.col_type = RULE.col_type\\\\nMY_RULE.detail_col_type = ['', '*'].includes(RULE.sdetail_find_rule) ? RULE.detail_col_type : RULE.sdetail_col_type\\\\nMY_RULE.find_rule = RULE.searchFind\\\\nMY_RULE.detail_find_rule = ['', '*'].includes(RULE.sdetail_find_rule) ? RULE.detail_find_rule : RULE.sdetail_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\\\\nconst { runCode, urlParse } = $.require('hiker://page/utility?rule=' + getItem('myCollection'))\\\\nvar { MY_URL, MY_URL_Options } = urlParse(RULE.search_url, {}, pageNum, (url) => {\\\\n    url[0] = url[0].replace(url[0].includes('%%') ? /%%/g : /\\\\\\\\*\\\\\\\\*/g, encodeStr(keyword, url[2]))\\\\n}),\\\\n    indexHtml = fetch(MY_URL, MY_URL_Options)\\\\nMY_RULE.url = MY_URL\\\\nMY_RULE.urlHeaders = MY_URL_Options.headers\\\\n// 正文解析\\\\nif (pageNum == 1) setPageTitle('“' + keyword + '”的搜索结果')\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    function getUrl() {\\\\n        return MY_URL\\\\n    }\\\\n\\\\n    function getResCode() {\\\\n        return indexHtml\\\\n    }\\\\n\\\\n    function setResult(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                subTitle = v.title\\\\n            v.title += '““””<br>' + (RULE.title.fontcolor('#12b668') + ' ▪ ' + (v.desc || '').fontcolor('#666666')).small()\\\\n            v.desc = v.content || ''\\\\n            if(!v.img && !v.pic_url) v.col_type = 'text_1'\\\\n            delete v.content\\\\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, params] = v.url.split('#')[0].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?' + (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                v.url = v.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\\\\\"' + MY_URL + '\\\\\\\";')\\\\n                return v\\\\n            } else if (!MY_RULE.detail_find_rule || v.url.startsWith('hiker://')) { return v }\\\\n            v.extra = { url: v.url, RULE: MY__RULE, pageTitle: subTitle }\\\\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, url, desc, content, img] = findRule.map((v, i) => {\\\\n                try {\\\\n                    if (v == '*') return ''\\\\n                    else v = (i == 1 || i == 4) ?\\\\n                        parseDom(data, v) :\\\\n                        parseDomForHtml(data, v)\\\\n                    if (i != 1) v = runCode(v)\\\\n                    return v\\\\n                } catch (e) { return '' }\\\\n            }),\\\\n            res = {\\\\n                title: title + '““””<br>' + (RULE.title.fontcolor('#12b668') + ' ▪ ' + desc.fontcolor('#666666')).small(),\\\\n                url: url,\\\\n                desc: content,\\\\n                img: img\\\\n            }\\\\n        if(!res.img) res.col_type = 'text_1'\\\\n        if (res.url) {\\\\n            if (res.url.includes('@lazyRule=')) {\\\\n                res.url = res.url.replace('.js:', '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE,' + $.stringify({ pages: MY_RULE.pages, pageList: MY_RULE.pageList, find_rule: '', params: '' }) + ');MY_URL=\\\\\\\"' + MY_URL + '\\\\\\\";')\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.extra = { url: url, RULE: MY_RULE, pageTitle: title }\\\\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}\\\\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\\\"}]\"}","picUrl":"https://static01.imgkr.com/temp/238137efb61645879687a8503f34d893.png","title":"MyFieldᴰⁿ"}
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!