API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：⚙ 轻合集设置 ⚙

xiaomianao666
Jul 2nd, 2022
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 449.99 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥⚙ 轻合集设置 ⚙@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"text_1\",\"name\":\"ClassTab\",\"path\":\"ClassTab\",\"rule\":\"const ClassTab = function(classArray, params) {\\n    Object.assign(this, params)\\n    this.arr = classArray.map(v => this.init(v))\\n    this.sign = '$' + QING_TITLE + '_' + (this.name || '') + '_'\\n    this.color = this.color || '#12b668'\\n    this.boundary = this.boundary || 'blank_block'\\n}\\nClassTab.prototype = {\\n    constructor: ClassTab,\\n    load(el) {\\n        let folded = this.fold && getVar('fold_' + this.sign, '')\\n        if (this.arr.length > 1 && this.fold) el.push({\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\n                putVar('fold_' + sign, { '': 'T', 'T': '' } [folded])\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, this.sign, folded),\\n            col_type: 'scroll_button'\\n        })\\n        let arr = folded ? [this.arr[0]] : this.arr\\n        arr.forEach((v) => {\\n            let { id, class_name, class_url } = v,\\n            selected = JSON.stringify(this.getClass(id))\\n            class_name.forEach((name, i) => {\\n                let url = class_url[i],\\n                    now = JSON.stringify({ name: name, url: url })\\n                el.push({\\n                    title: selected == now ? '““””' + name.fontcolor(this.color).bold() : name,\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\n                        putVar(sign + id, now)\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, this.sign, id, now),\\n                    col_type: 'scroll_button'\\n                })\\n            })\\n            el.push({ col_type: this.boundary })\\n        })\\n    },\\n    init(classObject) {\\n        if (typeof classObject.class_name == 'string')\\n            classObject.class_name = classObject.class_name.split('&')\\n        if (typeof classObject.class_url == 'string')\\n            classObject.class_url = classObject.class_url.split('&').map((v) => v.trim())\\n        return classObject\\n    },\\n    push(classObject) {\\n        this.arr.push(this.init(classObject))\\n    },\\n    getClass(id) {\\n        let defaultClass = this.arr.find(item => item.id == id)\\n        defaultClass = JSON.stringify(defaultClass ? {\\n            name: defaultClass.class_name[0],\\n            url: defaultClass.class_url[0]\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\n    },\\n    setUrl(url) {\\n        return url.replace(/\\\\$\\\\{([^}]*)\\\\}/g, (_, id) => this.getClass(id).url)\\n    }\\n}\\n// 生成头部分类\\nconst fyAll = RULE.url.includes('fyAll')\\nlet tabHeader = []\\nif (RULE.class_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyclass',\\n    class_name: RULE.class_name,\\n    class_url: RULE.class_url\\n})\\nif (RULE.area_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyarea',\\n    class_name: RULE.area_name,\\n    class_url: RULE.area_url\\n})\\nif (RULE.year_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fyyear',\\n    class_name: RULE.year_name,\\n    class_url: RULE.year_url\\n})\\nif (RULE.sort_name) tabHeader.push({\\n    id: fyAll ? 'fyAll' : 'fysort',\\n    class_name: RULE.sort_name,\\n    class_url: RULE.sort_url\\n})\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title, fold: readFile('tabFold'), })\\n\"},{\"col_type\":\"icon_2_round\",\"name\":\"设置\",\"path\":\"Config\",\"rule\":\"js:\\naddListener('onClose', 'clearMyVar(\\\"sortFlag\\\");refreshPage()')\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\nconst QING_TITLE = getMyVar('myCollection')\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)(true),\\n    el = [{\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，不要频繁点击）',\\n        url: $('#noLoading#').lazyRule(() => {\\n            let url = getMyVar('remoteUrl')\\n            if(url.startsWith('hiker://') || url.startsWith('file://'))\\n                return 'toast://仓库为本地文件，不会进行缓存，本功能也无效'\\n            deleteFile('updateTime')\\n            back(false)\\n            return 'toast://已更新'\\n        }),\\n        img: 'hiker://images/icon4',\\n        col_type: 'avatar'\\n    }],\\n    updateInterval = readFile('updateInterval') || '1',\\n    newWindow = readFile('newWindow'),\\n    tabFold = readFile('tabFold'),\\n    disableCustom = readFile('disableCustom'),\\n    editMode = getMyVar('editMode', '启用/禁用')\\n\\nel.push({\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\n本地文件链接无效').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: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\n        saveFile('tabFold', tabFold ? '' : '1')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, tabFold),\\n    col_type: 'scroll_button'\\n}, */{\\n    title: '  💼 备份恢复  ',\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\n        let url = getMyVar('remoteUrl')\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\n        else if(url.startsWith('hiker://page/')) url = 'hiker://empty'\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\n                let rules = request(url),\\n                    customData = readFile('customData')\\n                writeFile(input, JSON.stringify({\\n                    updateInterval: updateInterval,\\n                    newWindow: newWindow,\\n                    tabFold: tabFold,\\n                    disableCustom: disableCustom,\\n                    customData: customData,\\n                    rules: rules\\n                }))\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\n            saveFile('updateInterval', updateInterval)\\n            saveFile('newWindow', newWindow)\\n            saveFile('tabFold', tabFold)\\n            saveFile('disableCustom', disableCustom)\\n            saveFile('customData', customData)\\n            if(rules) writeFile(url, rules)\\n            refreshPage()\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\n        }, url)\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '““””<font color=\\\"#666666\\\"><small>特别鸣谢，小程序提供者：\\\\n' +\\n        data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\n        .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、'),\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\n\\nel.push({ col_type: 'line' }, {\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\n        if (input == '清除自定义数据') {\\n            deleteFile('customData')\\n        } else if (input == '启用合集自定义') {\\n            saveFile('disableCustom', '')\\n        } else {\\n            saveFile('disableCustom', '1')\\n            input += '\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\n        }\\n        refreshPage(false)\\n        return 'toast://已' + input\\n    }),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\n    el.push({\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putMyVar('editMode', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'scroll_button'\\n    })\\n});\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\n    let d = { title: v.title, img: data[i].icon }\\n    switch (editMode) {\\n        case '启用/禁用':\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                rules[i].visible = !rules[i].visible\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '重新排序':\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\n            if (sortFlag == -1)\\n                d.url = $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('sortFlag', i.toString())\\n                    refreshPage(false)\\n                    return 'toast://选择要移动到的位置'\\n                }, i)\\n            else\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\n                    saveFile('customData', JSON.stringify(rules))\\n                    putMyVar('sortFlag', '-1')\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, sortFlag, i)\\n            break\\n        case '更改图标':\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                if (input)\\n                    rules[i].icon = input\\n                else\\n                    delete rules[i].icon\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '导入海阔':\\n            d.url = 'rule://' + base64Encode(JSON.stringify(data[i]))\\n            break\\n    }\\n    el.push(d)\\n})\\nsetResult(el)\"},{\"col_type\":\"movie_3\",\"name\":\"页面载入\",\"path\":\"frameLoad\",\"rule\":\"js:\\nconst QING_TITLE = getMyVar('myCollection')\\nlet myCollection_el = [],\\n    { RULE, isIndex, pageTitle } = MY_PARAMS,\\n    thisRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)().find((v) => v.title == RULE.title)\\nif (isIndex) {\\n    RULE = thisRULE\\n} else {\\n    RULE.pages = thisRULE.pages\\n}\\neval(JSON.parse(fetch('hiker://page/preFunc?rule=' + QING_TITLE)).rule)\\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\\n\\nif (isIndex) {\\n    if (MY_PAGE == 1) {\\n        // 加载ClassTab组件\\n        eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n        tabHeader.load(myCollection_el)\\n        if (RULE.search_url) myCollection_el.push({\\n            title: \\\"搜索\\\",\\n            desc: \\\"搜你想要的...\\\",\\n            url: '\\\"hiker://search?s=\\\"+input',\\n            extra: {\\n                rules: $.toString((QING_TITLE, title) => {\\n                    let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)()\\n                    rules = [rules.find((v) => v.title == title)]\\n                    return JSON.stringify(rules)\\n                }, QING_TITLE, RULE.title),\\n                defaultValue: getMyVar('searchKey', ''),\\n                onChange: \\\"putMyVar('searchKey',input)\\\"\\n            },\\n            col_type: \\\"input\\\",\\n        })\\n    }\\n    // 处理MY_RULE\\n    MY_RULE.url = RULE.url\\n    MY_RULE.col_type = RULE.col_type\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.find_rule\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\n    MY_RULE.params = {}\\n} else {\\n    MY_RULE.url = MY_PARAMS.url\\n    MY_RULE.col_type = RULE.detail_col_type\\n    MY_RULE.find_rule = RULE.detail_find_rule\\n    MY_RULE.params = RULE.params\\n}\\nMY_RULE.pages = RULE.pages\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\nMY_RULE.title = RULE.title\\n\\nif (!isIndex) {\\n    if (pageTitle) setPageTitle(pageTitle)\\n    setLastChapterRule(thisRULE.last_chapter_rule)\\n    MY_PARAMS = MY_RULE.params\\n}\\n// 预处理并初始化config\\nif (isIndex && MY_PAGE == 1) eval(thisRULE.preRule)\\nlet _cfg = getMyVar('initConfig', '{}')\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\n\\n// 正文解析通用变量\\nlet assignLazyRule = $.toString((QING_TITLE, title) => {\\n    let RULE = $.require(\\\"hiker://page/dataLoad?rule=\\\" + QING_TITLE)().find((v) => v.title == title)\\n    return { pages: RULE.pages, pageList: RULE.pageList }\\n}, QING_TITLE, RULE.title)\\nfunction genMyRule() {\\n    let rule = Object.assign({}, MY_RULE)\\n    delete rule.last_chapter_rule\\n    delete rule.preRule\\n    delete rule.pageList\\n    delete rule.pages\\n    return rule\\n}\\nfunction runCode(rule) {\\n    try {\\n        let [input, code] = rule.split('.js:')\\n        return code ? eval(code) : rule\\n    } catch (e) { return rule }\\n}\\nfunction genExUrl(url) {\\n    url = url.split(';')\\n    return url.shift() + ';' + paramHandle(url, thisRULE.ua, MY_RULE.url)\\n}\\n// 正文解析\\nif (MY_RULE.find_rule.startsWith('js:')) {\\n    setResult = function(el, param1, param2, param3) {\\n        param1 = CALLBACK_KEY\\n        param2 = MY_RULE\\n        param3 = MY_TYPE\\n        if (Array.isArray(el.data)) el = el.data\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra || {} })\\n            v.col_type = v.col_type || MY_RULE.col_type\\n\\n            if (!v.url || ['rule', 'pics', 'toast', 'input', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'select', 'x5Rule', 'webRule', 'download', 'share'].find((vv) => v.url.startsWith(vv + '://')) || ['x5_webview_single', 'input'].find((vv) => v.col_type == vv)) {\\n                return v\\n            } else if (v.url.includes('@rule=')) {\\n                let [_, url, rule] = v.url.match(/^([\\\\s\\\\S]*?)@rule=([\\\\s\\\\S]*)$/)\\n                v.url = url\\n                MY__RULE.detail_find_rule = rule\\n                MY__RULE.detail_col_type = MY_RULE.col_type\\n            } else if (v.url.startsWith('hiker://page/')) {\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\n                    return v\\n                let [_, path, flag, params] = v.url.match(/^hiker:\\\\/\\\\/page\\\\/(.+?)(#.*?)?(?:\\\\?(.*))?$/),\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path),\\n                    subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\n                v.url = subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (v.extra || {}).url || 'hiker://empty' + flag + '?' + (params || '')\\n                MY__RULE.detail_find_rule = subPage.rule\\n                MY__RULE.detail_col_type = subPage.col_type\\n            } else if (v.url.includes('@lazyRule=')) {\\n                let reIndex = v.url.indexOf('.js:')\\n                if (reIndex >= 0) v.url = v.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + v.url.slice(reIndex + 4)\\n                return v\\n            } else if (isIndex) {\\n                if (!MY_RULE.detail_find_rule || /hiker:\\\\/\\\\/(?!empty.+$)/.test(v.url)) return v\\n            } else {\\n                return v\\n            }\\n            v.extra = {\\n                url: genExUrl(v.url),\\n                RULE: MY__RULE,\\n                pageTitle: isIndex && v.title\\n            }\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.split(';')\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\n            } else if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: Object.assign(genMyRule(), { detail_find_rule: detailFindRule }),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: genMyRule(),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"数据载入\",\"path\":\"dataLoad\",\"rule\":\"$.exports = function(showAll) {\\n    let url = getMyVar('remoteUrl'),\\n        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        try {\\n            data = $.require(\\\"hiker://page/creator\\\");\\n        } catch (e) {}\\n        if(data.length == 0) {\\n            data = JSON.parse(fetch('hiker://files/libs/' + md5(url) + '.js') || '[]')\\n            log('没有获取到更新数据')\\n        } else {\\n            writeFile('hiker://files/libs/' + md5(url) + '.js', JSON.stringify(data));\\n            saveFile('updateTime', now.toString())\\n            log('更新数据已写入本地')\\n        }\\n    } else {\\n        data = JSON.parse(fetch('hiker://files/libs/' + md5(url) + '.js') || '[]')\\n    }\\n    \\n    //data = data.filter((v) => { return v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器') })\\n        if (readFile('disableCustom')) return data\\n        else { // 写入自定义数据\\n        let customData = JSON.parse(readFile('customData') || '[]'),\\n            rewriteData = []\\n        customData = customData.reduce((self, v) => {\\n            let index = data.findIndex((vv) => v.title == vv.title)\\n            if (index >= 0) {\\n                self.push(v)\\n                let rule = data.splice(index, 1)[0]\\n                if (showAll || v.visible)\\n                    rewriteData.push(Object.assign(rule, v))\\n            }\\n            return self\\n        }, [])\\n        data.forEach((v) => customData.push({ title: v.title, visible: true }))\\n        saveFile('customData', JSON.stringify(customData))\\n        return rewriteData.concat(data)\\n    }\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"函数重写\",\"path\":\"preFunc\",\"rule\":\"// 防止require多次运行\\nlet rCache = {}\\nrequire = function(param0, param1, param2, param3, param4) {\\n    if (!param0 || rCache[param0] != null) {\\n        return\\n    }\\n    rCache[param0] = 1\\n    param2 = param2 || 0\\n    param3 = MY_TICKET\\n    param4 = eval\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\n}\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\n    if (!param0 || rCache[param0] != null) {\\n        return\\n    }\\n    rCache[param0] = 1\\n    param3 = param3 || 0\\n    param4 = MY_TICKET\\n    param5 = eval\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\n}\\nrc = requireCache\\n\\n// 最新章节规则注入预处理代码\\nsetLastChapterRule = function(param0) {\\n    if (!param0) return\\n    if (param0.startsWith(\\\"js:\\\") && thisRULE.preRule) {\\n        param0 = 'js:\\\\ntry{eval(JSON.parse(fetch(\\\"hiker://page/preFunc?rule=' + QING_TITLE + '\\\")).rule);\\\\\\n            eval(base64Decode(\\\"' + base64Encode(thisRULE.preRule) + '\\\"));\\\\\\n            let _cfg = getMyVar(\\\"initConfig\\\", \\\"{}\\\");\\\\\\n            if (_cfg && _cfg.length>0) {config = JSON.parse(_cfg)}}catch(e){log(e.message)}\\\\n;' +\\n            param0.slice(3)\\n    }\\n    method_setLastChapterRule.invoke(javaContext, param0);\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"链接处理\",\"path\":\"urlParse\",\"rule\":\"// 首页链接替换分类\\nfunction indexUrl(param) {\\n    function runCode(rule) {\\n        try {\\n            let [input, code] = rule.split('.js:')\\n            return code ? eval(code) : rule\\n        } catch (e) { return rule }\\n    }\\n    let { RULE, pageNum, QING_TITLE } = JSON.parse(param.split('###')[1])\\n    RULE = JSON.parse(base64Decode(RULE))\\n    pageNum = parseInt(pageNum)\\n    let url = RULE.url\\n\\n    eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\n    url = url.replace(/fypage(?:@(-?\\\\d+)@)?(?:\\\\*(\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\n    url = /^([\\\\s\\\\S]*?)(?:\\\\[firstPage=([\\\\s\\\\S]*?)\\\\])?(?:(\\\\.js:[\\\\s\\\\S]*?))?$/.exec(url)\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\n    return runCode(url[1])\\n}\\n// 链接参数处理\\nfunction paramHandle(urlParam, ua, urlTmp) {\\n    let charset, UserAgent\\n    try { // 链接的编码和ua应该是首先继承首页链接\\n        [, , charset, UserAgent] = urlTmp.split(';')\\n        UserAgent = UserAgent.match(/^{(.*)}$/)[1].split('&&').find((v) => v.startsWith('User-Agent@'))\\n    } catch (e) {}\\n    urlParam[0] = urlParam[0] || 'GET'\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\n    try {\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { urlParam[2] = [] }\\n    // 添加全局UA\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\n        if (UserAgent) urlParam[2].push(UserAgent)\\n        else if (ua == 'pc')\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n        else if (ua == 'mobile')\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n    }\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\n    return urlParam.join(';')\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"生成规则集\",\"path\":\"creator\",\"rule\":\"let appjson = $.require('hiker://page/appJson');\\n\\nfunction randomSort3(arr) {\\n    /*arr.sort(function() {\\n        return Math.random() - 0.5;\\n    });*/\\n    return arr;\\n}\\n\\nlet appconts = appjson.data,\\n    rules = [],\\n    types = { \\\"\\\": \\\"全部\\\" };\\nfor (let i = 0; i < appconts.length; i++) {\\n    let applist = randomSort3(appconts[i].list),\\n        apptype = appconts[i].title /* + applist.length*/ ;\\n    types[apptype] = apptype;\\n    if (apptype.includes(\\\"个人收集\\\")) continue;\\n    for (let j = 0; j < applist.length; j++) {\\n        let apptitle = applist[j].title,\\n            appicon = applist[j].img,\\n            appUrl = applist[j].url,\\n            home_url = \\\"\\\",\\n            find_rule = \\\"\\\",\\n            search_url = \\\"\\\",\\n            searchFind = \\\"\\\",\\n            pages = [],\\n            last_chapter_rule = \\\"\\\",\\n            appUa = \\\"\\\";\\n        //处理重名的\\n        let num = 1,\\n            temp = apptitle;\\n        while (rules.some(cur => cur.title == apptitle)) {\\n            num = num + 1;\\n            apptitle = temp + num;\\n        }\\n        //规则链接和搜索链接\\n        if (/神马|TV/.test(apptype)) {\\n            home_url = \\\"hiker://empty##\\\" + appUrl + \\\"?ac=list&page=fypage\\\";\\n            if (/19jx|293ys|zhaikanys|ji\\\\-ding\\\\-he|phoebe|yunbo\\\\.bxin|lanrentk|hetaoys|pxun|139\\\\.155|fkkdy|056158|aixixi|ruoxinew|feifan123|siqitv/.test(appUrl)) {\\n                search_url = \\\"hiker://empty##\\\" + appUrl + '?ac=list&page=fypage&zm=**';\\n            } else {\\n                search_url = \\\"hiker://empty##\\\" + appUrl + '?ac=list&page=fypage&wd=**';\\n            }\\n        } else {\\n            if (appUrl.includes(\\\"api.php/app\\\")) {\\n                home_url = \\\"hiker://empty##\\\" + appUrl + \\\"index_video?token=\\\";\\n            } else if (appUrl.includes(\\\"xgapp\\\")) {\\n                home_url = \\\"hiker://empty##\\\" + appUrl + \\\"index_video?token=\\\";\\n            } else {\\n                home_url = \\\"hiker://empty##\\\" + appUrl + \\\"/vodPhbAll\\\";\\n            }\\n\\n            if (appUrl.includes('api.php/app')) {\\n                search_url = \\\"hiker://empty##\\\" + appUrl + 'search?pg=fypage&token=&text=**';\\n            } else if (appUrl.includes('xgapp')) {\\n                search_url = \\\"hiker://empty##\\\" + appUrl + 'search?pg=fypage&text=**';\\n            } else {\\n                if (/iopenyun/.test(appUrl)) {\\n                    search_url = \\\"hiker://empty##\\\" + appUrl + '/list?page=fypage&limit=10&wd=**';\\n                } else {\\n                    search_url = \\\"hiker://empty##\\\" + appUrl + '?page=fypage&limit=10&wd=**';\\n                }\\n            }\\n        }\\n        //需要特殊处理的链接\\n        function changeUrl(url) {\\n            let newUrl = url;\\n            if (url.includes(\\\"omofun\\\")) {\\n                newUrl = url + \\\"&csrf=a%2BIKGLunJCZuad%2BxETLrZuBoqhluFCD0dH86E8IENvBzMfBLa6dB8RzoxxIvvBEMeJzJnUSt51FhlPBd4Kr5yhGXlyNvDkJyNMDgDZ1b%2FsjXAeMtj17XteM8puTY2PQnQwYOyj%2FHUCAVRZkrflsk87YG1VeSwnET8TprDD8t6ug%3D@signature=FED4A092D5BBBE18117A3B558EB6461A92A52CF7\\\";\\n            } else if (url.includes(\\\"xinluan\\\")) {\\n                newUrl = url + \\\"&csrf=SREQAPX8tFEKpV2dLDjLZhKk8IxJfDWhN%2BmksWJ%2FkdRVwgUh%2FQkTDZEoQASaAp7HzUix87T%2BPLkAIw6yH%2B6MrvaqJM9rJ5l2b85IQRbBbW%2BDbSYRO8bmTsKdLYDTVtRHhz5nylRWlGUidxHfVyLO9tZUiBk1Y2Awo%2Fzsa2tH2u8%3D@signature=FBC7088C677D297E6BBBC8584A93372DDE10FD96\\\";\\n            } else if (url.includes(\\\"sxbrd\\\")) {\\n                newUrl = url + \\\"&csrf=r2NDLtpS8Euqh%2F%2F8Y96ycOUOKS9ICzNYzyaw5C2UfEgoDFDHX%2Frqj%2BYcLWQzH5%2BR6moUOlwOAoJREtUa376ud74627UDzNQ1sRGdTD8kb36s1eTMemcn8d0i7WJ6k9ih5IP4Ad7fpa6%2F3Dst1joGncyr716dRHDMfcvrs3S29jI%3D@client_name=55WF55yL5b2x6KeG\\\";\\n            }\\n            return newUrl;\\n        }\\n        //请求UA\\n        if (appUrl.includes(\\\"api.php/app\\\") || appUrl.includes(\\\"xgapp\\\") || appUrl.includes(\\\"freekan\\\")) {\\n            appUa = \\\"Dart/2.14 (dart:io)\\\";\\n        } else if (/zsb|fkxs|xays|xcys|szys|dxys|ytys|qnys/.test(appUrl)) {\\n            appUa = \\\"Dart/2.15 (dart:io)\\\";\\n        } else if (appUrl.includes(\\\".vod\\\")) {\\n            appUa = \\\"okhttp/4.1.0\\\";\\n        } else {\\n            appUa = \\\"Dalvik/2.1.0\\\"; //TV\\n        }\\n        //首页规则、分类规则、二级规则和视频解析\\n        if (/神马|TV/.test(apptype)) {\\n            find_rule = \\\"js:\\\" + $.toString(function(appUrl, appUa) {\\n                let items = [];\\n                if (MY_PAGE == 1) {\\n                    try {\\n                        let typeJson = JSON.parse(fetch(appUrl + \\\"?ac=flitter\\\"), { headers: { \\\"User-Agent\\\": appUa } });\\n                        for (let key in typeJson) {\\n                            items.push({\\n                                title: key,\\n                                col_type: \\\"flex_button\\\",\\n                                url: $(\\\"hiker://empty##\\\" + appUrl + \\\"?ac=list&page=fypage&class=\\\" + key).rule((typeJson, appUa) => {\\n                                    addListener(\\\"onClose\\\", \\\"clearVar('filter')\\\");\\n                                    let items = [],\\n                                        keys = {},\\n                                        tykeys = [],\\n                                        filter = {},\\n                                        color = \\\"#FA7298\\\";\\n                                    for (let index in typeJson) {\\n                                        if (typeJson[index].values.length == 1) continue;\\n                                        let key = typeJson[index].field,\\n                                            filterName = \\\"全部\\\" + typeJson[index].name;\\n                                        tykeys.push(key);\\n                                        keys[\\\"f\\\" + key] = \\\"\\\";\\n                                        filter[\\\"f\\\" + key] = [filterName].concat(typeJson[index].values);\\n                                    }\\n                                    if (!getVar(\\\"filter\\\", \\\"\\\")) { putVar(\\\"filter\\\", JSON.stringify(keys)) }\\n                                    let temp = JSON.parse(getVar(\\\"filter\\\"));\\n                                    if (MY_PAGE == 1) {\\n                                        for (let item in filter) {\\n                                            for (let index = 0; index < filter[item].length; index++) {\\n                                                items.push({\\n                                                    title: temp[item] == \\\"\\\" ? (index === 0 ? \\\"““””\\\" + filter[item][0].bold().fontcolor(color) : filter[item][index]) : (temp[item] == filter[item][index] ? \\\"““””\\\" + filter[item][index].bold().fontcolor(color) : filter[item][index]),\\n                                                    col_type: \\\"scroll_button\\\",\\n                                                    url: $().lazyRule((des, name) => {\\n                                                        let temp = JSON.parse(getVar(\\\"filter\\\"));\\n                                                        temp[name] = des.indexOf(\\\"全部\\\") != -1 ? \\\"\\\" : des;\\n                                                        putVar(\\\"filter\\\", JSON.stringify(temp));\\n                                                        refreshPage(false);\\n                                                        return \\\"hiker://empty\\\"\\n                                                    }, filter[item][index], item)\\n                                                })\\n                                            }\\n                                            items.push({ col_type: \\\"blank_block\\\" })\\n                                        }\\n                                    }\\n                                    let url = MY_URL.split(\\\"##\\\")[1] + \\\"&\\\" + tykeys.map(cur => cur + \\\"=f\\\" + cur).join(\\\"&\\\");\\n                                    for (let item in temp) {\\n                                        url = url.replace(item, temp[item]);\\n                                    }\\n                                    let rescode = fetch(url, { headers: { \\\"User-Agent\\\": appUa } });\\n                                    if (rescode.indexOf('检测中') != -1) {\\n                                        rescode = fetch(url + '&btwaf' + rescode.match(/btwaf(.*?)\\\\\\\"/)[1], { headers: { \\\"User-Agent\\\": appUa } });\\n                                    }\\n                                    let html = JSON.parse(rescode);\\n                                    try {\\n                                        eval(JSON.parse(fetch('hiker://page/tvlistdata')).rule);\\n                                    } catch (e) {\\n                                        log(\\\"视频列表出错:\\\" + e.message);\\n                                    }\\n                                    setResult(items);\\n                                }, typeJson[key], appUa)\\n                            })\\n                        }\\n                    } catch (e) {\\n                        log(\\\"首页分类出错:\\\" + e.message);\\n                    }\\n                }\\n                try {\\n                    let url = MY_URL.split('##')[1],\\n                        html = JSON.parse(fetch(url));\\n                    eval(JSON.parse(fetch('hiker://page/tvlistdata')).rule);\\n                } catch (e) {\\n                    log(\\\"首页推荐出错:\\\" + e.message);\\n                }\\n                setResult(items);\\n            }, appUrl, appUa)\\n            let rule_tvlistdata = $.toString(function() {\\n                let list = html.data;\\n                for (let i = 0; i < list.length; i++) {\\n                    let { title, pic, nextlink, state } = list[i];\\n                    let url = nextlink.startsWith('http') ? nextlink : appUrl + '?ac=detail&ids=' + nextlink;\\n                    items.push({\\n                        title: title,\\n                        pic_url: pic + '@Referer=',\\n                        desc: state,\\n                        col_type: 'movie_3_marquee',\\n                        url: $(\\\"#immersiveTheme#hiker://empty##\\\" + url).rule(() => {\\n                            try {\\n                                eval(JSON.parse(fetch('hiker://page/tvmovlist')).rule);\\n                            } catch (e) {\\n                                log(\\\"影片详情出错:\\\" + e.message);\\n                                setResult([]);\\n                            }\\n                        })\\n                    });\\n                }\\n            });\\n            let rule_tvmovlist = $.toString(function(appUrl, appUa) {\\n                addListener(\\\"onClose\\\", $.toString((url) => {\\n                    clearVar('now');\\n                    clearVar(url);\\n                }, MY_URL));\\n                let items = [],\\n                    html = getVar(MY_URL, \\\"\\\");\\n                //domin = MY_URL.split(\\\"##\\\")[1].match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n                if (html == \\\"\\\") {\\n                    html = fetch(MY_URL.split(\\\"##\\\")[1], { headers: { \\\"User-Agent\\\": appUa } });\\n                    putVar(MY_URL, html);\\n                }\\n                html = JSON.parse(html);\\n\\n                //简介\\n                let { title, pubtime, trunk, area, type, director, actor, img_url, intro } = html;\\n                items.push({\\n                    title: title + \\\"(\\\" + pubtime + \\\")\\\" + \\\"\\\\n\\\" + area.join(\\\"/\\\") + \\\"/\\\" + type.join(\\\"/\\\") + \\\"/\\\" + trunk,\\n                    desc: \\\"导演:\\\" + director.join(\\\",\\\") + \\\"\\\\n\\\" + \\\"主演:\\\" + actor.join(\\\",\\\"),\\n                    pic_url: img_url,\\n                    url: \\\"hiker://empty\\\",\\n                    col_type: 'movie_1_vertical_pic_blur'\\n                }, {\\n                    title: '剧情简介:',\\n                    desc: intro,\\n                    url: $('hiker://empty#noRecordHistory#').rule((desc) => {\\n                        setResult([{\\n                            title: desc,\\n                            col_type: 'long_text'\\n                        }]);\\n                    }, intro),\\n                    col_type: 'text_1'\\n                });\\n                //断插\\n                let dnen = getMyVar(\\\"dnen\\\", \\\"0\\\");\\n                items.push({\\n                    title: '断插:' + (dnen == '1' ? '““✅””' : '❎'),\\n                    url: $('').lazyRule((dnen) => {\\n                        if (dnen == '1') {\\n                            putMyVar(\\\"dnen\\\", \\\"0\\\");\\n                            refreshPage(false);\\n                            return 'toast://已禁用断插调用!';\\n                        } else {\\n                            putMyVar(\\\"dnen\\\", \\\"1\\\");\\n                            refreshPage(false);\\n                            return 'toast://已开启断插调用!'\\n                        }\\n                    }, dnen),\\n                    col_type: 'text_2'\\n                });\\n                items.push({\\n                    title: '线路配置',\\n                    url: \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\",\\n                    //url:\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noRecordHistory#\\\",\\n                    col_type: 'text_2'\\n                });\\n                //线路列表\\n                let tabs = Object.keys(html.videolist);\\n                if (getVar(\\\"now\\\", \\\"\\\") == \\\"\\\") { putVar(\\\"now\\\", tabs[0]) }\\n                items.push({\\n                    title: \\\"““↓↑””\\\",\\n                    url: \\\"hiker://empty@lazyRule=.js:putVar('appmtvsort', getVar('appmtvsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功!'\\\",\\n                    col_type: 'scroll_button'\\n                });\\n                for (let i in tabs) {\\n                    items.push({\\n                        title: getVar(\\\"now\\\") == tabs[i] ? \\\"““””\\\" + tabs[i].bold().fontcolor(\\\"#FA7298\\\") : tabs[i],\\n                        url: \\\"hiker://empty@lazyRule=.js:putVar('now','\\\" + tabs[i] + \\\"');refreshPage(false);'toast://切换成功!'\\\",\\n                        col_type: 'scroll_button'\\n                    })\\n                }\\n                //视频列表\\n                let ptab = getVar(\\\"now\\\"),\\n                    list = html.videolist[ptab];\\n                log('当前线路:' + ptab);\\n                if (getVar('appmtvsort', '1') == '0') {\\n                    list.reverse();\\n                };\\n                for (let j = 0; j < list.length; j++) {\\n                    let srcurl = list[j].url;\\n                    if (/293jx1/.test(srcurl)) {\\n                        srcurl = srcurl.replace('293jx1', 'jx');\\n                    } else if (/8d8q|diliktv|haokanju1|cztv|fit\\\\:8|ppzhu/.test(appUrl)) {\\n                        srcurl = srcurl + '&app=10000&account=272775028&password=qq272775028';\\n                    }\\n                    let title = list[j].title;\\n                    //title = title.match(/(第|\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\n                    items.push({\\n                        title: title,\\n                        col_type: \\\"text_4\\\",\\n                        url: eval(JSON.parse(fetch(\\\"hiker://page/lazyParse\\\")).rule)\\n                    });\\n                }\\n                setResult(items);\\n            }, appUrl, appUa);\\n            let lazyParse = $.toString(() => {\\n                let vlink = srcurl;\\n                if (/(url|vid|v)\\\\=/.test(srcurl)) {\\n                    vlink = srcurl.substring(srcurl.search(/(url|vid|v)\\\\=/)).split('=')[1].split('&')[0];\\n                }\\n                let enDn = getMyVar(\\\"dnen\\\", \\\"0\\\"),\\n                    test1 = vlink.search(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) != -1,\\n                    test2 = vlink.search(/LT\\\\-|RongXingVR\\\\-|renrenmi\\\\-|xfy\\\\-|suoyo\\\\.cc|fen\\\\.laodi|ruifenglb|xueren\\\\-/) != -1;\\n                if ((test1 || test2) && enDn == '1') {\\n                    return $('hiker://empty').lazyRule((vlink) => {\\n                        log(\\\"调用断插解析,视频链接:\\\" + vlink);\\n                        eval(\\\"let config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                        eval(fetch(config.cj));\\n                        return aytmParse(vlink);\\n                    }, vlink)\\n                } else {\\n                    return $(\\\"hiker://empty\\\").lazyRule((ptab, srcurl, appUrl) => {\\n                        log(\\\"使用默认解析,视频链接:\\\" + srcurl);\\n                        //动态解析代码开始\\n                        function changeVideoUrl(url) {\\n                            //改变特定地址的Referer\\n                            if (url.includes(\\\"wkfile\\\")) {\\n                                url = url + ';{Referer@https://fantuan.wkfile.com/}';\\n                            } else if (ptab == 'bilibili') {\\n                                url = url + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\n                            } else if (ptab == 'mgtv') {\\n                                url = url + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                            } else if (url.includes(\\\"ojbk\\\")) {\\n                                url = url + ';{Referer@https://bak.ojbkjx.com/}';\\n                            }\\n                            //返回视频链接\\n                            if (!url.includes(\\\"http\\\")) {\\n                                throw new Error(\\\"链接不是以http开头(可能加密了)\\\");\\n                            } else {\\n                                if (/\\\\.m3u8/.test(url)) {\\n                                    return cacheM3u8(url);\\n                                } else {\\n                                    return url + '#isVideo=true#';\\n                                }\\n                            }\\n                        }\\n                        try {\\n                            if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(srcurl) && /http/.test(srcurl) && !/\\\\.html/.test(srcurl) && !/(url|v|vid)\\\\=/.test(srcurl)) {\\n                                if (!/fen\\\\.laodi|ruifenglb|suoyo\\\\.cc/.test(srcurl)) {\\n                                    log(\\\"检测到资源地址可能是视频链接\\\");\\n                                    return changeVideoUrl(srcurl);\\n                                }\\n                            }\\n                            //----分割线----//\\n                            let scode = JSON.parse(fetch(srcurl, {\\n                                headers: {\\n                                    \\\"User-Agent\\\": MOBILE_UA\\n                                },\\n                                redirect: false,\\n                                withStatusCode: true\\n                            }));\\n                            //返回重定向的链接 \\n                            if (scode.statusCode == '302' || scode.statusCode == '301') {\\n                                let redurl = scode.headers.location[0].replace(/\\\\\\\\/g, '');\\n                                log('重定向:' + redurl);\\n                                if (!/(url|vid|v)\\\\=/.test(redurl)) {\\n                                    return changeVideoUrl(redurl);\\n                                }\\n                                /*else if (/\\\\=http/.test(redurl) && /\\\\.m3u8|\\\\.mp4|\\\\.flv/.test(redurl)) {\\n                                    purl = redurl.substring(redurl.indexOf('=http') + 1);\\n                                }*/\\n                                scode.body = fetch(redurl);\\n                            }\\n                            //开始嗅探\\n                            let html = scode.body;\\n                            if (/404 Not Found|备案后可继续访问/.test(html)) {\\n                                throw new Error(\\\"404了\\\");\\n                            } else if (/\\\\<body/.test(html)) {\\n                                return $([\\\"开始视频嗅探\\\", \\\"打开解析网页\\\", \\\"使用内置解析\\\"], 1, \\\"检测到解析为网页数据\\\").select((ptab, srcurl, appUrl) => {\\n                                    if (input == \\\"开始视频嗅探\\\") {\\n                                        requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\n                                        return x5rule(srcurl, srcurl);\\n                                    } else if (input == \\\"打开解析网页\\\") {\\n                                        return \\\"web://\\\" + srcurl;\\n                                    } else if (input == \\\"使用内置解析\\\") {\\n                                        let vlink = srcurl;\\n                                        if (/(url|vid|v)\\\\=/.test(srcurl)) {\\n                                            vlink = srcurl.substring(srcurl.search(/(url|vid|v)\\\\=/)).split('=')[1].split('&')[0];\\n                                        }\\n                                        log(\\\"使用内置解析,视频链接:\\\" + vlink);\\n                                        showLoading(\\\"正在进行解析...\\\");\\n                                        return eval(JSON.parse(fetch(\\\"hiker://page/myParse\\\")).rule);\\n                                    }\\n                                }, ptab, srcurl, appUrl)\\n                            } else {\\n                                //log('尝试从json数据获取');\\n                                try {\\n                                    let purl = JSON.parse(html).url;\\n                                    return changeVideoUrl(purl);\\n                                } catch (e) {\\n                                    /*let purl = html.match(/[\\\\'\\\\\\\"]url[\\\\'\\\\\\\"]:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1].replace(/\\\\\\\\/g, '');\\n                                    return changeVideoUrl(purl);*/\\n                                    throw new Error('解析可能加密了');\\n                                }\\n                            }\\n                        } catch (e) {\\n                            log('未能成功获取视频地址:' + e.message);\\n                            let vlink = srcurl;\\n                            if (/(url|vid|v)\\\\=/.test(srcurl)) {\\n                                vlink = srcurl.substring(srcurl.search(/(url|vid|v)\\\\=/)).split('=')[1].split('&')[0];\\n                            }\\n                            log(\\\"尝试使用内置解析,视频链接:\\\" + vlink);\\n                            return eval(JSON.parse(fetch(\\\"hiker://page/myParse\\\")).rule);\\n                        }\\n                        //动态解析代码结束\\n                    }, ptab, srcurl, appUrl);\\n                }\\n            });\\n            pages.push({\\n                name: \\\"TV列表\\\",\\n                path: \\\"tvlistdata\\\",\\n                rule: rule_tvlistdata\\n            }, {\\n                name: \\\"TV选集\\\",\\n                path: \\\"tvmovlist\\\",\\n                rule: rule_tvmovlist\\n            }, {\\n                name: \\\"视频解析\\\",\\n                path: \\\"lazyParse\\\",\\n                rule: lazyParse\\n            });\\n        } else {\\n            find_rule = \\\"js:\\\" + $.toString(function(changeUrl, appUrl, appUa) {\\n                let items = [];\\n                //获取分类内容\\n                try {\\n                    let typeJson = [];\\n                    if (appUrl.includes(\\\"api.php/app\\\")) {\\n                        let typeUrl = changeUrl(appUrl + \\\"nav?token=\\\");\\n                        let typcode = request(typeUrl, { headers: { \\\"User-Agent\\\": appUa } });\\n                        if (typcode.indexOf('检测中') != -1) {\\n                            typcode = fetch(typeUrl + '&btwaf' + typcode.match(/btwaf(.*?)\\\\\\\"/)[1], { headers: { \\\"User-Agent\\\": appUa } });\\n                        }\\n                        typeJson = JSON.parse(typcode).list;\\n                    } else if (appUrl.includes(\\\"xgapp\\\")) {\\n                        let typeUrl = changeUrl(appUrl + \\\"nav?token=\\\");\\n                        let typcode = request(typeUrl, { headers: { \\\"User-Agent\\\": appUa } });\\n                        if (typcode.indexOf('检测中') != -1) {\\n                            typcode = fetch(typeUrl + '&btwaf' + typcode.match(/btwaf(.*?)\\\\\\\"/)[1], { headers: { \\\"User-Agent\\\": appUa } });\\n                        }\\n                        typeJson = JSON.parse(typcode).data;\\n                    } else if (appUrl.includes(\\\".vod\\\")) {\\n                        let typeUrl = changeUrl(appUrl + \\\"/types\\\");\\n                        let typcode = request(typeUrl, { headers: { \\\"User-Agent\\\": appUa } });\\n                        if (typcode.indexOf('检测中') != -1) {\\n                            typcode = fetch(typeUrl + '?btwaf' + typcode.match(/btwaf(.*?)\\\\\\\"/)[1], { headers: { \\\"User-Agent\\\": appUa } });\\n                        }\\n                        typeJson = JSON.parse(typcode).data.list;\\n                    }\\n                    //获取分类列表\\n                    for (let i = 0; i < typeJson.length; i++) {\\n                        //分类视频地址\\n                        let tyurl = \\\"\\\",\\n                            typeArray = Object.keys(typeJson[i].type_extend).filter(cur => [\\\"class\\\", \\\"area\\\", \\\"lang\\\", \\\"year\\\"].includes(cur)),\\n                            typeUrl = typeArray.map(cur => cur + \\\"=f\\\" + cur).join(\\\"&\\\");\\n                        if (appUrl.includes('api.php/app')) {\\n                            tyurl = appUrl + 'video?tid=' + typeJson[i].type_id + '&page=fypage&token=&' + typeUrl;\\n                        } else if (appUrl.includes('xgapp')) {\\n                            tyurl = appUrl + 'video?tid=' + typeJson[i].type_id + '&page=fypage&' + typeUrl;\\n                        } else if (appUrl.includes(\\\".vod\\\")) {\\n                            if (/iopenyun/.test(appUrl)) {\\n                                tyurl = appUrl + '/list?type=' + typeJson[i].type_id + '&page=fypage&by=fby&limit=9&' + typeUrl;\\n                            } else {\\n                                tyurl = appUrl + '?type=' + typeJson[i].type_id + '&page=fypage&by=fby&limit=9&' + typeUrl;\\n                            }\\n                        }\\n                        //构建动态分类\\n                        items.push({\\n                            title: typeJson[i].type_name,\\n                            url: $(\\\"hiker://empty##\\\" + tyurl).rule((appUrl, type_extend, changeUrl, appUa) => {\\n                                addListener(\\\"onClose\\\", \\\"clearVar('filter')\\\");\\n                                let items = [];\\n                                if (MY_PAGE == 1) { //动态分类\\n                                    let keys = {},\\n                                        filter = {},\\n                                        filterNames = { class: \\\"类型\\\", area: \\\"地区\\\", lang: \\\"语言\\\", year: \\\"年份\\\", star: \\\"明星\\\", director: \\\"导演\\\", state: \\\"状态\\\", version: \\\"版本\\\" },\\n                                        defaultFilter = {\\n                                            fclass: [\\\"全部类型\\\", \\\"喜剧\\\", \\\"爱情\\\", \\\"恐怖\\\", \\\"动作\\\", \\\"科幻\\\", \\\"剧情\\\", \\\"战争\\\", \\\"警匪\\\", \\\"犯罪\\\", \\\"动画\\\", \\\"奇幻\\\", \\\"武侠\\\", \\\"冒险\\\", \\\"枪战\\\", \\\"悬疑\\\", \\\"惊悚\\\", \\\"经典\\\", \\\"青春\\\", \\\"文艺\\\", \\\"微电影\\\", \\\"古装\\\", \\\"历史\\\", \\\"运动\\\", \\\"农村\\\", \\\"儿童\\\", \\\"网络电影\\\"],\\n                                            farea: [\\\"全部地区\\\", \\\"内地\\\", \\\"香港\\\", \\\"台湾\\\", \\\"美国\\\", \\\"英国\\\", \\\"法国\\\", \\\"日本\\\", \\\"韩国\\\", \\\"德国\\\", \\\"泰国\\\", \\\"印度\\\", \\\"西班牙\\\", \\\"加拿大\\\", \\\"其他\\\"],\\n                                            fyear: [\\\"全部年份\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2019\\\", \\\"2018\\\", \\\"2017\\\", \\\"2016\\\", \\\"2015\\\", \\\"2014\\\", \\\"2013\\\", \\\"2012\\\", \\\"2011\\\", \\\"2010\\\", \\\"2009\\\", \\\"2008\\\", \\\"2007\\\", \\\"2006\\\", \\\"2005\\\", \\\"2004\\\", \\\"2003\\\", \\\"2002\\\", \\\"2001\\\", \\\"2000\\\"],\\n                                            flang: [\\\"全部语言\\\", \\\"国语\\\", \\\"英语\\\", \\\"粤语\\\", \\\"闽南语\\\", \\\"韩语\\\", \\\"日语\\\", \\\"法语\\\", \\\"德语\\\", \\\"其他\\\"]\\n                                        };\\n                                    for (let key in type_extend) {\\n                                        if (![\\\"class\\\", \\\"area\\\", \\\"lang\\\", \\\"year\\\"].includes(key)) continue;\\n                                        keys[\\\"f\\\" + key] = \\\"\\\";\\n                                        keys[\\\"fby\\\"] = \\\"\\\";\\n                                        let filterName = \\\"全部\\\" + filterNames[key];\\n                                        filter[\\\"f\\\" + key] = [filterName].concat(type_extend[key].split(\\\",\\\"));\\n                                        if (filter[\\\"f\\\" + key].length == 2) {\\n                                            filter[\\\"f\\\" + key] = defaultFilter[\\\"f\\\" + key]\\n                                        }\\n                                    }\\n                                    if (!getVar(\\\"filter\\\", \\\"\\\")) { putVar(\\\"filter\\\", JSON.stringify(keys)) }\\n                                    var temp = JSON.parse(getVar(\\\"filter\\\")),\\n                                        color = \\\"#FA7298\\\";\\n                                    for (let item in filter) {\\n                                        for (let index = 0; index < filter[item].length; index++) {\\n                                            items.push({\\n                                                title: temp[item] == \\\"\\\" ? (index === 0 ? \\\"““””\\\" + filter[item][0].bold().fontcolor(color) : filter[item][index]) : (temp[item] == filter[item][index] ? \\\"““””\\\" + filter[item][index].bold().fontcolor(color) : filter[item][index]),\\n                                                col_type: \\\"scroll_button\\\",\\n                                                url: $().lazyRule((des, name) => {\\n                                                    let temp = JSON.parse(getVar(\\\"filter\\\"));\\n                                                    temp[name] = des.indexOf(\\\"全部\\\") != -1 ? \\\"\\\" : des;\\n                                                    putVar(\\\"filter\\\", JSON.stringify(temp));\\n                                                    refreshPage(false);\\n                                                    return \\\"hiker://empty\\\"\\n                                                }, filter[item][index], item)\\n                                            })\\n                                        }\\n                                        items.push({ col_type: \\\"blank_block\\\" })\\n                                    }\\n                                    let by = { 默认顺序: \\\"\\\", 最新: \\\"time\\\", 最热: \\\"hits\\\", 评分: \\\"score\\\" };\\n                                    if (appUrl.indexOf('api.php/app') == -1 && appUrl.indexOf('xgapp') == -1) {\\n                                        for (let item in by) {\\n                                            items.push({\\n                                                title: temp[\\\"fby\\\"] == by[item] ? \\\"““””\\\" + item.bold().fontcolor(color) : item,\\n                                                col_type: \\\"scroll_button\\\",\\n                                                url: $().lazyRule((des) => {\\n                                                    let temp = JSON.parse(getVar(\\\"filter\\\"));\\n                                                    temp[\\\"fby\\\"] = des;\\n                                                    putVar(\\\"filter\\\", JSON.stringify(temp));\\n                                                    refreshPage(false);\\n                                                    return \\\"hiker://empty\\\"\\n                                                }, by[item])\\n                                            })\\n                                        }\\n                                    }\\n                                } else {\\n                                    var temp = JSON.parse(getVar(\\\"filter\\\"));\\n                                }\\n                                let url = MY_URL.split(\\\"##\\\")[1];\\n                                for (let item in temp) {\\n                                    url = url.replace(item, temp[item]);\\n                                }\\n                                url = changeUrl(url);\\n                                let rescode = fetch(url, { headers: { \\\"User-Agent\\\": appUa } });\\n                                if (rescode.indexOf('检测中') != -1) {\\n                                    rescode = fetch(url + '&btwaf' + rescode.match(/btwaf(.*?)\\\\\\\"/)[1], { headers: { \\\"User-Agent\\\": appUa } });\\n                                }\\n                                let html = JSON.parse(rescode);\\n                                try {\\n                                    eval(JSON.parse(fetch('hiker://page/applistdata', {})).rule);\\n                                } catch (e) {\\n                                    log(\\\"视频列表出错:\\\" + e.message);\\n                                }\\n                                setResult(items);\\n                            }, appUrl, typeJson[i].type_extend, changeUrl, appUa),\\n                            col_type: 'flex_button'\\n                        })\\n                    }\\n                } catch (e) {\\n                    log('首页分类出错:' + e.message);\\n                }\\n                //获取推荐视频列表\\n                try {\\n                    let url = MY_URL.split('##')[1];\\n                    url = changeUrl(url);\\n                    let html = request(url, { headers: { \\\"User-Agent\\\": appUa } });\\n                    if (html.indexOf('检测中') != -1) {\\n                        html = fetch(url + '&btwaf' + html.match(/btwaf(.*?)\\\\\\\"/)[1], { headers: { \\\"User-Agent\\\": appUa } });\\n                    }\\n                    html = JSON.parse(html);\\n                    eval(JSON.parse(fetch('hiker://page/appindexdata')).rule);\\n                } catch (e) {\\n                    log('首页推荐出错:' + e.message);\\n                }\\n                setResult(items);\\n            }, changeUrl, appUrl, appUa)\\n\\n            let rule_applistdata = $.toString(function() {\\n                let list = [];\\n                if (appUrl.includes('api.php/app')) {\\n                    list = html.list;\\n                } else if (appUrl.includes('xgapp')) {\\n                    list = html.data;\\n                } else if (appUrl.includes(\\\".vod\\\")) {\\n                    list = html.data.list;\\n                }\\n\\n                for (let i = 0; i < list.length; i++) {\\n                    let { vod_name, vod_pic, vod_id, vod_remarks } = list[i];\\n                    let link = \\\"\\\";\\n                    if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\n                        link = appUrl + 'video_detail?id=' + vod_id + '&token=';\\n                    } else if (appUrl.includes(\\\".vod\\\")) {\\n                        let date = new Date();\\n                        link = appUrl + '/detail?vod_id=' + vod_id + '&rel_limit=10&key=' + (date.getMonth() + 1) + (date.getDate() < 10 ? '0' + date.getDate() : date.getDate());\\n                    };\\n\\n                    if (/iopenyun/.test(appUrl)) {\\n                        link = appUrl + '/detailID?vod_id=' + vod_id + '&rel_limit=10';\\n                    }\\n\\n                    items.push({\\n                        title: vod_name,\\n                        pic_url: vod_pic + '@Referer=',\\n                        desc: vod_remarks,\\n                        col_type: 'movie_3_marquee',\\n                        url: $(\\\"#immersiveTheme#hiker://empty##\\\" + link).rule(() => {\\n                            try {\\n                                eval(JSON.parse(fetch('hiker://page/appmovlist')).rule);\\n                            } catch (e) {\\n                                log(\\\"影片详情出错:\\\" + e.message);\\n                                setResult([]);\\n                            }\\n                        })\\n                    });\\n                }\\n            })\\n            let rule_appindexdata = $.toString(function() {\\n                let list = [];\\n                if (appUrl.includes('api.php/app')) {\\n                    list = html.list;\\n                } else if (appUrl.includes('xgapp')) {\\n                    list = html.data;\\n                } else if (appUrl.includes(\\\".vod\\\")) {\\n                    list = html.data.list;\\n                }\\n\\n                for (let i = 0; i < list.length; i++) {\\n                    let lists = [],\\n                        typename = \\\"\\\";\\n                    if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\n                        lists = list[i].vlist;\\n                        typename = list[i].type_name;\\n                    } else if (appUrl.includes(\\\".vod\\\")) {\\n                        lists = list[i].vod_list;\\n                        typename = list[i].vod_type_name;\\n\\n                    }\\n\\n                    items.push({\\n                        title: typename,\\n                        col_type: 'text_1',\\n                        url: \\\"hiker://empty\\\"\\n                    });\\n\\n                    for (let j = 0; j < lists.length; j++) {\\n                        let { vod_name, vod_pic, vod_id, vod_remarks } = lists[j];\\n                        let link = \\\"\\\";\\n                        if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\n                            link = appUrl + 'video_detail?id=' + vod_id + '&token=&key=';\\n                        } else if (appUrl.includes(\\\".vod\\\")) {\\n                            let date = new Date();\\n                            link = appUrl + '/detail?vod_id=' + vod_id + '&rel_limit=10&key=' + (date.getMonth() + 1) + (date.getDate() < 10 ? '0' + date.getDate() : date.getDate());\\n                        };\\n\\n                        if (/iopenyun/.test(appUrl)) {\\n                            link = appUrl + '/detailID?vod_id=' + vod_id + '&rel_limit=10';\\n                        }\\n\\n                        items.push({\\n                            title: vod_name,\\n                            pic_url: vod_pic + '@Referer=',\\n                            desc: vod_remarks,\\n                            col_type: 'movie_3_marquee',\\n                            url: $(\\\"#immersiveTheme#hiker://empty##\\\" + link).rule(() => {\\n                                try {\\n                                    eval(JSON.parse(fetch('hiker://page/appmovlist')).rule);\\n                                } catch (e) {\\n                                    log(\\\"影片详情出错:\\\" + e.message);\\n                                    setResult([]);\\n                                }\\n                            })\\n                        });\\n                    }\\n                }\\n            })\\n            let rule_appmovlist = $.toString(function(changeUrl, appUrl, appUa) {\\n                addListener(\\\"onClose\\\", $.toString((url) => {\\n                    clearVar('appnow');\\n                    clearVar(url);\\n                }, MY_URL));\\n                let items = [],\\n                    html = getVar(MY_URL, \\\"\\\"),\\n                    data = {};\\n                if (html == \\\"\\\") {\\n                    let url = MY_URL.split(\\\"##\\\")[1];\\n                    url = changeUrl(url);\\n                    html = fetch(url, { headers: { \\\"User-Agent\\\": appUa } });\\n                    putVar(MY_URL, html);\\n                }\\n                if (appUrl.includes(\\\"xgapp\\\")) {\\n                    data = JSON.parse(html).data.vod_info;\\n                } else {\\n                    data = JSON.parse(html).data;\\n                }\\n\\n                //简介\\n                let { vod_name, vod_pic, vod_content, vod_class, vod_remarks, vod_director, vod_actor, vod_area, vod_lang, vod_year } = data;\\n                items.push({\\n                    title: vod_name + '\\\\n' + vod_class + \\\",\\\" + vod_remarks + \\\"\\\\n\\\" + vod_area + \\\"/\\\" + vod_lang + \\\"/\\\" + vod_year,\\n                    desc: \\\"导演:\\\" + vod_director + \\\"\\\\n主演:\\\" + vod_actor,\\n                    pic_url: vod_pic,\\n                    url: \\\"hiker://empty\\\",\\n                    col_type: 'movie_1_vertical_pic_blur'\\n                }, {\\n                    title: '剧情简介:',\\n                    desc: vod_content,\\n                    url: $('hiker://empty#noRecordHistory#').rule((desc) => {\\n                        setResult([{\\n                            title: desc,\\n                            col_type: 'long_text'\\n                        }]);\\n                    }, vod_content),\\n                    col_type: 'text_1'\\n                });\\n                //断插\\n                let dnen = getMyVar(\\\"dnen\\\", \\\"0\\\");\\n                items.push({\\n                    title: '断插:' + (dnen == '1' ? '““✅””' : '❎'),\\n                    url: $('#noLoading#').lazyRule((dnen) => {\\n                        if (dnen == '1') {\\n                            putMyVar(\\\"dnen\\\", \\\"0\\\");\\n                            refreshPage(false);\\n                            return 'toast://已禁用断插调用!';\\n                        } else {\\n                            putMyVar(\\\"dnen\\\", \\\"1\\\");\\n                            refreshPage(false);\\n                            return 'toast://已开启断插调用!'\\n                        }\\n                    }, dnen),\\n                    col_type: 'text_2'\\n                });\\n                items.push({\\n                    title: '线路配置',\\n                    url: \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\",\\n                    //url: \\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noRecordHistory#\\\",\\n                    col_type: 'text_2'\\n                });\\n                //线路列表\\n\\n                let conts = [],\\n                    tabs = [];\\n                if (appUrl.includes(\\\"api.php/app\\\") || appUrl.includes(\\\"xgapp\\\")) {\\n                    conts = data.vod_url_with_player;\\n                } else {\\n                    conts = data.vod_play_list;\\n                }\\n                if (conts.length < 1) {\\n                    conts = data.vod_play_url.split('$$$');\\n                    tabs = data.vod_play_from.split('$$$');\\n                }\\n                //线路名称\\n                let ptab = \\\"\\\",\\n                    ptabname = \\\"\\\";\\n                if (getVar(\\\"appnow\\\", \\\"\\\") == \\\"\\\") { putVar(\\\"appnow\\\", \\\"0\\\") }\\n                for (let i = 0; i < conts.length; i++) {\\n                    let sptab = \\\"\\\",\\n                        tabname = \\\"\\\";\\n                    if (appUrl.includes(\\\"api.php/app\\\") || appUrl.includes(\\\"xgapp\\\")) {\\n                        sptab = conts[i].code ? conts[i].code : tabs[i];\\n                        tabname = conts[i].name || sptab;\\n                    } else {\\n                        sptab = conts[i].from ? conts[i].from : tabs[i];\\n                        tabname = conts[i].player_info ? conts[i].player_info.show : sptab;\\n                    }\\n                    items.push({\\n                        title: getVar(\\\"appnow\\\") == i ? \\\"““””\\\" + tabname.bold().fontcolor(\\\"#FA7298\\\") : tabname,\\n                        url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('appnow','\\\" + i + \\\"');refreshPage(false);'toast://切换成功!'\\\",\\n                        col_type: 'scroll_button'\\n                    })\\n                    if (getVar(\\\"appnow\\\") == i) {\\n                        ptab = sptab;\\n                        ptabname = tabname;\\n                    }\\n                }\\n                items.push({\\n                    title: \\\"““↓↑””\\\" + ptabname + \\\"-\\\" + ptab,\\n                    url: \\\"hiker://empty@lazyRule=.js:putVar('appmappsort', getVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功!'\\\",\\n                    col_type: 'text_1',\\n                    extra: { lineVisible: false }\\n                });\\n                //链接列表\\n                let list = [],\\n                    index = getVar(\\\"appnow\\\");\\n                if (appUrl.includes(\\\"api.php/app\\\") || appUrl.includes(\\\"xgapp\\\")) {\\n                    list = conts[index].url.split(\\\"#\\\");\\n                } else {\\n                    list = conts[index].urls ? conts[index].urls : conts[index].url.split(\\\"#\\\");\\n                };\\n                if (getVar('appmappsort', '1') == '0') {\\n                    list.reverse();\\n                }\\n                //解析接口\\n                let jiek = [];\\n                try {\\n                    if (appUrl.includes(\\\"api.php/app\\\") || appUrl.includes(\\\"xgapp\\\")) {\\n                        jiek.push(conts[index].parse_api || \\\"\\\");\\n                    } else {\\n                        jiek = (conts[index].player_info.parse2 || \\\"\\\").split(\\\",\\\").concat((conts[index].player_info.parse || \\\"\\\").split(\\\",\\\"));\\n                        jiek = jiek.map(cur => cur.replace(\\\"..\\\", \\\".\\\").replace('jsonbs', ''));\\n                    }\\n                } catch (e) {}\\n                jiek = jiek.filter(cur => !!cur);\\n                let jxUrl = jiek[0] || \\\"\\\";\\n                /*if (jxUrl.substring(0, 2) == '\\\\/\\\\/') {\\n                    jxUrl = 'https:' + jxUrl;\\n                }*/\\n                //打印接口\\n                log('\\\\n当前线路:' + ptab + '\\\\n解析列表:' + $.stringify(jiek));\\n                //视频列表\\n                for (let j = 0; j < list.length; j++) {\\n                    let vlink = \\\"\\\",\\n                        title = \\\"\\\";\\n                    if (list[j].url) {\\n                        vlink = list[j].url.replace(/#456#/g, 'http').replace(/#123#/g, '.').replace(/#789#/g, ':');\\n                        title = list[j].name;\\n                    } else {\\n                        vlink = list[j].split(\\\"$\\\")[1];\\n                        title = list[j].split(\\\"$\\\")[0];\\n                    }\\n                    //title = title.match(/(第|\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\n                    items.push({\\n                        title: title,\\n                        col_type: \\\"text_4\\\",\\n                        url: eval(JSON.parse(fetch(\\\"hiker://page/lazyParse\\\")).rule)\\n                    });\\n                }\\n                setResult(items);\\n            }, changeUrl, appUrl, appUa);\\n\\n            let lazyParse = $.toString(function() {\\n                let enDn = getMyVar(\\\"dnen\\\", \\\"0\\\"),\\n                    test1 = vlink.search(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) != -1,\\n                    test2 = vlink.search(/LT\\\\-|RongXingVR\\\\-|renrenmi\\\\-|xfy\\\\-|suoyo\\\\.cc|fen\\\\.laodi|ruifenglb|xueren\\\\-/) != -1;\\n                if ((test1 || test2) && enDn == '1') {\\n                    return $('hiker://empty').lazyRule((vlink) => {\\n                        log(\\\"\\\\n调用断插解析,视频链接:\\\" + vlink);\\n                        eval(\\\"let config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                        eval(fetch(config.cj));\\n                        return aytmParse(vlink);\\n                    }, vlink)\\n                } else {\\n                    return $('hiker://empty').lazyRule((ptab, vlink, jxUrl, appUrl) => {\\n                        log(\\\"\\\\n使用默认解析,视频链接:\\\" + vlink);\\n                        //视频链接处理\\n                        function changeVideoUrl(url) {\\n                            //改变特定地址的Referer\\n                            if (url.includes(\\\"wkfile\\\")) {\\n                                url = url + ';{Referer@https://fantuan.wkfile.com/}';\\n                            } else if (ptab == 'bilibili') {\\n                                url = url + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\n                            } else if (ptab == 'mgtv') {\\n                                url = url + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                            } else if (url.includes(\\\"ojbk\\\")) {\\n                                url = url + ';{Referer@https://bak.ojbkjx.com/}';\\n                            }\\n                            //返回视频链接\\n                            if (!url.includes(\\\"http\\\")) {\\n                                throw new Error(\\\"链接不是以http开头(可能加密了)\\\");\\n                            } else {\\n                                if (/\\\\.m3u8/.test(url)) {\\n                                    return cacheM3u8(url);\\n                                } else {\\n                                    return url + '#isVideo=true#';\\n                                }\\n                            }\\n                        }\\n                        //动态解析代码开始\\n                        try {\\n                            //处理视频样式的资源链接\\n                            if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(vlink) && /http/.test(vlink) && !/\\\\.html/.test(vlink)) {\\n                                if (!/fen\\\\.laodi|ruifenglb|suoyo\\\\.cc/.test(vlink)) {\\n                                    log(\\\"检测到资源地址可能是视频链接\\\");\\n                                    return changeVideoUrl(vlink);\\n                                }\\n                            }\\n                            //无可用解析直接报错\\n                            if (!jxUrl || /x\\\\-n\\\\.cc/.test(jxUrl)) {\\n                                throw new Error(\\\"无可用解析\\\");\\n                            }\\n                            //使用解析\\n                            log(\\\"使用解析:\\\" + jxUrl);\\n                            let link = jxUrl + vlink,\\n                                scode = JSON.parse(fetch(link, {\\n                                    headers: {\\n                                        \\\"User-Agent\\\": \\\"Dart/2.13 (dart:io)\\\"\\n                                    },\\n                                    redirect: false,\\n                                    withStatusCode: true\\n                                }));\\n                            //返回重定向的链接 \\n                            if (scode.statusCode == '302' || scode.statusCode == '301') {\\n                                let redurl = scode.headers.location[0].replace(/\\\\\\\\/g, '');\\n                                log('重定向:' + redurl);\\n                                if (!/(url|vid|v)\\\\=/.test(redurl)) {\\n                                    return changeVideoUrl(redurl);\\n                                }\\n                                /*else if (/\\\\=http/.test(redurl) && /\\\\.m3u8|\\\\.mp4|\\\\.flv/.test(redurl)) {\\n                                    purl = redurl.substring(redurl.indexOf('=http') + 1);\\n                                }*/\\n                                scode.body = fetch(redurl);\\n                            }\\n                            //开始嗅探\\n                            let html = scode.body;\\n                            if (/404 Not Found|备案后可继续访问/.test(html)) {\\n                                throw new Error(\\\"404了\\\");\\n                            } else if (/\\\\<body/.test(html)) {\\n                                return $([\\\"开始视频嗅探\\\", \\\"打开解析网页\\\", \\\"使用内置解析\\\"], 1, \\\"检测到解析为网页数据\\\").select((link, ptab, vlink, appUrl) => {\\n                                    if (input == \\\"开始视频嗅探\\\") {\\n                                        requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\n                                        return x5rule(link, link);\\n                                    } else if (input == \\\"打开解析网页\\\") {\\n                                        return \\\"web://\\\" + link;\\n                                    } else if (input == \\\"使用内置解析\\\") {\\n                                        log(\\\"使用内置解析\\\");\\n                                        showLoading(\\\"正在进行解析...\\\");\\n                                        return eval(JSON.parse(fetch(\\\"hiker://page/myParse\\\")).rule);\\n                                    }\\n                                }, link, ptab, vlink, appUrl);\\n                            } else {\\n                                //log('尝试从json数据获取');\\n                                try {\\n                                    let purl = JSON.parse(html).url;\\n                                    return changeVideoUrl(purl);\\n                                } catch (e) {\\n                                    /*let purl = html.match(/[\\\\'\\\\\\\"]url[\\\\'\\\\\\\"]:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1].replace(/\\\\\\\\/g, '');\\n                                    return changeVideoUrl(purl);*/\\n                                    throw new Error('解析可能加密了');\\n                                }\\n                            }\\n                        } catch (e) {\\n                            log('\\\\n未能成功获取视频地址:' + e.message + \\\"\\\\n尝试使用规则内置解析\\\");\\n                            return eval(JSON.parse(fetch(\\\"hiker://page/myParse\\\")).rule);\\n                        }\\n                        //动态解析代码结束\\n                    }, ptab, vlink, jxUrl, appUrl);\\n                }\\n            });\\n            pages.push({\\n                name: \\\"APP分类列表\\\",\\n                path: \\\"applistdata\\\",\\n                rule: rule_applistdata\\n            }, {\\n                name: \\\"APP首页列表\\\",\\n                path: \\\"appindexdata\\\",\\n                rule: rule_appindexdata\\n            }, {\\n                name: \\\"APP选集\\\",\\n                path: \\\"appmovlist\\\",\\n                rule: rule_appmovlist\\n            }, {\\n                name: \\\"视频解析\\\",\\n                path: \\\"lazyParse\\\",\\n                rule: lazyParse\\n            });\\n        }\\n\\n        let myParse = JSON.parse(fetch(\\\"hiker://page/myParse\\\")).rule;\\n        pages.push({\\n            name: \\\"内置解析\\\",\\n            path: \\\"myParse\\\",\\n            rule: myParse\\n        })\\n\\n        searchFind = \\\"js:\\\" + $.toString(function(changeUrl, apptype, appUrl, appUa) {\\n            let items = [],\\n                search_url = changeUrl(MY_URL.split('##')[1]),\\n                bhtml = \\\"\\\";\\n\\n            bhtml = fetch(search_url, { headers: { \\\"User-Agent\\\": appUa } });\\n\\n            try {\\n                bhtml = bhtml.startsWith('\\\\r\\\\n') ? bhtml.replace('\\\\r\\\\n', '') : bhtml;\\n            } catch (e) {}\\n\\n            if (/btwaf/.test(bhtml)) {\\n                bhtml = fetch(search_url + '&btwaf' + bhtml.match(/btwaf(.*?)\\\\\\\"/)[1], { headers: { \\\"User-Agent\\\": appUa } });\\n            }\\n\\n            let html = JSON.parse(bhtml),\\n                list = [];\\n            if (/神马|TV/.test(apptype)) {\\n                list = html.data;\\n            } else {\\n                if (appUrl.includes('api.php/app')) {\\n                    list = html.list;\\n                } else if (appUrl.includes('xgapp')) {\\n                    list = html.data;\\n                } else {\\n                    list = html.data.list;\\n                }\\n            }\\n\\n            for (let i = 0; i < list.length; i++) {\\n                if (/神马|TV/.test(apptype)) {\\n                    var { title, pic, nextlink: url, state: desc } = list[i];\\n                } else {\\n                    if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\n                        var { vod_name: title, vod_pic: pic, vod_remarks: desc } = list[i],\\n                            url = appUrl + 'video_detail?id=' + list[i].vod_id + '&token=';\\n                    } else {\\n                        var { vod_name: title, vod_pic: pic, vod_remarks: desc } = list[i];\\n                        if (/iopenyun/.test(appUrl)) {\\n                            var url = appUrl + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\n                        } else {\\n                            var url = appUrl + '/detail?vod_id=' + list[i].vod_id + '&token=';\\n                        }\\n                    }\\n                }\\n\\n                items.push({\\n                    title: title,\\n                    pic_url: pic + '@Referer=',\\n                    desc: desc,\\n                    col_type: 'movie_1_vertical_pic',\\n                    url: $(\\\"#immersiveTheme#hiker://empty##\\\" + url).rule((apptype) => {\\n                        if (/神马|TV/.test(apptype)) {\\n                            eval(JSON.parse(fetch('hiker://page/tvmovlist')).rule);\\n                        } else {\\n                            eval(JSON.parse(fetch('hiker://page/appmovlist')).rule);\\n                        }\\n                    }, apptype)\\n                });\\n            }\\n\\n            setResult(items);\\n        }, changeUrl, apptype, appUrl, appUa)\\n\\n        last_chapter_rule = \\\"js:\\\" + $.toString(function(apptype, appUrl, appUa) {\\n            let chp = [];\\n            try {\\n                let conts = [],\\n                    html = JSON.parse(fetch(MY_URL.split(\\\"##\\\")[1], { headers: { \\\"User-Agent\\\": appUa } }));\\n                if (/神马|TV/.test(apptype)) {\\n                    conts = Object.keys(html.videolist);\\n                } else if (appUrl.includes(\\\"api.php/app\\\")) {\\n                    conts = html.data.vod_url_with_player;\\n                    if (conts.length < 1) {\\n                        conts = html.data.vod_play_url.split('$$$');\\n                    }\\n                } else if (appUrl.includes(\\\"xgapp\\\")) {\\n                    conts = html.data.vod_info.vod_url_with_player;\\n                    if (conts.length < 1) {\\n                        conts = html.data.vod_info.vod_play_url.split('$$$');\\n                    }\\n                } else {\\n                    conts = html.data.vod_play_list;\\n                    if (conts.length < 1) {\\n                        conts = html.data.vod_play_url.split('$$$');\\n                    }\\n                }\\n\\n                let list = [];\\n                for (let i = 0; i < conts.length; i++) {\\n                    if (/神马|TV/.test(apptype)) {\\n                        list = html.videolist[conts[i]];\\n                    } else if (conts[i].urls) {\\n                        list = conts[i].urls;\\n                    } else if (conts[i].url) {\\n                        list = conts[i].url.split(\\\"#\\\");\\n                    } else {\\n                        list = conts[i].split(\\\"#\\\");\\n                    }\\n                    chp.push(list.length);\\n                }\\n            } catch (e) {}\\n            setResult('更新至:' + (Math.max.apply(Math, chp)));\\n        }, apptype, appUrl, appUa);\\n\\n        rules.push({\\n            title: apptitle,\\n            author: getMyVar('remoteUrl'),\\n            type: apptype,\\n            url: home_url,\\n            find_rule: find_rule,\\n            search_url: search_url,\\n            searchFind: searchFind,\\n            pages: JSON.stringify(pages),\\n            last_chapter_rule: last_chapter_rule,\\n            icon: appicon\\n        });\\n    }\\n}\\n/*$.exports = {\\n    rules: rules,\\n    types: types\\n}*/\\n$.exports = rules;\"},{\"col_type\":\"movie_3\",\"name\":\"内置数据\",\"path\":\"ResCode\",\"rule\":\"{\\n    \\\"data\\\":[\\n        {\\n        \\\"title\\\":\\\"优质\\\",\\n        \\\"list\\\":[\\n            {\\n            \\\"title\\\":\\\"1080p\\\",\\n            \\\"url\\\":\\\"https://1080p.one/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1080p.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"1231D\\\",\\n            \\\"url\\\":\\\"https://vue.app.yunboys.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1231D.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"300看世界\\\",\\n            \\\"url\\\":\\\"https://300ys.xyz/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/300看世界.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"4K影院\\\",\\n            \\\"url\\\":\\\"http://1api.4kdytv.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/4K影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"80K影视\\\",\\n            \\\"url\\\":\\\"https://1080p.tv/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80K影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"CJT影院\\\",\\n            \\\"url\\\":\\\"https://www.cjt521.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CJT影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"DC影视\\\",\\n            \\\"url\\\":\\\"http://chaorenbb.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/DC影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"F7高清\\\",\\n            \\\"url\\\":\\\"http://bc.haokanju1.cc/lvdou_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/F7高清.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"HG影视\\\",\\n            \\\"url\\\":\\\"http://hgyx.vip/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"l0l影院\\\",\\n            \\\"url\\\":\\\"https://l0l.tv/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/l0l影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"爱看美剧\\\",\\n            \\\"url\\\":\\\"https://www.uumjw.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱看美剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"爱酷影视\\\",\\n            \\\"url\\\":\\\"https://www.zhanlangbu.com/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱酷影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"菜鸟追剧\\\",\\n            \\\"url\\\":\\\"http://81.71.18.95:5555/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟追剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"白嫖影视\\\",\\n            \\\"url\\\":\\\"http://zgjxdtg.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白嫖影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"爱看影院\\\",\\n            \\\"url\\\":\\\"http://www.a91.cm/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"初心影视\\\",\\n            \\\"url\\\":\\\"https://www.18mv.club/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/初心影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"独播社\\\",\\n            \\\"url\\\":\\\"http://35ys.cc/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/独播社.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"叮当影视\\\",\\n            \\\"url\\\":\\\"https://tv.0573wl.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/叮当影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"段友影视\\\",\\n            \\\"url\\\":\\\"http://121.204.249.135:4433/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视3.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"段友影视\\\",\\n            \\\"url\\\":\\\"https://shangjihuoke.com/api.php/tv.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"饭后电影\\\",\\n            \\\"url\\\":\\\"http://summ.vip/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/饭后电影.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"飞捷影视\\\",\\n            \\\"url\\\":\\\"https://www.fj6080.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞捷影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"疯狂看\\\",\\n            \\\"url\\\":\\\"http://app.fkkdy.vip/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/疯狂看电影.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"粉象视界\\\",\\n            \\\"url\\\":\\\"http://42.157.129.15:34444/lvdou_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/粉象视界.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"汇聚库TV\\\",\\n            \\\"url\\\":\\\"https://www.zzclove666.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/汇聚库TV.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"虎猫视频\\\",\\n            \\\"url\\\":\\\"https://humaosp.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虎猫视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"可米影视\\\",\\n            \\\"url\\\":\\\"http://www.kmys.vip/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"康耀影视\\\",\\n            \\\"url\\\":\\\"http://app.ybyyds.cn/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/康耀影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"绿箭影视\\\",\\n            \\\"url\\\":\\\"http://www.69ty.cc/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿箭影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"懒猫电影\\\",\\n            \\\"url\\\":\\\"http://www.esellauto.com/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫电影.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"蜜蜂影视\\\",\\n            \\\"url\\\":\\\"http://app.f8tp.com/lvdou_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜蜂影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"麻瓜视频\\\",\\n            \\\"url\\\":\\\"http://aliyun.k8aa.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻瓜视频1.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"美剧虫\\\",\\n            \\\"url\\\":\\\"https://meijuchong.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧虫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"木子电影\\\",\\n            \\\"url\\\":\\\"http://www.muzidy.top/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/木子电影.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"奈非迷\\\",\\n            \\\"url\\\":\\\"https://app.netflixmi.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈非迷影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"南府影视\\\",\\n            \\\"url\\\":\\\"http://iapp.nfuxs.club/dnmb.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/南府影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"暖光影视\\\",\\n            \\\"url\\\":\\\"https://app.bl210.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/暖光影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"念念影视\\\",\\n            \\\"url\\\":\\\"https://998.yuanmajs.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/念念影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"柠柚影视\\\",\\n            \\\"url\\\":\\\"http://nu.e4tv.cn/lvdou_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柠柚影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"奇怪视频\\\",\\n            \\\"url\\\":\\\"https://giguai.net/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"七零动漫\\\",\\n            \\\"url\\\":\\\"https://cf.70yu.cn/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七零动漫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"瑞丰资源\\\",\\n            \\\"url\\\":\\\"https://tv.yjhan.com:4433/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/瑞丰.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"闪光影视\\\",\\n            \\\"url\\\":\\\"http://101.35.128.192/mubai_api.php/m2.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/闪光影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"思乐影视\\\",\\n            \\\"url\\\":\\\"https://www.huandian.top/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思乐影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"天诚影视\\\",\\n            \\\"url\\\":\\\"http://tcspvip.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天诚影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"天天影视\\\",\\n            \\\"url\\\":\\\"https://app.daishusc.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"温妮影视\\\",\\n            \\\"url\\\":\\\"https://www.wenniys.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/温妮影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"小白动漫\\\",\\n            \\\"url\\\":\\\"http://121.62.60.222:20222/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小白动漫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"星辰视频\\\",\\n            \\\"url\\\":\\\"https://m.hj0999.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星辰视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"小极影视\\\",\\n            \\\"url\\\":\\\"http://app.8d8q.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"心鸾影视\\\",\\n            \\\"url\\\":\\\"http://zhiyutv.xyz/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/心鸾影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"雪人影视\\\",\\n            \\\"url\\\":\\\"https://zy.qd234.cn/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雪人影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"益达影院\\\",\\n            \\\"url\\\":\\\"http://luobu.yss6080.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/益达影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"雨果影视\\\",\\n            \\\"url\\\":\\\"http://2.yhys63.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雨果影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"影视大全\\\",\\n            \\\"url\\\":\\\"http://app.269w.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"月色影视\\\",\\n            \\\"url\\\":\\\"http://69ty.cc/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月色影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"优视影视\\\",\\n            \\\"url\\\":\\\"http://cc.ysys.asia/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优视影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"影阅阁\\\",\\n            \\\"url\\\":\\\"http://221.236.18.12:665/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影阅阁.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"追剧吧\\\",\\n            \\\"url\\\":\\\"http://zhuiju8.vip/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧吧影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            }\\n        ]\\n        },\\n        {\\n        \\\"title\\\":\\\"普通\\\",\\n        \\\"list\\\":[\\n            {\\n            \\\"title\\\":\\\"51视频\\\",\\n            \\\"url\\\":\\\"http://51shipin.cc/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/51视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"80影视\\\",\\n            \\\"url\\\":\\\"http://www.ccc8.net/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"JDODO\\\",\\n            \\\"url\\\":\\\"https://appys.jdodo.xyz/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/JDODO影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"QC影视\\\",\\n            \\\"url\\\":\\\"https://www.qcsvip.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/QC影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"U5影视\\\",\\n            \\\"url\\\":\\\"https://appx.uy07.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/U5影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"XG影视\\\",\\n            \\\"url\\\":\\\"http://cms.xggm.top/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/XG影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"yoyo\\\",\\n            \\\"url\\\":\\\"http://jx.wnvod.net/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/yoyo影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"阿里影视\\\",\\n            \\\"url\\\":\\\"http://aliys.cn:90/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/阿里影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"嗷呜影院\\\",\\n            \\\"url\\\":\\\"http://aowu.pro/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嗷呜影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"爱影视\\\",\\n            \\\"url\\\":\\\"https://www.hzlff.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"爱追剧\\\",\\n            \\\"url\\\":\\\"http://81.71.18.95:520/lvdou_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱追剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"艾特影视\\\",\\n            \\\"url\\\":\\\"https://www.aitee.cc/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/艾特影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"白菜追剧\\\",\\n            \\\"url\\\":\\\"http://lbapp.huimaojia.com:30119/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白菜追剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"比邻影视\\\",\\n            \\\"url\\\":\\\"http://0hzy.cn:9990/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/比邻影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"百讯视频\\\",\\n            \\\"url\\\":\\\"https://z.iopenyun.com:99/app_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/百讯视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"菜鸟动漫\\\",\\n            \\\"url\\\":\\\"http://taikong.huangguay.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟动漫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"大头影视\\\",\\n            \\\"url\\\":\\\"http://dy.idsao.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大头影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"段友影视\\\",\\n            \\\"url\\\":\\\"http://js.66app.me/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视2.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"豆渣影视\\\",\\n            \\\"url\\\":\\\"http://douzhayss.cc/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/豆渣影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"二九影视\\\",\\n            \\\"url\\\":\\\"https://app.19kp.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二九影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"风启影视\\\",\\n            \\\"url\\\":\\\"http://ysw.ee/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/风启影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"辉哥影视\\\",\\n            \\\"url\\\":\\\"https://app.y.hgyule8.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/辉哥影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"黄河影视\\\",\\n            \\\"url\\\":\\\"http://i.ledu8.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黄河影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"火星人\\\",\\n            \\\"url\\\":\\\"https://www.huoxing9.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/火星人影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"晗先森\\\",\\n            \\\"url\\\":\\\"https://hantv.top/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/晗先森影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"盒子影院\\\",\\n            \\\"url\\\":\\\"http://i.nihaohezi.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/盒子影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"筋斗云\\\",\\n            \\\"url\\\":\\\"https://tv.jindcloud.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/筋斗云影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"极光影院\\\",\\n            \\\"url\\\":\\\"http://app.winxz.cc/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/极光影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"聚合视频\\\",\\n            \\\"url\\\":\\\"https://app.jhystv.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚合视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"久久影视\\\",\\n            \\\"url\\\":\\\"http://s9t9.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"剧迷视频\\\",\\n            \\\"url\\\":\\\"http://pan.hzafw.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/剧迷视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"橘子影视\\\",\\n            \\\"url\\\":\\\"http://jz.juzidy.vip/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/橘子影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"快播吧\\\",\\n            \\\"url\\\":\\\"http://app.hd8.pw/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/快播吧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"看剧吧\\\",\\n            \\\"url\\\":\\\"http://app.ishen520.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看剧吧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"看看剧\\\",\\n            \\\"url\\\":\\\"https://www.kankanju.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看看剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"酷酷影视\\\",\\n            \\\"url\\\":\\\"http://www.ccc8.net/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/酷酷影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"可米影视\\\",\\n            \\\"url\\\":\\\"http://sj.kmys.vip/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"绿豆视频\\\",\\n            \\\"url\\\":\\\"https://v.lvdoui.cn/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿豆影音.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"蓝光视频\\\",\\n            \\\"url\\\":\\\"http://vip.91iqiyi.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蓝光视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"林谷影视\\\",\\n            \\\"url\\\":\\\"http://ys.linguyy.xyz/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/林谷影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"冷视TV\\\",\\n            \\\"url\\\":\\\"https://len.tv/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷视TV.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"美剧范\\\",\\n            \\\"url\\\":\\\"http://ttzmz.net/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧范.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"喵乐影视\\\",\\n            \\\"url\\\":\\\"http://miaoleys.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/喵乐影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"名视影\\\",\\n            \\\"url\\\":\\\"http://app.qqccv.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/名视影.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"麻子追剧\\\",\\n            \\\"url\\\":\\\"http://b.2maz.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻子追剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"奈飞中文\\\",\\n            \\\"url\\\":\\\"https://www.naifei.org/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈飞中文.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"苹果影视\\\",\\n            \\\"url\\\":\\\"https://apple678.xyz/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/苹果影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"皮皮动漫\\\",\\n            \\\"url\\\":\\\"http://dm.muying.me/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/皮皮动漫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"奇趣影视\\\",\\n            \\\"url\\\":\\\"https://app.qiqu.me/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奇趣影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"任性看\\\",\\n            \\\"url\\\":\\\"https://renxingkan.net/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/任性看.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"思奇影视\\\",\\n            \\\"url\\\":\\\"http://app.siqitv.vip/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"三日影院\\\",\\n            \\\"url\\\":\\\"https://www.3ri.net/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/三日影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"神马影视\\\",\\n            \\\"url\\\":\\\"http://xs.78tv.cc/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/神马影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"视听星球\\\",\\n            \\\"url\\\":\\\"http://zjyapijzys.shynwlkj.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/视听星球.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"土豆TV\\\",\\n            \\\"url\\\":\\\"http://xiuxian.qd234.cn/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/土豆TV.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"淘剧社\\\",\\n            \\\"url\\\":\\\"https://app.shuhai99.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/淘剧社.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"天空影视\\\",\\n            \\\"url\\\":\\\"https://tv.51aizn.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"天天视频\\\",\\n            \\\"url\\\":\\\"http://app.qianju.cc/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"兔子窝\\\",\\n            \\\"url\\\":\\\"http://cj.huimaojia.com:12345/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/兔子窝.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"我爱跟剧\\\",\\n            \\\"url\\\":\\\"https://www.genmov.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/我爱跟剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"吾爱影视\\\",\\n            \\\"url\\\":\\\"http://app.5lp.net/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"吾爱影视\\\",\\n            \\\"url\\\":\\\"http://52ysw.xyz/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视1.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"吻痕视频\\\",\\n            \\\"url\\\":\\\"http://www.kissone.cn/ruifenglb_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吻痕视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"蜗牛动漫\\\",\\n            \\\"url\\\":\\\"http://woniudm.woniu.cyou:20000/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜗牛动漫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"寻常影视\\\",\\n            \\\"url\\\":\\\"http://tv.91ymz.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/寻常影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"熊猫动漫\\\",\\n            \\\"url\\\":\\\"http://dongman.k8aa.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫动漫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"熊猫视频\\\",\\n            \\\"url\\\":\\\"http://anegh.com/lvdou_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"玺娜影视\\\",\\n            \\\"url\\\":\\\"https://pp.wxina.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺娜影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"小蜻蜓\\\",\\n            \\\"url\\\":\\\"http://3ketv.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小蜻蜓视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"星球视频\\\",\\n            \\\"url\\\":\\\"http://119.29.121.48:8088/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星球视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"玺心影视\\\",\\n            \\\"url\\\":\\\"https://tv.arbd.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺心影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"新享影视\\\",\\n            \\\"url\\\":\\\"https://app.jiagan.cx/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/新享影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"星影相随\\\",\\n            \\\"url\\\":\\\"http://app.rootthree.top/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星影相随.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"小易影视\\\",\\n            \\\"url\\\":\\\"http://xy.irop.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小易影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"云城影院\\\",\\n            \\\"url\\\":\\\"https://ayyf.cn/mubai_api.php/m2.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/云城影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"月儿影视\\\",\\n            \\\"url\\\":\\\"https://yue52.xyz/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"樱花动漫\\\",\\n            \\\"url\\\":\\\"https://www.dmwu.cc/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/樱花动漫.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"月亮影视\\\",\\n            \\\"url\\\":\\\"http://ys.13tv.top/acj_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月亮影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"影视大全\\\",\\n            \\\"url\\\":\\\"https://xc.xixi2yy.xyz/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全HD.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"影视热剧\\\",\\n            \\\"url\\\":\\\"http://lb.26ys.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视热剧.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"渔渔影视\\\",\\n            \\\"url\\\":\\\"http://luobo.yugenye.site/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/渔渔影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"优优影院\\\",\\n            \\\"url\\\":\\\"http://xin.jjsvip.cc/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优优影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"柚子视频\\\",\\n            \\\"url\\\":\\\"http://yz.26ys.cn/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柚子视频.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"鱼仔影视\\\",\\n            \\\"url\\\":\\\"http://yuzaio.top/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/鱼仔影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"追剧达人\\\",\\n            \\\"url\\\":\\\"https://www.zhuijudaren.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧达人.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"追剧猫\\\",\\n            \\\"url\\\":\\\"http://tv.kmtvb.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧猫1.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"侦探影视\\\",\\n            \\\"url\\\":\\\"http://ys.huangguay.com/mogai_api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/侦探影视.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"猪猪影院\\\",\\n            \\\"url\\\":\\\"http://app.2zdyy.com/api.php/v1.vod\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/猪猪影院.png\\\",\\n            \\\"murl\\\":\\\"q:APP影视\\\"\\n            }\\n        ]\\n        },\\n        {\\n        \\\"title\\\":\\\"IPTV\\\",\\n        \\\"list\\\":[\\n            {\\n            \\\"title\\\":\\\"2号币\\\",\\n            \\\"url\\\":\\\"http://phoebe.cf/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/2号币影院.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"CV影视\\\",\\n            \\\"url\\\":\\\"http://www.cccvvv.top/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CV影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"HG影视\\\",\\n            \\\"url\\\":\\\"http://api.hgyx.vip/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"傲视影院\\\",\\n            \\\"url\\\":\\\"http://j.zjj.life:88/mv/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/傲视影院.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"爱西西TV\\\",\\n            \\\"url\\\":\\\"http://tv.aixixi.vip/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱西西TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"白熊影院\\\",\\n            \\\"url\\\":\\\"http://qt.yhzy.xyz/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白熊影院.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"刺桐影视\\\",\\n            \\\"url\\\":\\\"http://tv.cttv.vip/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/刺桐影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"尘梓TV\\\",\\n            \\\"url\\\":\\\"http://cztv.vip:83/api.php/chenziystv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/尘梓TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"嘀哩嘀哩\\\",\\n            \\\"url\\\":\\\"https://api.diliktv.xyz/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘀哩嘀哩TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"动力影视\\\",\\n            \\\"url\\\":\\\"http://www.love9989.com/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/动力影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"大师兄\\\",\\n            \\\"url\\\":\\\"http://dsxtv.tv.ci/api.php/dsx/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大师兄影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"二货影视\\\",\\n            \\\"url\\\":\\\"http://d.zjj.life:88/mv/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二货影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"非凡影院\\\",\\n            \\\"url\\\":\\\"http://cms.feifan12.xyz/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/非凡影院.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"飞扬TV\\\",\\n            \\\"url\\\":\\\"http://diancj.zhenfy.cn/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞扬TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"嘿荼锋\\\",\\n            \\\"url\\\":\\\"http://tv.hfys8.vip/api.php/Sntv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘿荼锋.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"黑龙影视\\\",\\n            \\\"url\\\":\\\"http://vip.ji-ding-he.site/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黑龙影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"河马影院\\\",\\n            \\\"url\\\":\\\"http://1.14.63.101/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/河马影院.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"聚多影视\\\",\\n            \\\"url\\\":\\\"http://jdyy.weetai.cn/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚多影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"久久影院\\\",\\n            \\\"url\\\":\\\"http://l.bhtv.org.cn/mv/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影院.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"乐酷TV\\\",\\n            \\\"url\\\":\\\"http://150.138.78.177:2021/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/乐酷TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"懒猫TV\\\",\\n            \\\"url\\\":\\\"http://www.esellauto.com/api.php/lh/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"六维影视\\\",\\n            \\\"url\\\":\\\"http://liuweiiptv.gq:1357/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/六维影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"流星雨\\\",\\n            \\\"url\\\":\\\"http://nn.lxyyy.xyz:8/c/api.php/WAiLaowang/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/流星雨影院.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"冷月TV\\\",\\n            \\\"url\\\":\\\"https://tv.521x5.com/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷月TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"荔枝影视\\\",\\n            \\\"url\\\":\\\"http://api.zjys.vip/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/荔枝影视TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"免费看TV\\\",\\n            \\\"url\\\":\\\"http://www.freekan.vip/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/免费看TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"蜜果TV\\\",\\n            \\\"url\\\":\\\"http://vv.miguotv.net/m/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜果TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"米来影视\\\",\\n            \\\"url\\\":\\\"http://42.51.37.161:2346/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米来影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"米奇TV\\\",\\n            \\\"url\\\":\\\"http://www.s6ep3.top/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米奇TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"七科影视\\\",\\n            \\\"url\\\":\\\"http://tv.7kfm.cn/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七科影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"若惜影视\\\",\\n            \\\"url\\\":\\\"http://rxw.ruoxinew.com/api.php/Sntv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/若惜影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"思奇TV\\\",\\n            \\\"url\\\":\\\"http://tv.siqitv.vip/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"双子星\\\",\\n            \\\"url\\\":\\\"http://tv.diyoui.cc/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/双子星.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"山楂影视\\\",\\n            \\\"url\\\":\\\"http://dy6.dcd1.cn/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/山楂影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"天空TV\\\",\\n            \\\"url\\\":\\\"http://tv.tkys.tv/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"虾皮视频\\\",\\n            \\\"url\\\":\\\"http://tv.cmt8.xyz/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虾皮视频.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"小极TV\\\",\\n            \\\"url\\\":\\\"http://api.8d8q.com/mmv/api.php/Chengcheng/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"小熊猫TV\\\",\\n            \\\"url\\\":\\\"http://tv2.hetaoys.vip/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小熊猫TV.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            },\\n            {\\n            \\\"title\\\":\\\"紫曦影视\\\",\\n            \\\"url\\\":\\\"http://appys.azx.tools:88/api.php/iptv/vod/\\\",\\n            \\\"img\\\":\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/紫曦影视.png\\\",\\n            \\\"murl\\\":\\\"q:TV影视\\\"\\n            }\\n        ]\\n        }\\n    ]\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"获取app列表\",\"path\":\"appJson\",\"rule\":\"let appfile = \\\"\\\";\\ntry {\\n    appfile = fetch(getMyVar(\\\"subscription\\\"));\\n} catch (e) {}\\n\\nlet appjson = {};\\nif (/InMemory/.test(appfile)) {\\n    appjson = JSON.parse(appfile);\\n} else {\\n    appjson = JSON.parse(JSON.parse(fetch(\\\"hiker://page/ResCode\\\", {})).rule);\\n}\\n\\n$.exports = appjson;\"},{\"col_type\":\"movie_3\",\"name\":\"内置数据2\",\"path\":\"myParse\",\"rule\":\"(() => {\\n    function changeVideoUrl(url) {\\n        //改变特定地址的Referer\\n        if (url.includes(\\\"wkfile\\\")) {\\n            url = url + ';{Referer@https://fantuan.wkfile.com/}';\\n        } else if (ptab == 'bilibili') {\\n            url = url + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\n        } else if (ptab == 'mgtv') {\\n            url = url + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n        } else if (url.includes(\\\"ojbk\\\")) {\\n            url = url + ';{Referer@https://bak.ojbkjx.com/}';\\n        }\\n        //返回视频链接\\n        if (!url.includes(\\\"http\\\")) {\\n            throw new Error(\\\"链接不是以http开头(可能加密了)\\\");\\n        } else {\\n            if (/\\\\.m3u8/.test(url)) {\\n                return cacheM3u8(url);\\n            } else {\\n                return url + '#isVideo=true#';\\n            }\\n        }\\n    }\\n    //aes解密\\n    function De(data, token_key, token_iv) {\\n        eval(getCryptoJS());\\n        var key = CryptoJS.enc.Utf8.parse(token_key);\\n        var iv = CryptoJS.enc.Utf8.parse(token_iv);\\n        return CryptoJS.AES.decrypt(data, key, {\\n            iv: iv,\\n            mode: CryptoJS.mode.CBC,\\n            padding: CryptoJS.pad.Pkcs7\\n        }).toString(CryptoJS.enc.Utf8);\\n    };\\n    if (vlink.includes('m3u8.cache.suoyo.cc')) {\\n        let url = JSON.parse(fetch('https://jhpc.manduhu.com/duoduo/api.php', { body: 'url=' + vlink, method: 'POST' })).url;\\n        return changeVideoUrl(De(url, md5('rXjWvXl6'), 'NXbHoWJbpsEOin8b'));\\n    } else if (vlink.includes('ruifenglb')) {\\n        let url = JSON.parse(fetch('http://ts.yjhan.com:8090/api/?key=DSQFgXdmj9xkDyiXdr&url=' + vlink)).url;\\n        return changeVideoUrl(url);\\n        /*let html = fetch('https://tv.yjhan.com:4423/CL4K/?url=' + vlink),\\n            le_token = html.match(/le_token.*=.*\\\"(.*)\\\"/)[1],\\n            url = html.match(/\\\"url\\\".*:.*\\\"(.*)\\\"/)[1];\\n        return changeVideoUrl(De(url, \\\"A42EAC0C2B408472\\\", le_token));*/\\n    } else if (vlink.includes(\\\"xueren-\\\")) {\\n        let html = fetch('https://diaoyong.qd234.cn/?url=' + vlink),\\n            le_token = html.match(/le_token\\\\s*=\\\\s*\\\"(.*)\\\"/)[1],\\n            url = html.match(/\\\"url\\\"\\\\s*:\\\\s*\\\"(.*)\\\"/)[1];\\n        return changeVideoUrl(De(url, 'A42EAC0C2B408473', le_token));\\n    } else if (vlink.includes(\\\"netflixmom-\\\")) {\\n        let html = fetch('https://player.4kya.com/?url=' + vlink, { headers: { referer: 'https://netflix.mom' } }),\\n            le_token = html.match(/le_token\\\\s*=\\\\s*\\\"(.*)\\\"/)[1],\\n            url = html.match(/\\\"url\\\"\\\\s*:\\\\s*\\\"(.*)\\\"/)[1];\\n        return changeVideoUrl(De(url, '333180B3EF0ED9D0', le_token));\\n    } else if (ptab.includes('nfuxs')) {\\n        let html = fetch('https://api.xkvideo.design/m3u8.php?url=' + vlink),\\n            bt_token = html.match(/bt_token\\\\s*=\\\\s*\\\"(.*)\\\"/)[1],\\n            url = html.match(/\\\"url\\\"\\\\s*:\\\\s*getVideoInfo\\\\(\\\"(.*)\\\"/)[1];\\n        return changeVideoUrl(De(url, 'zsdrf880203ghurd', bt_token));\\n    } else if (/qiyi|youku|qq.com|mgtv|bilibili|ixigua|migu|sohu|pptv|le|1905\\\\.com|fun\\\\.tv/.test(vlink)) {\\n        let html = request(\\\"https://jxqd.tkys.tv/dnma.php?url=\\\" + vlink),\\n            bt_token = html.match(/bt_token\\\\s*=\\\\s*\\\"(.*)\\\"/)[1],\\n            url = html.match(/\\\"url\\\"\\\\s*:\\\\s*getVideoInfo\\\\(\\\"(.*)\\\"/)[1];\\n        return changeVideoUrl(De(url, \\\"7692AA70EEF92B42\\\", bt_token));\\n    } else if (vlink.includes(\\\"LT-\\\")) {\\n        let html = request(\\\"https://jxqd.tkys.tv/dnma.php?url=\\\" + vlink),\\n            bt_token = html.match(/bt_token\\\\s*=\\\\s*\\\"(.*)\\\"/)[1],\\n            url = html.match(/\\\"url\\\"\\\\s*:\\\\s*getVideoInfo\\\\(\\\"(.*)\\\"/)[1];\\n        return changeVideoUrl(De(url, \\\"7692AA70EEF92B42\\\", bt_token));\\n    } else if (vlink.includes(\\\"renrenmi-\\\")) {\\n        let html = request(\\\"https://jxqd.tkys.tv/dnma.php?url=\\\" + vlink),\\n            bt_token = html.match(/bt_token\\\\s*=\\\\s*\\\"(.*)\\\"/)[1],\\n            url = html.match(/\\\"url\\\"\\\\s*:\\\\s*getVideoInfo\\\\(\\\"(.*)\\\"/)[1];\\n        return changeVideoUrl(De(url, \\\"7692AA70EEF92B42\\\", bt_token));\\n    } else if (vlink.includes(\\\"RongXingVR-\\\")) {\\n        let url = JSON.parse(request(\\\"https://vvip.funsline.cn:8866/api/?key=fK6x076k18LU34x02N&url=\\\" + vlink)).url;\\n        return changeVideoUrl(url);\\n    } else if (vlink.includes(\\\"xfy-\\\")) {\\n        let url = JSON.parse(request(\\\"https://vip.xfyun.one/home/api?type=ys&uid=2581923&key=aefiklotwzCEFHJO48&url=\\\" + vlink)).url;\\n        return changeVideoUrl(url);\\n    } else if (vlink.includes(\\\"fen.laodi\\\")) {\\n        let html = fetch(\\\"https://play.tkys.tv/laodi.php/?url=\\\" + vlink),\\n            url = html.match(/vurl\\\\s*=\\\\s*'(.*)'/)[1];\\n        return changeVideoUrl(url);\\n    } else {\\n        return vlink;\\n    }\\n})();\"}],\"saved\":false,\"title\":\"轻合集.app\",\"version\":0,\"url\":\"hiker://page/Config?rule=轻合集.app&#noRecordHistory#\",\"col_type\":\"icon_2_round\",\"find_rule\":\"js:\\naddListener('onClose', 'clearMyVar(\\\"sortFlag\\\");refreshPage()')\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\nconst QING_TITLE = getMyVar('myCollection')\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)(true),\\n    el = [{\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，不要频繁点击）',\\n        url: $('#noLoading#').lazyRule(() => {\\n            let url = getMyVar('remoteUrl')\\n            if(url.startsWith('hiker://') || url.startsWith('file://'))\\n                return 'toast://仓库为本地文件，不会进行缓存，本功能也无效'\\n            deleteFile('updateTime')\\n            back(false)\\n            return 'toast://已更新'\\n        }),\\n        img: 'hiker://images/icon4',\\n        col_type: 'avatar'\\n    }],\\n    updateInterval = readFile('updateInterval') || '1',\\n    newWindow = readFile('newWindow'),\\n    tabFold = readFile('tabFold'),\\n    disableCustom = readFile('disableCustom'),\\n    editMode = getMyVar('editMode', '启用/禁用')\\n\\nel.push({\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\n本地文件链接无效').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: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\n        saveFile('tabFold', tabFold ? '' : '1')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, tabFold),\\n    col_type: 'scroll_button'\\n}, */{\\n    title: '  💼 备份恢复  ',\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\n        let url = getMyVar('remoteUrl')\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\n        else if(url.startsWith('hiker://page/')) url = 'hiker://empty'\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\n                let rules = request(url),\\n                    customData = readFile('customData')\\n                writeFile(input, JSON.stringify({\\n                    updateInterval: updateInterval,\\n                    newWindow: newWindow,\\n                    tabFold: tabFold,\\n                    disableCustom: disableCustom,\\n                    customData: customData,\\n                    rules: rules\\n                }))\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\n            saveFile('updateInterval', updateInterval)\\n            saveFile('newWindow', newWindow)\\n            saveFile('tabFold', tabFold)\\n            saveFile('disableCustom', disableCustom)\\n            saveFile('customData', customData)\\n            if(rules) writeFile(url, rules)\\n            refreshPage()\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\n        }, url)\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '““””<font color=\\\"#666666\\\"><small>特别鸣谢，小程序提供者：\\\\n' +\\n        data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\n        .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、'),\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\n\\nel.push({ col_type: 'line' }, {\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\n        if (input == '清除自定义数据') {\\n            deleteFile('customData')\\n        } else if (input == '启用合集自定义') {\\n            saveFile('disableCustom', '')\\n        } else {\\n            saveFile('disableCustom', '1')\\n            input += '\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\n        }\\n        refreshPage(false)\\n        return 'toast://已' + input\\n    }),\\n    col_type: 'text_center_1',\\n    extra: { lineVisible: false }\\n});\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\n    el.push({\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putMyVar('editMode', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'scroll_button'\\n    })\\n});\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\n    let d = { title: v.title, img: data[i].icon }\\n    switch (editMode) {\\n        case '启用/禁用':\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\n            d.url = $('#noLoading#').lazyRule((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                rules[i].visible = !rules[i].visible\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '重新排序':\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\n            if (sortFlag == -1)\\n                d.url = $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('sortFlag', i.toString())\\n                    refreshPage(false)\\n                    return 'toast://选择要移动到的位置'\\n                }, i)\\n            else\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\n                    saveFile('customData', JSON.stringify(rules))\\n                    putMyVar('sortFlag', '-1')\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, sortFlag, i)\\n            break\\n        case '更改图标':\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\n                let rules = JSON.parse(readFile('customData') || '[]')\\n                if (input)\\n                    rules[i].icon = input\\n                else\\n                    delete rules[i].icon\\n                saveFile('customData', JSON.stringify(rules))\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, i)\\n            break\\n        case '导入海阔':\\n            d.url = 'rule://' + base64Encode(JSON.stringify(data[i]))\\n            break\\n    }\\n    el.push(d)\\n})\\nsetResult(el)\",\"group\":\"①轻合集\",\"ua\":\"auto\",\"preRule\":\"putMyVar('myCollection', MY_RULE.title);\\nputMyVar('remoteUrl', 'app影视');\\nputMyVar('subscription','https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/APP.json');\",\"pages\":\"[{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"ClassTab\\\",\\\"path\\\":\\\"ClassTab\\\",\\\"rule\\\":\\\"const ClassTab = function(classArray, params) {\\\\n    Object.assign(this, params)\\\\n    this.arr = classArray.map(v => this.init(v))\\\\n    this.sign = '$' + QING_TITLE + '_' + (this.name || '') + '_'\\\\n    this.color = this.color || '#12b668'\\\\n    this.boundary = this.boundary || 'blank_block'\\\\n}\\\\nClassTab.prototype = {\\\\n    constructor: ClassTab,\\\\n    load(el) {\\\\n        let folded = this.fold && getVar('fold_' + this.sign, '')\\\\n        if (this.arr.length > 1 && this.fold) el.push({\\\\n            title: '““””' + (folded ? '▶' : '▼').fontcolor('#049eff'),\\\\n            url: $('#noLoading#').lazyRule((sign, folded) => {\\\\n                putVar('fold_' + sign, { '': 'T', 'T': '' } [folded])\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, this.sign, folded),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n        let arr = folded ? [this.arr[0]] : this.arr\\\\n        arr.forEach((v) => {\\\\n            let { id, class_name, class_url } = v,\\\\n            selected = JSON.stringify(this.getClass(id))\\\\n            class_name.forEach((name, i) => {\\\\n                let url = class_url[i],\\\\n                    now = JSON.stringify({ name: name, url: url })\\\\n                el.push({\\\\n                    title: selected == now ? '““””' + name.fontcolor(this.color).bold() : name,\\\\n                    url: selected == now ? 'hiker://empty' : $('#noLoading#').lazyRule((sign, id, now) => {\\\\n                        putVar(sign + id, now)\\\\n                        refreshPage(false)\\\\n                        return 'hiker://empty'\\\\n                    }, this.sign, id, now),\\\\n                    col_type: 'scroll_button'\\\\n                })\\\\n            })\\\\n            el.push({ col_type: this.boundary })\\\\n        })\\\\n    },\\\\n    init(classObject) {\\\\n        if (typeof classObject.class_name == 'string')\\\\n            classObject.class_name = classObject.class_name.split('&')\\\\n        if (typeof classObject.class_url == 'string')\\\\n            classObject.class_url = classObject.class_url.split('&').map((v) => v.trim())\\\\n        return classObject\\\\n    },\\\\n    push(classObject) {\\\\n        this.arr.push(this.init(classObject))\\\\n    },\\\\n    getClass(id) {\\\\n        let defaultClass = this.arr.find(item => item.id == id)\\\\n        defaultClass = JSON.stringify(defaultClass ? {\\\\n            name: defaultClass.class_name[0],\\\\n            url: defaultClass.class_url[0]\\\\n        } : { name:  'cannot find id: ' + id + ' in classTab: ' + this.sign, url: ''})\\\\n        return JSON.parse(getVar(this.sign + id, defaultClass))\\\\n    },\\\\n    setUrl(url) {\\\\n        return url.replace(/\\\\\\\\$\\\\\\\\{([^}]*)\\\\\\\\}/g, (_, id) => this.getClass(id).url)\\\\n    }\\\\n}\\\\n// 生成头部分类\\\\nconst fyAll = RULE.url.includes('fyAll')\\\\nlet tabHeader = []\\\\nif (RULE.class_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyclass',\\\\n    class_name: RULE.class_name,\\\\n    class_url: RULE.class_url\\\\n})\\\\nif (RULE.area_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyarea',\\\\n    class_name: RULE.area_name,\\\\n    class_url: RULE.area_url\\\\n})\\\\nif (RULE.year_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fyyear',\\\\n    class_name: RULE.year_name,\\\\n    class_url: RULE.year_url\\\\n})\\\\nif (RULE.sort_name) tabHeader.push({\\\\n    id: fyAll ? 'fyAll' : 'fysort',\\\\n    class_name: RULE.sort_name,\\\\n    class_url: RULE.sort_url\\\\n})\\\\ntabHeader = new ClassTab(tabHeader, { name: RULE.title, fold: readFile('tabFold'), })\\\\n\\\"},{\\\"col_type\\\":\\\"icon_2_round\\\",\\\"name\\\":\\\"设置\\\",\\\"path\\\":\\\"Config\\\",\\\"rule\\\":\\\"js:\\\\naddListener('onClose', 'clearMyVar(\\\\\\\"sortFlag\\\\\\\");refreshPage()')\\\\nsetPageTitle('⚙ 轻合集设置 ⚙')\\\\nconst QING_TITLE = getMyVar('myCollection')\\\\nlet data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)(true),\\\\n    el = [{\\\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，不要频繁点击）',\\\\n        url: $('#noLoading#').lazyRule(() => {\\\\n            let url = getMyVar('remoteUrl')\\\\n            if(url.startsWith('hiker://') || url.startsWith('file://'))\\\\n                return 'toast://仓库为本地文件，不会进行缓存，本功能也无效'\\\\n            deleteFile('updateTime')\\\\n            back(false)\\\\n            return 'toast://已更新'\\\\n        }),\\\\n        img: 'hiker://images/icon4',\\\\n        col_type: 'avatar'\\\\n    }],\\\\n    updateInterval = readFile('updateInterval') || '1',\\\\n    newWindow = readFile('newWindow'),\\\\n    tabFold = readFile('tabFold'),\\\\n    disableCustom = readFile('disableCustom'),\\\\n    editMode = getMyVar('editMode', '启用/禁用')\\\\n\\\\nel.push({\\\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\\\\\n本地文件链接无效').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: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\\\n        saveFile('tabFold', tabFold ? '' : '1')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }, tabFold),\\\\n    col_type: 'scroll_button'\\\\n}, */{\\\\n    title: '  💼 备份恢复  ',\\\\n    url: $(['备份', '恢复'], 1).select((QING_TITLE, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n        let url = getMyVar('remoteUrl')\\\\n        if (!url.startsWith('hiker://') && !url.startsWith('file://'))\\\\n            url = 'hiker://files/libs/' + md5(url) + '.js'\\\\n        else if(url.startsWith('hiker://page/')) url = 'hiker://empty'\\\\n        if (input == '备份') return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径')\\\\n            .input((url, updateInterval, newWindow, tabFold, disableCustom) => {\\\\n                let rules = request(url),\\\\n                    customData = readFile('customData')\\\\n                writeFile(input, JSON.stringify({\\\\n                    updateInterval: updateInterval,\\\\n                    newWindow: newWindow,\\\\n                    tabFold: tabFold,\\\\n                    disableCustom: disableCustom,\\\\n                    customData: customData,\\\\n                    rules: rules\\\\n                }))\\\\n                return 'toast://已备份，注意若仓库为子页面则不备份'\\\\n            }, url, updateInterval, newWindow, tabFold, disableCustom)\\\\n        else return $('hiker://files/tmp/' + QING_TITLE + '_backup.json', '输入备份路径').input((url) => {\\\\n            let { updateInterval, newWindow, tabFold, disableCustom, customData, rules } = JSON.parse(request(input))\\\\n            saveFile('updateInterval', updateInterval)\\\\n            saveFile('newWindow', newWindow)\\\\n            saveFile('tabFold', tabFold)\\\\n            saveFile('disableCustom', disableCustom)\\\\n            saveFile('customData', customData)\\\\n            if(rules) writeFile(url, rules)\\\\n            refreshPage()\\\\n            return 'toast://已恢复，如果不想同步远程仓库，可以设置更新频率为手动'\\\\n        }, url)\\\\n    }, QING_TITLE, updateInterval, newWindow, tabFold, disableCustom),\\\\n    col_type: 'scroll_button'\\\\n}, {\\\\n    title: '““””<font color=\\\\\\\"#666666\\\\\\\"><small>特别鸣谢，小程序提供者：\\\\\\\\n' +\\\\n        data.reduce((self, v) => v.author ? self.concat(v.author.split('&')) : self, [])\\\\n        .filter((v, i, arr) => v && arr.indexOf(v) == i).join('、'),\\\\n    url: 'hiker://empty',\\\\n    col_type: 'text_center_1'\\\\n})\\\\n\\\\nel.push({ col_type: 'line' }, {\\\\n    title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\\\n    url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select(() => {\\\\n        if (input == '清除自定义数据') {\\\\n            deleteFile('customData')\\\\n        } else if (input == '启用合集自定义') {\\\\n            saveFile('disableCustom', '')\\\\n        } else {\\\\n            saveFile('disableCustom', '1')\\\\n            input += '\\\\\\\\n小程序启用/禁用、重新排序等操作均不会体现在首页小程序列表中'\\\\n        }\\\\n        refreshPage(false)\\\\n        return 'toast://已' + input\\\\n    }),\\\\n    col_type: 'text_center_1',\\\\n    extra: { lineVisible: false }\\\\n});\\\\n(disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\\\n    el.push({\\\\n        title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\\\n        url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\\\n            putMyVar('editMode', v)\\\\n            refreshPage(false)\\\\n            return 'hiker://empty'\\\\n        }, v),\\\\n        col_type: 'scroll_button'\\\\n    })\\\\n});\\\\n(disableCustom ? data : JSON.parse(readFile('customData') || '[]')).forEach((v, i) => {\\\\n    let d = { title: v.title, img: data[i].icon }\\\\n    switch (editMode) {\\\\n        case '启用/禁用':\\\\n            d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title\\\\n            d.url = $('#noLoading#').lazyRule((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                rules[i].visible = !rules[i].visible\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '重新排序':\\\\n            let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\\\n            d.title = (sortFlag == i ? '🔃  ' : '') + d.title\\\\n            if (sortFlag == -1)\\\\n                d.url = $('#noLoading#').lazyRule((i) => {\\\\n                    putMyVar('sortFlag', i.toString())\\\\n                    refreshPage(false)\\\\n                    return 'toast://选择要移动到的位置'\\\\n                }, i)\\\\n            else\\\\n                d.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\\\n                    let rules = JSON.parse(readFile('customData') || '[]')\\\\n                    rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\\\n                    saveFile('customData', JSON.stringify(rules))\\\\n                    putMyVar('sortFlag', '-1')\\\\n                    refreshPage(false)\\\\n                    return 'hiker://empty'\\\\n                }, sortFlag, i)\\\\n            break\\\\n        case '更改图标':\\\\n            d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i) => {\\\\n                let rules = JSON.parse(readFile('customData') || '[]')\\\\n                if (input)\\\\n                    rules[i].icon = input\\\\n                else\\\\n                    delete rules[i].icon\\\\n                saveFile('customData', JSON.stringify(rules))\\\\n                refreshPage(false)\\\\n                return 'hiker://empty'\\\\n            }, i)\\\\n            break\\\\n        case '导入海阔':\\\\n            d.url = 'rule://' + base64Encode(JSON.stringify(data[i]))\\\\n            break\\\\n    }\\\\n    el.push(d)\\\\n})\\\\nsetResult(el)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面载入\\\",\\\"path\\\":\\\"frameLoad\\\",\\\"rule\\\":\\\"js:\\\\nconst QING_TITLE = getMyVar('myCollection')\\\\nlet myCollection_el = [],\\\\n    { RULE, isIndex, pageTitle } = MY_PARAMS,\\\\n    thisRULE = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)().find((v) => v.title == RULE.title)\\\\nif (isIndex) {\\\\n    RULE = thisRULE\\\\n} else {\\\\n    RULE.pages = thisRULE.pages\\\\n}\\\\neval(JSON.parse(fetch('hiker://page/preFunc?rule=' + QING_TITLE)).rule)\\\\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\\\\n\\\\nif (isIndex) {\\\\n    if (MY_PAGE == 1) {\\\\n        // 加载ClassTab组件\\\\n        eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\\\n        tabHeader.load(myCollection_el)\\\\n        if (RULE.search_url) myCollection_el.push({\\\\n            title: \\\\\\\"搜索\\\\\\\",\\\\n            desc: \\\\\\\"搜你想要的...\\\\\\\",\\\\n            url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n            extra: {\\\\n                rules: $.toString((QING_TITLE, title) => {\\\\n                    let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)()\\\\n                    rules = [rules.find((v) => v.title == title)]\\\\n                    return JSON.stringify(rules)\\\\n                }, QING_TITLE, RULE.title),\\\\n                defaultValue: getMyVar('searchKey', ''),\\\\n                onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n            },\\\\n            col_type: \\\\\\\"input\\\\\\\",\\\\n        })\\\\n    }\\\\n    // 处理MY_RULE\\\\n    MY_RULE.url = RULE.url\\\\n    MY_RULE.col_type = RULE.col_type\\\\n    MY_RULE.detail_col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.find_rule\\\\n    MY_RULE.detail_find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = {}\\\\n} else {\\\\n    MY_RULE.url = MY_PARAMS.url\\\\n    MY_RULE.col_type = RULE.detail_col_type\\\\n    MY_RULE.find_rule = RULE.detail_find_rule\\\\n    MY_RULE.params = RULE.params\\\\n}\\\\nMY_RULE.pages = RULE.pages\\\\nMY_RULE.pageList = JSON.parse(MY_RULE.pages || '[]')\\\\nMY_RULE.title = RULE.title\\\\n\\\\nif (!isIndex) {\\\\n    if (pageTitle) setPageTitle(pageTitle)\\\\n    setLastChapterRule(thisRULE.last_chapter_rule)\\\\n    MY_PARAMS = MY_RULE.params\\\\n}\\\\n// 预处理并初始化config\\\\nif (isIndex && MY_PAGE == 1) eval(thisRULE.preRule)\\\\nlet _cfg = getMyVar('initConfig', '{}')\\\\nif (_cfg && _cfg.length > 0) {\\\\n    config = JSON.parse(_cfg)\\\\n}\\\\n\\\\n// 正文解析通用变量\\\\nlet assignLazyRule = $.toString((QING_TITLE, title) => {\\\\n    let RULE = $.require(\\\\\\\"hiker://page/dataLoad?rule=\\\\\\\" + QING_TITLE)().find((v) => v.title == title)\\\\n    return { pages: RULE.pages, pageList: RULE.pageList }\\\\n}, QING_TITLE, RULE.title)\\\\nfunction genMyRule() {\\\\n    let rule = Object.assign({}, MY_RULE)\\\\n    delete rule.last_chapter_rule\\\\n    delete rule.preRule\\\\n    delete rule.pageList\\\\n    delete rule.pages\\\\n    return rule\\\\n}\\\\nfunction runCode(rule) {\\\\n    try {\\\\n        let [input, code] = rule.split('.js:')\\\\n        return code ? eval(code) : rule\\\\n    } catch (e) { return rule }\\\\n}\\\\nfunction genExUrl(url) {\\\\n    url = url.split(';')\\\\n    return url.shift() + ';' + paramHandle(url, thisRULE.ua, MY_RULE.url)\\\\n}\\\\n// 正文解析\\\\nif (MY_RULE.find_rule.startsWith('js:')) {\\\\n    setResult = function(el, param1, param2, param3) {\\\\n        param1 = CALLBACK_KEY\\\\n        param2 = MY_RULE\\\\n        param3 = MY_TYPE\\\\n        if (Array.isArray(el.data)) el = el.data\\\\n        Array.prototype.push.apply(myCollection_el, el.map((v) => {\\\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra || {} })\\\\n            v.col_type = v.col_type || MY_RULE.col_type\\\\n\\\\n            if (!v.url || ['rule', 'pics', 'toast', 'input', 'copy', 'editFile', 'x5', 'x5WebView', 'x5Play', 'web', 'select', 'x5Rule', 'webRule', 'download', 'share'].find((vv) => v.url.startsWith(vv + '://')) || ['x5_webview_single', 'input'].find((vv) => v.col_type == vv)) {\\\\n                return v\\\\n            } else if (v.url.includes('@rule=')) {\\\\n                let [_, url, rule] = v.url.match(/^([\\\\\\\\s\\\\\\\\S]*?)@rule=([\\\\\\\\s\\\\\\\\S]*)$/)\\\\n                v.url = url\\\\n                MY__RULE.detail_find_rule = rule\\\\n                MY__RULE.detail_col_type = MY_RULE.col_type\\\\n            } else if (v.url.startsWith('hiker://page/')) {\\\\n                if (v.url.includes('rule=') || (v.extra || {}).rule)\\\\n                    return v\\\\n                let [_, path, flag, params] = v.url.match(/^hiker:\\\\\\\\/\\\\\\\\/page\\\\\\\\/(.+?)(#.*?)?(?:\\\\\\\\?(.*))?$/),\\\\n                    subPage = MY_RULE.pageList.find((v) => v.path == path),\\\\n                    subUrl = (params || '').split('&').find((v) => v.startsWith('url='))\\\\n                v.url = subUrl ? subUrl.slice(4).replace(/？？/g, '?').replace(/＆＆/g, '&') : (v.extra || {}).url || 'hiker://empty' + flag + '?' + (params || '')\\\\n                MY__RULE.detail_find_rule = subPage.rule\\\\n                MY__RULE.detail_col_type = subPage.col_type\\\\n            } else if (v.url.includes('@lazyRule=')) {\\\\n                let reIndex = v.url.indexOf('.js:')\\\\n                if (reIndex >= 0) v.url = v.url.slice(0, reIndex) + '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + v.url.slice(reIndex + 4)\\\\n                return v\\\\n            } else if (isIndex) {\\\\n                if (!MY_RULE.detail_find_rule || /hiker:\\\\\\\\/\\\\\\\\/(?!empty.+$)/.test(v.url)) return v\\\\n            } else {\\\\n                return v\\\\n            }\\\\n            v.extra = {\\\\n                url: genExUrl(v.url),\\\\n                RULE: MY__RULE,\\\\n                pageTitle: isIndex && v.title\\\\n            }\\\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            return v\\\\n        }))\\\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\\\n    }\\\\n    setHomeResult = setResult\\\\n    setSearchResult = setResult\\\\n\\\\n    eval(MY_RULE.find_rule.slice(3))\\\\n} else {\\\\n    let [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\\\\\s\\\\\\\\S]*?)(?:==>([\\\\\\\\s\\\\\\\\S]*))?$/)\\\\n    findRule = findRule.split(';')\\\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\\\n                try {\\\\n                    if (v == '*') return ''\\\\n                    else v = (i == 1 || i == 3) ?\\\\n                        parseDom(data, v) :\\\\n                        parseDomForHtml(data, v)\\\\n                    if (i != 3) v = runCode(v)\\\\n                    return v\\\\n                } catch (e) { return '' }\\\\n            }),\\\\n            res = {\\\\n                title: title, url: url,\\\\n                desc: desc, img: img,\\\\n                col_type: MY_RULE.col_type\\\\n            }\\\\n        if (res.url) {\\\\n            if (res.url.includes('@lazyRule=')) {\\\\n                let reIndex = res.url.indexOf('.js:')\\\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:\\\\\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\\\n            } else if (detailFindRule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: Object.assign(genMyRule(), { detail_find_rule: detailFindRule }),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            } else if (MY_RULE.detail_find_rule) {\\\\n                res.extra = {\\\\n                    url: genExUrl(url),\\\\n                    RULE: genMyRule(),\\\\n                    pageTitle: isIndex && title\\\\n                }\\\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\\\n            }\\\\n        }\\\\n        myCollection_el.push(res)\\\\n    })\\\\n    setResult(myCollection_el)\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据载入\\\",\\\"path\\\":\\\"dataLoad\\\",\\\"rule\\\":\\\"$.exports = function(showAll) {\\\\n    let url = getMyVar('remoteUrl'),\\\\n        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        try {\\\\n            data = $.require(\\\\\\\"hiker://page/creator\\\\\\\");\\\\n        } catch (e) {}\\\\n        if(data.length == 0) {\\\\n            data = JSON.parse(fetch('hiker://files/libs/' + md5(url) + '.js') || '[]')\\\\n            log('没有获取到更新数据')\\\\n        } else {\\\\n            writeFile('hiker://files/libs/' + md5(url) + '.js', JSON.stringify(data));\\\\n            saveFile('updateTime', now.toString())\\\\n            log('更新数据已写入本地')\\\\n        }\\\\n    } else {\\\\n        data = JSON.parse(fetch('hiker://files/libs/' + md5(url) + '.js') || '[]')\\\\n    }\\\\n    \\\\n    //data = data.filter((v) => { return v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器') })\\\\n        if (readFile('disableCustom')) return data\\\\n        else { // 写入自定义数据\\\\n        let customData = JSON.parse(readFile('customData') || '[]'),\\\\n            rewriteData = []\\\\n        customData = customData.reduce((self, v) => {\\\\n            let index = data.findIndex((vv) => v.title == vv.title)\\\\n            if (index >= 0) {\\\\n                self.push(v)\\\\n                let rule = data.splice(index, 1)[0]\\\\n                if (showAll || v.visible)\\\\n                    rewriteData.push(Object.assign(rule, v))\\\\n            }\\\\n            return self\\\\n        }, [])\\\\n        data.forEach((v) => customData.push({ title: v.title, visible: true }))\\\\n        saveFile('customData', JSON.stringify(customData))\\\\n        return rewriteData.concat(data)\\\\n    }\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"函数重写\\\",\\\"path\\\":\\\"preFunc\\\",\\\"rule\\\":\\\"// 防止require多次运行\\\\nlet rCache = {}\\\\nrequire = function(param0, param1, param2, param3, param4) {\\\\n    if (!param0 || rCache[param0] != null) {\\\\n        return\\\\n    }\\\\n    rCache[param0] = 1\\\\n    param2 = param2 || 0\\\\n    param3 = MY_TICKET\\\\n    param4 = eval\\\\n    return method_require.invoke(javaContext, param0, param1, param2, param3, param4)\\\\n}\\\\nrequireCache = function(param0, param1, param2, param3, param4, param5) {\\\\n    if (!param0 || rCache[param0] != null) {\\\\n        return\\\\n    }\\\\n    rCache[param0] = 1\\\\n    param3 = param3 || 0\\\\n    param4 = MY_TICKET\\\\n    param5 = eval\\\\n    return method_requireCache.invoke(javaContext, param0, param1, param2, param3, param4, param5)\\\\n}\\\\nrc = requireCache\\\\n\\\\n// 最新章节规则注入预处理代码\\\\nsetLastChapterRule = function(param0) {\\\\n    if (!param0) return\\\\n    if (param0.startsWith(\\\\\\\"js:\\\\\\\") && thisRULE.preRule) {\\\\n        param0 = 'js:\\\\\\\\ntry{eval(JSON.parse(fetch(\\\\\\\"hiker://page/preFunc?rule=' + QING_TITLE + '\\\\\\\")).rule);\\\\\\\\\\\\n            eval(base64Decode(\\\\\\\"' + base64Encode(thisRULE.preRule) + '\\\\\\\"));\\\\\\\\\\\\n            let _cfg = getMyVar(\\\\\\\"initConfig\\\\\\\", \\\\\\\"{}\\\\\\\");\\\\\\\\\\\\n            if (_cfg && _cfg.length>0) {config = JSON.parse(_cfg)}}catch(e){log(e.message)}\\\\\\\\n;' +\\\\n            param0.slice(3)\\\\n    }\\\\n    method_setLastChapterRule.invoke(javaContext, param0);\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"链接处理\\\",\\\"path\\\":\\\"urlParse\\\",\\\"rule\\\":\\\"// 首页链接替换分类\\\\nfunction indexUrl(param) {\\\\n    function runCode(rule) {\\\\n        try {\\\\n            let [input, code] = rule.split('.js:')\\\\n            return code ? eval(code) : rule\\\\n        } catch (e) { return rule }\\\\n    }\\\\n    let { RULE, pageNum, QING_TITLE } = JSON.parse(param.split('###')[1])\\\\n    RULE = JSON.parse(base64Decode(RULE))\\\\n    pageNum = parseInt(pageNum)\\\\n    let url = RULE.url\\\\n\\\\n    eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\\\n    url = tabHeader.setUrl(fyAll ? url.replace(/fyAll/g, '$${fyAll}') : url.replace(/fy(class|area|year|sort)/g, '$${fy$1}'))\\\\n    url = url.replace(/fypage(?:@(-?\\\\\\\\d+)@)?(?:\\\\\\\\*(\\\\\\\\d+)@)?/g, (_, start, space) => parseInt(start || 0) + 1 + (pageNum - 1) * parseInt(space || 1))\\\\n    url = /^([\\\\\\\\s\\\\\\\\S]*?)(?:\\\\\\\\[firstPage=([\\\\\\\\s\\\\\\\\S]*?)\\\\\\\\])?(?:(\\\\\\\\.js:[\\\\\\\\s\\\\\\\\S]*?))?$/.exec(url)\\\\n    if (pageNum == 1 && url[2]) url[1] = url[2]\\\\n    if (url[3] && !url[1].includes('.js:')) url[1] += url[3]\\\\n    return runCode(url[1])\\\\n}\\\\n// 链接参数处理\\\\nfunction paramHandle(urlParam, ua, urlTmp) {\\\\n    let charset, UserAgent\\\\n    try { // 链接的编码和ua应该是首先继承首页链接\\\\n        [, , charset, UserAgent] = urlTmp.split(';')\\\\n        UserAgent = UserAgent.match(/^{(.*)}$/)[1].split('&&').find((v) => v.startsWith('User-Agent@'))\\\\n    } catch (e) {}\\\\n    urlParam[0] = urlParam[0] || 'GET'\\\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\\\n    try {\\\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\\\n    } catch (e) { urlParam[2] = [] }\\\\n    // 添加全局UA\\\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\\\n        if (UserAgent) urlParam[2].push(UserAgent)\\\\n        else if (ua == 'pc')\\\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n        else if (ua == 'mobile')\\\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\\\\\?/, '？？'))\\\\n    }\\\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\\\n    return urlParam.join(';')\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"生成规则集\\\",\\\"path\\\":\\\"creator\\\",\\\"rule\\\":\\\"let appjson = $.require('hiker://page/appJson');\\\\n\\\\nfunction randomSort3(arr) {\\\\n    /*arr.sort(function() {\\\\n        return Math.random() - 0.5;\\\\n    });*/\\\\n    return arr;\\\\n}\\\\n\\\\nlet appconts = appjson.data,\\\\n    rules = [],\\\\n    types = { \\\\\\\"\\\\\\\": \\\\\\\"全部\\\\\\\" };\\\\nfor (let i = 0; i < appconts.length; i++) {\\\\n    let applist = randomSort3(appconts[i].list),\\\\n        apptype = appconts[i].title /* + applist.length*/ ;\\\\n    types[apptype] = apptype;\\\\n    if (apptype.includes(\\\\\\\"个人收集\\\\\\\")) continue;\\\\n    for (let j = 0; j < applist.length; j++) {\\\\n        let apptitle = applist[j].title,\\\\n            appicon = applist[j].img,\\\\n            appUrl = applist[j].url,\\\\n            home_url = \\\\\\\"\\\\\\\",\\\\n            find_rule = \\\\\\\"\\\\\\\",\\\\n            search_url = \\\\\\\"\\\\\\\",\\\\n            searchFind = \\\\\\\"\\\\\\\",\\\\n            pages = [],\\\\n            last_chapter_rule = \\\\\\\"\\\\\\\",\\\\n            appUa = \\\\\\\"\\\\\\\";\\\\n        //处理重名的\\\\n        let num = 1,\\\\n            temp = apptitle;\\\\n        while (rules.some(cur => cur.title == apptitle)) {\\\\n            num = num + 1;\\\\n            apptitle = temp + num;\\\\n        }\\\\n        //规则链接和搜索链接\\\\n        if (/神马|TV/.test(apptype)) {\\\\n            home_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + \\\\\\\"?ac=list&page=fypage\\\\\\\";\\\\n            if (/19jx|293ys|zhaikanys|ji\\\\\\\\-ding\\\\\\\\-he|phoebe|yunbo\\\\\\\\.bxin|lanrentk|hetaoys|pxun|139\\\\\\\\.155|fkkdy|056158|aixixi|ruoxinew|feifan123|siqitv/.test(appUrl)) {\\\\n                search_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + '?ac=list&page=fypage&zm=**';\\\\n            } else {\\\\n                search_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + '?ac=list&page=fypage&wd=**';\\\\n            }\\\\n        } else {\\\\n            if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\")) {\\\\n                home_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + \\\\\\\"index_video?token=\\\\\\\";\\\\n            } else if (appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                home_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + \\\\\\\"index_video?token=\\\\\\\";\\\\n            } else {\\\\n                home_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + \\\\\\\"/vodPhbAll\\\\\\\";\\\\n            }\\\\n\\\\n            if (appUrl.includes('api.php/app')) {\\\\n                search_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + 'search?pg=fypage&token=&text=**';\\\\n            } else if (appUrl.includes('xgapp')) {\\\\n                search_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + 'search?pg=fypage&text=**';\\\\n            } else {\\\\n                if (/iopenyun/.test(appUrl)) {\\\\n                    search_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + '/list?page=fypage&limit=10&wd=**';\\\\n                } else {\\\\n                    search_url = \\\\\\\"hiker://empty##\\\\\\\" + appUrl + '?page=fypage&limit=10&wd=**';\\\\n                }\\\\n            }\\\\n        }\\\\n        //需要特殊处理的链接\\\\n        function changeUrl(url) {\\\\n            let newUrl = url;\\\\n            if (url.includes(\\\\\\\"omofun\\\\\\\")) {\\\\n                newUrl = url + \\\\\\\"&csrf=a%2BIKGLunJCZuad%2BxETLrZuBoqhluFCD0dH86E8IENvBzMfBLa6dB8RzoxxIvvBEMeJzJnUSt51FhlPBd4Kr5yhGXlyNvDkJyNMDgDZ1b%2FsjXAeMtj17XteM8puTY2PQnQwYOyj%2FHUCAVRZkrflsk87YG1VeSwnET8TprDD8t6ug%3D@signature=FED4A092D5BBBE18117A3B558EB6461A92A52CF7\\\\\\\";\\\\n            } else if (url.includes(\\\\\\\"xinluan\\\\\\\")) {\\\\n                newUrl = url + \\\\\\\"&csrf=SREQAPX8tFEKpV2dLDjLZhKk8IxJfDWhN%2BmksWJ%2FkdRVwgUh%2FQkTDZEoQASaAp7HzUix87T%2BPLkAIw6yH%2B6MrvaqJM9rJ5l2b85IQRbBbW%2BDbSYRO8bmTsKdLYDTVtRHhz5nylRWlGUidxHfVyLO9tZUiBk1Y2Awo%2Fzsa2tH2u8%3D@signature=FBC7088C677D297E6BBBC8584A93372DDE10FD96\\\\\\\";\\\\n            } else if (url.includes(\\\\\\\"sxbrd\\\\\\\")) {\\\\n                newUrl = url + \\\\\\\"&csrf=r2NDLtpS8Euqh%2F%2F8Y96ycOUOKS9ICzNYzyaw5C2UfEgoDFDHX%2Frqj%2BYcLWQzH5%2BR6moUOlwOAoJREtUa376ud74627UDzNQ1sRGdTD8kb36s1eTMemcn8d0i7WJ6k9ih5IP4Ad7fpa6%2F3Dst1joGncyr716dRHDMfcvrs3S29jI%3D@client_name=55WF55yL5b2x6KeG\\\\\\\";\\\\n            }\\\\n            return newUrl;\\\\n        }\\\\n        //请求UA\\\\n        if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\") || appUrl.includes(\\\\\\\"xgapp\\\\\\\") || appUrl.includes(\\\\\\\"freekan\\\\\\\")) {\\\\n            appUa = \\\\\\\"Dart/2.14 (dart:io)\\\\\\\";\\\\n        } else if (/zsb|fkxs|xays|xcys|szys|dxys|ytys|qnys/.test(appUrl)) {\\\\n            appUa = \\\\\\\"Dart/2.15 (dart:io)\\\\\\\";\\\\n        } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n            appUa = \\\\\\\"okhttp/4.1.0\\\\\\\";\\\\n        } else {\\\\n            appUa = \\\\\\\"Dalvik/2.1.0\\\\\\\"; //TV\\\\n        }\\\\n        //首页规则、分类规则、二级规则和视频解析\\\\n        if (/神马|TV/.test(apptype)) {\\\\n            find_rule = \\\\\\\"js:\\\\\\\" + $.toString(function(appUrl, appUa) {\\\\n                let items = [];\\\\n                if (MY_PAGE == 1) {\\\\n                    try {\\\\n                        let typeJson = JSON.parse(fetch(appUrl + \\\\\\\"?ac=flitter\\\\\\\"), { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                        for (let key in typeJson) {\\\\n                            items.push({\\\\n                                title: key,\\\\n                                col_type: \\\\\\\"flex_button\\\\\\\",\\\\n                                url: $(\\\\\\\"hiker://empty##\\\\\\\" + appUrl + \\\\\\\"?ac=list&page=fypage&class=\\\\\\\" + key).rule((typeJson, appUa) => {\\\\n                                    addListener(\\\\\\\"onClose\\\\\\\", \\\\\\\"clearVar('filter')\\\\\\\");\\\\n                                    let items = [],\\\\n                                        keys = {},\\\\n                                        tykeys = [],\\\\n                                        filter = {},\\\\n                                        color = \\\\\\\"#FA7298\\\\\\\";\\\\n                                    for (let index in typeJson) {\\\\n                                        if (typeJson[index].values.length == 1) continue;\\\\n                                        let key = typeJson[index].field,\\\\n                                            filterName = \\\\\\\"全部\\\\\\\" + typeJson[index].name;\\\\n                                        tykeys.push(key);\\\\n                                        keys[\\\\\\\"f\\\\\\\" + key] = \\\\\\\"\\\\\\\";\\\\n                                        filter[\\\\\\\"f\\\\\\\" + key] = [filterName].concat(typeJson[index].values);\\\\n                                    }\\\\n                                    if (!getVar(\\\\\\\"filter\\\\\\\", \\\\\\\"\\\\\\\")) { putVar(\\\\\\\"filter\\\\\\\", JSON.stringify(keys)) }\\\\n                                    let temp = JSON.parse(getVar(\\\\\\\"filter\\\\\\\"));\\\\n                                    if (MY_PAGE == 1) {\\\\n                                        for (let item in filter) {\\\\n                                            for (let index = 0; index < filter[item].length; index++) {\\\\n                                                items.push({\\\\n                                                    title: temp[item] == \\\\\\\"\\\\\\\" ? (index === 0 ? \\\\\\\"““””\\\\\\\" + filter[item][0].bold().fontcolor(color) : filter[item][index]) : (temp[item] == filter[item][index] ? \\\\\\\"““””\\\\\\\" + filter[item][index].bold().fontcolor(color) : filter[item][index]),\\\\n                                                    col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                                                    url: $().lazyRule((des, name) => {\\\\n                                                        let temp = JSON.parse(getVar(\\\\\\\"filter\\\\\\\"));\\\\n                                                        temp[name] = des.indexOf(\\\\\\\"全部\\\\\\\") != -1 ? \\\\\\\"\\\\\\\" : des;\\\\n                                                        putVar(\\\\\\\"filter\\\\\\\", JSON.stringify(temp));\\\\n                                                        refreshPage(false);\\\\n                                                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                                                    }, filter[item][index], item)\\\\n                                                })\\\\n                                            }\\\\n                                            items.push({ col_type: \\\\\\\"blank_block\\\\\\\" })\\\\n                                        }\\\\n                                    }\\\\n                                    let url = MY_URL.split(\\\\\\\"##\\\\\\\")[1] + \\\\\\\"&\\\\\\\" + tykeys.map(cur => cur + \\\\\\\"=f\\\\\\\" + cur).join(\\\\\\\"&\\\\\\\");\\\\n                                    for (let item in temp) {\\\\n                                        url = url.replace(item, temp[item]);\\\\n                                    }\\\\n                                    let rescode = fetch(url, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                                    if (rescode.indexOf('检测中') != -1) {\\\\n                                        rescode = fetch(url + '&btwaf' + rescode.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                                    }\\\\n                                    let html = JSON.parse(rescode);\\\\n                                    try {\\\\n                                        eval(JSON.parse(fetch('hiker://page/tvlistdata')).rule);\\\\n                                    } catch (e) {\\\\n                                        log(\\\\\\\"视频列表出错:\\\\\\\" + e.message);\\\\n                                    }\\\\n                                    setResult(items);\\\\n                                }, typeJson[key], appUa)\\\\n                            })\\\\n                        }\\\\n                    } catch (e) {\\\\n                        log(\\\\\\\"首页分类出错:\\\\\\\" + e.message);\\\\n                    }\\\\n                }\\\\n                try {\\\\n                    let url = MY_URL.split('##')[1],\\\\n                        html = JSON.parse(fetch(url));\\\\n                    eval(JSON.parse(fetch('hiker://page/tvlistdata')).rule);\\\\n                } catch (e) {\\\\n                    log(\\\\\\\"首页推荐出错:\\\\\\\" + e.message);\\\\n                }\\\\n                setResult(items);\\\\n            }, appUrl, appUa)\\\\n            let rule_tvlistdata = $.toString(function() {\\\\n                let list = html.data;\\\\n                for (let i = 0; i < list.length; i++) {\\\\n                    let { title, pic, nextlink, state } = list[i];\\\\n                    let url = nextlink.startsWith('http') ? nextlink : appUrl + '?ac=detail&ids=' + nextlink;\\\\n                    items.push({\\\\n                        title: title,\\\\n                        pic_url: pic + '@Referer=',\\\\n                        desc: state,\\\\n                        col_type: 'movie_3_marquee',\\\\n                        url: $(\\\\\\\"#immersiveTheme#hiker://empty##\\\\\\\" + url).rule(() => {\\\\n                            try {\\\\n                                eval(JSON.parse(fetch('hiker://page/tvmovlist')).rule);\\\\n                            } catch (e) {\\\\n                                log(\\\\\\\"影片详情出错:\\\\\\\" + e.message);\\\\n                                setResult([]);\\\\n                            }\\\\n                        })\\\\n                    });\\\\n                }\\\\n            });\\\\n            let rule_tvmovlist = $.toString(function(appUrl, appUa) {\\\\n                addListener(\\\\\\\"onClose\\\\\\\", $.toString((url) => {\\\\n                    clearVar('now');\\\\n                    clearVar(url);\\\\n                }, MY_URL));\\\\n                let items = [],\\\\n                    html = getVar(MY_URL, \\\\\\\"\\\\\\\");\\\\n                //domin = MY_URL.split(\\\\\\\"##\\\\\\\")[1].match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n                if (html == \\\\\\\"\\\\\\\") {\\\\n                    html = fetch(MY_URL.split(\\\\\\\"##\\\\\\\")[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                    putVar(MY_URL, html);\\\\n                }\\\\n                html = JSON.parse(html);\\\\n\\\\n                //简介\\\\n                let { title, pubtime, trunk, area, type, director, actor, img_url, intro } = html;\\\\n                items.push({\\\\n                    title: title + \\\\\\\"(\\\\\\\" + pubtime + \\\\\\\")\\\\\\\" + \\\\\\\"\\\\\\\\n\\\\\\\" + area.join(\\\\\\\"/\\\\\\\") + \\\\\\\"/\\\\\\\" + type.join(\\\\\\\"/\\\\\\\") + \\\\\\\"/\\\\\\\" + trunk,\\\\n                    desc: \\\\\\\"导演:\\\\\\\" + director.join(\\\\\\\",\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\" + \\\\\\\"主演:\\\\\\\" + actor.join(\\\\\\\",\\\\\\\"),\\\\n                    pic_url: img_url,\\\\n                    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n                    col_type: 'movie_1_vertical_pic_blur'\\\\n                }, {\\\\n                    title: '剧情简介:',\\\\n                    desc: intro,\\\\n                    url: $('hiker://empty#noRecordHistory#').rule((desc) => {\\\\n                        setResult([{\\\\n                            title: desc,\\\\n                            col_type: 'long_text'\\\\n                        }]);\\\\n                    }, intro),\\\\n                    col_type: 'text_1'\\\\n                });\\\\n                //断插\\\\n                let dnen = getMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n                items.push({\\\\n                    title: '断插:' + (dnen == '1' ? '““✅””' : '❎'),\\\\n                    url: $('').lazyRule((dnen) => {\\\\n                        if (dnen == '1') {\\\\n                            putMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n                            refreshPage(false);\\\\n                            return 'toast://已禁用断插调用!';\\\\n                        } else {\\\\n                            putMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n                            refreshPage(false);\\\\n                            return 'toast://已开启断插调用!'\\\\n                        }\\\\n                    }, dnen),\\\\n                    col_type: 'text_2'\\\\n                });\\\\n                items.push({\\\\n                    title: '线路配置',\\\\n                    url: \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\\\\\",\\\\n                    //url:\\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noRecordHistory#\\\\\\\",\\\\n                    col_type: 'text_2'\\\\n                });\\\\n                //线路列表\\\\n                let tabs = Object.keys(html.videolist);\\\\n                if (getVar(\\\\\\\"now\\\\\\\", \\\\\\\"\\\\\\\") == \\\\\\\"\\\\\\\") { putVar(\\\\\\\"now\\\\\\\", tabs[0]) }\\\\n                items.push({\\\\n                    title: \\\\\\\"““↓↑””\\\\\\\",\\\\n                    url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('appmtvsort', getVar('appmtvsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功!'\\\\\\\",\\\\n                    col_type: 'scroll_button'\\\\n                });\\\\n                for (let i in tabs) {\\\\n                    items.push({\\\\n                        title: getVar(\\\\\\\"now\\\\\\\") == tabs[i] ? \\\\\\\"““””\\\\\\\" + tabs[i].bold().fontcolor(\\\\\\\"#FA7298\\\\\\\") : tabs[i],\\\\n                        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('now','\\\\\\\" + tabs[i] + \\\\\\\"');refreshPage(false);'toast://切换成功!'\\\\\\\",\\\\n                        col_type: 'scroll_button'\\\\n                    })\\\\n                }\\\\n                //视频列表\\\\n                let ptab = getVar(\\\\\\\"now\\\\\\\"),\\\\n                    list = html.videolist[ptab];\\\\n                log('当前线路:' + ptab);\\\\n                if (getVar('appmtvsort', '1') == '0') {\\\\n                    list.reverse();\\\\n                };\\\\n                for (let j = 0; j < list.length; j++) {\\\\n                    let srcurl = list[j].url;\\\\n                    if (/293jx1/.test(srcurl)) {\\\\n                        srcurl = srcurl.replace('293jx1', 'jx');\\\\n                    } else if (/8d8q|diliktv|haokanju1|cztv|fit\\\\\\\\:8|ppzhu/.test(appUrl)) {\\\\n                        srcurl = srcurl + '&app=10000&account=272775028&password=qq272775028';\\\\n                    }\\\\n                    let title = list[j].title;\\\\n                    //title = title.match(/(第|\\\\\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\\\n                    items.push({\\\\n                        title: title,\\\\n                        col_type: \\\\\\\"text_4\\\\\\\",\\\\n                        url: eval(JSON.parse(fetch(\\\\\\\"hiker://page/lazyParse\\\\\\\")).rule)\\\\n                    });\\\\n                }\\\\n                setResult(items);\\\\n            }, appUrl, appUa);\\\\n            let lazyParse = $.toString(() => {\\\\n                let vlink = srcurl;\\\\n                if (/(url|vid|v)\\\\\\\\=/.test(srcurl)) {\\\\n                    vlink = srcurl.substring(srcurl.search(/(url|vid|v)\\\\\\\\=/)).split('=')[1].split('&')[0];\\\\n                }\\\\n                let enDn = getMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"0\\\\\\\"),\\\\n                    test1 = vlink.search(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) != -1,\\\\n                    test2 = vlink.search(/LT\\\\\\\\-|RongXingVR\\\\\\\\-|renrenmi\\\\\\\\-|xfy\\\\\\\\-|suoyo\\\\\\\\.cc|fen\\\\\\\\.laodi|ruifenglb|xueren\\\\\\\\-/) != -1;\\\\n                if ((test1 || test2) && enDn == '1') {\\\\n                    return $('hiker://empty').lazyRule((vlink) => {\\\\n                        log(\\\\\\\"调用断插解析,视频链接:\\\\\\\" + vlink);\\\\n                        eval(\\\\\\\"let config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                        eval(fetch(config.cj));\\\\n                        return aytmParse(vlink);\\\\n                    }, vlink)\\\\n                } else {\\\\n                    return $(\\\\\\\"hiker://empty\\\\\\\").lazyRule((ptab, srcurl, appUrl) => {\\\\n                        log(\\\\\\\"使用默认解析,视频链接:\\\\\\\" + srcurl);\\\\n                        //动态解析代码开始\\\\n                        function changeVideoUrl(url) {\\\\n                            //改变特定地址的Referer\\\\n                            if (url.includes(\\\\\\\"wkfile\\\\\\\")) {\\\\n                                url = url + ';{Referer@https://fantuan.wkfile.com/}';\\\\n                            } else if (ptab == 'bilibili') {\\\\n                                url = url + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\\\n                            } else if (ptab == 'mgtv') {\\\\n                                url = url + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                            } else if (url.includes(\\\\\\\"ojbk\\\\\\\")) {\\\\n                                url = url + ';{Referer@https://bak.ojbkjx.com/}';\\\\n                            }\\\\n                            //返回视频链接\\\\n                            if (!url.includes(\\\\\\\"http\\\\\\\")) {\\\\n                                throw new Error(\\\\\\\"链接不是以http开头(可能加密了)\\\\\\\");\\\\n                            } else {\\\\n                                if (/\\\\\\\\.m3u8/.test(url)) {\\\\n                                    return cacheM3u8(url);\\\\n                                } else {\\\\n                                    return url + '#isVideo=true#';\\\\n                                }\\\\n                            }\\\\n                        }\\\\n                        try {\\\\n                            if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos|netease\\\\\\\\.com/.test(srcurl) && /http/.test(srcurl) && !/\\\\\\\\.html/.test(srcurl) && !/(url|v|vid)\\\\\\\\=/.test(srcurl)) {\\\\n                                if (!/fen\\\\\\\\.laodi|ruifenglb|suoyo\\\\\\\\.cc/.test(srcurl)) {\\\\n                                    log(\\\\\\\"检测到资源地址可能是视频链接\\\\\\\");\\\\n                                    return changeVideoUrl(srcurl);\\\\n                                }\\\\n                            }\\\\n                            //----分割线----//\\\\n                            let scode = JSON.parse(fetch(srcurl, {\\\\n                                headers: {\\\\n                                    \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                                },\\\\n                                redirect: false,\\\\n                                withStatusCode: true\\\\n                            }));\\\\n                            //返回重定向的链接 \\\\n                            if (scode.statusCode == '302' || scode.statusCode == '301') {\\\\n                                let redurl = scode.headers.location[0].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                                log('重定向:' + redurl);\\\\n                                if (!/(url|vid|v)\\\\\\\\=/.test(redurl)) {\\\\n                                    return changeVideoUrl(redurl);\\\\n                                }\\\\n                                /*else if (/\\\\\\\\=http/.test(redurl) && /\\\\\\\\.m3u8|\\\\\\\\.mp4|\\\\\\\\.flv/.test(redurl)) {\\\\n                                    purl = redurl.substring(redurl.indexOf('=http') + 1);\\\\n                                }*/\\\\n                                scode.body = fetch(redurl);\\\\n                            }\\\\n                            //开始嗅探\\\\n                            let html = scode.body;\\\\n                            if (/404 Not Found|备案后可继续访问/.test(html)) {\\\\n                                throw new Error(\\\\\\\"404了\\\\\\\");\\\\n                            } else if (/\\\\\\\\<body/.test(html)) {\\\\n                                return $([\\\\\\\"开始视频嗅探\\\\\\\", \\\\\\\"打开解析网页\\\\\\\", \\\\\\\"使用内置解析\\\\\\\"], 1, \\\\\\\"检测到解析为网页数据\\\\\\\").select((ptab, srcurl, appUrl) => {\\\\n                                    if (input == \\\\\\\"开始视频嗅探\\\\\\\") {\\\\n                                        requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\\\n                                        return x5rule(srcurl, srcurl);\\\\n                                    } else if (input == \\\\\\\"打开解析网页\\\\\\\") {\\\\n                                        return \\\\\\\"web://\\\\\\\" + srcurl;\\\\n                                    } else if (input == \\\\\\\"使用内置解析\\\\\\\") {\\\\n                                        let vlink = srcurl;\\\\n                                        if (/(url|vid|v)\\\\\\\\=/.test(srcurl)) {\\\\n                                            vlink = srcurl.substring(srcurl.search(/(url|vid|v)\\\\\\\\=/)).split('=')[1].split('&')[0];\\\\n                                        }\\\\n                                        log(\\\\\\\"使用内置解析,视频链接:\\\\\\\" + vlink);\\\\n                                        showLoading(\\\\\\\"正在进行解析...\\\\\\\");\\\\n                                        return eval(JSON.parse(fetch(\\\\\\\"hiker://page/myParse\\\\\\\")).rule);\\\\n                                    }\\\\n                                }, ptab, srcurl, appUrl)\\\\n                            } else {\\\\n                                //log('尝试从json数据获取');\\\\n                                try {\\\\n                                    let purl = JSON.parse(html).url;\\\\n                                    return changeVideoUrl(purl);\\\\n                                } catch (e) {\\\\n                                    /*let purl = html.match(/[\\\\\\\\'\\\\\\\\\\\\\\\"]url[\\\\\\\\'\\\\\\\\\\\\\\\"]:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                                    return changeVideoUrl(purl);*/\\\\n                                    throw new Error('解析可能加密了');\\\\n                                }\\\\n                            }\\\\n                        } catch (e) {\\\\n                            log('未能成功获取视频地址:' + e.message);\\\\n                            let vlink = srcurl;\\\\n                            if (/(url|vid|v)\\\\\\\\=/.test(srcurl)) {\\\\n                                vlink = srcurl.substring(srcurl.search(/(url|vid|v)\\\\\\\\=/)).split('=')[1].split('&')[0];\\\\n                            }\\\\n                            log(\\\\\\\"尝试使用内置解析,视频链接:\\\\\\\" + vlink);\\\\n                            return eval(JSON.parse(fetch(\\\\\\\"hiker://page/myParse\\\\\\\")).rule);\\\\n                        }\\\\n                        //动态解析代码结束\\\\n                    }, ptab, srcurl, appUrl);\\\\n                }\\\\n            });\\\\n            pages.push({\\\\n                name: \\\\\\\"TV列表\\\\\\\",\\\\n                path: \\\\\\\"tvlistdata\\\\\\\",\\\\n                rule: rule_tvlistdata\\\\n            }, {\\\\n                name: \\\\\\\"TV选集\\\\\\\",\\\\n                path: \\\\\\\"tvmovlist\\\\\\\",\\\\n                rule: rule_tvmovlist\\\\n            }, {\\\\n                name: \\\\\\\"视频解析\\\\\\\",\\\\n                path: \\\\\\\"lazyParse\\\\\\\",\\\\n                rule: lazyParse\\\\n            });\\\\n        } else {\\\\n            find_rule = \\\\\\\"js:\\\\\\\" + $.toString(function(changeUrl, appUrl, appUa) {\\\\n                let items = [];\\\\n                //获取分类内容\\\\n                try {\\\\n                    let typeJson = [];\\\\n                    if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\")) {\\\\n                        let typeUrl = changeUrl(appUrl + \\\\\\\"nav?token=\\\\\\\");\\\\n                        let typcode = request(typeUrl, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                        if (typcode.indexOf('检测中') != -1) {\\\\n                            typcode = fetch(typeUrl + '&btwaf' + typcode.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                        }\\\\n                        typeJson = JSON.parse(typcode).list;\\\\n                    } else if (appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                        let typeUrl = changeUrl(appUrl + \\\\\\\"nav?token=\\\\\\\");\\\\n                        let typcode = request(typeUrl, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                        if (typcode.indexOf('检测中') != -1) {\\\\n                            typcode = fetch(typeUrl + '&btwaf' + typcode.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                        }\\\\n                        typeJson = JSON.parse(typcode).data;\\\\n                    } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n                        let typeUrl = changeUrl(appUrl + \\\\\\\"/types\\\\\\\");\\\\n                        let typcode = request(typeUrl, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                        if (typcode.indexOf('检测中') != -1) {\\\\n                            typcode = fetch(typeUrl + '?btwaf' + typcode.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                        }\\\\n                        typeJson = JSON.parse(typcode).data.list;\\\\n                    }\\\\n                    //获取分类列表\\\\n                    for (let i = 0; i < typeJson.length; i++) {\\\\n                        //分类视频地址\\\\n                        let tyurl = \\\\\\\"\\\\\\\",\\\\n                            typeArray = Object.keys(typeJson[i].type_extend).filter(cur => [\\\\\\\"class\\\\\\\", \\\\\\\"area\\\\\\\", \\\\\\\"lang\\\\\\\", \\\\\\\"year\\\\\\\"].includes(cur)),\\\\n                            typeUrl = typeArray.map(cur => cur + \\\\\\\"=f\\\\\\\" + cur).join(\\\\\\\"&\\\\\\\");\\\\n                        if (appUrl.includes('api.php/app')) {\\\\n                            tyurl = appUrl + 'video?tid=' + typeJson[i].type_id + '&page=fypage&token=&' + typeUrl;\\\\n                        } else if (appUrl.includes('xgapp')) {\\\\n                            tyurl = appUrl + 'video?tid=' + typeJson[i].type_id + '&page=fypage&' + typeUrl;\\\\n                        } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n                            if (/iopenyun/.test(appUrl)) {\\\\n                                tyurl = appUrl + '/list?type=' + typeJson[i].type_id + '&page=fypage&by=fby&limit=9&' + typeUrl;\\\\n                            } else {\\\\n                                tyurl = appUrl + '?type=' + typeJson[i].type_id + '&page=fypage&by=fby&limit=9&' + typeUrl;\\\\n                            }\\\\n                        }\\\\n                        //构建动态分类\\\\n                        items.push({\\\\n                            title: typeJson[i].type_name,\\\\n                            url: $(\\\\\\\"hiker://empty##\\\\\\\" + tyurl).rule((appUrl, type_extend, changeUrl, appUa) => {\\\\n                                addListener(\\\\\\\"onClose\\\\\\\", \\\\\\\"clearVar('filter')\\\\\\\");\\\\n                                let items = [];\\\\n                                if (MY_PAGE == 1) { //动态分类\\\\n                                    let keys = {},\\\\n                                        filter = {},\\\\n                                        filterNames = { class: \\\\\\\"类型\\\\\\\", area: \\\\\\\"地区\\\\\\\", lang: \\\\\\\"语言\\\\\\\", year: \\\\\\\"年份\\\\\\\", star: \\\\\\\"明星\\\\\\\", director: \\\\\\\"导演\\\\\\\", state: \\\\\\\"状态\\\\\\\", version: \\\\\\\"版本\\\\\\\" },\\\\n                                        defaultFilter = {\\\\n                                            fclass: [\\\\\\\"全部类型\\\\\\\", \\\\\\\"喜剧\\\\\\\", \\\\\\\"爱情\\\\\\\", \\\\\\\"恐怖\\\\\\\", \\\\\\\"动作\\\\\\\", \\\\\\\"科幻\\\\\\\", \\\\\\\"剧情\\\\\\\", \\\\\\\"战争\\\\\\\", \\\\\\\"警匪\\\\\\\", \\\\\\\"犯罪\\\\\\\", \\\\\\\"动画\\\\\\\", \\\\\\\"奇幻\\\\\\\", \\\\\\\"武侠\\\\\\\", \\\\\\\"冒险\\\\\\\", \\\\\\\"枪战\\\\\\\", \\\\\\\"悬疑\\\\\\\", \\\\\\\"惊悚\\\\\\\", \\\\\\\"经典\\\\\\\", \\\\\\\"青春\\\\\\\", \\\\\\\"文艺\\\\\\\", \\\\\\\"微电影\\\\\\\", \\\\\\\"古装\\\\\\\", \\\\\\\"历史\\\\\\\", \\\\\\\"运动\\\\\\\", \\\\\\\"农村\\\\\\\", \\\\\\\"儿童\\\\\\\", \\\\\\\"网络电影\\\\\\\"],\\\\n                                            farea: [\\\\\\\"全部地区\\\\\\\", \\\\\\\"内地\\\\\\\", \\\\\\\"香港\\\\\\\", \\\\\\\"台湾\\\\\\\", \\\\\\\"美国\\\\\\\", \\\\\\\"英国\\\\\\\", \\\\\\\"法国\\\\\\\", \\\\\\\"日本\\\\\\\", \\\\\\\"韩国\\\\\\\", \\\\\\\"德国\\\\\\\", \\\\\\\"泰国\\\\\\\", \\\\\\\"印度\\\\\\\", \\\\\\\"西班牙\\\\\\\", \\\\\\\"加拿大\\\\\\\", \\\\\\\"其他\\\\\\\"],\\\\n                                            fyear: [\\\\\\\"全部年份\\\\\\\", \\\\\\\"2022\\\\\\\", \\\\\\\"2021\\\\\\\", \\\\\\\"2020\\\\\\\", \\\\\\\"2019\\\\\\\", \\\\\\\"2018\\\\\\\", \\\\\\\"2017\\\\\\\", \\\\\\\"2016\\\\\\\", \\\\\\\"2015\\\\\\\", \\\\\\\"2014\\\\\\\", \\\\\\\"2013\\\\\\\", \\\\\\\"2012\\\\\\\", \\\\\\\"2011\\\\\\\", \\\\\\\"2010\\\\\\\", \\\\\\\"2009\\\\\\\", \\\\\\\"2008\\\\\\\", \\\\\\\"2007\\\\\\\", \\\\\\\"2006\\\\\\\", \\\\\\\"2005\\\\\\\", \\\\\\\"2004\\\\\\\", \\\\\\\"2003\\\\\\\", \\\\\\\"2002\\\\\\\", \\\\\\\"2001\\\\\\\", \\\\\\\"2000\\\\\\\"],\\\\n                                            flang: [\\\\\\\"全部语言\\\\\\\", \\\\\\\"国语\\\\\\\", \\\\\\\"英语\\\\\\\", \\\\\\\"粤语\\\\\\\", \\\\\\\"闽南语\\\\\\\", \\\\\\\"韩语\\\\\\\", \\\\\\\"日语\\\\\\\", \\\\\\\"法语\\\\\\\", \\\\\\\"德语\\\\\\\", \\\\\\\"其他\\\\\\\"]\\\\n                                        };\\\\n                                    for (let key in type_extend) {\\\\n                                        if (![\\\\\\\"class\\\\\\\", \\\\\\\"area\\\\\\\", \\\\\\\"lang\\\\\\\", \\\\\\\"year\\\\\\\"].includes(key)) continue;\\\\n                                        keys[\\\\\\\"f\\\\\\\" + key] = \\\\\\\"\\\\\\\";\\\\n                                        keys[\\\\\\\"fby\\\\\\\"] = \\\\\\\"\\\\\\\";\\\\n                                        let filterName = \\\\\\\"全部\\\\\\\" + filterNames[key];\\\\n                                        filter[\\\\\\\"f\\\\\\\" + key] = [filterName].concat(type_extend[key].split(\\\\\\\",\\\\\\\"));\\\\n                                        if (filter[\\\\\\\"f\\\\\\\" + key].length == 2) {\\\\n                                            filter[\\\\\\\"f\\\\\\\" + key] = defaultFilter[\\\\\\\"f\\\\\\\" + key]\\\\n                                        }\\\\n                                    }\\\\n                                    if (!getVar(\\\\\\\"filter\\\\\\\", \\\\\\\"\\\\\\\")) { putVar(\\\\\\\"filter\\\\\\\", JSON.stringify(keys)) }\\\\n                                    var temp = JSON.parse(getVar(\\\\\\\"filter\\\\\\\")),\\\\n                                        color = \\\\\\\"#FA7298\\\\\\\";\\\\n                                    for (let item in filter) {\\\\n                                        for (let index = 0; index < filter[item].length; index++) {\\\\n                                            items.push({\\\\n                                                title: temp[item] == \\\\\\\"\\\\\\\" ? (index === 0 ? \\\\\\\"““””\\\\\\\" + filter[item][0].bold().fontcolor(color) : filter[item][index]) : (temp[item] == filter[item][index] ? \\\\\\\"““””\\\\\\\" + filter[item][index].bold().fontcolor(color) : filter[item][index]),\\\\n                                                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                                                url: $().lazyRule((des, name) => {\\\\n                                                    let temp = JSON.parse(getVar(\\\\\\\"filter\\\\\\\"));\\\\n                                                    temp[name] = des.indexOf(\\\\\\\"全部\\\\\\\") != -1 ? \\\\\\\"\\\\\\\" : des;\\\\n                                                    putVar(\\\\\\\"filter\\\\\\\", JSON.stringify(temp));\\\\n                                                    refreshPage(false);\\\\n                                                    return \\\\\\\"hiker://empty\\\\\\\"\\\\n                                                }, filter[item][index], item)\\\\n                                            })\\\\n                                        }\\\\n                                        items.push({ col_type: \\\\\\\"blank_block\\\\\\\" })\\\\n                                    }\\\\n                                    let by = { 默认顺序: \\\\\\\"\\\\\\\", 最新: \\\\\\\"time\\\\\\\", 最热: \\\\\\\"hits\\\\\\\", 评分: \\\\\\\"score\\\\\\\" };\\\\n                                    if (appUrl.indexOf('api.php/app') == -1 && appUrl.indexOf('xgapp') == -1) {\\\\n                                        for (let item in by) {\\\\n                                            items.push({\\\\n                                                title: temp[\\\\\\\"fby\\\\\\\"] == by[item] ? \\\\\\\"““””\\\\\\\" + item.bold().fontcolor(color) : item,\\\\n                                                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                                                url: $().lazyRule((des) => {\\\\n                                                    let temp = JSON.parse(getVar(\\\\\\\"filter\\\\\\\"));\\\\n                                                    temp[\\\\\\\"fby\\\\\\\"] = des;\\\\n                                                    putVar(\\\\\\\"filter\\\\\\\", JSON.stringify(temp));\\\\n                                                    refreshPage(false);\\\\n                                                    return \\\\\\\"hiker://empty\\\\\\\"\\\\n                                                }, by[item])\\\\n                                            })\\\\n                                        }\\\\n                                    }\\\\n                                } else {\\\\n                                    var temp = JSON.parse(getVar(\\\\\\\"filter\\\\\\\"));\\\\n                                }\\\\n                                let url = MY_URL.split(\\\\\\\"##\\\\\\\")[1];\\\\n                                for (let item in temp) {\\\\n                                    url = url.replace(item, temp[item]);\\\\n                                }\\\\n                                url = changeUrl(url);\\\\n                                let rescode = fetch(url, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                                if (rescode.indexOf('检测中') != -1) {\\\\n                                    rescode = fetch(url + '&btwaf' + rescode.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                                }\\\\n                                let html = JSON.parse(rescode);\\\\n                                try {\\\\n                                    eval(JSON.parse(fetch('hiker://page/applistdata', {})).rule);\\\\n                                } catch (e) {\\\\n                                    log(\\\\\\\"视频列表出错:\\\\\\\" + e.message);\\\\n                                }\\\\n                                setResult(items);\\\\n                            }, appUrl, typeJson[i].type_extend, changeUrl, appUa),\\\\n                            col_type: 'flex_button'\\\\n                        })\\\\n                    }\\\\n                } catch (e) {\\\\n                    log('首页分类出错:' + e.message);\\\\n                }\\\\n                //获取推荐视频列表\\\\n                try {\\\\n                    let url = MY_URL.split('##')[1];\\\\n                    url = changeUrl(url);\\\\n                    let html = request(url, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                    if (html.indexOf('检测中') != -1) {\\\\n                        html = fetch(url + '&btwaf' + html.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                    }\\\\n                    html = JSON.parse(html);\\\\n                    eval(JSON.parse(fetch('hiker://page/appindexdata')).rule);\\\\n                } catch (e) {\\\\n                    log('首页推荐出错:' + e.message);\\\\n                }\\\\n                setResult(items);\\\\n            }, changeUrl, appUrl, appUa)\\\\n\\\\n            let rule_applistdata = $.toString(function() {\\\\n                let list = [];\\\\n                if (appUrl.includes('api.php/app')) {\\\\n                    list = html.list;\\\\n                } else if (appUrl.includes('xgapp')) {\\\\n                    list = html.data;\\\\n                } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n                    list = html.data.list;\\\\n                }\\\\n\\\\n                for (let i = 0; i < list.length; i++) {\\\\n                    let { vod_name, vod_pic, vod_id, vod_remarks } = list[i];\\\\n                    let link = \\\\\\\"\\\\\\\";\\\\n                    if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\\\n                        link = appUrl + 'video_detail?id=' + vod_id + '&token=';\\\\n                    } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n                        let date = new Date();\\\\n                        link = appUrl + '/detail?vod_id=' + vod_id + '&rel_limit=10&key=' + (date.getMonth() + 1) + (date.getDate() < 10 ? '0' + date.getDate() : date.getDate());\\\\n                    };\\\\n\\\\n                    if (/iopenyun/.test(appUrl)) {\\\\n                        link = appUrl + '/detailID?vod_id=' + vod_id + '&rel_limit=10';\\\\n                    }\\\\n\\\\n                    items.push({\\\\n                        title: vod_name,\\\\n                        pic_url: vod_pic + '@Referer=',\\\\n                        desc: vod_remarks,\\\\n                        col_type: 'movie_3_marquee',\\\\n                        url: $(\\\\\\\"#immersiveTheme#hiker://empty##\\\\\\\" + link).rule(() => {\\\\n                            try {\\\\n                                eval(JSON.parse(fetch('hiker://page/appmovlist')).rule);\\\\n                            } catch (e) {\\\\n                                log(\\\\\\\"影片详情出错:\\\\\\\" + e.message);\\\\n                                setResult([]);\\\\n                            }\\\\n                        })\\\\n                    });\\\\n                }\\\\n            })\\\\n            let rule_appindexdata = $.toString(function() {\\\\n                let list = [];\\\\n                if (appUrl.includes('api.php/app')) {\\\\n                    list = html.list;\\\\n                } else if (appUrl.includes('xgapp')) {\\\\n                    list = html.data;\\\\n                } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n                    list = html.data.list;\\\\n                }\\\\n\\\\n                for (let i = 0; i < list.length; i++) {\\\\n                    let lists = [],\\\\n                        typename = \\\\\\\"\\\\\\\";\\\\n                    if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\\\n                        lists = list[i].vlist;\\\\n                        typename = list[i].type_name;\\\\n                    } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n                        lists = list[i].vod_list;\\\\n                        typename = list[i].vod_type_name;\\\\n\\\\n                    }\\\\n\\\\n                    items.push({\\\\n                        title: typename,\\\\n                        col_type: 'text_1',\\\\n                        url: \\\\\\\"hiker://empty\\\\\\\"\\\\n                    });\\\\n\\\\n                    for (let j = 0; j < lists.length; j++) {\\\\n                        let { vod_name, vod_pic, vod_id, vod_remarks } = lists[j];\\\\n                        let link = \\\\\\\"\\\\\\\";\\\\n                        if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\\\n                            link = appUrl + 'video_detail?id=' + vod_id + '&token=&key=';\\\\n                        } else if (appUrl.includes(\\\\\\\".vod\\\\\\\")) {\\\\n                            let date = new Date();\\\\n                            link = appUrl + '/detail?vod_id=' + vod_id + '&rel_limit=10&key=' + (date.getMonth() + 1) + (date.getDate() < 10 ? '0' + date.getDate() : date.getDate());\\\\n                        };\\\\n\\\\n                        if (/iopenyun/.test(appUrl)) {\\\\n                            link = appUrl + '/detailID?vod_id=' + vod_id + '&rel_limit=10';\\\\n                        }\\\\n\\\\n                        items.push({\\\\n                            title: vod_name,\\\\n                            pic_url: vod_pic + '@Referer=',\\\\n                            desc: vod_remarks,\\\\n                            col_type: 'movie_3_marquee',\\\\n                            url: $(\\\\\\\"#immersiveTheme#hiker://empty##\\\\\\\" + link).rule(() => {\\\\n                                try {\\\\n                                    eval(JSON.parse(fetch('hiker://page/appmovlist')).rule);\\\\n                                } catch (e) {\\\\n                                    log(\\\\\\\"影片详情出错:\\\\\\\" + e.message);\\\\n                                    setResult([]);\\\\n                                }\\\\n                            })\\\\n                        });\\\\n                    }\\\\n                }\\\\n            })\\\\n            let rule_appmovlist = $.toString(function(changeUrl, appUrl, appUa) {\\\\n                addListener(\\\\\\\"onClose\\\\\\\", $.toString((url) => {\\\\n                    clearVar('appnow');\\\\n                    clearVar(url);\\\\n                }, MY_URL));\\\\n                let items = [],\\\\n                    html = getVar(MY_URL, \\\\\\\"\\\\\\\"),\\\\n                    data = {};\\\\n                if (html == \\\\\\\"\\\\\\\") {\\\\n                    let url = MY_URL.split(\\\\\\\"##\\\\\\\")[1];\\\\n                    url = changeUrl(url);\\\\n                    html = fetch(url, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n                    putVar(MY_URL, html);\\\\n                }\\\\n                if (appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                    data = JSON.parse(html).data.vod_info;\\\\n                } else {\\\\n                    data = JSON.parse(html).data;\\\\n                }\\\\n\\\\n                //简介\\\\n                let { vod_name, vod_pic, vod_content, vod_class, vod_remarks, vod_director, vod_actor, vod_area, vod_lang, vod_year } = data;\\\\n                items.push({\\\\n                    title: vod_name + '\\\\\\\\n' + vod_class + \\\\\\\",\\\\\\\" + vod_remarks + \\\\\\\"\\\\\\\\n\\\\\\\" + vod_area + \\\\\\\"/\\\\\\\" + vod_lang + \\\\\\\"/\\\\\\\" + vod_year,\\\\n                    desc: \\\\\\\"导演:\\\\\\\" + vod_director + \\\\\\\"\\\\\\\\n主演:\\\\\\\" + vod_actor,\\\\n                    pic_url: vod_pic,\\\\n                    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n                    col_type: 'movie_1_vertical_pic_blur'\\\\n                }, {\\\\n                    title: '剧情简介:',\\\\n                    desc: vod_content,\\\\n                    url: $('hiker://empty#noRecordHistory#').rule((desc) => {\\\\n                        setResult([{\\\\n                            title: desc,\\\\n                            col_type: 'long_text'\\\\n                        }]);\\\\n                    }, vod_content),\\\\n                    col_type: 'text_1'\\\\n                });\\\\n                //断插\\\\n                let dnen = getMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n                items.push({\\\\n                    title: '断插:' + (dnen == '1' ? '““✅””' : '❎'),\\\\n                    url: $('#noLoading#').lazyRule((dnen) => {\\\\n                        if (dnen == '1') {\\\\n                            putMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n                            refreshPage(false);\\\\n                            return 'toast://已禁用断插调用!';\\\\n                        } else {\\\\n                            putMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n                            refreshPage(false);\\\\n                            return 'toast://已开启断插调用!'\\\\n                        }\\\\n                    }, dnen),\\\\n                    col_type: 'text_2'\\\\n                });\\\\n                items.push({\\\\n                    title: '线路配置',\\\\n                    url: \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\\\\\",\\\\n                    //url: \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noRecordHistory#\\\\\\\",\\\\n                    col_type: 'text_2'\\\\n                });\\\\n                //线路列表\\\\n\\\\n                let conts = [],\\\\n                    tabs = [];\\\\n                if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\") || appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                    conts = data.vod_url_with_player;\\\\n                } else {\\\\n                    conts = data.vod_play_list;\\\\n                }\\\\n                if (conts.length < 1) {\\\\n                    conts = data.vod_play_url.split('$$$');\\\\n                    tabs = data.vod_play_from.split('$$$');\\\\n                }\\\\n                //线路名称\\\\n                let ptab = \\\\\\\"\\\\\\\",\\\\n                    ptabname = \\\\\\\"\\\\\\\";\\\\n                if (getVar(\\\\\\\"appnow\\\\\\\", \\\\\\\"\\\\\\\") == \\\\\\\"\\\\\\\") { putVar(\\\\\\\"appnow\\\\\\\", \\\\\\\"0\\\\\\\") }\\\\n                for (let i = 0; i < conts.length; i++) {\\\\n                    let sptab = \\\\\\\"\\\\\\\",\\\\n                        tabname = \\\\\\\"\\\\\\\";\\\\n                    if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\") || appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                        sptab = conts[i].code ? conts[i].code : tabs[i];\\\\n                        tabname = conts[i].name || sptab;\\\\n                    } else {\\\\n                        sptab = conts[i].from ? conts[i].from : tabs[i];\\\\n                        tabname = conts[i].player_info ? conts[i].player_info.show : sptab;\\\\n                    }\\\\n                    items.push({\\\\n                        title: getVar(\\\\\\\"appnow\\\\\\\") == i ? \\\\\\\"““””\\\\\\\" + tabname.bold().fontcolor(\\\\\\\"#FA7298\\\\\\\") : tabname,\\\\n                        url: \\\\\\\"hiker://empty#noLoading#@lazyRule=.js:putVar('appnow','\\\\\\\" + i + \\\\\\\"');refreshPage(false);'toast://切换成功!'\\\\\\\",\\\\n                        col_type: 'scroll_button'\\\\n                    })\\\\n                    if (getVar(\\\\\\\"appnow\\\\\\\") == i) {\\\\n                        ptab = sptab;\\\\n                        ptabname = tabname;\\\\n                    }\\\\n                }\\\\n                items.push({\\\\n                    title: \\\\\\\"““↓↑””\\\\\\\" + ptabname + \\\\\\\"-\\\\\\\" + ptab,\\\\n                    url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('appmappsort', getVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功!'\\\\\\\",\\\\n                    col_type: 'text_1',\\\\n                    extra: { lineVisible: false }\\\\n                });\\\\n                //链接列表\\\\n                let list = [],\\\\n                    index = getVar(\\\\\\\"appnow\\\\\\\");\\\\n                if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\") || appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                    list = conts[index].url.split(\\\\\\\"#\\\\\\\");\\\\n                } else {\\\\n                    list = conts[index].urls ? conts[index].urls : conts[index].url.split(\\\\\\\"#\\\\\\\");\\\\n                };\\\\n                if (getVar('appmappsort', '1') == '0') {\\\\n                    list.reverse();\\\\n                }\\\\n                //解析接口\\\\n                let jiek = [];\\\\n                try {\\\\n                    if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\") || appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                        jiek.push(conts[index].parse_api || \\\\\\\"\\\\\\\");\\\\n                    } else {\\\\n                        jiek = (conts[index].player_info.parse2 || \\\\\\\"\\\\\\\").split(\\\\\\\",\\\\\\\").concat((conts[index].player_info.parse || \\\\\\\"\\\\\\\").split(\\\\\\\",\\\\\\\"));\\\\n                        jiek = jiek.map(cur => cur.replace(\\\\\\\"..\\\\\\\", \\\\\\\".\\\\\\\").replace('jsonbs', ''));\\\\n                    }\\\\n                } catch (e) {}\\\\n                jiek = jiek.filter(cur => !!cur);\\\\n                let jxUrl = jiek[0] || \\\\\\\"\\\\\\\";\\\\n                /*if (jxUrl.substring(0, 2) == '\\\\\\\\/\\\\\\\\/') {\\\\n                    jxUrl = 'https:' + jxUrl;\\\\n                }*/\\\\n                //打印接口\\\\n                log('\\\\\\\\n当前线路:' + ptab + '\\\\\\\\n解析列表:' + $.stringify(jiek));\\\\n                //视频列表\\\\n                for (let j = 0; j < list.length; j++) {\\\\n                    let vlink = \\\\\\\"\\\\\\\",\\\\n                        title = \\\\\\\"\\\\\\\";\\\\n                    if (list[j].url) {\\\\n                        vlink = list[j].url.replace(/#456#/g, 'http').replace(/#123#/g, '.').replace(/#789#/g, ':');\\\\n                        title = list[j].name;\\\\n                    } else {\\\\n                        vlink = list[j].split(\\\\\\\"$\\\\\\\")[1];\\\\n                        title = list[j].split(\\\\\\\"$\\\\\\\")[0];\\\\n                    }\\\\n                    //title = title.match(/(第|\\\\\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\\\n                    items.push({\\\\n                        title: title,\\\\n                        col_type: \\\\\\\"text_4\\\\\\\",\\\\n                        url: eval(JSON.parse(fetch(\\\\\\\"hiker://page/lazyParse\\\\\\\")).rule)\\\\n                    });\\\\n                }\\\\n                setResult(items);\\\\n            }, changeUrl, appUrl, appUa);\\\\n\\\\n            let lazyParse = $.toString(function() {\\\\n                let enDn = getMyVar(\\\\\\\"dnen\\\\\\\", \\\\\\\"0\\\\\\\"),\\\\n                    test1 = vlink.search(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) != -1,\\\\n                    test2 = vlink.search(/LT\\\\\\\\-|RongXingVR\\\\\\\\-|renrenmi\\\\\\\\-|xfy\\\\\\\\-|suoyo\\\\\\\\.cc|fen\\\\\\\\.laodi|ruifenglb|xueren\\\\\\\\-/) != -1;\\\\n                if ((test1 || test2) && enDn == '1') {\\\\n                    return $('hiker://empty').lazyRule((vlink) => {\\\\n                        log(\\\\\\\"\\\\\\\\n调用断插解析,视频链接:\\\\\\\" + vlink);\\\\n                        eval(\\\\\\\"let config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                        eval(fetch(config.cj));\\\\n                        return aytmParse(vlink);\\\\n                    }, vlink)\\\\n                } else {\\\\n                    return $('hiker://empty').lazyRule((ptab, vlink, jxUrl, appUrl) => {\\\\n                        log(\\\\\\\"\\\\\\\\n使用默认解析,视频链接:\\\\\\\" + vlink);\\\\n                        //视频链接处理\\\\n                        function changeVideoUrl(url) {\\\\n                            //改变特定地址的Referer\\\\n                            if (url.includes(\\\\\\\"wkfile\\\\\\\")) {\\\\n                                url = url + ';{Referer@https://fantuan.wkfile.com/}';\\\\n                            } else if (ptab == 'bilibili') {\\\\n                                url = url + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\\\n                            } else if (ptab == 'mgtv') {\\\\n                                url = url + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                            } else if (url.includes(\\\\\\\"ojbk\\\\\\\")) {\\\\n                                url = url + ';{Referer@https://bak.ojbkjx.com/}';\\\\n                            }\\\\n                            //返回视频链接\\\\n                            if (!url.includes(\\\\\\\"http\\\\\\\")) {\\\\n                                throw new Error(\\\\\\\"链接不是以http开头(可能加密了)\\\\\\\");\\\\n                            } else {\\\\n                                if (/\\\\\\\\.m3u8/.test(url)) {\\\\n                                    return cacheM3u8(url);\\\\n                                } else {\\\\n                                    return url + '#isVideo=true#';\\\\n                                }\\\\n                            }\\\\n                        }\\\\n                        //动态解析代码开始\\\\n                        try {\\\\n                            //处理视频样式的资源链接\\\\n                            if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos|netease\\\\\\\\.com/.test(vlink) && /http/.test(vlink) && !/\\\\\\\\.html/.test(vlink)) {\\\\n                                if (!/fen\\\\\\\\.laodi|ruifenglb|suoyo\\\\\\\\.cc/.test(vlink)) {\\\\n                                    log(\\\\\\\"检测到资源地址可能是视频链接\\\\\\\");\\\\n                                    return changeVideoUrl(vlink);\\\\n                                }\\\\n                            }\\\\n                            //无可用解析直接报错\\\\n                            if (!jxUrl || /x\\\\\\\\-n\\\\\\\\.cc/.test(jxUrl)) {\\\\n                                throw new Error(\\\\\\\"无可用解析\\\\\\\");\\\\n                            }\\\\n                            //使用解析\\\\n                            log(\\\\\\\"使用解析:\\\\\\\" + jxUrl);\\\\n                            let link = jxUrl + vlink,\\\\n                                scode = JSON.parse(fetch(link, {\\\\n                                    headers: {\\\\n                                        \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Dart/2.13 (dart:io)\\\\\\\"\\\\n                                    },\\\\n                                    redirect: false,\\\\n                                    withStatusCode: true\\\\n                                }));\\\\n                            //返回重定向的链接 \\\\n                            if (scode.statusCode == '302' || scode.statusCode == '301') {\\\\n                                let redurl = scode.headers.location[0].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                                log('重定向:' + redurl);\\\\n                                if (!/(url|vid|v)\\\\\\\\=/.test(redurl)) {\\\\n                                    return changeVideoUrl(redurl);\\\\n                                }\\\\n                                /*else if (/\\\\\\\\=http/.test(redurl) && /\\\\\\\\.m3u8|\\\\\\\\.mp4|\\\\\\\\.flv/.test(redurl)) {\\\\n                                    purl = redurl.substring(redurl.indexOf('=http') + 1);\\\\n                                }*/\\\\n                                scode.body = fetch(redurl);\\\\n                            }\\\\n                            //开始嗅探\\\\n                            let html = scode.body;\\\\n                            if (/404 Not Found|备案后可继续访问/.test(html)) {\\\\n                                throw new Error(\\\\\\\"404了\\\\\\\");\\\\n                            } else if (/\\\\\\\\<body/.test(html)) {\\\\n                                return $([\\\\\\\"开始视频嗅探\\\\\\\", \\\\\\\"打开解析网页\\\\\\\", \\\\\\\"使用内置解析\\\\\\\"], 1, \\\\\\\"检测到解析为网页数据\\\\\\\").select((link, ptab, vlink, appUrl) => {\\\\n                                    if (input == \\\\\\\"开始视频嗅探\\\\\\\") {\\\\n                                        requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\\\n                                        return x5rule(link, link);\\\\n                                    } else if (input == \\\\\\\"打开解析网页\\\\\\\") {\\\\n                                        return \\\\\\\"web://\\\\\\\" + link;\\\\n                                    } else if (input == \\\\\\\"使用内置解析\\\\\\\") {\\\\n                                        log(\\\\\\\"使用内置解析\\\\\\\");\\\\n                                        showLoading(\\\\\\\"正在进行解析...\\\\\\\");\\\\n                                        return eval(JSON.parse(fetch(\\\\\\\"hiker://page/myParse\\\\\\\")).rule);\\\\n                                    }\\\\n                                }, link, ptab, vlink, appUrl);\\\\n                            } else {\\\\n                                //log('尝试从json数据获取');\\\\n                                try {\\\\n                                    let purl = JSON.parse(html).url;\\\\n                                    return changeVideoUrl(purl);\\\\n                                } catch (e) {\\\\n                                    /*let purl = html.match(/[\\\\\\\\'\\\\\\\\\\\\\\\"]url[\\\\\\\\'\\\\\\\\\\\\\\\"]:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                                    return changeVideoUrl(purl);*/\\\\n                                    throw new Error('解析可能加密了');\\\\n                                }\\\\n                            }\\\\n                        } catch (e) {\\\\n                            log('\\\\\\\\n未能成功获取视频地址:' + e.message + \\\\\\\"\\\\\\\\n尝试使用规则内置解析\\\\\\\");\\\\n                            return eval(JSON.parse(fetch(\\\\\\\"hiker://page/myParse\\\\\\\")).rule);\\\\n                        }\\\\n                        //动态解析代码结束\\\\n                    }, ptab, vlink, jxUrl, appUrl);\\\\n                }\\\\n            });\\\\n            pages.push({\\\\n                name: \\\\\\\"APP分类列表\\\\\\\",\\\\n                path: \\\\\\\"applistdata\\\\\\\",\\\\n                rule: rule_applistdata\\\\n            }, {\\\\n                name: \\\\\\\"APP首页列表\\\\\\\",\\\\n                path: \\\\\\\"appindexdata\\\\\\\",\\\\n                rule: rule_appindexdata\\\\n            }, {\\\\n                name: \\\\\\\"APP选集\\\\\\\",\\\\n                path: \\\\\\\"appmovlist\\\\\\\",\\\\n                rule: rule_appmovlist\\\\n            }, {\\\\n                name: \\\\\\\"视频解析\\\\\\\",\\\\n                path: \\\\\\\"lazyParse\\\\\\\",\\\\n                rule: lazyParse\\\\n            });\\\\n        }\\\\n\\\\n        let myParse = JSON.parse(fetch(\\\\\\\"hiker://page/myParse\\\\\\\")).rule;\\\\n        pages.push({\\\\n            name: \\\\\\\"内置解析\\\\\\\",\\\\n            path: \\\\\\\"myParse\\\\\\\",\\\\n            rule: myParse\\\\n        })\\\\n\\\\n        searchFind = \\\\\\\"js:\\\\\\\" + $.toString(function(changeUrl, apptype, appUrl, appUa) {\\\\n            let items = [],\\\\n                search_url = changeUrl(MY_URL.split('##')[1]),\\\\n                bhtml = \\\\\\\"\\\\\\\";\\\\n\\\\n            bhtml = fetch(search_url, { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n\\\\n            try {\\\\n                bhtml = bhtml.startsWith('\\\\\\\\r\\\\\\\\n') ? bhtml.replace('\\\\\\\\r\\\\\\\\n', '') : bhtml;\\\\n            } catch (e) {}\\\\n\\\\n            if (/btwaf/.test(bhtml)) {\\\\n                bhtml = fetch(search_url + '&btwaf' + bhtml.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } });\\\\n            }\\\\n\\\\n            let html = JSON.parse(bhtml),\\\\n                list = [];\\\\n            if (/神马|TV/.test(apptype)) {\\\\n                list = html.data;\\\\n            } else {\\\\n                if (appUrl.includes('api.php/app')) {\\\\n                    list = html.list;\\\\n                } else if (appUrl.includes('xgapp')) {\\\\n                    list = html.data;\\\\n                } else {\\\\n                    list = html.data.list;\\\\n                }\\\\n            }\\\\n\\\\n            for (let i = 0; i < list.length; i++) {\\\\n                if (/神马|TV/.test(apptype)) {\\\\n                    var { title, pic, nextlink: url, state: desc } = list[i];\\\\n                } else {\\\\n                    if (appUrl.includes('api.php/app') || appUrl.includes('xgapp')) {\\\\n                        var { vod_name: title, vod_pic: pic, vod_remarks: desc } = list[i],\\\\n                            url = appUrl + 'video_detail?id=' + list[i].vod_id + '&token=';\\\\n                    } else {\\\\n                        var { vod_name: title, vod_pic: pic, vod_remarks: desc } = list[i];\\\\n                        if (/iopenyun/.test(appUrl)) {\\\\n                            var url = appUrl + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\\\n                        } else {\\\\n                            var url = appUrl + '/detail?vod_id=' + list[i].vod_id + '&token=';\\\\n                        }\\\\n                    }\\\\n                }\\\\n\\\\n                items.push({\\\\n                    title: title,\\\\n                    pic_url: pic + '@Referer=',\\\\n                    desc: desc,\\\\n                    col_type: 'movie_1_vertical_pic',\\\\n                    url: $(\\\\\\\"#immersiveTheme#hiker://empty##\\\\\\\" + url).rule((apptype) => {\\\\n                        if (/神马|TV/.test(apptype)) {\\\\n                            eval(JSON.parse(fetch('hiker://page/tvmovlist')).rule);\\\\n                        } else {\\\\n                            eval(JSON.parse(fetch('hiker://page/appmovlist')).rule);\\\\n                        }\\\\n                    }, apptype)\\\\n                });\\\\n            }\\\\n\\\\n            setResult(items);\\\\n        }, changeUrl, apptype, appUrl, appUa)\\\\n\\\\n        last_chapter_rule = \\\\\\\"js:\\\\\\\" + $.toString(function(apptype, appUrl, appUa) {\\\\n            let chp = [];\\\\n            try {\\\\n                let conts = [],\\\\n                    html = JSON.parse(fetch(MY_URL.split(\\\\\\\"##\\\\\\\")[1], { headers: { \\\\\\\"User-Agent\\\\\\\": appUa } }));\\\\n                if (/神马|TV/.test(apptype)) {\\\\n                    conts = Object.keys(html.videolist);\\\\n                } else if (appUrl.includes(\\\\\\\"api.php/app\\\\\\\")) {\\\\n                    conts = html.data.vod_url_with_player;\\\\n                    if (conts.length < 1) {\\\\n                        conts = html.data.vod_play_url.split('$$$');\\\\n                    }\\\\n                } else if (appUrl.includes(\\\\\\\"xgapp\\\\\\\")) {\\\\n                    conts = html.data.vod_info.vod_url_with_player;\\\\n                    if (conts.length < 1) {\\\\n                        conts = html.data.vod_info.vod_play_url.split('$$$');\\\\n                    }\\\\n                } else {\\\\n                    conts = html.data.vod_play_list;\\\\n                    if (conts.length < 1) {\\\\n                        conts = html.data.vod_play_url.split('$$$');\\\\n                    }\\\\n                }\\\\n\\\\n                let list = [];\\\\n                for (let i = 0; i < conts.length; i++) {\\\\n                    if (/神马|TV/.test(apptype)) {\\\\n                        list = html.videolist[conts[i]];\\\\n                    } else if (conts[i].urls) {\\\\n                        list = conts[i].urls;\\\\n                    } else if (conts[i].url) {\\\\n                        list = conts[i].url.split(\\\\\\\"#\\\\\\\");\\\\n                    } else {\\\\n                        list = conts[i].split(\\\\\\\"#\\\\\\\");\\\\n                    }\\\\n                    chp.push(list.length);\\\\n                }\\\\n            } catch (e) {}\\\\n            setResult('更新至:' + (Math.max.apply(Math, chp)));\\\\n        }, apptype, appUrl, appUa);\\\\n\\\\n        rules.push({\\\\n            title: apptitle,\\\\n            author: getMyVar('remoteUrl'),\\\\n            type: apptype,\\\\n            url: home_url,\\\\n            find_rule: find_rule,\\\\n            search_url: search_url,\\\\n            searchFind: searchFind,\\\\n            pages: JSON.stringify(pages),\\\\n            last_chapter_rule: last_chapter_rule,\\\\n            icon: appicon\\\\n        });\\\\n    }\\\\n}\\\\n/*$.exports = {\\\\n    rules: rules,\\\\n    types: types\\\\n}*/\\\\n$.exports = rules;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"内置数据\\\",\\\"path\\\":\\\"ResCode\\\",\\\"rule\\\":\\\"{\\\\n    \\\\\\\"data\\\\\\\":[\\\\n        {\\\\n        \\\\\\\"title\\\\\\\":\\\\\\\"优质\\\\\\\",\\\\n        \\\\\\\"list\\\\\\\":[\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"1080p\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://1080p.one/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1080p.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"1231D\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://vue.app.yunboys.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1231D.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"300看世界\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://300ys.xyz/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/300看世界.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"4K影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://1api.4kdytv.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/4K影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"80K影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://1080p.tv/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80K影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"CJT影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.cjt521.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CJT影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"DC影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://chaorenbb.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/DC影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"F7高清\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://bc.haokanju1.cc/lvdou_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/F7高清.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"HG影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://hgyx.vip/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"l0l影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://l0l.tv/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/l0l影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"爱看美剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.uumjw.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱看美剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"爱酷影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.zhanlangbu.com/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱酷影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"菜鸟追剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://81.71.18.95:5555/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟追剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"白嫖影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://zgjxdtg.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白嫖影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"爱看影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.a91.cm/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"初心影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.18mv.club/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/初心影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"独播社\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://35ys.cc/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/独播社.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"叮当影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://tv.0573wl.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/叮当影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"段友影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://121.204.249.135:4433/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视3.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"段友影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://shangjihuoke.com/api.php/tv.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"饭后电影\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://summ.vip/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/饭后电影.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"飞捷影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.fj6080.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞捷影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"疯狂看\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.fkkdy.vip/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/疯狂看电影.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"粉象视界\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://42.157.129.15:34444/lvdou_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/粉象视界.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"汇聚库TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.zzclove666.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/汇聚库TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"虎猫视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://humaosp.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虎猫视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"可米影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.kmys.vip/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"康耀影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.ybyyds.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/康耀影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"绿箭影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.69ty.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿箭影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"懒猫电影\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.esellauto.com/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫电影.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"蜜蜂影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.f8tp.com/lvdou_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜蜂影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"麻瓜视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://aliyun.k8aa.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻瓜视频1.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"美剧虫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://meijuchong.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧虫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"木子电影\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.muzidy.top/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/木子电影.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"奈非迷\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.netflixmi.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈非迷影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"南府影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://iapp.nfuxs.club/dnmb.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/南府影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"暖光影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.bl210.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/暖光影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"念念影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://998.yuanmajs.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/念念影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"柠柚影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://nu.e4tv.cn/lvdou_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柠柚影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"奇怪视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://giguai.net/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"七零动漫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://cf.70yu.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七零动漫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"瑞丰资源\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://tv.yjhan.com:4433/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/瑞丰.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"闪光影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://101.35.128.192/mubai_api.php/m2.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/闪光影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"思乐影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.huandian.top/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思乐影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"天诚影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tcspvip.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天诚影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"天天影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.daishusc.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"温妮影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.wenniys.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/温妮影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"小白动漫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://121.62.60.222:20222/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小白动漫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"星辰视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://m.hj0999.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星辰视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"小极影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.8d8q.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"心鸾影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://zhiyutv.xyz/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/心鸾影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"雪人影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://zy.qd234.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雪人影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"益达影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://luobu.yss6080.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/益达影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"雨果影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://2.yhys63.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雨果影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"影视大全\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.269w.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"月色影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://69ty.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月色影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"优视影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://cc.ysys.asia/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优视影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"影阅阁\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://221.236.18.12:665/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影阅阁.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"追剧吧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://zhuiju8.vip/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧吧影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            }\\\\n        ]\\\\n        },\\\\n        {\\\\n        \\\\\\\"title\\\\\\\":\\\\\\\"普通\\\\\\\",\\\\n        \\\\\\\"list\\\\\\\":[\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"51视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://51shipin.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/51视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"80影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.ccc8.net/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"JDODO\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://appys.jdodo.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/JDODO影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"QC影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.qcsvip.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/QC影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"U5影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://appx.uy07.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/U5影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"XG影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://cms.xggm.top/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/XG影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"yoyo\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://jx.wnvod.net/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/yoyo影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"阿里影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://aliys.cn:90/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/阿里影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"嗷呜影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://aowu.pro/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嗷呜影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"爱影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.hzlff.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"爱追剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://81.71.18.95:520/lvdou_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱追剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"艾特影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.aitee.cc/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/艾特影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"白菜追剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://lbapp.huimaojia.com:30119/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白菜追剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"比邻影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://0hzy.cn:9990/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/比邻影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"百讯视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://z.iopenyun.com:99/app_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/百讯视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"菜鸟动漫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://taikong.huangguay.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟动漫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"大头影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://dy.idsao.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大头影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"段友影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://js.66app.me/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视2.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"豆渣影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://douzhayss.cc/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/豆渣影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"二九影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.19kp.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二九影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"风启影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://ysw.ee/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/风启影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"辉哥影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.y.hgyule8.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/辉哥影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"黄河影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://i.ledu8.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黄河影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"火星人\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.huoxing9.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/火星人影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"晗先森\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://hantv.top/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/晗先森影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"盒子影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://i.nihaohezi.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/盒子影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"筋斗云\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://tv.jindcloud.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/筋斗云影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"极光影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.winxz.cc/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/极光影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"聚合视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.jhystv.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚合视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"久久影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://s9t9.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"剧迷视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://pan.hzafw.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/剧迷视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"橘子影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://jz.juzidy.vip/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/橘子影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"快播吧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.hd8.pw/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/快播吧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"看剧吧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.ishen520.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看剧吧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"看看剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.kankanju.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看看剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"酷酷影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.ccc8.net/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/酷酷影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"可米影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://sj.kmys.vip/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"绿豆视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://v.lvdoui.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿豆影音.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"蓝光视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://vip.91iqiyi.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蓝光视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"林谷影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://ys.linguyy.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/林谷影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"冷视TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://len.tv/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷视TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"美剧范\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://ttzmz.net/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧范.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"喵乐影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://miaoleys.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/喵乐影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"名视影\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.qqccv.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/名视影.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"麻子追剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://b.2maz.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻子追剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"奈飞中文\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.naifei.org/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈飞中文.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"苹果影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://apple678.xyz/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/苹果影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"皮皮动漫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://dm.muying.me/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/皮皮动漫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"奇趣影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.qiqu.me/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奇趣影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"任性看\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://renxingkan.net/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/任性看.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"思奇影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.siqitv.vip/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"三日影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.3ri.net/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/三日影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"神马影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://xs.78tv.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/神马影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"视听星球\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://zjyapijzys.shynwlkj.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/视听星球.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"土豆TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://xiuxian.qd234.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/土豆TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"淘剧社\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.shuhai99.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/淘剧社.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"天空影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://tv.51aizn.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"天天视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.qianju.cc/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"兔子窝\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://cj.huimaojia.com:12345/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/兔子窝.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"我爱跟剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.genmov.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/我爱跟剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"吾爱影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.5lp.net/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"吾爱影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://52ysw.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视1.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"吻痕视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.kissone.cn/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吻痕视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"蜗牛动漫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://woniudm.woniu.cyou:20000/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜗牛动漫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"寻常影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.91ymz.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/寻常影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"熊猫动漫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://dongman.k8aa.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫动漫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"熊猫视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://anegh.com/lvdou_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"玺娜影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://pp.wxina.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺娜影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"小蜻蜓\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://3ketv.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小蜻蜓视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"星球视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://119.29.121.48:8088/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星球视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"玺心影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://tv.arbd.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺心影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"新享影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://app.jiagan.cx/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/新享影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"星影相随\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.rootthree.top/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星影相随.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"小易影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://xy.irop.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小易影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"云城影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://ayyf.cn/mubai_api.php/m2.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/云城影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"月儿影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://yue52.xyz/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"樱花动漫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.dmwu.cc/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/樱花动漫.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"月亮影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://ys.13tv.top/acj_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月亮影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"影视大全\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://xc.xixi2yy.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全HD.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"影视热剧\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://lb.26ys.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视热剧.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"渔渔影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://luobo.yugenye.site/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/渔渔影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"优优影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://xin.jjsvip.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优优影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"柚子视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://yz.26ys.cn/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柚子视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"鱼仔影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://yuzaio.top/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/鱼仔影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"追剧达人\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://www.zhuijudaren.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧达人.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"追剧猫\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.kmtvb.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧猫1.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"侦探影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://ys.huangguay.com/mogai_api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/侦探影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"猪猪影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://app.2zdyy.com/api.php/v1.vod\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/猪猪影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:APP影视\\\\\\\"\\\\n            }\\\\n        ]\\\\n        },\\\\n        {\\\\n        \\\\\\\"title\\\\\\\":\\\\\\\"IPTV\\\\\\\",\\\\n        \\\\\\\"list\\\\\\\":[\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"2号币\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://phoebe.cf/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/2号币影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"CV影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.cccvvv.top/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CV影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"HG影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://api.hgyx.vip/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"傲视影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://j.zjj.life:88/mv/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/傲视影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"爱西西TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.aixixi.vip/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱西西TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"白熊影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://qt.yhzy.xyz/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白熊影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"刺桐影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.cttv.vip/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/刺桐影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"尘梓TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://cztv.vip:83/api.php/chenziystv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/尘梓TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"嘀哩嘀哩\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://api.diliktv.xyz/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘀哩嘀哩TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"动力影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.love9989.com/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/动力影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"大师兄\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://dsxtv.tv.ci/api.php/dsx/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大师兄影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"二货影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://d.zjj.life:88/mv/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二货影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"非凡影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://cms.feifan12.xyz/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/非凡影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"飞扬TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://diancj.zhenfy.cn/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞扬TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"嘿荼锋\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.hfys8.vip/api.php/Sntv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘿荼锋.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"黑龙影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://vip.ji-ding-he.site/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黑龙影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"河马影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://1.14.63.101/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/河马影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"聚多影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://jdyy.weetai.cn/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚多影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"久久影院\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://l.bhtv.org.cn/mv/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"乐酷TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://150.138.78.177:2021/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/乐酷TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"懒猫TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.esellauto.com/api.php/lh/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"六维影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://liuweiiptv.gq:1357/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/六维影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"流星雨\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://nn.lxyyy.xyz:8/c/api.php/WAiLaowang/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/流星雨影院.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"冷月TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"https://tv.521x5.com/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷月TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"荔枝影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://api.zjys.vip/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/荔枝影视TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"免费看TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.freekan.vip/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/免费看TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"蜜果TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://vv.miguotv.net/m/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜果TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"米来影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://42.51.37.161:2346/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米来影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"米奇TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://www.s6ep3.top/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米奇TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"七科影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.7kfm.cn/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七科影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"若惜影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://rxw.ruoxinew.com/api.php/Sntv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/若惜影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"思奇TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.siqitv.vip/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"双子星\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.diyoui.cc/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/双子星.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"山楂影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://dy6.dcd1.cn/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/山楂影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"天空TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.tkys.tv/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"虾皮视频\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv.cmt8.xyz/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虾皮视频.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"小极TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://api.8d8q.com/mmv/api.php/Chengcheng/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"小熊猫TV\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://tv2.hetaoys.vip/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小熊猫TV.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            },\\\\n            {\\\\n            \\\\\\\"title\\\\\\\":\\\\\\\"紫曦影视\\\\\\\",\\\\n            \\\\\\\"url\\\\\\\":\\\\\\\"http://appys.azx.tools:88/api.php/iptv/vod/\\\\\\\",\\\\n            \\\\\\\"img\\\\\\\":\\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/紫曦影视.png\\\\\\\",\\\\n            \\\\\\\"murl\\\\\\\":\\\\\\\"q:TV影视\\\\\\\"\\\\n            }\\\\n        ]\\\\n        }\\\\n    ]\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"获取app列表\\\",\\\"path\\\":\\\"appJson\\\",\\\"rule\\\":\\\"let appfile = \\\\\\\"\\\\\\\";\\\\ntry {\\\\n    appfile = fetch(getMyVar(\\\\\\\"subscription\\\\\\\"));\\\\n} catch (e) {}\\\\n\\\\nlet appjson = {};\\\\nif (/InMemory/.test(appfile)) {\\\\n    appjson = JSON.parse(appfile);\\\\n} else {\\\\n    appjson = JSON.parse(JSON.parse(fetch(\\\\\\\"hiker://page/ResCode\\\\\\\", {})).rule);\\\\n}\\\\n\\\\n$.exports = appjson;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"内置数据2\\\",\\\"path\\\":\\\"myParse\\\",\\\"rule\\\":\\\"(() => {\\\\n    function changeVideoUrl(url) {\\\\n        //改变特定地址的Referer\\\\n        if (url.includes(\\\\\\\"wkfile\\\\\\\")) {\\\\n            url = url + ';{Referer@https://fantuan.wkfile.com/}';\\\\n        } else if (ptab == 'bilibili') {\\\\n            url = url + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\\\n        } else if (ptab == 'mgtv') {\\\\n            url = url + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n        } else if (url.includes(\\\\\\\"ojbk\\\\\\\")) {\\\\n            url = url + ';{Referer@https://bak.ojbkjx.com/}';\\\\n        }\\\\n        //返回视频链接\\\\n        if (!url.includes(\\\\\\\"http\\\\\\\")) {\\\\n            throw new Error(\\\\\\\"链接不是以http开头(可能加密了)\\\\\\\");\\\\n        } else {\\\\n            if (/\\\\\\\\.m3u8/.test(url)) {\\\\n                return cacheM3u8(url);\\\\n            } else {\\\\n                return url + '#isVideo=true#';\\\\n            }\\\\n        }\\\\n    }\\\\n    //aes解密\\\\n    function De(data, token_key, token_iv) {\\\\n        eval(getCryptoJS());\\\\n        var key = CryptoJS.enc.Utf8.parse(token_key);\\\\n        var iv = CryptoJS.enc.Utf8.parse(token_iv);\\\\n        return CryptoJS.AES.decrypt(data, key, {\\\\n            iv: iv,\\\\n            mode: CryptoJS.mode.CBC,\\\\n            padding: CryptoJS.pad.Pkcs7\\\\n        }).toString(CryptoJS.enc.Utf8);\\\\n    };\\\\n    if (vlink.includes('m3u8.cache.suoyo.cc')) {\\\\n        let url = JSON.parse(fetch('https://jhpc.manduhu.com/duoduo/api.php', { body: 'url=' + vlink, method: 'POST' })).url;\\\\n        return changeVideoUrl(De(url, md5('rXjWvXl6'), 'NXbHoWJbpsEOin8b'));\\\\n    } else if (vlink.includes('ruifenglb')) {\\\\n        let url = JSON.parse(fetch('http://ts.yjhan.com:8090/api/?key=DSQFgXdmj9xkDyiXdr&url=' + vlink)).url;\\\\n        return changeVideoUrl(url);\\\\n        /*let html = fetch('https://tv.yjhan.com:4423/CL4K/?url=' + vlink),\\\\n            le_token = html.match(/le_token.*=.*\\\\\\\"(.*)\\\\\\\"/)[1],\\\\n            url = html.match(/\\\\\\\"url\\\\\\\".*:.*\\\\\\\"(.*)\\\\\\\"/)[1];\\\\n        return changeVideoUrl(De(url, \\\\\\\"A42EAC0C2B408472\\\\\\\", le_token));*/\\\\n    } else if (vlink.includes(\\\\\\\"xueren-\\\\\\\")) {\\\\n        let html = fetch('https://diaoyong.qd234.cn/?url=' + vlink),\\\\n            le_token = html.match(/le_token\\\\\\\\s*=\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1],\\\\n            url = html.match(/\\\\\\\"url\\\\\\\"\\\\\\\\s*:\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1];\\\\n        return changeVideoUrl(De(url, 'A42EAC0C2B408473', le_token));\\\\n    } else if (vlink.includes(\\\\\\\"netflixmom-\\\\\\\")) {\\\\n        let html = fetch('https://player.4kya.com/?url=' + vlink, { headers: { referer: 'https://netflix.mom' } }),\\\\n            le_token = html.match(/le_token\\\\\\\\s*=\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1],\\\\n            url = html.match(/\\\\\\\"url\\\\\\\"\\\\\\\\s*:\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1];\\\\n        return changeVideoUrl(De(url, '333180B3EF0ED9D0', le_token));\\\\n    } else if (ptab.includes('nfuxs')) {\\\\n        let html = fetch('https://api.xkvideo.design/m3u8.php?url=' + vlink),\\\\n            bt_token = html.match(/bt_token\\\\\\\\s*=\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1],\\\\n            url = html.match(/\\\\\\\"url\\\\\\\"\\\\\\\\s*:\\\\\\\\s*getVideoInfo\\\\\\\\(\\\\\\\"(.*)\\\\\\\"/)[1];\\\\n        return changeVideoUrl(De(url, 'zsdrf880203ghurd', bt_token));\\\\n    } else if (/qiyi|youku|qq.com|mgtv|bilibili|ixigua|migu|sohu|pptv|le|1905\\\\\\\\.com|fun\\\\\\\\.tv/.test(vlink)) {\\\\n        let html = request(\\\\\\\"https://jxqd.tkys.tv/dnma.php?url=\\\\\\\" + vlink),\\\\n            bt_token = html.match(/bt_token\\\\\\\\s*=\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1],\\\\n            url = html.match(/\\\\\\\"url\\\\\\\"\\\\\\\\s*:\\\\\\\\s*getVideoInfo\\\\\\\\(\\\\\\\"(.*)\\\\\\\"/)[1];\\\\n        return changeVideoUrl(De(url, \\\\\\\"7692AA70EEF92B42\\\\\\\", bt_token));\\\\n    } else if (vlink.includes(\\\\\\\"LT-\\\\\\\")) {\\\\n        let html = request(\\\\\\\"https://jxqd.tkys.tv/dnma.php?url=\\\\\\\" + vlink),\\\\n            bt_token = html.match(/bt_token\\\\\\\\s*=\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1],\\\\n            url = html.match(/\\\\\\\"url\\\\\\\"\\\\\\\\s*:\\\\\\\\s*getVideoInfo\\\\\\\\(\\\\\\\"(.*)\\\\\\\"/)[1];\\\\n        return changeVideoUrl(De(url, \\\\\\\"7692AA70EEF92B42\\\\\\\", bt_token));\\\\n    } else if (vlink.includes(\\\\\\\"renrenmi-\\\\\\\")) {\\\\n        let html = request(\\\\\\\"https://jxqd.tkys.tv/dnma.php?url=\\\\\\\" + vlink),\\\\n            bt_token = html.match(/bt_token\\\\\\\\s*=\\\\\\\\s*\\\\\\\"(.*)\\\\\\\"/)[1],\\\\n            url = html.match(/\\\\\\\"url\\\\\\\"\\\\\\\\s*:\\\\\\\\s*getVideoInfo\\\\\\\\(\\\\\\\"(.*)\\\\\\\"/)[1];\\\\n        return changeVideoUrl(De(url, \\\\\\\"7692AA70EEF92B42\\\\\\\", bt_token));\\\\n    } else if (vlink.includes(\\\\\\\"RongXingVR-\\\\\\\")) {\\\\n        let url = JSON.parse(request(\\\\\\\"https://vvip.funsline.cn:8866/api/?key=fK6x076k18LU34x02N&url=\\\\\\\" + vlink)).url;\\\\n        return changeVideoUrl(url);\\\\n    } else if (vlink.includes(\\\\\\\"xfy-\\\\\\\")) {\\\\n        let url = JSON.parse(request(\\\\\\\"https://vip.xfyun.one/home/api?type=ys&uid=2581923&key=aefiklotwzCEFHJO48&url=\\\\\\\" + vlink)).url;\\\\n        return changeVideoUrl(url);\\\\n    } else if (vlink.includes(\\\\\\\"fen.laodi\\\\\\\")) {\\\\n        let html = fetch(\\\\\\\"https://play.tkys.tv/laodi.php/?url=\\\\\\\" + vlink),\\\\n            url = html.match(/vurl\\\\\\\\s*=\\\\\\\\s*'(.*)'/)[1];\\\\n        return changeVideoUrl(url);\\\\n    } else {\\\\n        return vlink;\\\\n    }\\\\n})();\\\"}]\"}","picUrl":"https://lanmeiguojiang.com/tubiao/q/52.png","title":"⚙ 轻合集设置 ⚙"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!