API tools faq
paste
xiaomianao666

小程序：轻订阅

xiaomianao666
Oct 28th, 2023
138
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 161.52 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@轻订阅@{"last_chapter_rule":"","title":"轻订阅","author":"Joker","url":"hiker://empty","version":105,"col_type":"icon_small_4","class_name":"","type":"all","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nconst QING_TITLE = getMyVar('myCollection'),\n    newWindow = readFile('newWindow'),\n    types = {},\n    tempTypes = { 'all': '聚合', 'video': '视频', 'music': '音频', 'live': '直播', 'cartoon': '漫画', 'read': '阅读', 'picture': '图集', 'news': '资讯', 'tool': '工具', 'other': '其它' };\nlet typeShow = getMyVar('typeShow', 'find:'),\n     el = [{\n        title: ' ' + QING_TITLE.bold() + ' &nbsp &nbsp ' + '⚙ 轻合集设置 ⚙'.small(),\n        url: 'hiker://page/Config?rule=' + QING_TITLE + '&#noRecordHistory#',\n        img: MY_RULE.icon || 'hiker://images/icon1',\n        col_type: 'avatar'\n    }, {\n        url: '\"hiker://search?s=\"+input',\n        desc: '搜你想要的...',\n        title: '搜索',\n        col_type: 'input',\n        extra: {\n            rules: $.toString((QING_TITLE, typeShow) => {\n                let rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)()\n                if (typeShow.startsWith('find:')) {\n                    let filterKey = typeShow.slice(5)\n                    if (filterKey) rules = rules.filter((v) => v.title.includes(filterKey))\n                } else rules = rules.filter((v) => v.type == typeShow)\n                return JSON.stringify(rules)\n            }, QING_TITLE, typeShow),\n            defaultValue: getMyVar('searchKey', ''),\n            onChange: \"putMyVar('searchKey',input)\"\n        }\n    }],\n    rules = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)(),\n    rulesType = rules.reduce((obj, v) => {\n        let type = v.type\n        if (type) {\n            if (!Array.isArray(obj[type]))\n                obj[type] = []\n            obj[type].push(v)\n        }\n        return obj\n    }, {});\n/*gg*/\nArray.from(new Set(rules.map(e => e.type))).forEach(t => {\n    types[t] = tempTypes[t] || t;\n}); \nlet subs = JSON.parse(readFile(\"appSub\") || '[]').filter(v => !v.inVisible),\n     subnow = parseInt(getItem('subnow',''));\nsubs.forEach((it, i) => {\n    el.push({\n        title: subnow === i ? \"““””\" + it.name.bold().fontcolor('#12b668') : it.name,\n        col_type: \"scroll_button\",\n        url: subnow === i ? 'hiker://empty' : $('#noLoading#').lazyRule((url, index) => {\n            putMyVar('remoteUrl', url);\n            setItem(\"subnow\", String(index));\n            refreshPage(false)\n            return 'hiker://empty'\n        }, it.url, i),\n    })\n});\nel.push({\n    col_type: \"blank_block\"\n});\nif (!Object.keys(types).includes(typeShow) && !typeShow.startsWith('find:')) {\n    putMyVar('typeShow', 'find:');\n    typeShow = 'find:';\n}\n/*gg*/\nif (typeShow.startsWith('find:')) {\n    let filterKey = typeShow.slice(5)\n    if (filterKey) rules = rules.filter((v) => v.title.includes(filterKey))\n}\nel.push(typeShow.startsWith('find:') ? {\n    title: '““””' + ('全部' + (typeShow[5] ? '[' + typeShow.slice(5) + ']' : '')).bold().fontcolor('#12b668') + ' ' + (rules.length).toString().small(),\n    url: $(typeShow.slice(5), '查找小程序关键词').input(() => {\n        putMyVar('typeShow', 'find:' + input)\n        refreshPage(false)\n        return 'hiker://empty'\n    }),\n    col_type: 'scroll_button'\n} : {\n    title: '““””全部 ' + (rules.length).toString().small(),\n    url: $('#noLoading#').lazyRule(() => {\n        putMyVar('typeShow', 'find:')\n        refreshPage(false)\n        return 'hiker://empty'\n    }),\n    col_type: 'scroll_button'\n})\nfor (let k in types) {\n    if (k in rulesType) {\n        el.push({\n            title: '““””' + (k == typeShow ? types[k].bold().fontcolor('#12b668') : types[k]) + ' ' + (rulesType[k].length).toString().small(),\n            url: k == typeShow ? 'hiker://empty' : $('#noLoading#').lazyRule((k) => {\n                putMyVar('typeShow', k)\n                refreshPage(false)\n                return 'hiker://empty'\n            }, k),\n            col_type: 'scroll_button'\n        })\n    }\n}\nif (!typeShow.startsWith('find:')) rules = rulesType[typeShow]\neval(JSON.parse(fetch('hiker://page/urlParse?rule=' + QING_TITLE)).rule)\nrules.forEach((v) => {\n    let urlParam = v.url.split(';'),\n        ruleTmp = {\n            title: v.title,\n            url: urlParam.shift(),\n            class_name: v.class_name,\n            class_url: v.class_url,\n            area_name: v.area_name,\n            area_url: v.area_url,\n            year_name: v.year_name,\n            year_url: v.year_url,\n            sort_name: v.sort_name,\n            sort_url: v.sort_url\n        },\n        fypage = ruleTmp.url.includes('fypage') ? 'fypage' : '1',\n        domain = (/^(https?:\\/\\/.+?)(?:#|\\?|\\/|$)/i.exec(ruleTmp.url) || [, 'hiker://empty'])[1],\n        d = {\n            title: v.title,\n            url: 'hiker://page/frameLoad',\n            img: v.icon || 'hiker://images/icon1',\n            extra: {\n                url: domain + '/#noHistory##noRecordHistory####' + JSON.stringify({\n                    RULE: base64Encode(JSON.stringify(ruleTmp)),\n                    pageNum: fypage,\n                    QING_TITLE: getMyVar('myCollection')\n                }) + '.js:eval(JSON.parse(fetch(\"hiker://page/urlParse？？rule=' + QING_TITLE + '\")).rule)；；indexUrl(input);' + paramHandle(urlParam, v.ua),\n                RULE: {\n                    title: v.title\n                },\n                isIndex: true\n            }\n        }\n    if (newWindow) {\n        Object.assign(d.extra, {\n            newWindow: true,\n            windowId: QING_TITLE + '_' + d.title\n        })\n    }\n    el.push(d)\n})\nsetResult(el)","search_url":"hiker://empty?keyword=**","group":"①轻合集","searchFind":"js:\nsetResult(JSON.parse(readFile('appSub')).map((it, i) => {\n    return {\n        title: it.name + \"•视界聚搜\",\n        url: \"hiker://search?s=\" + getParam(\"keyword\"),\n        extra: {\n            rules: $.toString((url, index) => {\n                putMyVar('remoteUrl', url);\n                setItem(\"subnow\", String(index));\n                let rules = $.require('hiker://page/dataLoad?rule=' + getMyVar('myCollection'))()\n                return JSON.stringify(rules)\n            }, it.url, i)\n        }\n    }\n}))","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"auto","preRule":"let subnow = getItem(\"subnow\", \"\"),\n    appSub = JSON.parse(readFile(\"appSub\") || '[]').filter(v => !v.inVisible);\nif(isNaN(parseInt(subnow))){\n    subnow = \"\";\n}\nif (subnow === '') {\n    if (appSub.length > 0) setItem(\"subnow\", '0');\n} else if (subnow !== '' && (!appSub[parseInt(subnow)] || !appSub[parseInt(subnow)].url)) {\n    if (appSub.length > 0) {\n        setItem(\"subnow\", '0');\n    } else {\n        setItem('subnow', '');\n    }\n}\nputMyVar('myCollection', MY_RULE.title);\nsubnow = getItem(\"subnow\", \"\")\nlet url = subnow === \"\" ? \"hiker://empty\" : appSub[parseInt(subnow)].url;\nputMyVar('remoteUrl', url);","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'),\\n    url = getMyVar('remoteUrl');\\nlet //data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)(true),\\n    el = [{\\n        title: '<b> 清除缓存，立即更新 <small> （基于远程仓库，不要频繁点击）',\\n        url: $('#noLoading#').lazyRule((url) => {\\n            if (url.startsWith('hiker://') || url.startsWith('file://'))\\n                return 'toast://仓库为本地文件，不会进行缓存，本功能也无效'\\n            deleteCache(url)\\n            back(false)\\n            return 'toast://已更新'\\n        }, url),\\n        img: 'hiker://images/icon4',\\n        col_type: 'avatar'\\n    }],\\n    updateInterval = readFile('updateInterval') || '1',\\n    newWindow = readFile('newWindow'),\\n    tabFold = readFile('tabFold'),\\n    disableCustom = readFile('disableCustom'),\\n    /*gg*/\\n    editMode = disableCustom ? '导入海阔' : getMyVar('editMode', '启用/禁用'),\\n    what = getMyVar('what', '管理规则'),\\n    filterKey = getMyVar('filterKey', '');\\n\\nel.push({\\n    title: '  💡 更新频率: ' + (updateInterval == 0 ? '手动' : updateInterval + '天') + '  ',\\n    url: $(updateInterval, '输入更新间隔（天），为0则手动更新\\\\n本地文件链接无效').input(() => {\\n        input = parseInt(input)\\n        if (Number.isNaN(input)) input = 1\\n        else if (input < 1) input = 0\\n        saveFile('updateInterval', input.toString())\\n        refreshPage()\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  🖥 独立首页: ' + (newWindow ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((newWindow) => {\\n        saveFile('newWindow', newWindow ? '' : '1')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, newWindow),\\n    col_type: 'scroll_button'\\n}, {\\n    title: '  💠 分类折叠: ' + (tabFold ? '是' : '否') + '  ',\\n    url: $('#noLoading#').lazyRule((tabFold) => {\\n        saveFile('tabFold', tabFold ? '' : '1')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, tabFold),\\n    col_type: 'scroll_button'\\n});\\n\\n['管理规则', '管理订阅'].forEach((v) => {\\n    el.push({\\n        title: v == what ? '““””' + v.bold().fontcolor('#12b668') : v,\\n        url: v == what ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n            putMyVar('what', v)\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }, v),\\n        col_type: 'text_2'\\n    })\\n});\\n\\nel.push({\\n    col_type: \\\"line\\\"\\n});\\n\\nif (what == '管理订阅') {\\n    el = $.require('hiker://page/subscription')(el);\\n} else {\\n    let data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)(true);\\n    let customData = JSON.parse(readFile('customData_' + md5(url)) || '[]');\\n    if(editMode == '导入海阔'){\\n        data = data.filter(it => it.title.includes(filterKey));\\n        customData = customData.filter(it => it.title.includes(filterKey));\\n    }\\n    el.push({\\n        title: '““””' + '📝'.small() + '&nbsp 轻合集自定义 &nbsp'.bold().fontcolor('#757575') + (disableCustom ? '❌' : '⭕').small(),\\n        url: $([(disableCustom ? '启用' : '禁用') + '合集自定义', '清除自定义数据'], 1).select((url) => {\\n            if (input == '清除自定义数据') {\\n                deleteFile('customData_' + md5(url))\\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        }, url),\\n        col_type: 'text_center_1',\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n    (disableCustom ? ['导入海阔'] : ['启用/禁用', '重新排序', '更改图标', '导入海阔']).forEach((v) => {\\n        el.push({\\n            title: v == editMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n            url: v == editMode ? $(filterKey, '查找小程序关键词').input(() => {\\n                putMyVar('filterKey', input)\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }) /*gg*/ : $('#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 : customData).forEach((v, i) => {\\n        let d = {\\n            title: v.title,\\n            img: data[i].icon\\n        };\\n        switch (editMode) {\\n            case '启用/禁用':\\n                d.title = (v.visible ? '🟢  ' : '🔴  ') + d.title;\\n                d.url = $('#noLoading#').lazyRule((i, url) => {\\n                    let rules = JSON.parse(readFile('customData_' + md5(url)) || '[]')\\n                    rules[i].visible = !rules[i].visible\\n                    saveFile('customData_' + md5(url), JSON.stringify(rules))\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, i, url);\\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, url) => {\\n                        let rules = JSON.parse(readFile('customData_' + md5(url)) || '[]')\\n                        rules.splice(newIndex, 0, rules.splice(oldIndex, 1)[0])\\n                        saveFile('customData_' + md5(url), JSON.stringify(rules))\\n                        putMyVar('sortFlag', '-1')\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, sortFlag, i, url)\\n                break\\n            case '更改图标':\\n                d.url = $(v.icon || '', '输入新图标地址或颜色代码：').input((i, url) => {\\n                    let rules = JSON.parse(readFile('customData_' + md5(url)) || '[]')\\n                    if (input)\\n                        rules[i].icon = input\\n                    else\\n                        delete rules[i].icon\\n                    saveFile('customData_' + md5(url), JSON.stringify(rules))\\n                    refreshPage(false)\\n                    return 'hiker://empty'\\n                }, i, url)\\n                break\\n            case '导入海阔':\\n                d.url = $('#noLoading#').lazyRule((i, filterKey) => {\\n                    let QING_TITLE = getMyVar('myCollection'),\\n                        data = $.require('hiker://page/dataLoad?rule=' + QING_TITLE)(true).filter(it => it.title.includes(filterKey));\\n                    return 'rule://' + base64Encode(JSON.stringify(data[i]))\\n                }, i, filterKey);\\n                break\\n        }\\n        el.push(d)\\n    })\\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    eval(JSON.parse(fetch('hiker://page/ClassTab?rule=' + QING_TITLE)).rule)\\n    if (MY_PAGE == 1) {\\n        // 加载ClassTab组件\\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.class_url = tabHeader.getClass(fyAll ? 'fyAll' : 'fyclass').url\\n    MY_RULE.area_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyarea').url\\n    MY_RULE.year_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fyyear').url\\n    MY_RULE.sort_url = fyAll ? MY_RULE.class_url : tabHeader.getClass('fysort').url\\n    MY_RULE.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 (MY_PAGE == 1) {\\n    let loaded = getMyVar(MY_RULE.title + \\\"@pre\\\")\\n    if (!loaded || isIndex) {\\n        eval(thisRULE.preRule)\\n        putMyVar(MY_RULE.title + \\\"@pre\\\", \\\"1\\\")\\n    }\\n}\\nlet _cfg = getMyVar('initConfig', '{}')\\nif (_cfg && _cfg.length > 0) {\\n    config = JSON.parse(_cfg)\\n}\\n\\n// 正文解析通用变量\\nlet assignLazyRule = $.toString((QING_TITLE, title, url) => {\\n    let RULE = $.require(\\\"hiker://page/dataLoad?rule=\\\" + QING_TITLE)().find((v) => v.title == title)\\n    return { title:title, url: url, pages: RULE.pages, pageList: JSON.parse(RULE.pages || '[]') }\\n}, QING_TITLE, MY_RULE.title, MY_RULE.url)\\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            if(!v.extra) v.extra = {}\\n            v.col_type = v.col_type || MY_RULE.col_type\\n            let MY__RULE = Object.assign(genMyRule(), { params: v.extra })\\n\\n            if (typeof v.url != 'string' || ['rule', 'pics', 'toast', 'input', 'confirm', '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 = Object.assign({}, v.extra, {\\n                url: genExUrl(v.url),\\n                RULE: MY__RULE,\\n                pageTitle: isIndex && v.title\\n            })\\n            v.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            return v\\n        }))\\n        method_setResult.invoke(javaContext, myCollection_el, param1, param2, param3)\\n    }\\n    setHomeResult = setResult\\n    setSearchResult = setResult\\n\\n    eval(MY_RULE.find_rule.slice(3))\\n} else {\\n    let [_, findRule, detailFindRule] = MY_RULE.find_rule.match(/^([\\\\s\\\\S]*?)(?:==>([\\\\s\\\\S]*))?$/)\\n    findRule = findRule.split(';')\\n    parseDomForArray(getResCode(), findRule.shift()).forEach((data) => {\\n        let [title, img, desc, url] = findRule.map((v, i) => {\\n                try {\\n                    if (v == '*') return ''\\n                    else v = (i == 1 || i == 3) ?\\n                        parseDom(data, v) :\\n                        parseDomForHtml(data, v)\\n                    if (i != 3) v = runCode(v)\\n                    return v\\n                } catch (e) { return '' }\\n            }),\\n            res = {\\n                title: title, url: url,\\n                desc: desc, img: img,\\n                col_type: MY_RULE.col_type\\n            }\\n        if (res.url) {\\n            if (res.url.includes('@lazyRule=')) {\\n                let reIndex = res.url.indexOf('.js:')\\n                if (reIndex >= 0) res.url = res.url.slice(0, reIndex) + '.js:\\\\nif(MY_RULE)Object.assign(MY_RULE, ' + assignLazyRule + ');' + res.url.slice(reIndex + 4)\\n            } else  if (detailFindRule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: Object.assign(genMyRule(), { detail_find_rule: detailFindRule }),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            } else if (MY_RULE.detail_find_rule) {\\n                res.extra = {\\n                    url: genExUrl(url),\\n                    RULE: genMyRule(),\\n                    pageTitle: isIndex && title\\n                }\\n                res.url = 'hiker://page/frameLoad?rule=' + QING_TITLE\\n            }\\n        }\\n        myCollection_el.push(res)\\n    })\\n    setResult(myCollection_el)\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"数据载入\",\"path\":\"dataLoad\",\"rule\":\"$.exports = function(showAll) {\\n    let url = getMyVar('remoteUrl'),\\n        data = [];\\n    if (url.startsWith('hiker://files') || url.startsWith('hiker://page/') || url.startsWith('file://')) {\\n        // 如果为本地文件则不进行缓存\\n        try {\\n            let oriData = fetch(url)\\n            if (url.startsWith('hiker://page/')) {\\n                oriData = JSON.parse(oriData).rule\\n            }\\n            data = $.require(\\\"hiker://page/appJson\\\")(oriData) /*gg*/\\n        } catch (e) {\\n            log(e.toString())\\n        }\\n    } else {\\n        // 获取远程数据，检查间隔默认一天\\n        let interval = parseInt(readFile('updateInterval') || '1'),\\n            oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\n            remoteData = []\\n        if (interval == 0) interval = -1\\n        try {\\n            let oriData = fetchCache(url, 24 * interval, {\\n                timeout: 50000\\n            })\\n            remoteData = $.require(\\\"hiker://page/appJson\\\")(oriData) /*gg*/\\n        } catch (e) {\\n            log(e.toString())\\n        }\\n        if (!Array.isArray(remoteData)) remoteData = [];\\n        if (remoteData.length < 1) {\\n            log('未获取到数据');\\n            if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData);\\n            try {\\n                data = $.require(\\\"hiker://page/appJson\\\")(oldData) /*gg*/ ;\\n            } catch (e) {}\\n        } else {\\n            data = remoteData\\n        }\\n    }\\n    data = data.filter((v) => {\\n        return v.title != getMyVar('myCollection') && !(v.author || '').includes('轻合集生成器')\\n    })\\n    if (readFile('disableCustom')) return data\\n    else { // 写入自定义数据\\n        let customData = JSON.parse(readFile('customData_' + md5(url)) || '[]'),/*gg*/\\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({\\n            title: v.title,\\n            visible: true\\n        }))\\n        saveFile('customData_' + md5(url), JSON.stringify(customData))/*gg*/\\n        return rewriteData.concat(data)\\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}\\nfunction paramHandle(urlParam, ua, urlTmp) {\\n    let charset, paramTmp\\n    try { // 链接的编码、UA和Referer应该是首先继承首页链接\\n        [, , charset, paramTmp] = urlTmp.split(';')\\n        paramTmp = paramTmp.match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { paramTmp = [] }\\n    let UserAgent = paramTmp.find((v) => v.startsWith('User-Agent@')),\\n        Referer = paramTmp.find((v) => v.startsWith('Referer@'))\\n    urlParam[0] = urlParam[0] || 'GET'\\n    urlParam[1] = urlParam[1] || charset || 'UTF-8'\\n    try {\\n        urlParam[2] = urlParam[2].match(/^{(.*)}$/)[1].split('&&')\\n    } catch (e) { urlParam[2] = [] }\\n    // 添加全局UA和上级Referer\\n    if (!urlParam[2].some((v) => v.startsWith('User-Agent@'))) {\\n        if (UserAgent) urlParam[2].push(UserAgent)\\n        else if (ua == 'pc')\\n            urlParam[2].push('User-Agent@' + PC_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n        else if (ua == 'mobile')\\n            urlParam[2].push('User-Agent@' + MOBILE_UA.replace(/;/g, '；；').replace(/\\\\?/, '？？'))\\n    }\\n    if (Referer && !urlParam[2].some((v) => v.startsWith('Referer@')))\\n        urlParam[2].push(Referer)\\n    urlParam[2] = '{' + urlParam[2].join('&&') + '}'\\n    return urlParam.join(';')\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"规则运行-app\",\"path\":\"creator\",\"rule\":\"let appUrl = getParam(\\\"appUrl\\\"),\\n    appUa = \\\"\\\";\\n//请求UA\\nif (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//首页规则、分类规则、二级规则和视频解析\\nif (appUrl.includes(\\\"/vod\\\")) {\\n    var listdata = function(items, html) {\\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?appUrl=\\\" + appUrl +\\\"&href=\\\" + base64Encode(url)).rule(() => {\\n                    try {\\n                        eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n                        movlist();\\n                    } catch (e) {\\n                        log(\\\"影片详情出错:\\\" + e.message);\\n                        setResult([]);\\n                    }\\n                })\\n            });\\n        }\\n        return items;\\n    };\\n    var find_rule = function() {\\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=\\\" + appUrl + '&page=fypage&href=' + base64Encode(appUrl + \\\"?ac=list&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: $('hiker://empty#noLoading#').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 = base64Decode(getParam('href')) + '&page=' + MY_PAGE + \\\"&\\\" + 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/creator')).rule);\\n                                items = listdata(items, html);\\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 = appUrl + \\\"?ac=list&page=\\\" + MY_PAGE,\\n                html = JSON.parse(fetch(url));\\n            eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n            items = listdata(items, html);\\n        } catch (e) {\\n            log(\\\"首页推荐出错:\\\" + e.message);\\n        }\\n        setResult(items);\\n    }\\n    var movlist = function() {\\n        addListener(\\\"onClose\\\", $.toString((url) => {\\n            clearVar('now');\\n            clearVar(url);\\n            clearMyVar(\\\"parsemode\\\");\\n        }, MY_URL));\\n        let items = [],\\n            html = getVar(MY_URL, \\\"\\\");\\n        if (html == \\\"\\\") {\\n            html = fetch(base64Decode(getParam(\\\"href\\\")), { 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#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\",\\n            col_type: 'movie_1_vertical_pic_blur'\\n        }, {\\n            title: '剧情简介',\\n            desc: intro,\\n            pic_url: 'https://lanmeiguojiang.com/tubiao/messy/32.svg',\\n            url: $('hiker://empty#noRecordHistory#').rule((desc) => {\\n                setResult([{\\n                    title: desc,\\n                    col_type: 'long_text'\\n                }]);\\n            }, intro),\\n            col_type: 'icon_small_3',\\n            extra: { lineVisible: false }\\n        });\\n        //设置项\\n        let parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\"),\\n            sels = [\\\"智能识别链接\\\", \\\"强制自带解析\\\", \\\"强制断插解析\\\", \\\"强制内置解析\\\", \\\"强制直链打开\\\", \\\"强制网页打开\\\",'复制接口地址'];\\n        for (let i in sels) {\\n            if (sels[i] == parsemode) { sels[i] = \\\"❤️\\\" + sels[i] }\\n        }\\n        items.push({\\n            title: \\\"解析设置\\\",\\n            pic_url: 'https://lanmeiguojiang.com/tubiao/messy/37.svg',\\n            url: $(sels, 1, \\\"请选择\\\").select((appUrl) => {\\n                if(input == '复制接口地址'){return 'copy://' + appUrl}\\n                putMyVar(\\\"parsemode\\\", input);\\n                refreshPage();\\n                return \\\"hiker://empty\\\"\\n            },appUrl),\\n            col_type: 'icon_small_3'\\n        });\\n        let sortmode = getVar('appmtvsort', '1');\\n        items.push({\\n            title: \\\"列表\\\" + (sortmode == '1' ? '正序' : '逆序'),\\n            pic_url: 'https://lanmeiguojiang.com/tubiao/q/127.png',\\n            url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('appmtvsort', getVar('appmtvsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功!'\\\",\\n            col_type: 'icon_small_3'\\n        });\\n        items.push({\\n            col_type: \\\"big_blank_block\\\"\\n        });\\n        //线路列表\\n        let tabs = Object.keys(html.videolist);\\n        if (getVar(\\\"now\\\", \\\"\\\") == \\\"\\\") { putVar(\\\"now\\\", tabs[0]) }\\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#noLoading#@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        if (getVar('appmtvsort', '1') == '0') {\\n            list.reverse();\\n        };\\n        eval(JSON.parse(fetch('hiker://page/creator')).rule)\\n        for (let j = 0; j < list.length; j++) {\\n            let srcurl = list[j].url;\\n            if (/8\\\\.142\\\\.23\\\\.147|zjj\\\\.life|yhzy|zhenfy|cztv|1\\\\.14\\\\.63\\\\.101|fit:8|diliktv\\\\.xyz|ppzhu\\\\.vip|api\\\\.8d8q\\\\.com|haokanju1\\\\.cc|cztv/.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: lazyParse(srcurl)\\n            });\\n        }\\n        setResult(items);\\n    };\\n    var lazyParse = function(srcurl) {\\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 parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\")/*,\\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|xueren\\\\-/) != -1*/;\\n        if (parsemode == '强制断插解析') {\\n            return $('hiker://empty').lazyRule((vlink, srcurl) => {\\n                log(\\\"\\\\n资源链接:\\\" + srcurl);\\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, srcurl)\\n        } else if (parsemode == \\\"强制网页打开\\\") {\\n            return \\\"web://\\\" + vlink;\\n        } else if (parsemode == \\\"强制内置解析\\\") {\\n            return $('hiker://empty').lazyRule((vlink) => {\\n                log(\\\"使用内置解析\\\");\\n                log(\\\"视频链接:\\\" + vlink);\\n                eval(JSON.parse(fetch('hiker://page/myParse')).rule);\\n                return myParse(vlink);\\n            }, vlink);\\n        } else {\\n            return $(\\\"hiker://empty\\\").lazyRule((ptab, srcurl) => {\\n                log(\\\"\\\\n资源链接:\\\" + 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                let parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\");\\n                if (parsemode == \\\"强制直链打开\\\") {\\n                    try {\\n                        return changeVideoUrl(srcurl);\\n                    } catch (e) {\\n                        return \\\"toast://链接不是以http开头(可能加密了)\\\";\\n                    }\\n                }\\n                try {\\n                    if (parsemode == \\\"智能识别链接\\\") {\\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|suoyo\\\\.cc/.test(srcurl)) {\\n                                log(\\\"检测到资源地址可能是视频链接\\\");\\n                                return changeVideoUrl(srcurl);\\n                            }\\n                        }\\n                    }\\n                    //----分割线----//\\n                    log(\\\"使用自带解析\\\");\\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) || scode.statusCode == \\\"404\\\") {\\n                        throw new Error(\\\"404了\\\");\\n                    } else if (/\\\\<body/.test(html)) {\\n                        return $([\\\"开始视频嗅探\\\", \\\"打开解析网页\\\"], 1, \\\"检测到解析为网页数据\\\").select((srcurl) => {\\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                            }\\n                        }, srcurl)\\n                    } else {\\n                        //log('尝试从json数据获取');\\n                        try {\\n                            let purl = '',\\n                                 json = JSON.parse(html);\\n                            if(json.url){\\n                                purl = json.url;\\n                                return changeVideoUrl(purl);\\n                            }else{\\n                                purl = json.data.url;\\n                                return changeVideoUrl(purl);\\n                            }\\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                    if (parsemode == \\\"智能识别链接\\\") {\\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(\\\"使用内置解析\\\\n视频链接:\\\" + vlink);\\n                        eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n                        return myParse(vlink);\\n                    } else {\\n                        return \\\"toast://未能成功获取视频地址\\\"\\n                    }\\n                }\\n                //动态解析代码结束\\n            }, ptab, srcurl);\\n        }\\n    };\\n} else {\\n    var indexdata = function(items) {\\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 + '&key=';\\n                } else if (appUrl.includes(\\\".vod\\\")) {\\n                    let date = new Date();\\n                    let key = '' + (date.getMonth() + 1) + (date.getDate() < 10 ? '0' + date.getDate() : date.getDate());\\n                    let keytime = ('' + date.getTime()).slice(0,-3);\\n                    link = appUrl + '/detail?vod_id=' + vod_id + '&key=' + key + '&keytime=' + keytime;\\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?appUrl=\\\"+appUrl+\\\"&href=\\\" + base64Encode(link)).rule(() => {\\n                        try {\\n                            eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n                            movlist();\\n                        } catch (e) {\\n                            log(\\\"影片详情出错:\\\" + e.message);\\n                            setResult([]);\\n                        }\\n                    })\\n                });\\n            }\\n        }\\n        return items;\\n    };\\n    var find_rule = function() {\\n        let items = [];\\n        //获取分类内容\\n        try {\\n            let typeJson = [];\\n            if (appUrl.includes(\\\"api.php/app\\\")) {\\n                let typeUrl = appUrl + \\\"nav\\\";\\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 = appUrl + \\\"nav\\\";\\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 = 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 + '&' + typeUrl;\\n                } else if (appUrl.includes('xgapp')) {\\n                    tyurl = appUrl + 'video?tid=' + typeJson[i].type_id + '&' + typeUrl;\\n                } else if (appUrl.includes(\\\".vod\\\")) {\\n                    tyurl = appUrl + '?type=' + typeJson[i].type_id + '&by=fby&limit=9&' + typeUrl;\\n                }\\n                //构建动态分类\\n                items.push({\\n                    title: typeJson[i].type_name,\\n                    url: $(\\\"hiker://empty?page=fypage&appUrl=\\\"+appUrl+\\\"&href=\\\" + base64Encode(tyurl)).rule((appUrl, type_extend,  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: $('hiker://empty#noLoading#').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 = base64Decode(getParam(\\\"href\\\"));\\n                        for (let item in temp) {\\n                            url = url.replace(item, temp[item]);\\n                        }\\n                        url = url + (appUrl.includes(\\\".vod\\\") ? \\\"&page=\\\" : \\\"&pg=\\\" )+ MY_PAGE;\\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/creator')).rule);\\n                            items = listdata(items, html);\\n                        } catch (e) {\\n                            log(\\\"视频列表出错:\\\" + e.toString());\\n                        }\\n                        setResult(items);\\n                    }, appUrl, typeJson[i].type_extend, appUa),\\n                    col_type: 'flex_button'\\n                })\\n            }\\n        } catch (e) {\\n            log('首页分类出错:' + e.message);\\n        }\\n        //获取推荐视频列表\\n        try {\\n            let url = \\\"\\\";\\n            if (appUrl.includes(\\\"api.php/app\\\")) {\\n                url = appUrl + \\\"index_video\\\";\\n            } else if (appUrl.includes(\\\"xgapp\\\")) {\\n                url = appUrl + \\\"index_video\\\";\\n            } else {\\n                url = appUrl + \\\"/vodPhbAll\\\";\\n            }\\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/creator')).rule);\\n            items = indexdata(items, html);\\n        } catch (e) {\\n            log('首页推荐出错:' + e.message);\\n        }\\n        setResult(items);\\n    };\\n\\n    var listdata = function(items, html) {\\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;\\n            } else if (appUrl.includes(\\\".vod\\\")) {\\n                let date = new Date();\\n                let key = '' + (date.getMonth() + 1) + (date.getDate() < 10 ? '0' + date.getDate() : date.getDate());\\n                let keytime = ('' + date.getTime()).slice(0,-3);\\n                link = appUrl + '/detail?vod_id=' + vod_id + '&key=' + key + '&keytime=' + keytime;\\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?appUrl=\\\"+appUrl+\\\"&href=\\\" + base64Encode(link)).rule(() => {\\n                    try {\\n                        eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n                        movlist();\\n                    } catch (e) {\\n                        log(\\\"影片详情出错:\\\" + e.message);\\n                        setResult([]);\\n                    }\\n                })\\n            });\\n        }\\n        return items;\\n    };\\n    var movlist = function() {\\n        addListener(\\\"onClose\\\", $.toString((url) => {\\n            clearVar('appnow');\\n            clearVar(url);\\n            clearMyVar('jiexi');\\n            clearMyVar(\\\"parsemode\\\");\\n        }, MY_URL));\\n        let items = [],\\n            html = getVar(MY_URL, \\\"\\\"),\\n            data = {};\\n        if (html == \\\"\\\") {\\n            let url = base64Decode(getParam(\\\"href\\\"));            \\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#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\",\\n            col_type: 'movie_1_vertical_pic_blur'\\n        }, {\\n            title: '剧情简介',\\n            pic_url: 'https://lanmeiguojiang.com/tubiao/messy/32.svg',\\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: 'icon_small_3',\\n            extra: { lineVisible: false }\\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 || conts.length < 1) {\\n            conts = data.vod_play_url.split('$$$');\\n            tabs = data.vod_play_from.split('$$$');\\n        }\\n        //设置项\\n        let parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\"),\\n            sels = [\\\"智能识别链接\\\", \\\"强制自带解析\\\", \\\"强制断插解析\\\", \\\"强制内置解析\\\", \\\"强制直链打开\\\", \\\"强制网页打开\\\",'复制接口地址'];\\n        for (let i in sels) {\\n            if (sels[i] == parsemode) { sels[i] = \\\"❤️\\\" + sels[i] }\\n        }\\n        items.push({\\n            title: \\\"解析设置\\\",\\n            pic_url: 'https://lanmeiguojiang.com/tubiao/messy/37.svg',\\n            url: $(sels, 1, \\\"请选择\\\").select((appUrl) => {\\n                if(input == '复制接口地址'){return 'copy://' +appUrl}\\n                putMyVar(\\\"parsemode\\\", input);\\n                refreshPage();\\n                return \\\"hiker://empty\\\"\\n            },appUrl),\\n            col_type: 'icon_small_3'\\n        });\\n        let sortmode = getVar('appmappsort', '1');\\n        items.push({\\n            title: \\\"列表\\\" + (sortmode == '1' ? '正序' : '逆序'),\\n            pic_url: 'https://lanmeiguojiang.com/tubiao/q/127.png',\\n            url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('appmappsort', getVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功!'\\\",\\n            col_type: 'icon_small_3'\\n        });\\n        items.push({\\n            col_type: \\\"big_blank_block\\\"\\n        });\\n        //线路名称\\n        let ptab = \\\"\\\";\\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) ? conts[i].player_info.show : sptab;\\n            }\\n            items.push({\\n                title: getVar(\\\"appnow\\\") == i ? \\\"““””\\\" + tabname.bold().fontcolor(\\\"#FA7298\\\") + \\\"-\\\" + sptab : tabname + \\\"-\\\" + sptab,\\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            }\\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            try {\\n                list = conts[index].urls ? conts[index].urls : conts[index].url.split(\\\"#\\\");\\n            } catch (e) {\\n                list = conts[index].split('#');\\n            }\\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 = Array.from(new Set(jiek.filter(cur => !!cur)));\\n        if (jiek.length == 0) jiek.push('');\\n        if ([\\\"智能识别链接\\\", \\\"强制自带解析\\\"].includes(parsemode)) {\\n            items.push({\\n                title: '当前解析:' + getMyVar('jiexi', jiek[0]),\\n                url: $(jiek, 1).select(() => {\\n                    putMyVar('jiexi', input);\\n                    refreshPage(false);\\n                    return 'toast://已更改解析'\\n                }),\\n                col_type: 'text_1',\\n                extra: { lineVisible: false }\\n            })\\n        }\\n\\n        let jxUrl = getMyVar('jiexi', jiek[0]) || \\\"\\\";\\n        //视频列表\\n        eval(JSON.parse(fetch('hiker://page/creator')).rule);\\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            items.push({\\n                title: title,\\n                col_type: \\\"text_4\\\",\\n                url: lazyParse(vlink, jxUrl)\\n            });\\n        }\\n        setResult(items);\\n    };\\n\\n    var lazyParse = function(vlink, jxUrl) {\\n        let parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\")\\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|xueren\\\\-/) != -1*/;\\n        if (parsemode == '强制断插解析') {\\n            return $('hiker://empty').lazyRule((vlink) => {\\n                log(\\\"\\\\n资源链接:\\\" + vlink);\\n                log(\\\"调用断插解析\\\");\\n                eval(\\\"let config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                eval(fetch(config.cj));\\n                return aytmParse(vlink);\\n            }, vlink)\\n        } else if (parsemode == \\\"强制网页打开\\\") {\\n            return \\\"web://\\\" + vlink;\\n        } else if (parsemode == \\\"强制内置解析\\\") {\\n            return $('hiker://empty').lazyRule((vlink) => {\\n                log(\\\"\\\\n资源链接:\\\" + vlink);\\n                log(\\\"使用内置解析\\\");\\n                eval(JSON.parse(fetch('hiker://page/myParse')).rule);\\n                return myParse(vlink);\\n            }, vlink)\\n        } else {\\n            return $('hiker://empty').lazyRule((ptab, vlink, jxUrl) => {\\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                    }\\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                let parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\");\\n                if (parsemode == \\\"强制直链打开\\\") {\\n                    try {\\n                        return changeVideoUrl(vlink);\\n                    } catch (e) {\\n                        return \\\"toast://链接不是以http开头(可能加密了)\\\";\\n                    }\\n                }\\n                //动态解析代码开始\\n                try {\\n                    //处理视频样式的资源链接\\n                    if (parsemode == \\\"智能识别链接\\\") {\\n                        if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(vlink) && /http/.test(vlink) && !/\\\\.html/.test(vlink)) {\\n                            if (!/fen\\\\.laodi|suoyo\\\\.cc/.test(vlink)) {\\n                                log(\\\"检测到资源地址可能是视频链接\\\");\\n                                return changeVideoUrl(vlink);\\n                            }\\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                        scode.body = fetch(redurl);\\n                    }\\n                    //开始嗅探\\n                    let html = scode.body;\\n                    if (/404 Not Found|备案后可继续访问/.test(html) || scode.statusCode == \\\"404\\\") {\\n                        throw new Error(\\\"404了\\\");\\n                    } else if (/\\\\<body/.test(html)) {\\n                        return $([\\\"开始视频嗅探\\\", \\\"打开解析网页\\\"], 1, \\\"检测到解析为网页数据\\\").select((link) => {\\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                            }\\n                        }, link);\\n                    } else {\\n                        log('尝试以json格式获取视频链接');\\n                        try {\\n                            let purl = JSON.parse(html).url;\\n                            return changeVideoUrl(purl);\\n                        } catch (e) {\\n                            throw new Error('解析可能加密了');\\n                        }\\n                    }\\n                } catch (e) {\\n                    log('\\\\n未能成功获取视频地址:' + e.message);\\n                    if (parsemode == \\\"智能识别链接\\\") {\\n                        log(\\\"使用内置解析\\\");\\n                        eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n                        return myParse(vlink);\\n                    } else {\\n                        return \\\"toast://未能成功获取视频地址\\\"\\n                    }\\n                }\\n                //动态解析代码结束\\n            }, ptab, vlink, jxUrl);\\n        }\\n    };\\n}\\n\\nsearchFind = function() {\\n    let items = [],\\n        search_url = \\\"\\\",\\n        bhtml = \\\"\\\",\\n        word = getParam(\\\"word\\\")/*,\\n        appUrl = getParam(\\\"href\\\")*/;\\n    if (appUrl.includes(\\\"/vod\\\")) {\\n        if (/hfys8|tvzy.\\\\cc|175\\\\.178\\\\.7\\\\.35|jpsb|hyddys|ddmym|esellauto|1\\\\.14\\\\.63\\\\.101|zjys|tv\\\\.cttv|dcd|lxue|weetai\\\\.cn|haokanju1|fit:8|zjj\\\\.life|love9989|8d8q|lk\\\\.pxun|hgyx|521x5|lxyyy|0818tv|diyoui|diliktv|ppzhu|aitesucai|zz\\\\.ci|chxjon|watchmi|vipbp|bhtv|xfykl|cccvvv|vipdytv|sztuotai|aacc\\\\.tv|0009988|106\\\\.13\\\\.10\\\\.156|n293\\\\.ngys|809394|xhdj\\\\.vip/.test(appUrl)) {\\n            search_url = appUrl + '?ac=list&page=' + MY_PAGE + '&wd=' + word;\\n        } else {\\n            search_url = appUrl + '?ac=list&page=' + MY_PAGE + '&zm=' + word;\\n        }\\n    } else if (appUrl.includes(\\\"api.php/app\\\")) {\\n        search_url = appUrl + 'search?pg=' + MY_PAGE + '&text=' + word;\\n    } else if (appUrl.includes(\\\"xgapp\\\")) {\\n        search_url = appUrl + 'search?pg=' + MY_PAGE + '&text=' + word;\\n    } else {\\n        search_url = appUrl + '?page=' + MY_PAGE + '&limit=10&wd=' + word;\\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 (appUrl.includes(\\\"/vod\\\")) {\\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 (appUrl.includes(\\\"/vod\\\")) {\\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;\\n            } else {\\n                var { vod_name: title, vod_pic: pic, vod_remarks: desc } = list[i];\\n                let date = new Date();\\n                let key = '' + (date.getMonth() + 1) + (date.getDate() < 10 ? '0' + date.getDate() : date.getDate());\\n                let keytime = ('' + date.getTime()).slice(0,-3);\\n                var url = appUrl + '/detail?vod_id=' + list[i].vod_id + '&key=' + key + '&keytime=' + keytime;\\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?appUrl=\\\"+appUrl+\\\"&href=\\\" + base64Encode(url)).rule(() => {\\n                eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n                movlist();\\n            })\\n        });\\n    }\\n\\n    setResult(items);\\n};\\n\\nlast_chapter_rule = function() {\\n    let chp = [];\\n    try {\\n        let conts = [],\\n            html = JSON.parse(fetch(getParam(\\\"href\\\"), {\\n                headers: {\\n                    \\\"User-Agent\\\": appUa\\n                }\\n            }));\\n        if (appUrl.includes(\\\"/vod\\\")) {\\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 (appUrl.includes(\\\"/vod\\\")) {\\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};\"},{\"col_type\":\"movie_3\",\"name\":\"生成规则列表\",\"path\":\"appJson\",\"rule\":\"function getRules(remoteData) {\\n    let rules = [],\\n         data = [],\\n         appSub = JSON.parse(readFile(\\\"appSub\\\") || '[]').filter(v => !v.inVisible),\\n         subnow = parseInt(getItem('subnow',''));\\n    if(subnow === \\\"\\\" ){return [];}\\n    let sub = appSub[parseInt(subnow)];\\n    if (sub.code == '') {\\n        data =  JSON.parse(remoteData);\\n    }else{\\n        eval('var fun =' + sub.code);\\n        data = fun(remoteData);\\n    }\\n    if(!Array.isArray(data)) return [];\\n    if (sub.type == 'app接口') {\\n        var find_rule = \\\"js:\\\" + $.toString(function() {\\n            eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n            find_rule();\\n        });\\n        var searchFind = \\\"js:\\\" + $.toString(function() {\\n            eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n            searchFind();\\n        });\\n        var last_chapter_rule = \\\"js:\\\" + $.toString(function() {\\n            eval(JSON.parse(fetch('hiker://page/creator')).rule);\\n            last_chapter_rule();\\n        });\\n        var pages = JSON.stringify([JSON.parse(fetch('hiker://page/creator')), JSON.parse(fetch('hiker://page/myParse'))]);\\n        for (let rule of data) {\\n            let url = rule.url;\\n            rule.url = \\\"hiker://empty?appUrl=\\\" + url + (url.includes(\\\"/vod\\\") ? \\\"&page=fypage\\\" : \\\"\\\");\\n            rule.search_url = \\\"hiker://empty?page=fypage&word=**&appUrl=\\\" + url;\\n            rule.find_rule = find_rule;\\n            rule.searchFind = searchFind;\\n            rule.last_chapter_rule = last_chapter_rule;\\n            rule.pages = pages;\\n            rules.push(rule);\\n        }\\n        return rules;\\n    } else if (sub.type == '资源网接口') {\\n        var find_rule = \\\"js:\\\" + $.toString(function() {\\n            eval(JSON.parse(fetch('hiker://page/creator2')).rule);\\n            find_rule();\\n        });\\n        var searchFind = \\\"js:\\\" + $.toString(function() {\\n            eval(JSON.parse(fetch('hiker://page/creator2')).rule);\\n            searchFind();\\n        });\\n        var last_chapter_rule = \\\"js:\\\" + $.toString(function() {\\n            eval(JSON.parse(fetch('hiker://page/creator2')).rule);\\n            last_chapter_rule();\\n        });\\n        var pages = JSON.stringify([JSON.parse(fetch('hiker://page/creator2')), JSON.parse(fetch('hiker://page/myParse'))]);\\n        for (let rule of data) {\\n            let url = rule.url.split('?')[0];\\n            rule.url = \\\"hiker://empty?appUrl=\\\"+url+\\\"&pg=fypage\\\";\\n            rule.search_url = \\\"hiker://empty?appUrl=\\\" + url + '&wd=**&page=fypage';\\n            rule.find_rule = find_rule;\\n            rule.searchFind = searchFind;\\n            rule.last_chapter_rule = last_chapter_rule;\\n            rule.pages = pages;\\n            rule.ua = 'mobile';\\n            rules.push(rule);\\n        }\\n        return rules;\\n    } else {\\n        return data;\\n    }\\n}\\n$.exports = getRules;\"},{\"col_type\":\"movie_3\",\"name\":\"管理订阅\",\"path\":\"subscription\",\"rule\":\"$.exports = function (el) {\\n    let d = el,\\n        subEditMode = getMyVar('subEditMode', '编辑');\\n    //导入订阅\\n    d.push({\\n        title: \\\"新增订阅\\\",\\n        col_type: \\\"text_2\\\",\\n        url: $().lazyRule(() => {\\n            putVar('name', '');\\n            putVar('url', '');\\n            putVar('code', '');\\n            putVar('type', 'app接口');\\n            return \\\"hiker://page/edit\\\";\\n        })\\n    });\\n    d.push({\\n        title: \\\"导入订阅\\\",\\n        col_type: \\\"text_2\\\",\\n        url: $('').input(() => {\\n            try {\\n                input = input.trim();\\n                let href = input.match(/轻订阅:.*?\\\\n(http.*?)(?:\\\\n|$)/)[1],\\n                    text = parsePaste(href),\\n                    [type, name, url, code, ] = text.split('★★★');\\n                putVar('name', name);\\n                putVar('url', url);\\n                putVar('code', code);\\n                putVar('type', type);\\n                return \\\"hiker://page/edit\\\";\\n            } catch (e) {\\n                return 'toast://格式不对';\\n            }\\n        })\\n    });\\n    //管理订阅(删除、排序)\\n    ['编辑', '启停',  '删除', '排序', '导出', '查看'].forEach((v) => {\\n        d.push({\\n            title: v == subEditMode ? '““””' + v.bold().fontcolor('#12b668') : v,\\n            url: v == subEditMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n                putMyVar('subEditMode', v);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, v),\\n            col_type: 'scroll_button'\\n        })\\n    });\\n    JSON.parse(readFile('appSub') || \\\"[]\\\").forEach((v, i) => {\\n        let item = {\\n            title: v.name,\\n            col_type: \\\"text_3\\\"\\n        };\\n        switch (subEditMode) {\\n            case '编辑':\\n                item.url = $().lazyRule((v, i) => {\\n                    putVar('name', v.name);\\n                    putVar('url', v.url);\\n                    putVar('code', v.code);\\n                    putVar('type', v.type);\\n                    return \\\"hiker://page/edit?mode=编辑&index=\\\" + i;\\n                }, v, i);\\n                break;\\n            case '启停':\\n                item.title = (v.inVisible ? '🔴' : '🟢') + item.title;\\n                item.url = $('#noLoading#').lazyRule((i)=>{\\n                    let subscriptions = JSON.parse(readFile('appSub') || \\\"[]\\\");\\n                    subscriptions[i].inVisible = !subscriptions[i].inVisible;\\n                    saveFile('appSub', JSON.stringify(subscriptions));\\n                    refreshPage(false);\\n                    return 'hiker://empty';\\n                },i);\\n                break;\\n            case '删除':\\n                item.url = $('确定删除“' + v.name + '”订阅?').confirm((i,v) => {\\n                    let subscriptions = JSON.parse(readFile('appSub') || \\\"[]\\\");\\n                    subscriptions.splice(i, 1);\\n                    saveFile('appSub', JSON.stringify(subscriptions));\\n                    deleteCache(v.url);\\n                    refreshPage(false);\\n                    return 'hiker://empty';\\n                }, i, v);\\n                break;\\n            case '排序':\\n                let sortFlag = parseInt(getMyVar('appSortFlag', '-1'));\\n                item.title = (sortFlag == i ? '🔃  ' : '') + item.title;\\n                if (sortFlag == -1) {\\n                    item.url = $('#noLoading#').lazyRule((i) => {\\n                        putMyVar('appSortFlag', i.toString());\\n                        refreshPage(false);\\n                        return 'toast://选择要移动到的位置';\\n                    }, i);\\n                } else {\\n                    item.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                        let subscriptions = JSON.parse(readFile('appSub') || '[]');\\n                        subscriptions.splice(newIndex, 0, subscriptions.splice(oldIndex, 1)[0]);\\n                        saveFile('appSub', JSON.stringify(subscriptions));\\n                        putMyVar('appSortFlag', '-1');\\n                        refreshPage(false);\\n                        return 'hiker://empty';\\n                    }, sortFlag, i);\\n                }\\n                break;\\n            case '导出':\\n                item.url = $('确定导出“' + v.name + '”订阅?').confirm((v) => {\\n                    let text = v.type + '★★★' + v.name + '★★★' + v.url + '★★★' + v.code,\\n                        href = sharePaste(text);\\n                    copy('轻订阅:' + v.name + '\\\\n' + href);\\n                    return 'hiker://empty'\\n                }, v)\\n                break;\\n            case '查看':\\n                item.url =  'editFile://hiker://files/libs/' + md5(v.url) + '.js';\\n                break;\\n        }\\n        d.push(item);\\n    });\\n    return d;\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"编辑订阅\",\"path\":\"edit\",\"rule\":\"js:\\nsetPageTitle('编辑订阅');\\naddListener('onClose', $.toString(() => {\\n    clearVar('name');\\n    clearVar('url');\\n    clearVar('code');\\n    clearVar('type');\\n}));\\nlet d = [],\\n    mode = getParam('mode'),\\n    index = getParam('index');\\nd.push({\\n    title: \\\"““””\\\" + '订阅类型:' + getVar('type', 'app接口').fontcolor('red'),\\n    url: $(['app接口', '资源网接口', '普通规则合集'], 1).select(() => {\\n        putVar('type', input);\\n        refreshPage(false);\\n        return 'hiker://empty';\\n    }),\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nd.push({\\n    title: '名称',\\n    url: '\\\"hiker://empty\\\"',\\n    col_type: \\\"input\\\",\\n    desc: \\\"输入订阅名称\\\",\\n    extra: {\\n        type: 'textarea',\\n        height: -1,\\n        defaultValue: getVar('name', ''),\\n        onChange: 'putVar(\\\"name\\\",input)'\\n    }\\n});\\nd.push({\\n    title: '链接',\\n    url: '\\\"hiker://empty\\\"',\\n    col_type: \\\"input\\\",\\n    desc: \\\"输入订阅链接\\\",\\n    extra: {\\n        type: 'textarea',\\n        height: -1,\\n        defaultValue: getVar('url', ''),\\n        onChange: 'putVar(\\\"url\\\",input)'\\n    }\\n});\\nd.push({\\n    title: '代码',\\n    url: 'hiker://empty',\\n    col_type: \\\"input\\\",\\n    desc: \\\"输入转换代码\\\\n更新订阅时会调用此代码将订阅内容转换为规则数组,数组每一项至少应包括title(注意去重)和url\\\\n格式: function(remoteData){return arr}\\\\nremoteData为获取到的远程数据,arr为返回的规则数组\\\",\\n    extra: {\\n        type: 'textarea',\\n        highlight: true,\\n        height: -1,\\n        defaultValue: getVar('code', ''),\\n        onChange: 'putVar(\\\"code\\\",input)'\\n    }\\n});\\nd.push({\\n    title: '测试',\\n    col_type: 'text_2',\\n    url: $('hiker://empty').lazyRule(()=>{\\n            let url = getVar('url'),\\n                 code = getVar('code'),\\n                 data = '',\\n                 remoteData = '';\\n            if(!url) {return 'toast://还没写订阅链接'}\\n            if(!/^http|^hiker|^file/.test(url)) {return 'toast://链接不太对啊'}\\n            try{\\n                remoteData = fetch(url);\\n            }catch(e){\\n                return 'toast://访问链接出了问题'\\n            }\\n            if (code === '') {\\n                try{\\n                    data =  JSON.parse(remoteData);\\n                }catch(e){\\n                    return 'toast://远程数据不为json格式'\\n                }\\n            }else{\\n                try{\\n                    eval('var fun =' + code);\\n                    data = fun(remoteData);\\n                }catch(e){\\n                    log('代码问题:\\\\n' + e.toString());\\n                    return 'toast://转换代码有问题,详见日志'\\n                }\\n            }\\n            log(data);\\n            if(!Array.isArray(data)){\\n                return 'toast://结果不是数组啊'\\n            }\\n            if(data.length === 0 || (!data[0].title || !data[0].url)){\\n                return 'toast://结果数组不包含title或url'\\n            }\\n            return 'toast://测试成功,结果显示在日志中'\\n    })\\n});\\nd.push({\\n    title: '保存',\\n    url: $().lazyRule((mode, index) => {\\n        let name = getVar('name'),\\n            url = getVar('url'),\\n            code = getVar('code'),\\n            type = getVar('type', ''),\\n            subs = JSON.parse(readFile('appSub') || '[]');\\n        if(!type) {return 'toast://还没选订阅类型'}\\n        if(!name) {return 'toast://还没写订阅名字'}\\n        if(!url) {return 'toast://还没写订阅链接'}\\n        if(!/^http|^hiker|^file/.test(url)) {return 'toast://链接不太对啊'}\\n        if(code !== ''){\\n            try{\\n                eval('var test=' + code)\\n            }catch(e){\\n                log('代码问题:\\\\n' + e.toString());\\n            return 'toast://代码有问题啊，去看看日志'\\n        }\\n        if(code !=='' && $.type(test) !== 'function'){return 'toast://代码格式不对'}\\n        }\\n        //let i = subs.findIndex(it => it.url == url);\\n        if (mode == '编辑') {\\n            //if (index != i) return 'toast://此订阅链接已存在';\\n            subs[index] = {\\n                name: name,\\n                url: url,\\n                code: code,\\n                type: type\\n            };\\n        } else {\\n            //if (i != -1) return 'toast://此订阅链接已存在'\\n            subs.push({\\n                name: name,\\n                url: url,\\n                code: code,\\n                type: type\\n            });\\n        }\\n        saveFile(\\\"appSub\\\", JSON.stringify(subs));\\n        back(true);\\n        return \\\"toast://保存成功\\\"\\n    }, mode, index),\\n    col_type: \\\"text_2\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nfor (let i = 0; i < 10; i++){\\n    d.push({\\n        col_type: \\\"big_blank_block\\\"\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"规则运行-cms\",\"path\":\"creator2\",\"rule\":\"let appUrl = getParam(\\\"appUrl\\\");\\n//首页规则\\nfunction find_rule() {\\n    let items = [],\\n        listmode = getItem(\\\"listmode\\\", \\\"text\\\"),\\n        html = request(appUrl + (listmode == \\\"text\\\" ? '?ac=list' : \\\"?ac=videolist\\\") + '&pg=' + MY_PAGE);\\n    if (MY_PAGE == 1) {\\n        try {\\n            let type = [],\\n                rescod = request(appUrl + \\\"?ac=list\\\");\\n            /*if (!/\\\\<\\\\/class\\\\>|type_name/.test(rescod)) {\\n                rescod = request(appUrl + \\\"?ac=list\\\");\\n            }*/\\n            if (/list_name/.test(rescod)) {\\n                type = JSON.parse(rescod).list;\\n            } else if (/type_name/.test(rescod)) {\\n                type = JSON.parse(rescod).class;\\n            } else {\\n                type = pdfh(rescod, \\\"class&&Html\\\").match(/<ty[\\\\s]id[\\\\s\\\\S]*?<\\\\/ty>/g);\\n            }\\n            for (let i = 0; i < type.length; i++) {\\n                let type_name = \\\"\\\",\\n                    type_id = \\\"\\\";\\n                if (/list_name/.test(rescod)) {\\n                    type_name = type[i].list_name;\\n                    type_id = type[i].list_id;\\n                } else if (/vod_play_from/.test(rescod)) {\\n                    type_name = type[i].type_name;\\n                    type_id = type[i].type_id;\\n                } else {\\n                    type_name = parseDomForHtml(type[i], \\\"body&&Text\\\").split('{')[0];\\n                    type_id = parseDomForHtml(type[i], \\\"body&&ty&&id\\\");\\n                }\\n                items.push({\\n                    title: type_name,\\n                    url: $('hiker://empty?appUrl=' + appUrl + \\\"&pg=fypage&href=\\\" + base64Encode(appUrl + \\\"?ac=list&t=\\\" + type_id)).rule((appUrl) => {\\n                        let html = fetch(base64Decode(getParam('href')) + '&pg=' + MY_PAGE);\\n                        let items = [];\\n                        try {\\n                            eval(JSON.parse(fetch(\\\"hiker://page/creator2\\\")).rule);\\n                            if (/vod_play_from/.test(html)) {\\n                                html = JSON.parse(html);\\n                                items = jsonlist(items, html);\\n                            } else {\\n                                items = listfun(items, html);\\n                            }\\n                        } catch (e) {\\n                            log('分类列表出错:' + e.message);\\n                        }\\n                        setResult(items);\\n                    }, appUrl),\\n                    col_type: 'scroll_button'\\n                });\\n            }\\n            items.unshift({\\n                title: '‘‘’’' + '切换样式'.fontcolor(\\\"#FA7298\\\"),\\n                url: $('hiker://empty#noLoading#').lazyRule(() => {\\n                    let listmode = getItem(\\\"listmode\\\", \\\"text\\\"),\\n                        alt = listmode == \\\"text\\\" ? \\\"video\\\" : \\\"text\\\";\\n                    setItem(\\\"listmode\\\", alt);\\n                    refreshPage();\\n                    return 'toast://' + (alt == \\\"text\\\" ? '已切换为文本样式' : \\\"已切换为图文样式\\\");\\n                }),\\n                col_type: 'scroll_button'\\n            });\\n        } catch (e) {\\n            log('首页分类出错:' + e.message);\\n        }\\n    }\\n    try {\\n        eval(JSON.parse(fetch(\\\"hiker://page/creator2\\\")).rule);\\n        if (/vod_play_from/.test(html)) {\\n            html = JSON.parse(html);\\n            items = jsonlist(items, html);\\n        } else {\\n            items = listfun(items, html);\\n        }\\n    } catch (e) {\\n        log(\\\"首页推荐出错:\\\" + e.message);\\n    }\\n    setResult(items);\\n};\\n//子页面\\nfunction listfun(items, html) {\\n    let list = pdfa(html, \\\"rss&&video\\\"),\\n        listmode = getItem(\\\"listmode\\\", \\\"text\\\");\\n    for (let j in list) {\\n        let title = pdfh(list[j], \\\"body&&name&&Text\\\").split('<')[0];\\n        let url = pdfh(list[j], \\\"body&&id&&Text\\\");\\n        let note = pdfh(list[j], \\\"body&&note&&Text\\\");\\n        let typ = pdfh(list[j], \\\"body&&type&&Text\\\");\\n        let last = pdfh(list[j], \\\"body&&last&&Text\\\");\\n        let dt = pdfh(list[j], \\\"body&&dt&&Text\\\");\\n        let item = {};\\n        if (html.includes(\\\"</pic>\\\") && listmode == \\\"video\\\") {\\n            let pic = pdfh(list[j], \\\"body&&pic&&Text\\\");\\n            item = {\\n                title: title,\\n                pic_url: pic + '@Referer=',\\n                desc: dt,\\n                col_type: \\\"movie_3\\\"\\n            };\\n        } else {\\n            item = {\\n                title: title + (note ? \\\"  状态:\\\" + note : ''),\\n                desc: last + ' ' + typ + ' ' + dt,\\n                col_type: \\\"text_1\\\"\\n            };\\n        }\\n        item.url = $(\\\"#immersiveTheme#hiker://empty?appUrl=\\\" + appUrl + '&href=' + base64Encode(appUrl + \\\"?ac=videolist&ids=\\\" + url)).rule(() => {\\n            try {\\n                eval(JSON.parse(fetch(\\\"hiker://page/creator2\\\")).rule);\\n                detail_rule();\\n            } catch (e) {\\n                setResult([]);\\n                log(\\\"资源详情出错:\\\" + e.message);\\n            }\\n        });\\n        items.push(item);\\n    }\\n    return items;\\n};\\n\\nfunction jsonlist(items, html) {\\n    let list = html.data ? html.data : html.list,\\n        listmode = getItem(\\\"listmode\\\", \\\"text\\\");\\n    for (let j in list) {\\n        let { vod_name, vod_id, type_name, vod_play_from } = list[j],\\n            note = list[j].vod_remarks ? list[j].vod_remarks : list[j].vod_total,\\n            last = list[j].vod_addtime ? list[j].vod_addtime : list[j].vod_time,\\n            pic = list[j].vod_pic || \\\"\\\",\\n            item = {};\\n        if (pic && listmode == \\\"video\\\") {\\n            item = {\\n                title: vod_name,\\n                pic_url: pic + '@Referer=',\\n                desc: vod_play_from,\\n                col_type: \\\"movie_3\\\"\\n            };\\n        } else {\\n            item = {\\n                title: vod_name + (note ? \\\"  状态:\\\" + note : ''),\\n                desc: last + ' ' + type_name + ' ' + vod_play_from,\\n                col_type: \\\"text_1\\\"\\n            };\\n        }\\n        item.url = $(\\\"#immersiveTheme#hiker://empty?appUrl=\\\" + appUrl + '&href=' + base64Encode(appUrl + \\\"?ac=videolist&ids=\\\" + vod_id)).rule(() => {\\n            try {\\n                eval(JSON.parse(fetch(\\\"hiker://page/creator2\\\")).rule);\\n                detail_rule();\\n            } catch (e) {\\n                setResult([]);\\n                log(\\\"资源详情出错:\\\" + e.message);\\n            }\\n        });\\n        items.push(item);\\n    }\\n    return items;\\n};\\n//二级规则\\nfunction detail_rule() {\\n    addListener(\\\"onClose\\\", $.toString((url) => {\\n        clearMyVar(\\\"parsemode\\\");\\n        clearVar('now');\\n        clearVar(url);\\n    }, MY_URL));\\n    let d = [],\\n        html = getVar(MY_URL, \\\"\\\");\\n    if (html == \\\"\\\") {\\n        html = request(base64Decode(getParam(\\\"href\\\")));\\n        putVar(MY_URL, html);\\n    }\\n    if (/vod_play_from/.test(html)) {\\n        let jhtml = JSON.parse(html),\\n            data = /list_name/.test(html) ? jhtml.data[0] : jhtml.list[0];\\n        var { vod_name, vod_class, vod_area, vod_lang, vod_year, vod_pic, type_name, vod_content, vod_actor, vod_director } = data;\\n        var tabs = data.vod_play_from.split('$$$');\\n        var conts = data.vod_play_url.split('$$$');\\n    } else {\\n        var vod_name = pdfh(html, \\\"rss&&name&&Text\\\");\\n        var vod_class = /class\\\\>.*\\\\</.test(html) ? html.match(/class\\\\>(.*?)\\\\</)[1] : ''; //pdfh(html, \\\"rss&&class&&Text\\\");\\n        var vod_area = /area\\\\>.*\\\\</.test(html) ? html.match(/area\\\\>(.*?)\\\\</)[1] : ''; //pdfh(html, \\\"rss&&area&&Text\\\");\\n        var vod_lang = pdfh(html, \\\"rss&&lang&&Text\\\");\\n        var vod_year = pdfh(html, \\\"rss&&year&&Text\\\");\\n        var vod_pic = pdfh(html, \\\"rss&&pic&&Text\\\");\\n        var type_name = pdfh(html, \\\"rss&&type&&Text\\\");\\n        var vod_content = pdfh(html, \\\"rss&&des&&Text\\\");\\n        var vod_actor = pdfh(html, \\\"rss&&actor&&Text\\\");\\n        var vod_director = pdfh(html, \\\"rss&&director&&Text\\\");\\n        var tabs = pdfa(html, 'rss&&dl&&dd').map(cur => pdfh(cur, \\\"dd&&flag\\\"));\\n        var conts = pdfa(html, 'rss&&dl&&dd');\\n    }\\n    //简介\\n    d.push({\\n        title: vod_name + '\\\\n' + type_name + (vod_class ? \\\",\\\" + vod_class : '') + \\\"\\\\n\\\" + vod_area + \\\"/\\\" + vod_lang + \\\"/\\\" + vod_year,\\n        desc: \\\"导演:\\\" + vod_director + \\\"\\\\n主演:\\\" + vod_actor,\\n        pic_url: vod_pic + '@Referer=',\\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=设置#noHistory##noRecordHistory#',\\n        col_type: 'movie_1_vertical_pic_blur'\\n    });\\n    d.push({\\n        title: \\\"剧情简介\\\",\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/messy/32.svg',\\n        desc: vod_content,\\n        url: $('hiker://empty').rule((des) => {\\n            let d = [];\\n            d.push({\\n                title: des,\\n                col_type: 'long_text'\\n            });\\n            setResult(d);\\n        }, vod_content),\\n        col_type: 'icon_small_3',\\n        extra: { lineVisible: false }\\n    });\\n    //设置项\\n    let parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\"),\\n        sels = [\\\"智能识别链接\\\", \\\"强制断插解析\\\", \\\"强制内置解析\\\", \\\"强制直链打开\\\", \\\"强制网页打开\\\",'复制接口地址'];\\n    for (let i in sels) {\\n        if (sels[i] == parsemode) { sels[i] = \\\"❤️\\\" + sels[i] }\\n    }\\n    d.push({\\n        title: \\\"解析设置\\\",\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/messy/37.svg',\\n        url: $(sels, 1, \\\"请选择\\\").select((appUrl) => {\\n            if(input == '复制接口地址'){return 'copy://' + appUrl}\\n            putMyVar(\\\"parsemode\\\", input);\\n            refreshPage();\\n            return \\\"hiker://empty\\\"\\n        },appUrl),\\n        col_type: 'icon_small_3'\\n    });\\n    let sortmode = getVar('zywlsort','1');\\n    d.push({\\n        title: \\\"列表\\\" + (sortmode == '1' ? '正序' : '逆序'),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/127.png',\\n        url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('zywlsort', getVar('zywlsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功!'\\\",\\n        col_type: 'icon_small_3'\\n    });\\n    d.push({\\n            col_type: \\\"big_blank_block\\\"\\n        });\\n    //线路列表\\n    let flag = getVar(\\\"now\\\", \\\"\\\");\\n    if (flag == \\\"\\\") {\\n        flag = tabs[0];\\n        putVar(\\\"now\\\", tabs[0]);\\n    }\\n    let index = tabs.indexOf(flag);\\n    for (let i in tabs) {\\n        d.push({\\n            title: flag == tabs[i] ? \\\"““””\\\" + tabs[i].bold().fontcolor(\\\"#FA7298\\\") : tabs[i],\\n            url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('now','\\\" + tabs[i] + \\\"');refreshPage(false);'toast://切换成功!'\\\",\\n            col_type: 'scroll_button'\\n        })\\n    }\\n    //视频列表\\n    let list = [];\\n    if (/dd flag/.test(conts[index])) {\\n        list = conts[index].match(/.*\\\\[(.*?)\\\\]/)[1].split('#');\\n    } else if (/\\\\r/.test(conts[index])) {\\n        list = conts[index].split(\\\"\\\\r\\\");\\n    } else {\\n        list = conts[index].split(\\\"#\\\");\\n    }\\n\\n    if (getVar('zywlsort', '1') != '1') {\\n        list = list.reverse();\\n    }\\n\\n    if (list != null) {\\n        var url = {};\\n        for (var j = 0; j < list.length; j++) {\\n            if (list[j].split('$')[1] != null) {\\n                url = list[j].split('$')[1];\\n            } else {\\n                url = list[j].split('$')[0];\\n            }\\n            d.push({\\n                title: list[j].split('$')[0].indexOf('http') != -1 ? [j + 1] : list[j].split('$')[0],\\n                url: $('hiker://empty##' + flag + '##' + url.replace(/\\\\n*/g, '')).lazyRule(() => {\\n                    var flag = input.split('##')[1];\\n                    var link = (input.split('##')[2]).replace(/amp;/g, \\\"\\\").replace(/^\\\\s*/, \\\"\\\");\\n                    let realUrl = link.split('\\\"')[0];\\n                    log(\\\"资源链接:\\\" + realUrl);\\n\\n                    function changeVideoUrl(url) {\\n                        //改变特定地址的Referer\\n                        if (url.includes(\\\"wkfile\\\")) {\\n                            url = url + ';{Referer@https://fantuan.wkfile.com/}';\\n                        } else if (flag == 'bilibili') {\\n                            url = url + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\n                        } else if (flag == 'mgtv') {\\n                            url = url + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                        }\\n                        //返回视频链接\\n                        if (/\\\\.m3u8/.test(url)) {\\n                            return cacheM3u8(url);\\n                        } else {\\n                            return url + '#isVideo=true#';\\n                        }\\n\\n                    }\\n                    let parsemode = getMyVar(\\\"parsemode\\\", \\\"智能识别链接\\\");\\n                    if (parsemode == \\\"智能识别链接\\\") {\\n                        if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(realUrl) && /http/.test(realUrl) && !/\\\\.html/.test(realUrl)) {\\n                            if (!/fen\\\\.laodi|ruifenglb|suoyo\\\\.cc/.test(realUrl)) {\\n                                log(\\\"检测到资源地址可能是视频链接\\\");\\n                                return changeVideoUrl(realUrl);\\n                            }\\n                        }\\n                        let test1 = /youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/.test(realUrl),\\n                             test2 = /LT\\\\-|RongXingVR\\\\-|renrenmi\\\\-|xfy\\\\-|suoyo\\\\.cc|fen\\\\.laodi|xueren\\\\-|canglan-/.test(realUrl);\\n                        if(test1 || test2){\\n                            log('调用断插解析');\\n                            eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                            eval(fetch(config.cj));\\n                            return aytmParse(realUrl);\\n                        }\\n                        return 'toast://未能识别的资源链接';\\n                    } else if (parsemode == \\\"强制断插解析\\\") {\\n                        log('调用断插解析');\\n                        eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                        eval(fetch(config.cj));\\n                        return aytmParse(realUrl);\\n                    }else if (parsemode == \\\"强制内置解析\\\") {\\n                        //return $('hiker://empty').lazyRule((realUrl) => {\\n                            log(\\\"使用内置解析\\\");\\n                            eval(JSON.parse(fetch('hiker://page/myParse')).rule);\\n                            return myParse(realUrl);\\n                        //}, realUrl);\\n                    } else if (parsemode == \\\"强制直链打开\\\") {\\n                        return changeVideoUrl(realUrl);\\n                    } else if (parsemode == \\\"强制网页打开\\\") {\\n                        return \\\"web://\\\" + realUrl;\\n                    }\\n                }),\\n                col_type: \\\"text_4\\\"\\n            });\\n        }\\n    }\\n    setResult(d);\\n};\\n//搜索规则\\nfunction searchFind() {\\n    let d = [];\\n    var  html = request(appUrl + \\\"?ac=list&page=\\\" + MY_PAGE + \\\"&wd=\\\" + getParam(\\\"wd\\\"));\\n    if (/list_name/.test(html)) {\\n        var list = JSON.parse(html).data;\\n    } else if (/vod_name/.test(html)) {\\n        var list = JSON.parse(html).list;\\n    } else {\\n        var list = parseDomForArray(html, 'rss&&video');\\n    }\\n    for (var j = 0; j < list.length; j++) {\\n        if (/vod_name/.test(html)) {\\n            var title = list[j].vod_name;\\n            var ids = list[j].vod_id;\\n            var note = /vod_remarks/.test(html) ? list[j].vod_remarks : list[j].vod_total;\\n            var last = /vod_addtime/.test(html) ? list[j].vod_addtime : list[j].vod_time;\\n            var typ = list[j].type_name;\\n            var dt = list[j].vod_play_from;\\n        } else {\\n            var title = parseDomForHtml(list[j], 'body&&name&&Text');\\n            var ids = parseDomForHtml(list[j], 'body&&id&&Text');\\n            var note = parseDomForHtml(list[j], 'body&&note&&Text');\\n            var last = parseDomForHtml(list[j], \\\"body&&last&&Text\\\");\\n            var typ = parseDomForHtml(list[j], 'body&&type&&Text');\\n            var dt = parseDomForHtml(list[j], 'body&&dt&&Text');\\n        }\\n        d.push({\\n            title: title + (note ? ' • ' + note : ''),\\n            desc: last + ' ·  ' + typ + ' ·  ' + dt,\\n            url: $('#immersiveTheme#hiker://empty?appUrl=' + appUrl + '&href=' +base64Encode(appUrl + \\\"?ac=videolist&ids=\\\" + ids )).rule(() => {\\n                try {\\n                    eval(JSON.parse(fetch(\\\"hiker://page/creator2\\\")).rule);\\n                    detail_rule();\\n                } catch (e) {\\n                    setResult([]);\\n                    log(\\\"资源详情出错:\\\" + e.message);\\n                }\\n            }),\\n            col_type: 'text_center_1'\\n        });\\n    }\\n    setResult(d);\\n};\\n//最新章节规则\\nfunction last_chapter_rule() {\\n    var chp = [];\\n    var html = request(base64Decode(getParam('href')));\\n    if (/vod_play_from/.test(html)) {\\n        var jhtml = JSON.parse(html);\\n        if (/list_name/.test(html)) {\\n            var conts = jhtml.data[0].vod_play_url.split('$$$');\\n        } else {\\n            var conts = jhtml.list[0].vod_play_url.split('$$$');\\n        }\\n    } else {\\n        var conts = parseDomForArray(html, 'rss&&dl&&dd');\\n    };\\n    for (var j = 0; j < conts.length; j++) {\\n        if (/dd flag/.test(conts)) {\\n            var list = conts[j].match(/.*\\\\[(.*?)\\\\]/)[1].split('#');\\n        } else if (/\\\\r/.test(conts)) {\\n            var list = conts[j].split(\\\"\\\\r\\\");\\n        } else {\\n            var list = conts[j].split(\\\"#\\\");\\n        }\\n        chp.push(list.length);\\n    }\\n    setResult('更新至:' + (Math.max.apply(Math, chp)));\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"内置解析\",\"path\":\"myParse\",\"rule\":\"js:\\nfunction myParse(vlink) {\\n    function changeVideoUrl(url) {\\n        //改变特定地址的Referer\\n        if (url.includes(\\\"wkfile\\\")) {\\n            url = url + ';{Referer@https://fantuan.wkfile.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    try {\\n        if (vlink.includes('m3u8.cache.suoyo.cc')) {\\n            let data = request(\\\"https://hls.json.shenglinyiyang.cn/api.php?url=\\\" + vlink, {\\n                headers: {\\n                    \\\"User-Agent\\\": \\\"Android\\\"\\n                }\\n            });\\n            return changeVideoUrl(JSON.parse(data).url);\\n        } else if (vlink.includes('canglan')) {\\n            let scode = JSON.parse(fetch(\\\"http://jx.yjhan.com:8090/home/api?type=app&uid=243669&key=adnqrtwyFJLOW02679&url=\\\" + vlink, {\\n                headers: {\\n                    \\\"User-Agent\\\": MOBILE_UA\\n                },\\n                redirect: false,\\n                withStatusCode: true\\n            }));\\n            let url = scode.headers.location[0].replace(/\\\\\\\\/g, \\\"\\\");\\n            return changeVideoUrl(url);\\n        } else if (vlink.includes(\\\"netflixmom-\\\")) {\\n            let html = fetch('https://player.4kya.com/?url=' + vlink, {\\n                    headers: {\\n                        referer: 'https://netflix.mom'\\n                    }\\n                }),\\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 (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    } catch (e) {\\n        return 'toast://无法解析出视频'\\n    }\\n}\"}]","icon":"https://lanmeiguojiang.com/tubiao/q/52.png","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
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!