API tools faq
paste
xiaomianao666

小程序：DrpyHiker

xiaomianao666
Jul 9th, 2024
162
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 202.35 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@DrpyHiker@{"firstHeader":"class","last_chapter_rule":"","title":"DrpyHiker","author":"@LoyDgIk&zetalpha","url":"hiker://empty##fypage","version":19,"col_type":"movie_3","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:$.require(\"MianLoad\");","search_url":"hiker://empty?s=**&page=fypage","group":"开发中心","searchFind":"js:\n(function() {\n    let smode = Number(getItem(\"smode\", \"0\"));\n    let temsmode = getMyVar(\"temsmode\", \"\");\n    if (temsmode) {\n        smode = Number(temsmode);\n        clearMyVar(\"temsmode\");\n    }\n    if (!fileExist(\"hiker://files/data/\" + MY_RULE.title + \"/libs_hiker/drpy2.js\")) return setResult([{\n        title: \"请前往小程序主页设置drpyPath\",\n        url: \"hiker://home@\" + MY_RULE.title\n    }]);\n    let runtimeConfig = GM.defineModule(\"runtimeConfig\");\n    let DrpyManage = GM.defineModule(\"DrpyManage\");\n    if (!runtimeConfig.isPrepared()) return setResult([{\n        title: \"请前往小程序主页设置源\",\n        url: \"hiker://home@\" + MY_RULE.title\n    }]);\n\n    if (smode === 0) {\n        let source = runtimeConfig.getCurrentSource();\n        if (!source.searchable) return setResult([{\n            title: \"当前源不支持搜索\",\n            url: \"hiker://empty\"\n        }]);\n        let drpy = DrpyManage.get(source.key);\n        \n        let homeList = []\n        try {\n            homeList = JSON.parse(drpy.search(MY_KEYWORD, false, MY_PAGE)).list || [];\n        } catch {}\n        let d = [];\n        for (let it of homeList) {\n            d.push({\n                title: it.vod_name,\n                desc: it.vod_remarks + \"·\" + source.name,\n                content: it.vod_content,\n                url: \"hiker://page/detailed#immersiveTheme#\",\n                pic_url: it.vod_pic,\n                col_type: \"movie_3\",\n                extra: {\n                    vodId: it.vod_id,\n                    img: it.vod_pic,\n                    sname: source.name,\n                    skey: source.key\n                }\n            });\n        }\n        setResult(d);\n    } else {\n        setResult([{\n            title: \"点我开始聚合搜索\" + MY_KEYWORD,\n            url: \"hiker://search?s=\" + MY_KEYWORD,\n            extra: {\n                delegateOnlySearch: true,\n                rules: $.toString(() => {\n                    try {\n                        let runtimeConfig = GM.defineModule(\"runtimeConfig\", \"runtimeConfig\");\n                        let list = runtimeConfig.getAllowSearchSource();\n\n                        let source = runtimeConfig.getCurrentSource();\n\n                        let listi = list.findIndex(x => x.key == source.key);\n\n                        if (source.searchable && listi != -1) {\n                            list.splice(list.indexOf(source), 1);\n                            list.unshift(source);\n                        }\n\n                        let rules = [];\n                        for (let it of list) {\n                            rules.push({\n                                title: it.name,\n                                search_url: \"hiker://empty?page=fypage&searchTerms=**\",\n                                searchFind: \"js:\" + $.toString((item) => {\n                                    let drpy = GM.defineModule(\"DrpyManage\").get(item.key);\n\n                                    let homeList = JSON.parse(drpy.search(MY_KEYWORD, false, MY_PAGE)).list || [];\n                                    let d = [];\n                                    for (let it of homeList) {\n                                        d.push({\n                                            title: it.vod_name,\n                                            desc: it.vod_remarks,\n                                            content: it.vod_content,\n                                            url: \"hiker://page/detailed#immersiveTheme#\",\n                                            pic_url: it.vod_pic,\n                                            col_type: \"movie_3\",\n                                            extra: {\n                                                vodId: it.vod_id,\n                                                isPolymerize: true,\n                                                img: it.vod_pic,\n                                                sname: item.name,\n                                                skey: item.key,\n                                            }\n                                        });\n                                    }\n                                    setResult(d);\n                                }, it)\n                            });\n                        }\n                        return JSON.stringify(rules);\n                    } catch (e) {\n                        log(e.toString());\n                    }\n                })\n            }\n        }]);\n    }\n})()","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"/*<$>\n@include start\nhttp://hiker.nokia.press/hikerule/rulelist.json?id=6916&auth=1d35e8f0-22e8-5270-a9d1-826f53f177ad\n@include end\n<$>*/\n","pages":"[{\"col_type\":\"movie_3\",\"name\":\"drpy\",\"path\":\"drpy\",\"rule\":\"const skey = module.importParam;\\n\\nfunction initHiker() {\\n    const isCloseLog = !getItem(\\\"useLog\\\", \\\"\\\");\\n    const localKey = \\\"drpy\\\";\\n    const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n    globalThis.local = {\\n        set(rulekey, k, v) {\\n            storage0.setItem(localKey + \\\"@\\\" + rulekey + \\\"@\\\" + k, v);\\n        },\\n        get(rulekey, k, v) {\\n            return storage0.getItem(localKey + \\\"@\\\" + rulekey + \\\"@\\\" + k, \\\"\\\") || v;\\n        },\\n        delete(rulekey, k) {\\n            storage0.clearItem(localKey + \\\"@\\\" + rulekey + \\\"@\\\" + k);\\n        }\\n    };\\n    globalThis.getProxy = function() {\\n        return getMyVar(\\\"Proxy_Url\\\", \\\"http://127.0.0.1:52020/proxy\\\") + \\\"?hikerSkey=\\\" + encodeURIComponent(skey) + \\\"&do=js\\\";\\n    }\\n    eval(getCryptoJS());\\n    globalThis.CryptoJS = CryptoJS;\\n\\n    let $request = request;\\n    let $post = post;\\n    globalThis.req = function(url, cobj) {\\n        try {\\n            let res = {};\\n            let obj = Object.assign({}, cobj);\\n            if (obj.data) {\\n                obj.body = obj.data;\\n                delete obj.data;\\n            }\\n\\n            if (obj.hasOwnProperty(\\\"redirect\\\")) obj.redirect = !!obj.redirect;\\n            if (obj.buffer === 2) {\\n                obj.toHex = true;\\n            }\\n            obj.headers = Object.assign({\\n                Cookie: \\\"#noCookie#\\\"\\n            }, obj.headers);\\n            if (url === \\\"https://api.nn.ci/ocr/b64/text\\\" && obj.headers) {\\n                obj.headers[\\\"Content-Type\\\"] = \\\"text/plain\\\";\\n            }\\n\\n            if (url.startsWith(\\\"file://\\\") && (url.includes(\\\"?type=\\\") || url.includes(\\\"?params=\\\"))) {\\n                url = url.slice(0, url.lastIndexOf(\\\"?\\\"));\\n            }\\n            for (let key in obj.headers) {\\n                if (typeof obj.headers[key] !== \\\"string\\\") {\\n                    obj.headers[key] = String(obj.headers[key]);\\n                }\\n            }\\n            let r = \\\"\\\";\\n            /* if (String(obj.method).toLowerCase() === \\\"post\\\") {\\n                 r = $post(url, obj);\\n             } else {\\n                 r = $request(url, obj);\\n             }*/\\n            r = $request(url, obj);\\n            if (obj.withHeaders) {\\n                r = JSON.parse(r);\\n                res.content = r.body;\\n                res.headers = {};\\n                for (let [k, v] of Object.entries(r.headers || {})) {\\n                    res.headers[k] = v[0];\\n                }\\n            } else {\\n                res.content = r;\\n            }\\n            if (obj.buffer === 2) {\\n                res.content = CryptoUtil.Data.parseHex(res.content).toBase64(_base64.NO_WRAP);\\n            }\\n            return res;\\n        } catch (e) {\\n            log(\\\"Error\\\" + e.toString());\\n        }\\n    }\\n    /*\\n    const JinJa = $.require(\\\"https://cdn.bootcdn.net/ajax/libs/mustache.js/4.1.0/mustache.js\\\");\\n  \\n    const JP = $.require(\\\"https://jsonpath-plus.github.io/JSONPath/dist/index-browser-umd.cjs\\\");\\n    globalThis.cheerio = {\\n        jinja2(template, obj) {\\n            \\n            return $.log(JinJa.render(template, obj));\\n        },\\n        jp(path, json) {\\n            return JP.JSONPath({\\n                path,\\n                json\\n            })[0];\\n        }\\n    }*/\\n    globalThis.pdfa = _pdfa;\\n    globalThis.pd = _pd;\\n    globalThis.pdfh = _pdfh;\\n    String.prototype.replaceAll = function(search, replacement) {\\n        return this.split(search).join(replacement);\\n    };\\n    let $toString = Function.prototype.toString;\\n    Function.prototype.toString = function() {\\n        return $toString.apply(this).trim();\\n    };\\n    if (isCloseLog) {\\n        // 重写console.log函数\\n        console.log = function() {\\n            // 检查传入参数的数量\\n            if (arguments.length > 1) {\\n                // 如果参数数量大于1，调用原始的console.log函数\\n                //originalLog.apply(console, arguments);\\n            } else {\\n                return;\\n            }\\n            // 如果参数只有一个，则不做任何操作\\n        };\\n    }\\n}\\ninitHiker();\\nconst drpyPath = getPath(\\\"hiker://files/data/\\\" + MY_RULE.title + \\\"/libs_hiker/drpy2.js\\\");\\n\\nif (!fileExist(drpyPath)) {\\n    throw new Error(\\\"缺少drpy.js运行库\\\");\\n}\\nlet drpy = $.require(drpyPath);\\n/*\\nlet currentPath = \\\"\\\";\\nlet $init = drpy.init;\\ndrpy.init = function(ext) {\\n    if (ext === currentPath) return;\\n    $init.call(this, ext);\\n    currentPath = ext;\\n}*/\\nfunction sync(func, sp) {\\n    return new org.mozilla.javascript.Synchronizer(func, sp || {});\\n}\\n//drpy.proxy = sync(drpy.proxy, drpy);\\n$.exports = drpy;\"},{\"col_type\":\"movie_1_vertical_pic_blur\",\"name\":\"详细页面\",\"path\":\"detailed\",\"rule\":\"js:\\n(function() {\\n    let id = MY_PARAMS.vodId;\\n    addListener(\\\"onClose\\\", () => {\\n        GM.clear(\\\"renovateList\\\");\\n        clearMyVar(\\\"sorti\\\");\\n        clearMyVar(\\\"pagenum\\\");\\n    });\\n    addListener('onRefresh', $.toString((id) => {\\n        //clearMyVar(id + \\\"erinfo\\\")\\n    }, id))\\n\\n    //方法\\n    function fontstyle(text, params) {\\n        params = params || undefined;\\n        var h = params.h !== false ? '““””' : '';\\n        var tags = params.tags || \\\"\\\";\\n        if (params.c != undefined) {\\n            text = text.fontcolor(params.c);\\n        }\\n        if (tags) {\\n            var tagArray = tags.split('|').filter(e => e);\\n            var openTags = '';\\n            var closeTags = '';\\n            for (var i = 0; i < tagArray.length; i++) {\\n                openTags += '<' + tagArray[i] + '>';\\n                closeTags = '</' + tagArray[i] + '>' + closeTags;\\n            }\\n            text = openTags + text + closeTags;\\n        }\\n        return h + text;\\n    }\\n\\n    function findLongestElement(arr) {\\n        return arr.reduce((a, b) => a.length > b.length ? a : b);\\n    }\\n\\n    function countTotalBytes(text) {\\n        var count = 0;\\n        for (var i = 0; i < text.length; i++) {\\n            var code = text.charCodeAt(i);\\n            if (code >= 0x0100) { // 双字节字符的 Unicode 编码大于 255\\n                count += 2; // 双字节字符计数为2\\n            } else {\\n                count += 1; // 单字节字符计数为1\\n            }\\n        }\\n        return count;\\n    }\\n\\n    function cacheShowTips() {\\n        /*if (storage0.getMyVar(id + \\\"erinfo\\\")) {\\n            d.push({\\n                title: fontstyle(\\\"当前为缓存,点我刷新\\\", {\\n                    c: \\\"grey\\\",\\n                    tags: \\\"small\\\"\\n                }),\\n                col_type: \\\"text_center_1\\\",\\n                url: $('#noLoading#').lazyRule((id) => {\\n                    clearMyVar(id + \\\"erinfo\\\")\\n                    refreshPage(false);\\n                    return \\\"hiker://empty\\\";\\n                }, id),\\n                extra: {\\n                    lineVisible: false\\n                }\\n            })\\n        }*/\\n    }\\n\\n    function substr(str, maxLength) {\\n        let len = 0;\\n        for (let i = 0; i < str.length; i++) {\\n            if (str.charCodeAt(i) > 255) {\\n                len += 2;\\n            } else {\\n                len++;\\n            }\\n            if (len > maxLength) {\\n                return str.slice(0, i) + '...';\\n            }\\n        }\\n        return str;\\n    }\\n\\n    function setDesc(desc, num) {\\n        if (desc == undefined) {\\n            return;\\n        }\\n        desc = desc.constructor == Array ? desc.join('<br>') : desc;\\n        if (desc.replace(/(<br>|\\\\s+)/g, '').length == 0) {\\n            d.push({\\n                col_type: 'big_blank_block'\\n            })\\n            d.push({\\n                col_type: 'big_blank_block'\\n            })\\n            return;\\n        }\\n\\n        const mark = 'desc';\\n        num = typeof(num) == 'undefined' ? 100 : num\\n        desc = desc.startsWith('　　') ? desc : '　　' + desc;\\n        desc = desc.replace(/'/g, \\\"&#39;\\\");\\n        desc = desc.replace(/\\\\r\\\\n/g, \\\"<br>\\\");\\n        desc = desc.replace(/\\\\n/g, \\\"<br>\\\");\\n        let sdesc = substr(desc, num);\\n\\n        var colors = {\\n            show: \\\"black\\\",\\n            hide: \\\"grey\\\"\\n        }\\n\\n        var lazy = $(`#noLoading#`).lazyRule((dc, sdc, m, cs) => {\\n            var show = storage0.getItem(m, '0');\\n            var title = findItem('desc').title;\\n            var re = /(<\\\\/small><br>.*?>).+/g;\\n            var exp = '展开:';\\n            var ret = '收起:';\\n            if (show == '1') {\\n                updateItem('desc', {\\n                    title: title\\n                        .replace(ret, exp)\\n                        .replace(re, '$1' + sdc + '</small>')\\n                        .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.hide + '$2')\\n\\n                })\\n                storage0.setItem(m, '0');\\n            } else {\\n                updateItem('desc', {\\n                    title: title\\n                        .replace(exp, ret)\\n                        .replace(re, '$1' + dc + '</small>')\\n                        .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.show + '$2')\\n                })\\n                storage0.setItem(m, '1');\\n            }\\n            return `hiker://empty`\\n        }, desc, sdesc, mark, colors)\\n        var sc = storage0.getItem(mark, '0') == '0' ? '展开:' : '收起:';\\n        var dc = storage0.getItem(mark, '0') == '0' ? sdesc : desc;\\n        var cs = storage0.getItem(mark, '0') == '0' ? colors.hide : colors.show;\\n        d.push({\\n            title: '' + '<b><font color=\\\"#098AC1\\\">∷剧情简介\\t</font></b>' + \\\"<small><a style='text-decoration: none;' href='\\\" + lazy + \\\"'>\\\" + sc + '</a></small><br><font color=\\\"' + cs + '\\\">' + `${dc}` + '</small>',\\n            col_type: 'rich_text',\\n            extra: {\\n                id: 'desc',\\n                lineSpacing: 6,\\n                textSize: 15,\\n                lineVisible: true,\\n            }\\n        })\\n    }\\n\\n    Object.defineProperty(String.prototype, 'Split', {\\n        value: function(s, e) {\\n            if (e) {\\n                return this.split(s).filter(item => item !== '');\\n            } else {\\n                return this.split(s);\\n            }\\n        },\\n        enumerable: false,\\n    });\\n\\n    Object.defineProperties(Array.prototype, {\\n        excludeKeys: {\\n            value: function(keys, exclude, renameCallback) {\\n                // 确定是排除还是只保留键\\n                const shouldExclude = typeof exclude === 'boolean' ? exclude : true;\\n                const keysToHandle = Array.isArray(keys) ? keys : [];\\n\\n                // 使用Array.prototype.map遍历数组中的每个元素\\n                return this.map(item => {\\n                    // 如果元素是一个数组，递归调用excludeKeys\\n                    if (Array.isArray(item)) {\\n                        return item.excludeKeys(exclude, keys, renameCallback);\\n                    } else if (typeof item === 'object' && item !== null) {\\n                        // 如果元素是一个对象，使用Object.fromEntries和Object.entries来处理键\\n                        const entries = Object.entries(item);\\n                        const processedEntries = entries.map(([key, value]) => {\\n                            // 如果有重命名回调函数，则调用它\\n                            if (typeof renameCallback === 'function') {\\n                                return [renameCallback(key, value), value];\\n                            }\\n                            return [key, value];\\n                        });\\n                        const filteredEntries = shouldExclude ?\\n                            processedEntries.filter(([key]) => !keysToHandle.includes(key)) :\\n                            processedEntries.filter(([key]) => keysToHandle.includes(key));\\n                        return Object.fromEntries(filteredEntries);\\n                    } else {\\n                        // 如果元素不是对象或数组，直接返回\\n                        return item;\\n                    }\\n                });\\n            },\\n            enumerable: false, // 设置为不可枚举\\n        },\\n        transformKeys: {\\n            value: function(keyMapping) {\\n                // 使用Array.prototype.map遍历数组中的每个元素\\n                return this.map(item => {\\n                    // 如果元素是一个数组，递归调用transformKeys\\n                    if (Array.isArray(item)) {\\n                        return item.transformKeys(keyMapping);\\n                    } else if (typeof item === 'object' && item !== null) {\\n                        // 如果元素是一个对象，使用Object.fromEntries和Object.entries来处理键\\n                        const entries = Object.entries(item);\\n                        const transformedEntries = entries.map(([key, value]) => {\\n                            const newKey = keyMapping[key] || key; // 如果键在映射中，使用新键；否则使用原始键\\n                            return [newKey, value];\\n                        });\\n                        return Object.fromEntries(transformedEntries);\\n                    } else {\\n                        // 如果元素不是对象或数组，直接返回\\n                        return item;\\n                    }\\n                });\\n            },\\n            enumerable: false, // 设置为不可枚举\\n        }\\n    });\\n\\n    let sortobj = [\\n        fontstyle(\\\"正序\\\", {\\n            c: \\\"#1AAD19\\\",\\n            tags: \\\"b\\\"\\n        }),\\n        fontstyle(\\\"逆序\\\", {\\n            c: \\\"#FF0000\\\",\\n            tags: \\\"b\\\"\\n        })\\n    ]\\n    //方法\\n\\n    var sorti = getMyVar(\\\"sorti\\\", \\\"0\\\");\\n\\n    //log(sortobj)\\n    $.extend({\\n        splitPage(totalItems, pageSize) {\\n            pageSize = pageSize || 50;\\n            let result = [];\\n            for (let i = 1; i <= totalItems; i += pageSize) {\\n                let end = i + pageSize - 1;\\n                if (end > totalItems) {\\n                    end = totalItems;\\n                }\\n                result.push(`${i}-${end}`);\\n            }\\n            return result;\\n        },\\n        splitArrayByRanges(array, ranges) {\\n            // 根据范围拆分数组\\n            var result = ranges.map(function(range) {\\n                var parts = range.split('-').map(Number);\\n                var start = parts[0] - 1; // 减1是因为数组索引从0开始\\n                var end = parts[1] - 1;\\n                // 使用Array.prototype.slice来获取子数组\\n                return array.slice(start, end + 1); // 包括结束索引，所以加1\\n            });\\n            return result;\\n        },\\n    })\\n\\n    let source = {};\\n    if (MY_PARAMS.source) {\\n        source = MY_PARAMS.source;\\n    } else {\\n        const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n        source = runtimeConfig.findSource(MY_PARAMS.skey);\\n        MY_PARAMS.source = source;\\n        setPageParams(MY_PARAMS);\\n    }\\n\\n    const DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n\\n    DrpyManage.initPage(\\\"er\\\");\\n\\n    let drpy = DrpyManage.getBySource(source);\\n    let stype = drpy.getRule(\\\"类型\\\");\\n/*\\n    let info = storage0.getMyVar(id + \\\"erinfo\\\", \\\"\\\");\\n\\n    if (info == \\\"\\\") {\\n        info = JSON.parse(drpy.detail(String(id))).list[0];\\n        storage0.putMyVar(id + \\\"erinfo\\\", info)\\n    }\\n*/\\n    let info = JSON.parse(drpy.detail(String(id))).list[0];\\n    let [导演, 主演] = [info.vod_director, info.vod_actor]\\n\\n    if (导演 != undefined && 导演 != \\\"\\\") {\\n        导演 = 导演.Split(/\\\\//g, true).join(\\\" \\\");\\n        导演 = /[:：]/.test(导演) ? 导演 : \\\"导演:\\\" + 导演\\n    }\\n    if (主演 != undefined && 主演 != \\\"\\\") {\\n        主演 = 主演.Split(/\\\\//g, true).join(\\\" \\\");\\n        主演 = /[:：]/.test(主演) ? 主演 : \\\"主演:\\\" + 主演\\n    }\\n    let [名称, 备注] = [info.vod_name, info.vod_remarks]\\n    if (备注 != undefined && 备注 != \\\"\\\") {\\n        备注 = 备注.Split(/\\\\//g, true).join(\\\" \\\");\\n        备注 = /[:：]/.test(备注) ? 备注 : \\\"备注:\\\" + 备注;\\n    }\\n    let titles = [名称, 备注];\\n    let descs = [导演, 主演, info.vod_area, info.vod_year]\\n\\n    let d = [];\\n    d.push({\\n        title: titles.filter(e => e).map((x, i) => i == 1 ? fontstyle(x, {\\n            tags: \\\"small\\\"\\n        }) : x).join(\\\"\\\\n\\\"),\\n        desc: descs.filter(e => e).join(\\\"\\\\n\\\"),\\n        url: \\\"hiker://empty\\\",\\n        pic_url: info.vod_pic || MY_PARAMS.img,\\n        extra: {\\n            gradient: false,\\n        }\\n    });\\n    d.push({\\n        title: '数据来源:' + MY_PARAMS.sname,\\n        //desc:\\\"\\\"+MY_PARAMS.skey+\\\"\\\\t\\\",\\n        img: \\\"https://hikerfans.com/tubiao/messy/78.svg\\\",\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"avatar\\\"\\n    })\\n    setDesc(info.vod_content)\\n\\n    /*\\n    function parseQuery(query) {\\n      var obj = {};\\n      query.split(\\\"&\\\").filter(e => e).forEach(function (item) {\\n        var parts = item.split(\\\"=\\\");\\n        obj[parts[0]] = parts[1];\\n      });\\n      return obj;\\n    }\\n\\n    //js执行\\n    let parse_obj = {\\n      defRules: [\\\"*.mp4\\\", \\\"*.m3u8\\\"],\\n    };\\n    var extra = {\\n      \\\"ua\\\": MOBILE_UA\\n    }\\n    let parse = JSON.parse(drpy.play());\\n    //console.log(parse);\\n    if (parse.hasOwnProperty(\\\"parse_extra\\\")) {\\n      let parse_extra = decodeURIComponent(parse.parse_extra);\\n      parse_obj = Object.assign(parse_obj, parseQuery(parse_extra));\\n      if (parse_obj.hasOwnProperty(\\\"init_script\\\")) {\\n        parse_obj[\\\"init_script\\\"] = base64Decode(parse_obj[\\\"init_script\\\"]);\\n      }\\n    }\\n    if (parse_obj.hasOwnProperty(\\\"is_pc\\\") && parse_obj[\\\"is_pc\\\"] == \\\"1\\\") {\\n      extra[\\\"ua\\\"] = PC_UA;\\n    }\\n    if (parse.hasOwnProperty(\\\"header\\\")) {\\n      extra[\\\"ua\\\"] = parse[\\\"header\\\"][\\\"User-Agent\\\"];\\n      //extra[\\\"redirect\\\"]=false;\\n      extra[\\\"js\\\"] = $.toString((js) => {\\n        eval(js)\\n        fba.log(navigator.userAgent)\\n        fba.log(location.href)\\n      }, $.toString(() => {\\n        Object.defineProperty(navigator, 'userAgent', {\\n          get: function () {\\n            return 'My-Custom-UA-String';\\n          }\\n        });\\n      }))\\n    }\\n    if (parse_obj.hasOwnProperty(\\\"custom_regex\\\")) {\\n      let current = parse_obj[\\\"defRules\\\"];\\n      extra[\\\"videoRules\\\"] = current.concat(parse_obj.custom_regex.split(/\\\\|/g).filter(e => e))\\n    }\\n    if (parse.hasOwnProperty(\\\"js\\\")) {\\n      extra[\\\"js\\\"] = $.toString((js, parse, t) => {\\n        if (parse.hasOwnProperty(\\\"init_script\\\")) {\\n          fba.log(t + \\\":执行init_script\\\");\\n          eval(parse.init_script);\\n        }\\n        fba.log(navigator.platform);\\n        fba.log(t + \\\":执行js点击\\\")\\n        eval(js)\\n      }, parse.js, parse_obj, MY_RULE.title)\\n    }\\n    //log(extra)\\n    */\\n    let from = [];\\n    if (info.vod_play_from != undefined) {\\n        from = info.vod_play_from.split(\\\"$$$\\\");\\n        /*let playLazy = $(\\\"\\\").lazyRule(() => {\\n          function isofficial(url) {\\n            let flag = new RegExp('qq\\\\.com|iqiyi\\\\.com|youku\\\\.com|mgtv\\\\.com|bilibili\\\\.com|sohu\\\\.com|ixigua\\\\.com|pptv\\\\.com|miguvideo\\\\.com|le\\\\.com|1905\\\\.com|fun\\\\.tv');\\n            return flag.test(url);\\n          }\\n\\n          let drpy = GM.defineModule(\\\"drpy\\\", \\\"drpy\\\");\\n          input = input.split(\\\"#\\\");\\n          let play = JSON.parse(drpy.play(input[1], input[0].replace(\\\"tvbox-xg:\\\", \\\"\\\"), []));\\n          log(play)\\n          log(\\\"play.url\\\")\\n          let parse_obj = {\\n            def_regex: String.raw`\\\\.(mp4|m3u8)|cn/tos`,\\n          };\\n\\n          if (play.url.includes(\\\"proxy?do\\\")) {\\n            MY_URL = play.url;\\n            play.url = decodeURIComponent(getParam(\\\"url\\\", \\\"\\\"));\\n          }\\n          if (play.url.startsWith(\\\"https://pan.quark.cn/\\\")) {\\n            return \\\"hiker://search?s=\\\" + play.url + \\\"&rule=uckk云\\\"\\n          }\\n          if (play.url.startsWith('https://www.aliyundrive.com/s/') || play.url.startsWith(\\\"https://www.alipan.com/s/\\\")) {\\n            return \\\"hiker://page/aliyun?rule=云盘君.简&page=fypage&realurl=\\\" + encodeURIComponent(play.url);\\n          }\\n          if (play.parse === 1) {\\n            if (play.url.startsWith(\\\"magnet:\\\")) {\\n              return play.url;\\n            }\\n            if (isofficial(play.url)) {\\n              return $.require(\\\"hiker://page/mulParse?rule=配置助手\\\").mulParse(play.url);\\n            }\\n            return \\\"video://\\\" + play.url;\\n          } else if (play.parse === 0) {\\n            return play.url;\\n          }\\n        });*/\\n    }\\n\\n    let playLazy = $(\\\"\\\").lazyRule((id, source) => {\\n        return $.require(\\\"videoUrl\\\").parse(input, id, source);\\n    }, \\\"id\\\", source);\\n\\n\\n\\n    let playUrlList = [];\\n    //console.log(info.vod_play_url);\\n    let isNovel=stype===\\\"小说\\\";\\n    let playpages = [];\\n    if (info.vod_play_url && info.vod_play_url != \\\"\\\") {\\n        let col = \\\"text_4\\\";\\n        let textalign = \\\"\\\";\\n        playUrlList = info.vod_play_url.split(\\\"$$$\\\").map((t, i) => {\\n            let img = \\\"\\\";\\n            let ts = t.split(\\\"#\\\").map((k) => k.split(\\\"$\\\")[0]);\\n            let pages = $.splitPage(ts.length)\\n            let tc = countTotalBytes(findLongestElement(ts));\\n            if (ts.filter(e => e != \\\"\\\").length) {\\n                playpages[i] = pages;\\n            }\\n            if (tc > 24) {\\n                col = \\\"text_1\\\";\\n                img = \\\"https://hikerfans.com/tubiao/movie/146.svg\\\";\\n            } else if (tc >= 12 && tc < 15) {\\n                col = \\\"text_3\\\";\\n            } else if (tc >= 15) {\\n                col = \\\"text_2\\\";\\n                textalign = \\\"left\\\";\\n            }\\n            let playobj = t.split(\\\"#\\\").map((j) => {\\n                let k = j.split(\\\"$\\\");\\n                let t = k[0];\\n                let uid = (k[1] || k[0]);\\n                return {\\n                    stitle: t,\\n                    title: fontstyle(t, {\\n                        tags: \\\"small\\\"\\n                    }),\\n                    surl: uid + \\\"#\\\" + from[i],\\n                    url: isNovel?\\\"hiker://page/novel#autoPage##readTheme#\\\":(uid + \\\"#\\\" + from[i] + playLazy.replace('\\\"id\\\"', '\\\"' + uid + '\\\"')),\\n                    col_type: col,\\n                    img: img,\\n                    /*extra: Object.assign({}, extra, {\\n                      \\\"Referer\\\": decodeURIComponent(k[1]),\\n                      id: k[1],\\n                      //lineVisible: false,\\n                      textAlign: textalign,\\n                      cls: \\\"playlist\\\",\\n                    })*/\\n                    extra: {\\n                        from: from[i],\\n                        source: source,\\n                        id: uid,\\n                        blockRules: ['bb.*.png', '.jpg', \\\"hm\\\\.baidu\\\\.com\\\\/hm.js\\\"],\\n                        videoExcludeRules: ['?url='],\\n                        lineVisible: false,\\n                        textAlign: textalign,\\n                        cls: \\\"playlist\\\",\\n                    }\\n                };\\n            });\\n\\n            if (stype == \\\"漫画\\\" || stype == \\\"小说\\\") {\\n\\n                var downloadlazy = $.toString((key, skey, title) => {\\n                    let {\\n                        GM\\n                    } = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6916&auth=1d35e8f0-22e8-5270-a9d1-826f53f177ad\\\");\\n                    GM.setSelfKey(key);\\n                    let DrpyManage = GM.defineModule(\\\"DrpyManage\\\",\\\"DrpyManage?rule=\\\"+title);\\n                    let drpy = DrpyManage.get(skey);\\n                    input = input.split(\\\"#\\\");\\n                    let result = JSON.parse(drpy.play(input[1], input[0]));\\n                    if (result.url.startsWith(\\\"pics://\\\")) return result.url;\\n                    else if (result.url.startsWith(\\\"novel://\\\")) return JSON.parse(result.url.replace(\\\"novel://\\\", \\\"\\\")).content;\\n                    throw new Error(\\\"漫画或正文获取失败\\\");\\n                }, GM.getSelfKey(), MY_PARAMS.skey, MY_RULE.title);\\n\\n                let chapterList = playobj.excludeKeys([\\\"surl\\\", \\\"stitle\\\"], false).transformKeys({\\n                    \\\"surl\\\": \\\"url\\\",\\n                    \\\"stitle\\\": \\\"title\\\"\\n                });\\n                writeFile(\\\"hiker://files/_cache/dr_dow_list.json\\\", JSON.stringify(chapterList));\\n                d.push({\\n                    title: \\\"下载\\\" + stype,\\n                    url: 'hiker://page/download.view#noRecordHistory##noRefresh#?rule=本地资源管理',\\n                    col_type: 'scroll_button',\\n                    extra: {\\n                        chapterList: \\\"hiker://files/_cache/dr_dow_list.json\\\",\\n                        info: {\\n                            bookName: info.vod_name, //漫画名称,\\n                            ruleName: MY_RULE.title ,\\n                            bookTopPic: info.vod_pic,\\n                            parseCode: downloadlazy,\\n                            bookId: MY_PARAMS.sname,\\n                            type: stype === \\\"漫画\\\" ? \\\"comic\\\" : \\\"novel\\\",\\n                        },\\n                        defaultView: \\\"1\\\"\\n                    }\\n                });\\n                d.push({\\n                    title: \\\"本地书架\\\",\\n                    url: 'hiker://page/Bookrack.view#noRecordHistory#?rule=本地资源管理&ruleName=' + MY_RULE.title,\\n                    col_type: 'scroll_button',\\n                    extra: {\\n                        type: stype === \\\"漫画\\\" ? \\\"comic\\\" : \\\"novel\\\",\\n                    }\\n                }, {\\n                    col_type: 'blank_block'\\n                });\\n            }\\n\\n            playobj = $.splitArrayByRanges(playobj, pages);\\n            return playobj;\\n        });\\n    } else {\\n        d.push({\\n            col_type: \\\"line\\\"\\n        }, {\\n            title: \\\"暂无播放源或播放列表定位错误\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: MY_PARAMS.vodId,\\n        });\\n        cacheShowTips();\\n        setResult(d);\\n    }\\n\\n\\n    let currentLocation = 0;\\n\\n    function renovateList(location) {\\n        //deleteItemByCls(\\\"playpage\\\");\\n        deleteItemByCls(\\\"playlist\\\");\\n        if (playUrlList.length == 0) {\\n            return;\\n        }\\n        let pagenum = getMyVar(\\\"pagenum\\\", \\\"0\\\");\\n        let pcount = playUrlList[location].length;\\n        let list = playUrlList[location][pagenum];\\n        if (!list) {\\n            for (let i = pagenum; i >= 0; i--) {\\n                list = playUrlList[location][i];\\n                if (list) {\\n                    pagenum = i;\\n                    break;\\n                }\\n            }\\n        }\\n        if (getMyVar(\\\"sorti\\\", \\\"0\\\") == 1) {\\n            list.reverse();\\n        }\\n        $.extend({\\n            temp_list: playUrlList[location],\\n        })\\n        let playp = playpages[location];\\n\\n        if (playp && playp.length > 1) {\\n            let temp = {\\n                col_type: 'text_1',\\n                extra: {\\n                    cls: \\\"playpage\\\"\\n                }\\n            }\\n            let pagearr = playp.map((x, i) => i == pagenum ? '““””' + x.fontcolor(\\\"red\\\") : x);\\n            deleteItemByCls(\\\"playpage\\\")\\n            addItemAfter(\\\"playpageline\\\", [{\\n                title: '上一页',\\n                col_type: \\\"text_4\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((location, pcount) => {\\n                    let pagenum = getMyVar(\\\"pagenum\\\", \\\"0\\\");\\n                    if (pagenum == 0) {\\n                        pagenum = pcount - 1;\\n                    } else {\\n                        pagenum--;\\n                    }\\n                    putMyVar(\\\"pagenum\\\", String(pagenum));\\n                    GM.get(\\\"renovateList\\\", () => {})(location);\\n                    return \\\"hiker://empty\\\";\\n                }, location, pcount),\\n                extra: {\\n                    cls: \\\"playpage\\\"\\n                }\\n            }, {\\n                title: playp[pagenum],\\n                col_type: \\\"text_2\\\",\\n                url: $(pagearr, 3).select((location) => {\\n                    putMyVar(\\\"pagenum\\\", String(MY_INDEX));\\n                    GM.get(\\\"renovateList\\\", () => {})(location);\\n                    return \\\"hiker://empty\\\"\\n                }, location),\\n                extra: {\\n                    cls: \\\"playpage\\\"\\n                }\\n            }, {\\n                title: '下一页',\\n                col_type: \\\"text_4\\\",\\n                url: $(\\\"#noLoading#\\\").lazyRule((location, pcount) => {\\n                    let pagenum = getMyVar(\\\"pagenum\\\", \\\"0\\\");\\n                    if (pagenum >= pcount - 1) {\\n                        pagenum = 0;\\n                    } else {\\n                        pagenum++;\\n                    }\\n                    putMyVar(\\\"pagenum\\\", String(pagenum));\\n                    GM.get(\\\"renovateList\\\", () => {})(location);\\n                    return \\\"hiker://empty\\\";\\n                }, location, pcount),\\n                extra: {\\n                    cls: \\\"playpage\\\"\\n                }\\n            }])\\n            /*playp = playp.map((x, i) => {\\n               let obj = Object.assign({}, temp, {\\n                 title: '““””' + (pagenum == i ? x.fontcolor(\\\"red\\\") : x),\\n                 url: $('#noLoading#').lazyRule((i) => {\\n                   if (getMyVar(\\\"pagenum\\\") == i) {\\n                     return \\\"hiker://empty\\\"\\n                   }\\n                   putMyVar(\\\"pagenum\\\", String(i));\\n                   deleteItemByCls(\\\"playlist\\\");\\n                   addItemAfter(\\\"playlists\\\", $.temp_list[i]);\\n                   findItemsByCls(\\\"playpage\\\").forEach((x, ii) => {\\n                     let title = x.title.replace(/‘|’|“|”|<[^>]+>/g, \\\"\\\");\\n                     if (ii == i) {\\n                       title = '““””' + title.fontcolor(\\\"red\\\");\\n                     }\\n                     updateItem(x.extra.id, {\\n                       title: title,\\n                     })\\n                   })\\n                   return \\\"hiker://empty\\\";\\n                 }, i),\\n                 extra: Object.assign({}, temp.extra, {\\n                   id: \\\"pagenum\\\" + i,\\n                 })\\n               })\\n               return obj;\\n             })\\n             addItemAfter(\\\"playpageline\\\", playp)*/\\n        }\\n        if (list) {\\n            addItemAfter(\\\"playlists\\\", list);\\n        }\\n        updateItem(\\\"location@\\\" + currentLocation, {\\n            title: from[currentLocation],\\n        });\\n        updateItem(\\\"location@\\\" + location, {\\n            title: \\\"““\\\" + from[location] + \\\"””\\\",\\n        });\\n        currentLocation = location;\\n    }\\n\\n    GM.put(\\\"renovateList\\\", renovateList);\\n    d.push({\\n        col_type: \\\"big_blank_block\\\"\\n    });\\n    if (from.length) {\\n        d.push({\\n            col_type: \\\"big_blank_block\\\",\\n        })\\n        d.push({\\n            title: sortobj[sorti],\\n            url: $('#noLoading#').lazyRule((so) => {\\n                let si = getMyVar(\\\"sorti\\\", \\\"0\\\");\\n                let ii = (si == \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n                updateItem(\\\"@sort\\\", {\\n                    title: so[ii]\\n                })\\n                var plays = findItemsByCls(\\\"playlist\\\").reverse().map(x => {\\n                    x.col_type = x.type;\\n                    return x;\\n                });\\n                deleteItemByCls(\\\"playlist\\\");\\n                addItemAfter(\\\"playlists\\\", plays);\\n\\n                putMyVar(\\\"sorti\\\", ii);\\n                return \\\"hiker://empty\\\";\\n            }, sortobj),\\n            col_type: 'scroll_button',\\n            extra: {\\n                id: \\\"@sort\\\",\\n            }\\n        })\\n        for (let i in from) {\\n            d.push({\\n                title: from[i],\\n                url: $(\\\"#noLoading#\\\").lazyRule((i, id) => {\\n                    if (getMyVar(id + \\\"sourcei\\\", \\\"0\\\") == i) {\\n                        return \\\"hiker://empty\\\";\\n                    }\\n                    putMyVar(id + \\\"sourcei\\\", String(i));\\n                    GM.get(\\\"renovateList\\\", () => {})(i);\\n                    return \\\"hiker://empty\\\";\\n                }, i, id),\\n                extra: {\\n                    id: \\\"location@\\\" + i\\n                },\\n                col_type: \\\"scroll_button\\\"\\n            });\\n        }\\n    }\\n    //console.log(playUrlList);\\n    /*if (playUrlList.length) {\\n      var ejobj = {\\n        \\\"list\\\": playUrlList,\\n        \\\"tab\\\": from.map((x, i) => from[i])\\n      };\\n      初始化(d, ejobj)\\n    } else {\\n      d.push({\\n        title: \\\"暂无播放源\\\",\\n        col_type: \\\"text_3\\\",\\n        url: MY_PARAMS.vodId,\\n      });\\n    }*/\\n\\n    d.push({\\n        col_type: \\\"blank_block\\\",\\n        extra: {\\n            id: \\\"playpageline\\\"\\n        }\\n    })\\n\\n\\n    d.push({\\n        col_type: \\\"line\\\",\\n        extra: {\\n            id: \\\"playlists\\\"\\n        }\\n    });\\n\\n    d.push({\\n        col_type: \\\"blank_block\\\",\\n        extra: {\\n            id: \\\"playlistsEND\\\"\\n        }\\n    });\\n    cacheShowTips();\\n    setResult(d);\\n    renovateList(getMyVar(id + \\\"sourcei\\\", \\\"0\\\"));\\n})()\"},{\"col_type\":\"movie_3\",\"name\":\"解析文件\",\"path\":\"configs\",\"rule\":\"const path = \\\"hiker://files/rules/LoyDgIk/parses.json\\\";\\nlet data;\\n\\nfunction getJson() {\\n    if (Array.isArray(data)) {\\n        return data;\\n    }\\n    try {\\n        data = JSON.parse(readFile(path) || \\\"[]\\\");\\n    } catch (e) {\\n        deleteFile(path);\\n        data = [];\\n    }\\n    return data;\\n}\\n\\nfunction saveJson(json) {\\n    saveFile(path, JSON.stringify(json));\\n}\\n\\nfunction getUsefulJson() {\\n    return getJson().filter(v => !v.forbidden);\\n}\\n\\nfunction getForbiddenJson() {\\n    return getJson().filter(v => v.forbidden);\\n}\\n\\n$.exports = {\\n    getJson,\\n    saveJson,\\n    getUsefulJson,\\n    getForbiddenJson,\\n    path,\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"解析管理\",\"path\":\"ruleManage\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle(\\\"解析管理\\\");\\nlet configs = $.require(\\\"configs\\\");\\nlet arr = configs.getJson();\\nlet length = arr.length;\\nd.push({\\n    col_type: \\\"avatar\\\",\\n    title: \\\"提示\\\",\\n    pic_url: \\\"https://hikerfans.com/tubiao/system/27.png\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n        let pop = hikerPop.infoBottom({\\n            options: [\\n                \\\"[建议]：解析只需要保存少量好用的即可，不需要太多。\\\",\\n                \\\"[提示]：解析有时效或重定向的'高级'解析，本程序不支持，建议删除。\\\",\\n                \\\"[Q&A]：为啥在编辑页面测试解析时能用，保存后再视频源中却解析不出来？\\\\n不知道，我的解决办法是建议删除。\\\"\\n            ],\\n        });\\n        return \\\"hiker://empty\\\";\\n    }),\\n});\\nd.push({\\n    title: \\\"新增\\\",\\n    url: \\\"hiker://page/ruleEdit#noRecordHistory##noHistory##noRefresh#\\\",\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_domain_config\\\",\\n    extra: {\\n        pageTitle: \\\"新增解析\\\"\\n    }\\n});\\n\\nd.push({\\n    title: \\\"分享\\\",\\n    url: $(\\\"-1\\\", \\\"输入你要分享解析的序号\\\\n-1全部，-2已启用的，-3已禁用的\\\").input((length) => {\\n        let indexc = input.split(/,|，/);\\n        let indexs = [];\\n        let mo = parseInt(indexc[0]);\\n        if (!(indexc.length !== 0 && mo < 0 && mo > -5)) {\\n            for (let it of indexc) {\\n                let num = parseInt(it);\\n                if (Number.isNaN(num) || num >= length || num < 0) {\\n                    return \\\"toast://数字不合法\\\";\\n                }\\n                indexs.push(num);\\n            }\\n        }\\n        return $([\\\"HIKER\\\", \\\"TXT\\\"].concat(getPastes()), 2, \\\"分享方式\\\").select((mo, indexs, ext) => {\\n            function up(rules) {\\n                let ruleb64 = base64Encode(JSON.stringify(rules));\\n                let getPass = (length, rule, type) => \\\"海阔视界，DRPY解析，共「\\\" + length + \\\"」条，复制整条口令打开软件就会自动导入$\\\" + rule + \\\"$\\\" + type + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input)\\\";\\n                if (getPastes().includes(input)) {\\n                    let u = sharePaste(ruleb64, input);\\n                    return \\\"copy://\\\" + getPass(rules.length, u, \\\"b\\\");\\n                } else {\\n                    let path = \\\"hiker://files/rules/LoyDgIk/share/drpy解析「\\\" + rules.length + \\\"」条.\\\" + (input === \\\"HIKER\\\" ? \\\"hiker\\\" : \\\"txt\\\");\\n                    writeFile(path, getPass(rules.length, ruleb64, \\\"a\\\"));\\n                    return \\\"share://\\\" + path;\\n                }\\n            }\\n            let rules;\\n            if (mo === -1) {\\n                rules = $.require(\\\"configs\\\").getJson();\\n            } else if (mo === -2) {\\n                rules = $.require(\\\"configs\\\").getUsefulJson();\\n            } else if (mo === -3) {\\n                rules = $.require(\\\"configs\\\").getForbiddenJson();\\n            } else {\\n                rules = $.require(\\\"configs\\\").getJson().filter((v, i) => indexs.includes(i));\\n            }\\n            rules = rules.map((v) => {\\n                v.forbidden = undefined;\\n                return v;\\n            });\\n            return up(rules);\\n        }, mo, indexs, indexc[1]);\\n\\n    }, length),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_share_green\\\"\\n});\\nd.push({\\n    title: \\\"重置\\\",\\n    url: $(\\\"你确定重置？\\\\n该操作会删除现有解析，恢复自带解析。\\\").confirm((path) => {\\n        deleteFile(path);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, $.require(\\\"configs\\\").path),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_refresh\\\"\\n});\\nd.push({\\n    title: \\\"清空\\\",\\n    url: $(\\\"你确定全部删除？\\\\n该操作会删除现有解析。\\\").confirm((path) => {\\n        writeFile(path, \\\"[]\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, $.require(\\\"configs\\\").path),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_code_view\\\"\\n});\\n\\nd.push({\\n    //title: '<font color=\\\"#13B61B\\\">▐ </font><b>解析列表<b> (' + String(length).fontcolor(\\\"#ff6601\\\") + \\\")\\\",\\n    col_type: \\\"rich_text\\\",\\n});\\nlet countTitle = d.at(-1);\\n\\n\\nlet count = d.length;\\n\\nfor (let i = 0; i < length; i++) {\\n    let it = arr[i];\\n\\n    d.push({\\n        title: '““””[' + i + ']<b>  ' + it.name + (it.forbidden ? \\\" #““禁用””\\\".small() : \\\"\\\"),\\n        desc: it.url,\\n        url: $([\\\"编辑\\\", \\\"分享\\\", \\\"禁用/启用\\\", \\\"移动\\\", \\\"置顶\\\", \\\"删除\\\"], 1, \\\"操作：\\\" + it.name).select((index, length) => {\\n            if (input === \\\"编辑\\\") {\\n                return \\\"hiker://page/ruleEdit#noRecordHistory##noHistory##noRefresh#\\\";\\n            } else if (input === \\\"分享\\\") {\\n                let ops = getPastes();\\n                ops.unshift(\\\"完整口令\\\");\\n                return $(ops, 2, \\\"分享方式\\\").select((index) => {\\n                    let rule = $.require(\\\"configs\\\").getJson()[index];\\n                    rule.user = undefined;\\n                    rule.forbidden = undefined;\\n                    let ruleb64 = base64Encode(JSON.stringify(rule));\\n                    let getPass = (name, rule, type) => \\\"海阔视界，「\\\" + name + \\\"」DRPY解析，复制整条口令打开软件就会自动导入$\\\" + rule + \\\"$\\\" + type + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input)\\\";\\n                    if (input == \\\"完整口令\\\") {\\n                        return \\\"copy://\\\" + getPass(rule.name, ruleb64, \\\"a\\\");\\n                    } else {\\n                        let u = sharePaste(ruleb64, input);\\n                        return \\\"copy://\\\" + getPass(rule.name, u, \\\"b\\\");\\n                    }\\n                }, index);\\n            } else if (input === \\\"移动\\\") {\\n                return $(index + \\\"\\\", \\\"输入位置\\\").input((index, length) => {\\n                    let newIndex = Number(input);\\n                    if (Number.isNaN(newIndex) || newIndex >= length) {\\n                        return \\\"toast://不和规的位置\\\";\\n                    }\\n                    let rules = $.require(\\\"configs\\\").getJson();\\n                    let rule = rules.splice(index, 1)[0];\\n                    rules.splice(newIndex, 0, rule);\\n                    $.require(\\\"configs\\\").saveJson(rules);\\n                    refreshPage(false);\\n                }, index, length);\\n            } else if (input === \\\"置顶\\\") {\\n                let newIndex = 0;\\n                let rules = $.require(\\\"configs\\\").getJson();\\n                let rule = rules.splice(index, 1)[0];\\n                rules.splice(newIndex, 0, rule);\\n                $.require(\\\"configs\\\").saveJson(rules);\\n                refreshPage(false);\\n            } else if (input === \\\"删除\\\") {\\n                return $(\\\"确认删除？\\\").confirm((index) => {\\n                    let rules = $.require(\\\"configs\\\").getJson();\\n                    let rule = rules.splice(index, 1)[0];\\n                    $.require(\\\"configs\\\").saveJson(rules);\\n                    refreshPage(false);\\n                    return \\\"toast://已删除\\\" + rule.name;\\n                }, index);\\n            } else {\\n                let arr = $.require(\\\"configs\\\").getJson();\\n                let rule = arr[index];\\n                rule.forbidden = !rule.forbidden;\\n                $.require(\\\"configs\\\").saveJson(arr);\\n                refreshPage(false);\\n                //return \\\"toast://\\\" + (rule.forbidden ? \\\"禁用\\\" : \\\"启用\\\") + rule.name;\\n            }\\n        }, i, length),\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            i: i,\\n            pageTitle: it.name\\n        }\\n    });\\n}\\ncountTitle.title = '<font color=\\\"#13B61B\\\">▐ </font><b>解析列表<b> (' + ((d.length - count) + \\\"/\\\" + length).fontcolor(\\\"#ff6601\\\") + \\\")\\\";\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"解析编辑\",\"path\":\"ruleEdit\",\"rule\":\"js:\\nvar d = [];\\n\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\"ps_name\\\");\\n    clearMyVar(\\\"ps_url\\\");\\n    clearMyVar(\\\"ps_flag\\\");\\n    clearMyVar(\\\"ps_headers\\\");\\n    clearMyVar(\\\"ps_method\\\");\\n    clearMyVar(\\\"ps_runType\\\");\\n    clearMyVar(\\\"ps_jsonPath\\\");\\n    clearMyVar(\\\"ps_js\\\");\\n}));\\nlet urlIndex = parseInt(getParam(\\\"index\\\", \\\"\\\"));\\nurlIndex = Number.isNaN(urlIndex) ? void(0) : urlIndex;\\nlet index = void(0) === urlIndex ? MY_PARAMS.i : urlIndex;\\nlet isImport = !!getParam(\\\"isImport\\\", \\\"\\\");\\nlet arr = $.require(\\\"configs\\\").getJson();\\nlet obj;\\nif (isImport) {\\n    try {\\n        obj = $.require(\\\"hiker://files/_cache/jiexiSimpleImport.json\\\");\\n        let tip = index !== void(0) ? \\\"更新解析\\\" : \\\"导入解析\\\";\\n        setPageTitle(tip + \\\":\\\" + obj.name);\\n        d.push({\\n            title: \\\"‘‘\\\" + tip + \\\"’’\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n\\n    } catch (e) {\\n        obj = {};\\n        back();\\n        toast(\\\"导入错误\\\");\\n    }\\n} else if (index !== void(0)) {\\n    obj = arr[index];\\n    setPageTitle(\\\"编辑解析:\\\" + obj.name);\\n} else {\\n    obj = {\\n        runType: \\\"WEB\\\",\\n        method: \\\"GET\\\"\\n    };\\n    setPageTitle(\\\"新建解析\\\");\\n}\\n\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"名字(必填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_name\\\", input);\\n        }),\\n        defaultValue: obj.name,\\n        titleVisible: false\\n    }\\n});\\n\\n\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"解析url(必填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_url\\\", input);\\n        }),\\n        defaultValue: obj.url,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"flag(必填)\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 2,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_flag\\\", input);\\n        }),\\n        defaultValue: getMyVar(\\\"ps_flag\\\",obj.flag||\\\"qiyi|imgo|爱奇艺|奇艺|qq|qq 预告及花絮|腾讯|youku|优酷|pptv|PPTV|letv|乐视|leshi|mgtv|芒果|sohu|xigua|fun|风行\\\"),\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"headers(选填)\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 2,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_headers\\\", input);\\n        }),\\n        defaultValue: obj.headers,\\n        titleVisible: false,\\n    }\\n});\\n\\nputMyVar(\\\"ps_runType\\\", obj.runType || \\\"\\\");\\nd.push({\\n    title: \\\"解析模式：\\\" + (obj.runType || \\\"WEB\\\"),\\n    col_type: \\\"text_center_1\\\",\\n    url: $([\\\"WEB\\\", \\\"JSON\\\", \\\"JS\\\"]).select(() => {\\n\\n        putMyVar(\\\"ps_runType\\\", input);\\n        updateItem(\\\"ps_runType\\\", {\\n            title: \\\"解析模式：\\\" + input\\n        });\\n        return \\\"hiker://empty\\\";\\n    }),\\n    extra: {\\n        id: \\\"ps_runType\\\",\\n        lineVisible: false\\n    }\\n});\\n\\n\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"jsonPath(JSON解析模式必填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_jsonPath\\\", input);\\n        }),\\n        defaultValue: obj.jsonPath,\\n        titleVisible: false,\\n    }\\n});\\nputMyVar(\\\"ps_method\\\", obj.method || \\\"\\\");\\nd.push({\\n    title: \\\"JSON请求模式：\\\" + (obj.method || \\\"GET\\\"),\\n    col_type: \\\"text_1\\\",\\n    url: $([\\\"GET\\\", \\\"POST\\\"]).select(() => {\\n\\n        putMyVar(\\\"ps_method\\\", input);\\n        updateItem(\\\"ps_method\\\", {\\n            title: \\\"JSON请求模式：\\\" + input\\n        });\\n        return \\\"hiker://empty\\\";\\n    }),\\n    extra: {\\n        id: \\\"ps_method\\\",\\n        lineVisible: false\\n    }\\n});\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"js(JS模式必填)\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 3,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_js\\\", input);\\n        }),\\n        defaultValue: obj.js,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    title: \\\"删除\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((index, urlIndex) => {\\n        if (index === void(0)) {\\n            return \\\"toast://此项无法删除\\\";\\n        }\\n        if (urlIndex !== void(0)) {\\n            return \\\"toast://正在更新解析，删除请从解析管理进入\\\";\\n        }\\n        confirm({\\n            title: \\\"温馨提示\\\",\\n            content: \\\"确定要删除此解析吗？注意删除后无法恢复\\\",\\n            confirm: $.toString((index) => {\\n                let arr = $.require(\\\"configs\\\").getJson();\\n                arr.splice(index, 1);\\n                $.require(\\\"configs\\\").saveJson(arr);\\n                back(true);\\n                return \\\"toast://删除成功\\\";\\n            }, index)\\n        });\\n        return \\\"hiker://empty\\\"\\n    }, index, urlIndex),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nd.push({\\n    title: \\\"测试\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let testKeyword = getItem(\\\"testUrl\\\", \\\"\\\");\\n        return $(testKeyword, \\\"请输入影视网站地址\\\").input(() => {\\n            setItem(\\\"testUrl\\\", input);\\n            let url = getMyVar(\\\"ps_url\\\", \\\"\\\");\\n            let name = getMyVar(\\\"ps_name\\\", \\\"\\\");\\n            let flag = getMyVar(\\\"ps_flag\\\", \\\"\\\");\\n            let headers = getMyVar(\\\"ps_headers\\\", \\\"\\\");\\n            let runType = getMyVar(\\\"ps_runType\\\", \\\"WEB\\\");\\n            let method = getMyVar(\\\"ps_method\\\", \\\"GET\\\");\\n            let jsonPath = getMyVar(\\\"ps_jsonPath\\\", \\\"\\\").trim() || void 0;\\n            let js = getMyVar(\\\"ps_js\\\", \\\"\\\") || void 0;\\n            if (headers) {\\n                try {\\n                    headers = JSON.parse(headers);\\n                } catch (e) {\\n                    return \\\"headers格式错误:\\\" + e.toString();\\n                }\\n            }\\n            return $.require(\\\"videoUrl\\\").prepareParses([{\\n                name,\\n                url,\\n                flag,\\n                headers,\\n                runType,\\n                method,\\n                jsonPath,\\n                js\\n            }], input,null, true);\\n        });\\n    }),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nd.push({\\n    title: \\\"保存\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((index, isImport) => {\\n        let name = getMyVar(\\\"ps_name\\\", \\\"\\\").trim();\\n        if (!name) {\\n            return \\\"toast://名字得有一个吧\\\";\\n        }\\n        let url = getMyVar(\\\"ps_url\\\", \\\"\\\").trim();\\n        if (!url) {\\n            return \\\"toast://解析地址不能为空\\\";\\n        }\\n        let flag = getMyVar(\\\"ps_flag\\\", \\\"\\\");\\n        if (!flag) {\\n            return \\\"toast://解析地址标识不能为空\\\";\\n        }\\n        let headers = getMyVar(\\\"ps_headers\\\", \\\"\\\").trim();\\n        if (headers) {\\n            try {\\n                headers = JSON.parse(headers);\\n                if(typeof headers!==\\\"object\\\") throw new Error(\\\"错误类型，必须为Object\\\");\\n            } catch (e) {\\n                return \\\"headers格式错误:\\\" + e.toString();\\n            }\\n        }\\n        let runType = getMyVar(\\\"ps_runType\\\", \\\"WEB\\\");\\n        let method = getMyVar(\\\"ps_method\\\", \\\"GET\\\");\\n        let jsonPath = getMyVar(\\\"ps_jsonPath\\\", \\\"\\\").trim() || void 0;\\n        let js = getMyVar(\\\"ps_js\\\", \\\"\\\") || void 0;\\n        if (runType === \\\"JSON\\\" && !jsonPath) {\\n            return \\\"toast://JSON模式下必须填jsonPath\\\";\\n        } else if (runType === \\\"JS\\\" && !js) {\\n            return \\\"toast://JS模式下必须填js\\\";\\n        }\\n        let arr = $.require(\\\"configs\\\").getJson();\\n        let obj1 = {\\n            name,\\n            url,\\n            flag,\\n            headers,\\n            runType,\\n            method,\\n            jsonPath,\\n            js\\n        };\\n        if (index === void(0)) {\\n            if (arr.some(v => v.name === name)) {\\n                return \\\"toast://已经存在该解析\\\";\\n            }\\n            if (obj1.group) {\\n                let group = obj1.group;\\n                let index = arr.findIndex(v => v.group === group);\\n                if (index === -1) {\\n                    arr.unshift(obj1);\\n                } else {\\n                    arr.splice(index, 0, obj1);\\n                }\\n            } else {\\n                if (isImport) {\\n                    arr.push(obj1);\\n                } else {\\n                    arr.unshift(obj1);\\n                }\\n            }\\n        } else {\\n            let namey = arr[index].name;\\n            if (name !== namey) {\\n                if (arr.some(v => v.name === name)) {\\n                    return \\\"toast://已经存在该解析\\\";\\n                }\\n            }\\n            obj1 = Object.assign(arr[index], obj1);\\n            arr.splice(index, 1, obj1);\\n        }\\n        $.require(\\\"configs\\\").saveJson(arr);\\n        back(true);\\n        return \\\"toast://保存成功\\\";\\n    }, index, isImport),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"解析导入\",\"path\":\"import\",\"rule\":\"js:\\nfunction saveCache(json) {\\n    writeFile(\\\"hiker://files/_cache/jiexiSimpleImport.json\\\", JSON.stringify(json));\\n}\\n\\nfunction importParse(pass) {\\n    try {\\n        let [_, rule, type] = pass.split(\\\"$\\\");\\n        if (type === \\\"b\\\") {\\n            rule = parsePaste(rule);\\n        }\\n        let rules = JSON.parse(base64Decode(rule));\\n        if (!Array.isArray(rules)) {\\n            rules = [rules];\\n        }\\n        //rules.reverse();\\n        MY_URL = module.id;\\n        let ruleTitle = getParam(\\\"rule\\\");\\n        let arr = $.require(\\\"configs?rule=\\\" + ruleTitle).getJson();\\n        let newI = 0;\\n        for (let rule of rules) {\\n            let index = arr.findIndex(v => v.name === rule.name);\\n            if (index > -1) {\\n                rule = Object.assign(arr[index], rule);\\n                arr.splice(index, 1, rule);\\n                if (rules.length === 1) {\\n                    saveCache(rule);\\n                    return \\\"hiker://page/ruleEdit#noHistory##noRecordHistory#?isImport=true&index=\\\" + index + \\\"&rule=\\\" + ruleTitle;\\n                    //toast(\\\"已更新规则：\\\" + rule.name);\\n                } else {\\n                    log(\\\"已更新规则：\\\" + rule.name)\\n                }\\n            } else {\\n                newI++;\\n                arr.push(rule);\\n                if (rules.length === 1) {\\n                    saveCache(rule);\\n                    return \\\"hiker://page/ruleEdit#noHistory##noRecordHistory#?isImport=true&rule=\\\" + ruleTitle;\\n                    //toast(\\\"已导入规则：\\\" + rule.name);\\n                } else {\\n                    log(\\\"已导入规则：\\\" + rule.name)\\n                }\\n            }\\n        }\\n        if (rules.length > 1) {\\n            $.require(\\\"configs?rule=\\\" + ruleTitle).saveJson(arr);\\n            toast(\\\"新增：\\\" + newI + \\\" 覆盖更新：\\\" + (rules.length - newI));\\n        }\\n    } catch (e) {\\n        log(e.toString());\\n        toast(\\\"导入失败\\\");\\n    }\\n}\\n\\nfunction importRule(pass) {\\n    try {\\n        let [_, rule, pname] = pass.split(\\\"$\\\");\\n        let path = getPublicItem(\\\"DrpyHiker@input_path\\\", \\\"\\\");\\n        if (!path) {\\n            MY_URL = module.id;\\n            let ruleTitle = getParam(\\\"rule\\\");\\n            toast(\\\"未指定默认保存目录，请先设置保存目录\\\");\\n            return \\\"hiker://page/sharedefaultpath#noRecordHistory##noHistory#?rule=\\\"+ruleTitle;\\n        }\\n        let rules = base64Decode(parsePaste(rule));\\n        if (!rules) toast(\\\"内容为空，导入失败\\\");\\n        path = path.endsWith(\\\"/\\\") ? path : (path + \\\"/\\\");\\n        writeFile(path + pname, rules);\\n        toast(\\\"导入成功请刷新配置\\\");\\n    } catch (e) {\\n        toast(\\\"导入失败:\\\" + e.toString())\\n    }\\n}\\n$.exports = function(pass, mode) {\\n    if (mode) {\\n        return importRule(pass);\\n    } else {\\n        return importParse(pass);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"视频解析\",\"path\":\"videoUrl\",\"rule\":\"function isofficial(url) {\\n    let flag = new RegExp('qq\\\\.com|iqiyi\\\\.com|youku\\\\.com|mgtv\\\\.com|bilibili\\\\.com|sohu\\\\.com|ixigua\\\\.com|pptv\\\\.com|miguvideo\\\\.com|le\\\\.com|1905\\\\.com|fun\\\\.tv');\\n    return flag.test(url);\\n}\\n\\n\\nfunction prepareParses(parses, url, playlist, isTest) {\\n    playlist = playlist || {\\n        urls: [],\\n        names: [],\\n        headers: [],\\n        is: \\\"#isVideo=true#\\\",\\n    };\\n    let Proxy = $.require(\\\"LocalProxy\\\");\\n    let proxyUrl=Proxy.startProxy(MY_RULE.title, GM.getSelfKey());\\n    parses.forEach((v, i) => {\\n        \\n        playlist.names.push(v.name);\\n        if (v.headers) {\\n            playlist.headers.push(v.headers);\\n        }\\n        if (v.runType === \\\"JSON\\\") {\\n            let param = {\\n                //url: v.url,\\n                method: v.method,\\n                headers: v.headers,\\n                jsonPath: v.jsonPath\\n            };\\n            playlist.urls.push(proxyUrl + \\\"?runType=JSON&url=\\\" + encodeURIComponent(base64Encode(v.url + url)) + \\\"&param=\\\" + encodeURIComponent(base64Encode(JSON.stringify(param))));\\n        } else if (v.runType === \\\"JS\\\") {\\n            playlist.urls.push(proxyUrl + \\\"?runType=JS&url=\\\" + encodeURIComponent(base64Encode(url)) + (isTest ? \\\"&param=\\\" + encodeURIComponent(base64Encode(JSON.stringify(v))) : \\\"&index=\\\" + i));\\n        } else {\\n            playlist.urls.push(\\\"video://\\\" + v.url + url);\\n        }\\n    });\\n    return JSON.stringify(playlist);\\n}\\n\\nfunction useParses(url, flag) {\\n    let parses = $.require(\\\"configs\\\").getJson();\\n    parses = parses.filter(v=>String(v.flag).split(\\\"|\\\").includes(flag)&&!v.forbidden);\\n    if (!parses.length) return \\\"web://\\\" + url;\\n    let playlist = {\\n        urls: [],\\n        names: [],\\n        headers: [],\\n        is: \\\"#isVideo=true#\\\",\\n    };\\n    try {\\n        let useDanmu = !!getItem(\\\"useDanmu\\\", \\\"\\\");\\n        if (useDanmu) {\\n            playlist.danmu = $.require('dmFun?rule=dm盒子').dmRoute(url);\\n        }\\n    } catch {}\\n    return prepareParses(parses, url, playlist);\\n}\\nfunction carryJs(play, id){\\n    var extra = {\\n        \\\"ua\\\": MOBILE_UA\\n    }\\n    let parse = play;\\n    let parse_obj = {\\n        defRules: [\\\"*.mp4\\\", \\\"*.m3u8\\\"],\\n    };\\n    if (parse.hasOwnProperty(\\\"parse_extra\\\")) {\\n        let parse_extra = decodeURIComponent(parse.parse_extra);\\n        parse_obj = Object.assign(parse_obj, parseQuery(parse_extra));\\n        if (parse_obj.hasOwnProperty(\\\"init_script\\\")) {\\n            parse_obj[\\\"init_script\\\"] = base64Decode(parse_obj[\\\"init_script\\\"]);\\n        }\\n    }\\n    if (parse_obj.hasOwnProperty(\\\"is_pc\\\") && parse_obj[\\\"is_pc\\\"] == \\\"1\\\") {\\n        extra[\\\"ua\\\"] = PC_UA;\\n    }\\n    if (parse.hasOwnProperty(\\\"header\\\")) {\\n        extra[\\\"ua\\\"] = parse[\\\"header\\\"][\\\"User-Agent\\\"];\\n        //extra[\\\"redirect\\\"]=false;\\n        /*extra[\\\"js\\\"] = $.toString((js) => {\\n          eval(js)\\n          fba.log(navigator.userAgent)\\n          fba.log(location.href)\\n        }, $.toString(() => {\\n          Object.defineProperty(navigator, 'userAgent', {\\n            get: function () {\\n              return 'My-Custom-UA-String';\\n            }\\n          });\\n        }))*/\\n    }\\n    if (parse_obj.hasOwnProperty(\\\"custom_regex\\\")) {\\n        let current = parse_obj[\\\"defRules\\\"];\\n        extra[\\\"videoRules\\\"] = current.concat(parse_obj.custom_regex.split(/\\\\|/g).filter(e => e))\\n    }\\n    if (parse.hasOwnProperty(\\\"js\\\") && parse.js != \\\"\\\") {\\n        extra[\\\"js\\\"] = $.toString((js, parse, t) => {\\n            if (parse.hasOwnProperty(\\\"init_script\\\")) {\\n                fba.log(t + \\\":执行init_script\\\");\\n                eval(parse.init_script);\\n            }\\n            fba.log(navigator.platform);\\n            fba.log(t + \\\":执行js点击\\\")\\n            eval(js)\\n        }, parse.js, parse_obj, MY_RULE.title)\\n    }\\n    try {\\n        let item = findItem(id);\\n        updateItem(id, {\\n            extra: Object.assign({}, item.extra, extra)\\n        });\\n    } catch (e) {}\\n}\\nfunction parseQuery(query) {\\n        var obj = {};\\n        query.split(\\\"&\\\").filter(e => e).forEach(function(item) {\\n            var parts = item.split(\\\"=\\\");\\n            obj[parts[0]] = parts[1];\\n        });\\n        return obj;\\n    }\\n$.exports.parse = function(input, id, source) {\\n    let drpy = GM.defineModule(\\\"DrpyManage\\\").getBySource(source);\\n    input = input.split(\\\"#\\\");\\n    let play = JSON.parse(drpy.play(input[1], input[0].replace(\\\"tvbox-xg:\\\", \\\"\\\"), []));\\n    // log(play)\\n    // log(id)\\n    //log(play)\\n    \\n    \\n    if (play.url.includes(\\\"proxy?do\\\")) {\\n        MY_URL = play.url;\\n        play.url = decodeURIComponent(getParam(\\\"url\\\", \\\"\\\"));\\n    }\\n    if (play.url.startsWith(\\\"push://\\\")) {\\n        play.url = play.url.replace(\\\"push://\\\", \\\"\\\");\\n    }\\n    if (play.url.startsWith(\\\"https://pan.quark.cn/\\\")) {\\n        return \\\"hiker://page/quarkList?rule=Quark.简&realurl=\\\" + encodeURIComponent(play.url) + \\\"&sharePwd=\\\";\\n    }\\n    if (play.url.startsWith('https://www.aliyundrive.com/s/') || play.url.startsWith(\\\"https://www.alipan.com/s/\\\")) {\\n        return \\\"hiker://page/aliyun?rule=云盘君.简&page=fypage&realurl=\\\" + encodeURIComponent(play.url);\\n    }\\n    if (play.url.startsWith(\\\"pics://\\\")) {\\n        return play.url;\\n    }\\n    if (play.url.startsWith(\\\"novel://\\\")) {\\n        return $(\\\"hiker://empty#readTheme#\\\").rule((data) => {\\n            let data = JSON.parse(data);\\n            let layout = [];\\n            let content = \\\"　　\\\" + data.content.split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it => it.trim()).join(\\\"<br>　　\\\");\\n            layout.push({\\n                col_type: \\\"rich_text\\\",\\n                title: (\\\"<strong>\\\" + data.title + \\\"</strong>\\\").big(),\\n            });\\n\\n            layout.push({\\n                title: content,\\n                col_type: 'rich_text',\\n                extra: {\\n                    textSize: 18,\\n                    click: true\\n                }\\n            });\\n            setResult(layout);\\n        }, play.url.replace(\\\"novel://\\\",\\\"\\\"));\\n    }\\n    //log(play);\\n    if (play.parse === 1||play.jx===1) {\\n        if (play.url.startsWith(\\\"magnet:\\\")) {\\n            return play.url;\\n        }\\n        carryJs(play, id);\\n        if (play.jx===1||(isofficial(play.url) && (play.flag || input[1]))) {            \\n            return useParses(play.url, play.flag || input[1]);\\n        }\\n        return \\\"video://\\\" + play.url;\\n    } else if (play.parse === 0) {\\n        if (play.url.startsWith(\\\"magnet:\\\")) {\\n            return play.url;\\n        }\\n        //log(play)\\n        var playobj = {};\\n        playobj.urls = [play.url + \\\"#isVideo=true#\\\"];\\n        if (play.hasOwnProperty(\\\"header\\\")) {\\n            playobj[\\\"headers\\\"] = play.header;\\n        }\\n        if (play.hasOwnProperty(\\\"danmaku\\\")) {\\n            playobj[\\\"danmu\\\"] = play.danmaku;\\n        }\\n        return JSON.stringify(playobj);\\n    } else {\\n        return play.url;\\n    }\\n}\\n$.exports.prepareParses = prepareParses;\"},{\"col_type\":\"movie_3\",\"name\":\"创建订阅\",\"path\":\"createSubscription\",\"rule\":\"js:\\nsetPageTitle(\\\"创建订阅\\\");\\nlet layout = [];\\nlet f = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\naddListener(\\\"onClose\\\", () => {\\n    clearMyVar(\\\"drpyHiker_sub_input\\\");\\n    clearMyVar(\\\"drpyHiker_suburl_input\\\");\\n    clearMyVar(\\\"drpyHiker_subname_input\\\");\\n});\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"订阅名称\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: \\\"\\\",\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_subname_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_subname_input\\\"\\n    }\\n});\\nlet path = joinUrl(getPath(\\\"hiker://files/\\\"), \\\"../\\\".repeat(5)).slice(7);\\nlayout.push({\\n    title: \\\"选择\\\",\\n    url: JSON.stringify(f.fileSelectionUri({\\n        callback: $.toString(() => {\\n            let target = findItem(\\\"drpyHiker_sub_input\\\").extra;\\n            updateItem(\\\"drpyHiker_sub_input\\\", {\\n                extra: Object.assign(target, {\\n                    defaultValue: PATH\\n                })\\n            });\\n            return true;\\n        }),\\n        rootDirPath: path,\\n        initialPath: path,\\n        pattern: 1\\n    })),\\n    col_type: \\\"input\\\",\\n    desc: \\\"储存路径\\\",\\n    extra: {\\n        defaultValue: \\\"\\\",\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_sub_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_sub_input\\\"\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"订阅地址\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: \\\"\\\",\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_suburl_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_suburl_input\\\"\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"确认\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n        let path = getMyVar(\\\"drpyHiker_sub_input\\\", \\\"\\\");\\n        let url = getMyVar(\\\"drpyHiker_suburl_input\\\", \\\"\\\");\\n        let name = getMyVar(\\\"drpyHiker_subname_input\\\", \\\"\\\");\\n        if (!(path && url && name)) {\\n            return \\\"toast://不可为空\\\";\\n        }\\n        let rule = base64Encode(\\\"海阔视界规则分享，当前分享的是：合集规则订阅￥home_sub￥\\\" + name + \\\"@@\\\" + url+`@js=$.require('subscribe?rule=${MY_RULE.title}').parseUrl(input, '${base64Encode(path)}')`);\\n        return \\\"rule://\\\" + rule;\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"解析订阅\",\"path\":\"subscribe\",\"rule\":\"js:\\nfunction generateConfigByGithub(url, path) {\\n    let rope = url.split(\\\"/\\\").slice(3, 5).join(\\\"/\\\");\\n    let html = fetch(url);\\n    \\n    let jsonText = pdfh(html, \\\"#repo-content-pjax-container&&script&&Html\\\");\\n    \\n    let json = JSON.parse(jsonText);\\n    let list = json.payload.tree.items;\\n    let rules = [];\\n    let count = 0;\\n    for (let it of list) {\\n        try {\\n            let name = it.name;\\n            let spath = it.path;\\n            if (!name.endsWith(\\\".js\\\")) continue;\\n            name = name.slice(0, name.lastIndexOf(\\\".\\\"));\\n            let rule = fetch(`https://raw.gitmirror.com/${rope}/master/${spath}`);\\n            if (!((!rule || !rule.includes(\\\"rule\\\")) && !fileExist(path + it.name))) {\\n                writeFile(path + it.name, rule);\\n                rules.push({\\n                    'key': `hipy_js_${name}`,\\n                    'name': `${name}`,\\n                    'type': 3,\\n                    'api':'../libs/drpy2.js',\\n                    'searchable': 1,\\n                    'quickSearch': 1,\\n                    'filterable': 1,\\n                    'ext': \\\"./\\\" + it.name,\\n                });\\n                count++;\\n            }\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n    writeFile(path + \\\"index.json\\\", JSON.stringify({sites:rules}));\\n    return \\\"toast://成功更新\\\" + count + \\\"个\\\";;\\n}\\n\\nfunction generateConfigByIndex(url, path) {\\n    let json = JSON.parse(toCorrectJSONString(request(url)));\\n    let arr = json.sites;\\n    let count = 0;\\n    let i = 0;\\n    for (let it of arr) {\\n        try {\\n            if ((String(it.api).includes(\\\"drpy2.min.js\\\") || String(it.api).includes(\\\"drpy2.js\\\"))) {\\n                let name = it.ext.endsWith(\\\".js\\\") ? decodeURIComponent(it.ext.split(\\\"/\\\").at(-1)) : (it.name + \\\".js\\\");\\n                let rule;\\n                if (String(it.ext).startsWith(\\\"http\\\")) {\\n                    rule = request(it.ext);\\n                } else {\\n                    rule = request(joinUrl(url, it.ext));\\n                }\\n                it.ext = \\\"./\\\" + name;\\n                if (!rule || !rule.includes(\\\"rule\\\")) {\\n                    if (!fileExist(path + name))\\n                        arr.splice(i, 1);\\n                    continue;\\n                };\\n                writeFile(path + name, rule);\\n                count++;\\n            }\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n        i++;\\n    }\\n    writeFile(path + \\\"index.json\\\", JSON.stringify(json));\\n    return \\\"toast://成功更新\\\" + count + \\\"个\\\";\\n}\\n$.exports.parseUrl = function(url, path) {\\n    path = base64Decode(path);\\n    path = path.endsWith(\\\"/\\\") ? path : path + \\\"/\\\";\\n    try {\\n        if (url.startsWith(\\\"https://github.com/hjdhnx/\\\")) {\\n            return generateConfigByGithub(url, path);\\n        } else {\\n            return generateConfigByIndex(url, path);\\n        }\\n    } catch (e) {\\n        log(e.toString());\\n        return \\\"error:\\\" + e.toString();\\n    }\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"运行时配置管理\",\"path\":\"runtimeConfig\",\"rule\":\"js:\\nconst searchAllowPath = \\\"hiker://files/rules/LoyDgIk/DrpyHiker/searchAllow.json\\\";\\nlet isPrepare = false;\\nlet configs, currentConfig = {},\\n    sourceList, currentSource, searchAllow = [];\\n\\nfunction init(config) {\\n    if (!config) return null;\\n    if (!config.path) return null;\\n    try {\\n        let file;\\n        let sourceList = [];\\n        if (config.path.startsWith(\\\"file://\\\") && (file = new java.io.File(config.path.replace(\\\"file://\\\", \\\"\\\"))).isDirectory()) {\\n            sourceList = generateConfigByLocal(file);\\n            config.type = \\\"localDir\\\";\\n        } else if (config.path.startsWith(\\\"https://github.com\\\")) {\\n            sourceList = generateConfigByGithub(config.path);\\n            config.type = \\\"githubDir\\\";\\n        } else {\\n            let json = JSON.parse(toCorrectJSONString(fetch(config.path) || \\\"{}\\\"));\\n            if (!Array.isArray(json.sites) || !json.sites.length) {\\n                return null;\\n            }\\n            sourceList = filterOther(json.sites);\\n            config.type = \\\"index\\\";\\n        }\\n        file = void 0;\\n        let currentSource, searchAllow;\\n        if (config.cKey) {\\n            currentSource = sourceList.find(v => v.key === config.cKey);\\n            if (!currentSource) {\\n                currentSource = sourceList[0];\\n                //currentConfig.cKey = sourceList[0].key;\\n            }\\n        } else {\\n            currentSource = sourceList[0];\\n            //config.cKey = sourceList[0].key;\\n        }\\n        try {\\n            searchAllow = JSON.parse(fetch(searchAllowPath) || \\\"[]\\\");\\n        } catch (e) {\\n            deleteFile(searchAllowPath);\\n            searchAllow = [];\\n        }\\n        return {\\n            currentSource,\\n            searchAllow,\\n            sourceList\\n        };\\n    } catch (e) {\\n        log(e.toString());\\n    }\\n    return null;\\n}\\n\\nfunction generateConfigByLocal(dirFile) {\\n    let list = dirFile.listFiles();\\n    let rules = [];\\n    for (let it of list) {\\n        let name = String(it.getName());\\n        let path = it.getPath();\\n        if (!name.endsWith(\\\".js\\\") || it.isDirectory()) continue;\\n        name = name.slice(0, name.lastIndexOf(\\\".\\\"));\\n        rules.push({\\n            'key': `hipy_js_${name}`,\\n            'name': `${name}`,\\n            'type': 3,\\n            'searchable': 1,\\n            'quickSearch': 1,\\n            'filterable': 1,\\n            'ext': `${path}`,\\n        });\\n    }\\n    return rules;\\n}\\n\\nfunction generateConfigByGithub(url) {\\n    //url=url.replace(/(#GITHUB#)$/,\\\"\\\");\\n    let rope = url.split(\\\"/\\\").slice(3, 5).join(\\\"/\\\");\\n    let html = fetch(url);\\n    let jsonText = pdfh(html, \\\"#repo-content-pjax-container&&script&&Html\\\");\\n    let json = JSON.parse(jsonText);\\n    let list = json.payload.tree.items;\\n    let rules = [];\\n    for (let it of list) {\\n        let name = it.name;\\n        let path = it.path;\\n        if (!name.endsWith(\\\".js\\\")) continue;\\n        name = name.slice(0, name.lastIndexOf(\\\".\\\"));\\n        rules.push({\\n            'key': `hipy_js_${name}`,\\n            'name': `${name}`,\\n            'type': 3,\\n            'searchable': 1,\\n            'quickSearch': 1,\\n            'filterable': 1,\\n            'ext': `https://raw.gitmirror.com/${rope}/master/${path}`,\\n        });\\n        /*\\n        https://github.com/hjdhnx/hipy-server/tree/master/app/t4/files/drpy_js\\n        https://raw.githubusercontent.com/hjdhnx/hipy-server/master/app/t4/files/drpy_js/360%E5%BD%B1%E8%A7%86%5B%E5%AE%98%5D.js*/\\n    }\\n    return rules;\\n}\\n\\nfunction prepare(config) {\\n    let data = init(config);\\n    if (!data) return false;\\n    currentSource = data.currentSource;\\n    searchAllow = data.searchAllow;\\n    sourceList = data.sourceList;\\n    currentConfig = config;\\n    return true;\\n}\\n\\nfunction filterOther(list) {\\n    return list.filter(it => String(it.api).includes(\\\"drpy2.min.js\\\") || String(it.api).includes(\\\"drpy2.js\\\"))\\n}\\n\\n\\nfunction getCurrentConfig() {\\n    return currentConfig || {};\\n}\\n\\nfunction setCurrentConfig(config) {\\n    let cpath = (currentConfig || {}).path;\\n    if (prepare(config)) {\\n        storage0.setItem(\\\"currentConfig\\\", config);\\n        if (cpath != config.path) {\\n            deleteFile(searchAllowPath);\\n            searchAllow = [];\\n        }\\n        isPrepare = true;\\n        return true;\\n    } else {\\n        return false;\\n    }\\n}\\n\\nfunction findSource(key) {\\n    let s = sourceList.find(v => v.key === key);\\n    if (s) {\\n        s.ext = getAbsolutePath(String(s.ext));\\n    }\\n    return s;\\n}\\n\\nfunction getCurrentSource() {\\n    return currentSource;\\n}\\n\\nfunction getCurrentSourcePath() {\\n    let path = String(currentSource.ext);\\n    return getAbsolutePath(path);\\n}\\n\\nfunction getAbsolutePath(path) {\\n    path = String(path);\\n    if (path.startsWith(\\\"http\\\") || path.startsWith(\\\"file://\\\")) {\\n        return path;\\n    } else {\\n        return joinUrl(currentConfig.path, path);\\n    }\\n}\\n\\nfunction setCurrentSource(key) {\\n    let source = sourceList.find(v => v.key === key);\\n    if (source) {\\n        currentConfig.cKey = key;\\n        storage0.setItem(\\\"currentConfig\\\", currentConfig);\\n        currentSource = source;\\n        return true;\\n    }\\n    return false;\\n}\\n\\nfunction getCanSearchSource() {\\n    return sourceList.filter(v => v.searchable === undefined || v.searchable);\\n}\\n\\nfunction getAllSource() {\\n    return sourceList.slice();\\n}\\n\\nfunction getAllSources() {\\n    return sourceList;\\n}\\n\\nfunction getSearchAllow() {\\n    return searchAllow;\\n}\\n\\nfunction setSearchAllow() {\\n    if (Array.isArray(searchAllow)) {\\n        saveFile(searchAllowPath, JSON.stringify(searchAllow));\\n    }\\n}\\n\\nfunction getAllowSearchSource() {\\n    let slist;\\n    if (searchAllow.length) {\\n        slist = sourceList.filter(v => searchAllow.includes(v.key));\\n    } else {\\n        slist = sourceList.filter(v => v.searchable);\\n    }\\n    if (slist.length == 0) {\\n        slist = sourceList.slice();\\n    }\\n    return slist;\\n}\\n\\nfunction isPrepared() {\\n    return isPrepare;\\n}\\n\\nisPrepare = prepare(storage0.getItem(\\\"currentConfig\\\", {}));\\n$.exports = {\\n    prepare,\\n    getCurrentConfig,\\n    setCurrentConfig,\\n    getCurrentSource,\\n    getCurrentSourcePath,\\n    setCurrentSource,\\n    getCanSearchSource,\\n    getSearchAllow,\\n    setSearchAllow,\\n    getAllSource,\\n    getAllowSearchSource,\\n    isPrepared,\\n    getAbsolutePath,\\n    getAllSources,\\n    findSource\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"编辑配置\",\"path\":\"createConfig\",\"rule\":\"js:\\nlet layout = [];\\nsetPageTitle(\\\"创建配置\\\");\\nlet runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\nlet currentconfig = runtimeConfig.getCurrentConfig();\\nlet f = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\naddListener(\\\"onClose\\\", () => {\\n    clearMyVar(\\\"drpyHiker_config_name\\\");\\n    clearMyVar(\\\"drpyHiker_config_path\\\");\\n});\\n\\n//历史配置记录\\nfunction uniqueArrayByProperty(array, property) {\\n    let unique = [];\\n    let map = new Map();\\n    for (let item of array) {\\n        let key = item[property];\\n        if (!map.has(key)) {\\n            map.set(key, true);\\n            unique.push(item);\\n        }\\n    }\\n    return unique;\\n}\\nlet cpath = \\\"hiker://files/cache/\\\" + \\\"drpyconfig.json\\\";\\nlet pathconfigs = [];\\ntry {\\n    pathconfigs = JSON.parse(readFile(cpath)) || [];\\n    //putMyVar(\\\"drpyHiker_configs\\\",pathconfigs);\\n} catch (e) {\\n    console.log(e.message);\\n}\\npathconfigs = uniqueArrayByProperty(pathconfigs, \\\"path\\\");\\n//log(pathconfigs)\\n\\nlet configs_obj = {\\n    path: cpath,\\n    configs: pathconfigs\\n}\\n//历史配置记录\\nlayout.push({\\n    col_type: \\\"avatar\\\",\\n    title: \\\"提示\\\",\\n    pic_url: \\\"https://hikerfans.com/tubiao/system/27.png\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n        let pop = hikerPop.infoBottom({\\n            content: \\\"详细\\\",\\n            options: [\\n                \\\"第一空(名称):方便下次找到\\\",\\n                \\\"第二空(路径)[填本地索引地址]:选择JSON/URL选项，点击旁边的选择可以浏览本地文件选择本地包的.json索引文件即可。\\\\n(注意：使用此种方式，在本地文件夹内新增或删除.js源时需要自行刚刚.json配置文件)\\\",\\n                \\\"第二空(路径)[填本填远程地址]:直接填写远程链接即可一般是以http开头.json结尾，也可可以输入github仓库的文件夹地址。此种方式可以保持与远程配置者同步更新，但不如本地快。\\\",\\n                \\\"第二空(路径)[填本地文件夹地址]:选择文件夹选项，可以直接输入js源所在#文件夹!!!#的路径，也可以点击旁边选择浏览本地路径选择#文件夹!!!#，使用该种方法，在文件夹新增或删除源时，不用手动配置.json文件，自动读取。(注意：需要刷新配置或重启软件才能读取)\\\",\\n                \\\"[Q&A]为什么订阅链接有很多源，却只识别到了几个源？\\\\n本小程序只支持道长的drpy[js]视频源，其他一概不支持。因此会自动过滤其他源\\\",\\n                \\\"[Q&A]打算支持其他tvbox的源吗？不支持不考虑。请看名字DrpyHiker，只支持drpy，要用其他源，建议删除本小程序，去用各种壳子。\\\"\\n            ]\\n        });\\n        return \\\"hiker://empty\\\";\\n    }),\\n});\\nlayout.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"名称(必填)\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getMyVar(\\\"drpyHiker_config_name\\\", \\\"\\\"),\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_config_name\\\", input);\\n        }),\\n        id: \\\"drpyHiker_config_name\\\"\\n    }\\n});\\n\\nlet select_mode = getItem(\\\"select_config_mode\\\", \\\"0\\\");\\nlet nav = [\\\"JSON/URL\\\", \\\"文件夹\\\"];\\n\\nnav.forEach((x, i) => {\\n    layout.push({\\n        title: '““””' + (i == select_mode ? x.fontcolor(\\\"#15B76C\\\") : x),\\n        url: $('#noLoading#').lazyRule((i) => {\\n            setItem(\\\"select_config_mode\\\", i + \\\"\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }, i),\\n        col_type: 'scroll_button',\\n    })\\n})\\n\\n\\nlet path = joinUrl(getPath(\\\"hiker://files/\\\"), \\\"../\\\".repeat(5)).slice(7);\\n\\nif (select_mode == \\\"0\\\") {\\n    layout.push({\\n        title: \\\"选择\\\",\\n        url: JSON.stringify(f.fileSelectionUri({\\n            callback: $.toString(() => {\\n                let target = findItem(\\\"drpyHiker_config_path\\\").extra;\\n                updateItem(\\\"drpyHiker_config_path\\\", {\\n                    extra: Object.assign(target, {\\n                        defaultValue: PATH\\n                    })\\n                });\\n                return true;\\n            }),\\n            rootDirPath: path,\\n            initialPath: path,\\n            pattern: 0,\\n            fileType: \\\".json\\\",\\n        })),\\n        col_type: \\\"input\\\",\\n        desc: \\\"路径(URL/JSON/github)\\\",\\n        extra: {\\n            defaultValue: \\\"\\\",\\n            onChange: $.toString(() => {\\n                putMyVar(\\\"drpyHiker_config_path\\\", input);\\n            }),\\n            id: \\\"drpyHiker_config_path\\\"\\n        }\\n    });\\n}\\nif (select_mode == \\\"1\\\") {\\n    layout.push({\\n        title: \\\"选择\\\",\\n        url: JSON.stringify(f.fileSelectionUri({\\n            callback: $.toString(() => {\\n                let target = findItem(\\\"drpyHiker_config_folder\\\").extra;\\n                updateItem(\\\"drpyHiker_config_folder\\\", {\\n                    extra: Object.assign(target, {\\n                        defaultValue: PATH\\n                    })\\n                });\\n                return true;\\n            }),\\n            rootDirPath: path,\\n            initialPath: path,\\n            pattern: 1,\\n            //fileType: \\\".json\\\",\\n        })),\\n        col_type: \\\"input\\\",\\n        desc: \\\"路径(文件夹)\\\",\\n        extra: {\\n            defaultValue: \\\"\\\",\\n            onChange: $.toString(() => {\\n                putMyVar(\\\"drpyHiker_config_path\\\", input);\\n            }),\\n            id: \\\"drpyHiker_config_folder\\\"\\n        }\\n    });\\n}\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"确认\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((cobj) => {\\n        let path = getMyVar(\\\"drpyHiker_config_path\\\", \\\"\\\");\\n        let name = getMyVar(\\\"drpyHiker_config_name\\\", \\\"\\\");\\n        if (!(path && name)) {\\n            return \\\"toast://不可为空\\\";\\n        }\\n        path = path.startsWith(\\\"http\\\") ? path : path.startsWith(\\\"/\\\") ? (\\\"file://\\\" + path) : path;\\n        //log(path)\\n        try {\\n            let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n            if (path.startsWith(\\\"http\\\")) {\\n                showLoading(\\\"正在加载配置...\\\");\\n            }\\n\\n            if (runtimeConfig.setCurrentConfig({\\n                    path,\\n                    name,\\n                })) {\\n                cobj.configs.push({\\n                    path,\\n                    name,\\n                })\\n                clearItem(\\\"no_loading\\\");\\n                saveFile(cobj.path, JSON.stringify(cobj.configs));\\n                back(false);\\n                let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n                DrpyManage.clear();\\n                $.require(\\\"ChangeSourcePop\\\").show(100);\\n                return \\\"toast://设置成功\\\";\\n            }\\n            return \\\"toast://配置文件有误\\\";\\n        } catch (e) {\\n            return \\\"toast://\\\" + e.toString();\\n        } finally {\\n            hideLoading();\\n        }\\n    }, configs_obj),\\n    col_type: \\\"text_center_1\\\",\\n});\\n\\nif (pathconfigs.length) {\\n    layout.push({\\n        title: '““””' + \\\"<small>历史配置记录 点我进行配置检验</small>\\\",\\n        url: $('#noLoading#').lazyRule((p) => {\\n            //log(p)\\n            function unique(arr) {\\n                const res = new Map();\\n                return arr.filter((a) => !res.has(a) && res.set(a, 1))\\n            }\\n            var results = [];\\n            if (p.length == 0) {\\n                return \\\"toast://无地址\\\";\\n            }\\n            list = p.map(x => x.path);\\n            var task = function(obj) {\\n                let s = Date.now();\\n                let jsFiles = [];\\n                let count = 0;\\n\\n                function filterOther(list) {\\n                    return list.filter(it => String(it.api).includes(\\\"drpy2.min.js\\\") || String(it.api).includes(\\\"drpy2.js\\\"))\\n                }\\n                if (obj.url.startsWith(\\\"file:\\\")) {\\n                    let code = \\\"no\\\";\\n                    let path = obj.url.replace(\\\"file://\\\", \\\"\\\");\\n                    let dir = new java.io.File(path);\\n                    if (dir.isDirectory()) {\\n                        let flist = dir.listFiles();\\n                        for (var f of flist) {\\n                            // 检查文件名是否以.js结尾\\n                            if (f.isFile() && f.getName().toLowerCase().endsWith(\\\".js\\\")) {\\n                                jsFiles.push(f);\\n                            }\\n                        }\\n                    }\\n                    if (dir.isFile() && fileExist(obj.url)) {\\n                        try {\\n                            json = JSON.parse(readFile(obj.url));\\n                            if (Array.isArray(json.sites) || json.sites.length) {\\n                                count = filterOther(json.sites).length;\\n                            }\\n                        } catch (e) {}\\n                        code = \\\"ok\\\";\\n                    }\\n                    if (jsFiles.length >= 5) {\\n                        count = jsFiles.length;\\n                        code = \\\"ok\\\";\\n                    }\\n                    return {\\n                        time: (Date.now() - s),\\n                        url: obj.url,\\n                        count: count,\\n                        code: code,\\n                        index: obj.i\\n                    }\\n                }\\n                var j = JSON.parse(fetch(obj.url, {\\n                    withHeaders: true,\\n                    timeout: 5000,\\n                }));\\n                let e = Date.now();\\n                let c = e - s;\\n                if (obj.url.includes(\\\"github.com\\\") && j.statusCode == 200) {\\n                    try {\\n                        var html = j.body;\\n                        var json = JSON.parse(pdfh(html, \\\"#repo-content-pjax-container&&script&&Html\\\"));\\n                        let list = json.payload.tree.items;\\n                        count = list.filter(x => x.name.endsWith(\\\".js\\\")).length;\\n                    } catch {}\\n                }\\n                try {\\n                    let json = JSON.parse(toCorrectJSONString(j.body) || \\\"{}\\\");\\n                    if (Array.isArray(json.sites) || json.sites.length) {\\n                        count = filterOther(json.sites).length;\\n                    }\\n                } catch (e) {}\\n\\n                return {\\n                    time: c,\\n                    url: j.url,\\n                    count: count,\\n                    code: j.statusCode,\\n                    index: obj.i,\\n                }\\n            };\\n            let tasks = list.map((x, i) => {\\n                i = i + 1;\\n                return {\\n                    func: task,\\n                    param: {\\n                        url: x,\\n                        i: i - 1,\\n                    },\\n                    id: 'taskid' + i\\n                }\\n            });\\n            var count = success = tasks.length;\\n            be(tasks, {\\n                func: function(obj, id, error, taskResult) {\\n                    obj.results.push(taskResult)\\n                    count = count - 1;\\n                    if (count > 0) {\\n                        showLoading(\\\"检测中...剩余地址：\\\" + count)\\n                    } else {\\n                        hideLoading();\\n                    }\\n                },\\n                param: {\\n                    hi: 'ccc',\\n                    results: results\\n                }\\n            }, success);\\n            //log(results)\\n            results = results.filter(f => f);\\n            results.forEach((x, i) => {\\n                let item = findItem(\\\"path\\\" + x.index);\\n                let regex = /(名称:.*?)(\\\\s+)?\\\\n/g;\\n                let title = \\\"名称:\\\" + p[x.index].name + \\\" \\\";\\n                let url = p[x.index].path;\\n                let msg = \\\"\\\";\\n                let count = x.count != 0 ? \\\" 源数量:\\\" + x.count : \\\"\\\";\\n                if (/no/.test(x.code)) {\\n                    msg = item.title.replace(regex, title + \\\"配置有误\\\".fontcolor(\\\"red\\\") + \\\"\\\\n\\\");\\n                } else if (/^(-1|0|404)/.test(x.code)) {\\n                    msg = item.title.replace(regex, title + \\\"无法访问\\\".fontcolor(\\\"red\\\") + \\\"\\\\n\\\");\\n                } else if (/^200/.test(x.code)) {\\n                    msg = item.title.replace(regex, title + \\\"通讯正常\\\".fontcolor(\\\"#3CB371\\\") + \\\"  延迟:\\\" + x.time + count + \\\"\\\\n\\\");\\n                    //url = item.url;\\n                } else {\\n                    msg = item.title.replace(regex, title + \\\"配置正确\\\".fontcolor(\\\"#3CB371\\\") + count + \\\"\\\\n\\\");\\n                    //url = item.url;\\n                }\\n                updateItem(item.extra.id, {\\n                    title: msg,\\n                    //url: url,\\n                })\\n            });\\n            return \\\"hiker://empty\\\"\\n        }, pathconfigs),\\n        col_type: \\\"text_center_1\\\"\\n    })\\n    pathconfigs.forEach((item, i) => {\\n        let longC = [{\\n            title: \\\"名称\\\",\\n            js: $.toString((item, p, c) => {\\n                let i = c.findIndex(x => x.name == item.name);\\n                if (i != -1) {\\n                    return $(c[i].name, \\\"输入新名称\\\").input((c, p, i) => {\\n                        c[i].name = input;\\n                        saveFile(p, JSON.stringify(c));\\n                        refreshPage();\\n                    }, c, p, i)\\n                }\\n            }, item, cpath, pathconfigs)\\n        }, {\\n            title: \\\"路径\\\",\\n            js: $.toString((item, p, c) => {\\n                let i = c.findIndex(x => x.name == item.name);\\n                if (i != -1) {\\n                    return $(c[i].path, \\\"输入新路径\\\").input((c, p, i) => {\\n                        c[i].path = input;\\n                        saveFile(p, JSON.stringify(c));\\n                        refreshPage();\\n                    }, c, p, i)\\n                }\\n            }, item, cpath, pathconfigs)\\n        }, {\\n            title: \\\"删除\\\",\\n            js: $.toString((item, p, c) => {\\n                let i = c.findIndex(x => x.name == item.name);\\n                if (i != -1) {\\n                    c.splice(i, 1);\\n                    saveFile(p, JSON.stringify(c));\\n                    refreshPage();\\n                }\\n            }, item, cpath, pathconfigs)\\n        }]\\n        if (item.path.startsWith(\\\"http\\\")) {\\n            longC.push({\\n                title: \\\"访问\\\",\\n                js: $.toString((item) => {\\n                    if (item.path.startsWith(\\\"http\\\")) {\\n                        return \\\"web://\\\" + item.path;\\n                    }\\n                }, item)\\n            })\\n        }\\n        let current = \\\"\\\";\\n        if (currentconfig && currentconfig.hasOwnProperty(\\\"path\\\")) {\\n            if (item.path == currentconfig.path) {\\n                current = \\\"➡️\\\";\\n            }\\n        }\\n        layout.push({\\n            title: '““””' + \\\"<small>\\\" + current + \\\"名称:\\\" + item.name + \\\"\\\\n路径:\\\" + item.path + \\\"</small>\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule(item => {\\n                clearItem(\\\"no_loading\\\");\\n                let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n                let {\\n                    path,\\n                    name\\n                } = item;\\n                if (path.startsWith(\\\"http\\\")) {\\n                    showLoading(\\\"正在加载配置...\\\");\\n                }\\n                if (runtimeConfig.setCurrentConfig({\\n                        path,\\n                        name,\\n                    })) {\\n                    back(false);\\n                    let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n                    DrpyManage.clear();\\n                    $.require(\\\"ChangeSourcePop\\\").show(100);\\n                    hideLoading();\\n                    return \\\"hiker://empty\\\";\\n                } else {\\n                    hideLoading();\\n                    return \\\"toast://切换失败\\\";\\n                }\\n            }, item),\\n            col_type: \\\"text_1\\\",\\n            extra: {\\n                id: 'path' + i,\\n                longClick: longC\\n            }\\n        })\\n    })\\n}\\n\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"换源弹窗\",\"path\":\"ChangeSourcePop\",\"rule\":\"$.exports.show = function (time) {\\n  if (time) {\\n    java.lang.Thread.sleep(time);\\n  }\\n  const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n  let source = runtimeConfig.getCurrentSource();\\n  let name = source ? source.name : \\\"\\\";\\n  const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n  let sourceNameList = runtimeConfig.getAllSource().map(v => {\\n    return v.name == name ? \\\"‘‘\\\" + v.name + \\\"’’\\\" : v.name;\\n  });\\n  hikerPop.setUseStartActivity(false);\\n\\n  function naturalSort(a, b) {\\n    a = a.replace(/[’‘]/g, \\\"\\\");\\n    b = b.replace(/[’‘]/g, \\\"\\\");\\n    return a.localeCompare(b, undefined, {\\n      numeric: true,\\n      sensitivity: 'base'\\n    });\\n  }\\n\\n  let spen = 3;\\n  let items = sourceNameList.map((x, i) => {\\n    return {\\n      title: x,\\n      url: i\\n    }\\n  })\\n\\n  let names = items.map(v => v.title);\\n  let sname = names.slice();\\n  if (getItem(\\\"natural\\\", \\\"\\\")) {\\n    names = names.sort(naturalSort);\\n  }\\n  let manage_all = names.slice();\\n  let searchKey = \\\"\\\";\\n  let pop = hikerPop.selectBottomRes({\\n    options: names,\\n    columns: spen,\\n    title: \\\"选择视频源\\\" + \\\"当前共:\\\" + items.length + \\\"个视频源\\\",\\n    noAutoDismiss: true,\\n    position: 1,\\n    extraInputBox: new hikerPop.ResExtraInputBox({\\n      hint: \\\"源关键字\\\",\\n      title: \\\"ok\\\",\\n      onChange(text, manage) {\\n        //log(\\\"onChange:\\\"+text)\\n        let flist = names.filter(x => x.includes(text));\\n        manage.list.length = 0;\\n        flist.forEach(x => {\\n          manage.list.push(x);\\n        });\\n        manage.change();\\n      },\\n      defaultValue: \\\"\\\",\\n      click(s, manage) {\\n        //toast(s);\\n        //log(manage.list);\\n      },\\n      titleVisible: false\\n    }), \\n    longClick(s, i) {\\n            showSelectOptions({\\n                title: \\\"分享视频源\\\",\\n                options: [\\\"JS文件分享\\\"].concat(getPastes()),\\n                col: 2,\\n                js: $.toString(name => {\\n                    const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n                    let sources = runtimeConfig.getAllSource();\\n                    let source = sources.find(v => v.name == name);\\n                    let path = runtimeConfig.getAbsolutePath(source.ext);\\n                    let pname = path.split(\\\"/\\\").at(-1);\\n                    let rule = fetch(path);\\n                    if (!rule) return \\\"toast://获取失败\\\";\\n                    if (MY_INDEX === 0) {\\n                        writeFile(\\\"hiker://files/_cache/\\\" + pname, fetch(path));\\n                        return \\\"share://hiker://files/_cache/\\\" + pname;\\n                    } else {\\n                        let url = sharePaste(base64Encode(rule), input);\\n                        return \\\"copy://海阔视界，DRPY视频源「\\\" + name + \\\"」复制整条口令打开软件就会自动导入$\\\" + url + \\\"$\\\" + pname + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input, true)\\\";\\n                    }\\n                }, s.replace(/[’‘]/g, \\\"\\\"))\\n            });\\n        },\\n    click(s, i, manage) {\\n      pop.dismiss();      \\n      setItem(\\\"no_loading\\\", \\\"1\\\");\\n      // manage.list.forEach((v, ii) => (\\n      //   manage.list[ii] = i === ii ? \\\"‘‘\\\" + names[ii] + \\\"’’\\\" : names[ii].replace(/[’‘]/g, \\\"\\\")\\n      // ));\\n      let name = manage.list[i].replace(/[’‘]/g, \\\"\\\");\\n      if (name == source.name) {\\n        refreshPage();\\n        return;\\n      }\\n      let sources = runtimeConfig.getAllSource();\\n      let key = sources.find(v => v.name == name).key;\\n\\n      //manage.change();\\n      let sourceNameList = runtimeConfig.setCurrentSource(key);\\n      clearMyVar(\\\"catei\\\");\\n      clearMyVar(\\\"cate_obj\\\");\\n      clearMyVar(\\\"ishome\\\");\\n      clearMyVar(\\\"links\\\");\\n      refreshPage();\\n\\n    },\\n    menuClick(manage) {\\n      hikerPop.selectCenter({\\n        options: [\\\"改变样式\\\", \\\"筛选源\\\", \\\"自然排序:\\\" + (getItem(\\\"natural\\\", \\\"\\\") == \\\"\\\" ? \\\"关闭\\\" : \\\"启用\\\"), \\\"倒序\\\", \\\"刷新配置\\\"],\\n        columns: 2,\\n        title: \\\"请选择\\\",\\n        click(s, i) {\\n          if (i === 0) {\\n            spen = spen == 3 ? 1 : 3;\\n            manage.changeColumns(spen);\\n          } else if (i === 1) {\\n            hikerPop.inputConfirm({\\n              content: \\\"输入关键字 空显示全部\\\",\\n              title: \\\"筛选源\\\",\\n              hint: \\\"源关键字\\\",\\n              defaultValue: searchKey,\\n              textarea: false, //多行模式\\n              maxTextarea: true,\\n              noAutoSoft: false,\\n              //hideCancel: true,\\n              confirm(text) {\\n                let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\", \\\"runtimeConfig\\\");\\n                searchKey = text;\\n                let list = runtimeConfig.getAllSource().map(x => x.name);\\n                let flist = list.filter(x => x.includes(text));\\n                manage.list.length = 0;\\n                flist.forEach(x => {\\n                  manage.list.push(x);\\n                });\\n                manage.change();\\n                //return \\\"toast://输入了\\\" + text;\\n              },\\n\\n            });\\n          } else if (i === 2) {\\n            let list = Object.assign([], manage.list);\\n            let natural = getItem(\\\"natural\\\", \\\"\\\");\\n            if (natural == \\\"\\\") {\\n              manage.list.length = 0;\\n              list.sort(naturalSort).forEach(x => {\\n                manage.list.push(x);\\n              });\\n            } else {\\n              manage.list.length = 0;\\n              sname.forEach(x => {\\n                manage.list.push(x);\\n              })\\n            }\\n            manage.change();\\n            setItem(\\\"natural\\\", natural ? \\\"\\\" : \\\"1\\\");\\n          } else if (i == 3) {\\n            manage.list.reverse();\\n            names.reverse();\\n            manage.change();\\n          } else {\\n            function arrayDifference(arr1, arr2) {\\n              const map = new Map(arr2.map(item => [item.key, item]));\\n              return arr1.filter(item => !map.has(item.key));\\n            }\\n\\n            let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\", \\\"runtimeConfig\\\");\\n            let list = runtimeConfig.getAllSource();\\n            let Ckey = runtimeConfig.getCurrentSource().key;\\n            //log(Ckey)\\n            let cfg = runtimeConfig.getCurrentConfig()\\n            let {\\n              path,\\n              name\\n            } = cfg;\\n            runtimeConfig.setCurrentConfig({\\n              path,\\n              name,\\n            });\\n            runtimeConfig.setCurrentSource(Ckey);\\n            let nsources = runtimeConfig.getAllSource();\\n\\n            let alist = arrayDifference(nsources, list);\\n            let dlist = arrayDifference(list, nsources);\\n\\n            if (alist.length > 0 || dlist.length > 0) {\\n              let msg = \\\"\\\";\\n              if (alist.length > 0) {\\n                alist.forEach(x => {\\n                  manage.list.push(x.name);\\n                })\\n                log(\\\"新增:\\\" + alist.map(k => k.name).join(\\\",\\\"))\\n                msg += \\\"新增\\\" + alist.length + \\\"个源\\\";\\n              }\\n              if (dlist.length > 0) {\\n                dlist.forEach(x => {\\n                  manage.list.splice(manage.list.indexOf(x.name), 1);\\n                })\\n                log(\\\"移除:\\\" + dlist.map(k => k.name).join(\\\",\\\"))\\n                msg += \\\" 移除\\\" + dlist.length + \\\"个源\\\";\\n              }\\n              manage.change();\\n              toast(msg + \\\" 更多详情看log\\\");\\n            } else {\\n              toast(\\\"已刷新\\\");\\n            }\\n          }\\n        },\\n      });\\n    }\\n  });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"drpy管理\",\"path\":\"DrpyManage\",\"rule\":\"js:\\nconst JSEngine = com.example.hikerview.service.parser.JSEngine;\\nconst runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\nconst drpyMap = new Map();\\nconst GMkey = module.importParam;\\n//log(\\\"初始化DrpyManage\\\");\\nconst proxySemaphore = new java.util.concurrent.Semaphore(3);\\n\\nfunction buildJsEnv(ticket) {\\n    let code = String.raw `\\n    // const my_rule = '\\n    const MY_RULE = ${my_rule};\\n    const my_rule = JSON.stringify(MY_RULE);\\n    const MY_TICKET = \\\"${ticket||\\\"\\\"}\\\";\\n    eval(getJsPlugin());\\n    eval(getJsLazyPlugin());\\n    `;\\n    return code;\\n}\\n\\nfunction sync(func, sp) {\\n    return new org.mozilla.javascript.Synchronizer(func, sp || {});\\n}\\n\\nfunction createDrpy(key) {\\n    JSEngine.getInstance().evalJS(buildJsEnv(MY_TICKET) + \\\"\\\\n!\\\" + $.toString((key, GMkey, MY_TICKET) => {\\n        let drpy = $.require(\\\"drpy\\\", key);\\n        GM.has(GMkey, (DrpyManage) => {\\n            DrpyManage.put(key, drpy);\\n        });\\n    }, key, GMkey, MY_TICKET) + \\\";\\\\n\\\", \\\"\\\", false);\\n}\\n\\nfunction get(key) {\\n    return sync(() => {\\n        //log(drpyMap.size)\\n        if (drpyMap.has(key)) {\\n            return drpyMap.get(key);\\n        }\\n        if (drpyMap.size >= 5) {\\n            //log(\\\"请求:\\\" + key)\\n            del(Array.from(drpyMap.keys()).at(0));\\n        }\\n        let source = runtimeConfig.getAllSources().find(v => v.key === key);\\n        createDrpy(key);\\n        let drpy = drpyMap.get(key);\\n        drpy.init(runtimeConfig.getAbsolutePath(source.ext));\\n        try {\\n            if (drpy.getRule(\\\"proxy_rule\\\")) {\\n                let Proxy = $.require(\\\"LocalProxy\\\");\\n                let proxyUrl = Proxy.startProxy(MY_RULE.title, GM.getSelfKey());\\n                putMyVar(\\\"Proxy_Url\\\", proxyUrl);\\n            }\\n        } catch (e) {\\n\\n        }\\n        return drpy;\\n    }, this).call();\\n}\\n//source.ext必须为绝对路径\\nfunction getBySource(source) {\\n    return sync(() => {\\n        let key = source.key;\\n        //log(drpyMap.size)\\n        if (drpyMap.has(key)) {\\n            return drpyMap.get(key);\\n        }\\n        if (drpyMap.size >= 5) {\\n            //log(\\\"请求:\\\" + key)\\n            del(Array.from(drpyMap.keys()).at(0));\\n        }\\n        createDrpy(key);\\n        let drpy = drpyMap.get(key);\\n        drpy.init(source.ext);\\n        return drpy;\\n    }, this).call();\\n}\\n\\nfunction put(key, drpy) {\\n    sync(() => drpyMap.set(key, drpy), this).call();\\n}\\n\\nfunction runProxy(drpy, args) {\\n    if (typeof drpy.proxy === \\\"function\\\") {\\n        try {\\n            //let time1 = Date.now();\\n            proxySemaphore.acquire();\\n            //let time2 = Date.now();\\n            //log(\\\"1等待时间:\\\" + (time2 - time1) + \\\"ms\\\");\\n            let res = drpy.proxy.apply(drpy, args);\\n            //let time3 = Date.now();\\n            //log(\\\"2执行代理耗时:\\\" + (time3 - time2) + \\\"ms\\\");\\n            //log(\\\"3总耗时耗时:\\\" + (time3 - time1) + \\\"ms\\\");\\n\\n            return res;\\n        } finally {\\n            proxySemaphore.release();\\n        }\\n    }\\n}\\n\\nfunction del(key) {\\n    sync(() => {\\n        //log(\\\"删除\\\" + key);\\n        if (drpyMap.has(key)) {\\n            drpyMap.delete(key);\\n        }\\n    }, this).call();\\n}\\nlet isInitHome = false;\\n//let isInitSearch = false;\\nlet isInitErPage = false;\\n\\nfunction initPage(type) {\\n    switch (type) {\\n        case \\\"home\\\":\\n            isInitHome = true;\\n            //case \\\"search\\\":\\n            //    isInitSearch = true;\\n        case \\\"er\\\":\\n            isIniterPage = true;\\n    }\\n    addListener(\\\"onClose\\\", $.toString((GMkey, type) => {\\n        //log(\\\"onClose\\\");\\n        GM.has(GMkey, DrpyManage => {\\n            //log(\\\"有GMkey\\\");\\n            DrpyManage.clear(type);\\n        });\\n    }, GMkey, type));\\n}\\n\\nfunction clear(type) {\\n    switch (type) {\\n        case \\\"home\\\":\\n            isInitHome = false;\\n            //case \\\"search\\\":\\n            //    isInitSearch = false;\\n        case \\\"er\\\":\\n            isIniterPage = false;\\n    }\\n\\n    if (!isInitHome && !isInitErPage) {\\n        //log(\\\"开始清理\\\");\\n        drpyMap.clear();\\n        GM.clear(GMkey);\\n    }\\n}\\n$.exports = {\\n    initPage,\\n    get,\\n    getBySource,\\n    del,\\n    clear,\\n    put,\\n    runProxy\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"指定搜索弹窗\",\"path\":\"SearchAllowPop\",\"rule\":\"js:\\n$.exports.show = function () {\\n  const runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\", \\\"runtimeConfig\\\");\\n  const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n  let searchAllow = runtimeConfig.getSearchAllow();\\n\\n  let canSearchSource = runtimeConfig.getCanSearchSource();\\n  //let sourceNameList = canSearchSource.map(v=>v.name);\\n  let getNames = () => dynamicSource.map(v => searchAllow.includes(v.key) ? \\\"““””\\\" + (v.name + \\\"\\\").fontcolor(\\\"#009966\\\") : v.name);\\n  let spen = 3;\\n\\n  //let dynamicNames = sourceNameList.slice();\\n  let dynamicSource = canSearchSource.slice();\\n  let searchoncount = dynamicSource.filter(v => searchAllow.includes(v.key)).length;\\n  if (searchoncount == 0) {\\n    searchoncount = canSearchSource.length;\\n  }\\n\\n  let searchKey = \\\"\\\";\\n  hikerPop.selectBottomRes({\\n    options: getNames(),\\n    columns: spen,\\n    title: \\\"启用搜索源:\\\" + searchoncount + \\\"个 共:\\\" + canSearchSource.length + \\\"个搜索源\\\",\\n    noAutoDismiss: true,\\n    position: 1,\\n    height: .9,\\n    extraInputBox: new hikerPop.ResExtraInputBox({\\n      hint: \\\"源关键字 多个用|隔开\\\",\\n      title: \\\"ok\\\",\\n      onChange(text, manage) {\\n        //log(\\\"onChange:\\\"+text)\\n        searchKey = text;\\n        manage.list.length = 0;\\n        dynamicSource.length = 0;\\n        if (text) {\\n          canSearchSource.forEach((v, i) => {\\n            if (text.split(/\\\\|/).filter(f => f).some(x => v.name.includes(x))) {\\n              dynamicSource.push(v);\\n              manage.list.push(searchAllow.includes(v.key) ? \\\"““””\\\" + (v.name + \\\"\\\").fontcolor(\\\"#009966\\\") : v.name)\\n            }\\n          });\\n        } else {\\n          dynamicSource = canSearchSource.slice();\\n          Object.assign(manage.list, getNames());\\n\\n        }\\n        manage.change();\\n      },\\n      defaultValue: \\\"\\\",\\n      click(s, manage) {\\n        //toast(s);\\n        //log(manage.list);\\n      },\\n      titleVisible: false\\n    }),\\n    click(s, i, manage) {\\n\\n      let key = dynamicSource[i].key;\\n      let index = -1;\\n      if ((index = searchAllow.indexOf(key)) !== -1) {\\n        manage.list[i] = dynamicSource[i].name;\\n        searchAllow.splice(index, 1);\\n      } else {\\n        manage.list[i] = \\\"““””\\\" + (dynamicSource[i].name + \\\"\\\").fontcolor(\\\"#009966\\\");\\n        searchAllow.push(key);\\n      }\\n\\n      runtimeConfig.setSearchAllow();\\n      manage.change();\\n    },\\n    menuClick(manage) {\\n      hikerPop.selectCenter({\\n        options: [\\\"改变样式\\\", \\\"筛选源\\\", \\\"自然排序\\\", \\\"倒序\\\", \\\"全选\\\", \\\"反选\\\"],\\n        columns: 2,\\n        title: \\\"请选择\\\",\\n        click(s, i) {\\n          if (i === 0) {\\n            spen = spen == 3 ? 1 : 3;\\n            manage.changeColumns(spen);\\n          } else if (i === 1) {\\n            hikerPop.inputConfirm({\\n              content: \\\"输入关键字 空显示全部\\\",\\n              title: \\\"筛选源\\\",\\n              hint: \\\"源关键字 多个用|隔开\\\",\\n              defaultValue: searchKey,\\n              textarea: false, //多行模式\\n              maxTextarea: true,\\n              noAutoSoft: false,\\n              //hideCancel: true,\\n              confirm(text) {\\n                searchKey = text;\\n                manage.list.length = 0;\\n                dynamicSource.length = 0;\\n                if (text) {\\n                  canSearchSource.forEach((v, i) => {\\n                    if (text.split(/\\\\|/).filter(f => f).some(x => v.name.includes(x))) {\\n                      dynamicSource.push(v);\\n                      manage.list.push(searchAllow.includes(v.key) ? \\\"““””\\\" + (v.name + \\\"\\\").fontcolor(\\\"#009966\\\") : v.name)\\n                    }\\n                  });\\n                } else {\\n                  dynamicSource = canSearchSource.slice();\\n                  Object.assign(manage.list, getNames());\\n\\n                }\\n                manage.change();\\n                //return \\\"toast://输入了\\\" + text;\\n              },\\n\\n            });\\n          } else if (i === 2) {\\n            let list = Object.assign([], manage.list);\\n            manage.list.length = 0;\\n\\n\\n            dynamicSource.sort((a, b) => {\\n              return String(a.name).localeCompare(String(b.name), undefined, {\\n                numeric: true,\\n                sensitivity: 'base'\\n              });\\n            });\\n            Object.assign(manage.list, getNames());\\n            manage.change();\\n          } else if (i == 3) {\\n            manage.list.reverse();\\n            dynamicSource.reverse();\\n\\n            manage.change();\\n          } else if (i == 4) {\\n            dynamicSource.forEach(v => {\\n              if (!searchAllow.includes(v)) {\\n                searchAllow.push(v.key);\\n              }\\n            });\\n            Object.assign(manage.list, getNames());\\n            runtimeConfig.setSearchAllow();\\n            manage.change();\\n          } else if (i == 5) {\\n            let temlist = searchAllow.slice();\\n            searchAllow.length = 0;\\n            dynamicSource.forEach(v => {\\n              if (temlist.includes(v.key)) return;\\n              searchAllow.push(v.key);\\n            });\\n            Object.assign(manage.list, getNames());\\n            runtimeConfig.setSearchAllow();\\n            manage.change();\\n          }\\n        },\\n      });\\n    }\\n  });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"categorys\",\"rule\":\"js:\\nlet fl = {};\\nlet results = [];\\nlet homelist = [];\\nlet cate = \\\"\\\";\\n\\nfunction getCategorys(layout,drpy, page) {\\n  let rule=drpy.runMain('function main(){return rule}');\\n  let loadi=layout.findIndex(x=>x.extra&&x.extra.id==MY_RULE.title+\\\"load\\\");\\n  if(rule.一级==\\\"\\\"||rule.一级==undefined){\\n    if (loadi != -1) {\\n      layout.splice(loadi, 1)\\n    }\\n    clearMyVar(\\\"links\\\");\\n    layout.length=0;\\n    throw new Error(\\\"该源为搜索源，仅能通过搜索访问数据\\\")\\n  }\\n  var getRangeColors = function () {\\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\n  }\\n  let categorys = JSON.parse(drpy.home());\\n  let filters = categorys.filters;\\n  let cates = categorys.class || [];\\n  if (page == 1) {\\n    homelist = JSON.parse(drpy.homeVod()).list;\\n    if (homelist != undefined && homelist.length) {\\n      putMyVar(\\\"ishome\\\", \\\"1\\\");\\n    }\\n  }\\n  if (cates.length == 0 && (homelist == undefined || homelist.length == 0)) {\\n    if (loadi != -1) {\\n      layout.splice(loadi, 1)\\n    }\\n    clearMyVar(\\\"links\\\");\\n    layout.length=0;\\n    throw new Error(\\\"分类获取失败可能网络问题\\\");\\n  }\\n  if (getMyVar(\\\"ishome\\\", \\\"0\\\") == \\\"1\\\") {\\n    cates.unshift({\\n      type_name: '推荐',\\n      type_id: 'home',\\n    })\\n  }\\n  if(loadi!=-1){\\n      layout.splice(loadi,1)\\n  }\\n  putMyVar(\\\"links\\\",\\\"1\\\");\\n  let catei = getMyVar(\\\"catei\\\", \\\"0\\\");\\n  cate = cates[catei].type_id;\\n\\n  var fold = storage0.getItem(\\\"fold\\\", \\\"0\\\");\\n  let color = getRangeColors();\\n\\n  if (page == 1) {\\n    cates.forEach((item, i) => {\\n      let t = catei == i ? \\\"““””\\\" + \\\"<b>\\\"+item.type_name.fontcolor(color) +\\\"</b>\\\": item.type_name;\\n      layout.push({\\n        title: t,\\n        url: $('#noLoading#').lazyRule((i, tid) => {\\n          putMyVar(\\\"catei\\\", i);\\n          refreshPage();\\n          return \\\"hiker://empty\\\";\\n        }, i, item.type_id),\\n        col_type: 'scroll_button',\\n        extra: {\\n          tid: item.type_id,\\n          active: catei == i ? true : false,\\n        }\\n      })\\n    })\\n  }\\n\\n  if (cate != 'home' && page == 1) {\\n    let homei = layout.findIndex(x => {\\n      return x.extra && x.extra.tid == \\\"home\\\"\\n    });\\n    if (homei == -1) {\\n      homei = layout.findIndex(x => {\\n        return x.extra && x.extra.tid;\\n      }) - 1;\\n    }\\n    if (filters && filters.hasOwnProperty(cate)) {\\n      if (homei != -1) {\\n        layout.splice(homei + 1, 0, {\\n          title: fold == \\\"0\\\" ? \\\"““””<b>\\\" + \\\"∧\\\".fontcolor(\\\"#1aad19\\\") + \\\"</b>\\\" : \\\"““””<b>\\\" + \\\"∨\\\".fontcolor(\\\"#FF0000\\\") + \\\"</b>\\\",\\n          col_type: \\\"scroll_button\\\",\\n          url: $(\\\"#noLoading#\\\").lazyRule((fold) => {\\n            storage0.setItem(\\\"fold\\\", fold == \\\"0\\\" ? \\\"1\\\" : \\\"0\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n          }, fold),\\n          extra: {\\n            active: false,\\n          }\\n        })\\n      }\\n\\n      let activei = layout.findIndex(x => x.extra && x.extra.active);\\n      if (activei != -1) {\\n        layout.splice(activei, 0, {\\n          title: \\\"““””\\\" + '🌀',\\n          col_type: 'scroll_button',\\n          url: $('#noLoading#').lazyRule((c) => {\\n            let cate_obj = storage0.getMyVar(\\\"cate_obj\\\", {});\\n            delete cate_obj[c];\\n            storage0.putMyVar(\\\"cate_obj\\\", cate_obj);\\n            refreshPage();\\n            return \\\"toast://清除完成\\\";\\n          }, cate)\\n        })\\n      }\\n\\n      let classify = filters[cate];\\n      var init_cate = new Array(classify.length).fill(\\\"-1\\\");\\n      let cate_obj = storage0.getMyVar(\\\"cate_obj\\\", {});\\n      cate_obj[cate] = cate_obj[cate] ? cate_obj[cate] : init_cate\\n      var cate_temp = cate_obj[cate];\\n      //var filter_def=storage0.getItem(\\\"filter_def\\\", {});\\n      classify.forEach((x, index) => {\\n        layout.push({\\n          col_type: 'blank_block'\\n        })\\n        x.value.forEach((it, i) => {\\n          let t = it.n;\\n          if (cate_temp[index] == i) {\\n            t = \\\"<b><font color=\\\" + color + \\\">\\\" + t + \\\"</font></b>\\\";\\n            fl[x.key] = it.v;\\n          }\\n          if (cate_temp[index] == \\\"-1\\\") {\\n            fl[x.key] = \\\"undefined\\\";\\n          }\\n          if (fold == 1) {\\n            layout.push({\\n              title: '““””' + t,\\n              url: $(\\\"#noLoading#\\\").lazyRule((o) => {\\n                let i = o.i;\\n                storage0.putMyVar(\\\"is_def\\\", \\\"1\\\");\\n                let cate_obj = storage0.getMyVar(\\\"cate_obj\\\", {});\\n\\n                let cate_temp = o.cate_temp;\\n                if (cate_temp.constructor != Array) {\\n                  cate_temp = [];\\n                }\\n                let index = o.index;\\n                let c = cate_temp[index] || \\\"-1\\\";\\n                //log(c)\\n                if (c == i) {\\n                  o.cate_temp[index] = \\\"-1\\\";\\n                } else {\\n                  o.cate_temp[index] = i + \\\"\\\";\\n                }\\n                cate_obj[o.cate] = cate_temp;\\n                //log(cate_temp)\\n                //storage0.putMyVar(\\\"cate_temp\\\", cate_temp);\\n                storage0.putMyVar(\\\"cate_obj\\\", cate_obj);\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n              }, {\\n                index: index,\\n                cate_temp: cate_temp,\\n                i: i,\\n                cate: cate\\n              }),\\n              col_type: 'scroll_button',\\n            })\\n          }\\n        })\\n      })\\n    }\\n  }\\n}\\n\\nfunction getFl() {\\n  fl = Object.keys(fl).filter(key => fl[key] !== \\\"undefined\\\").reduce((res, key) => {\\n    res[key] = fl[key];\\n    return res;\\n  }, {});\\n  return fl\\n}\\n\\nfunction getCateList() {\\n  return {\\n    cate,\\n    homelist\\n  }\\n}\\n\\n\\n$.exports = {\\n  getcatelist: getCateList,\\n  getcategorys: getCategorys,\\n  getfl: getFl\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"本地规则管理\",\"path\":\"LocalDir\",\"rule\":\"js:\\nsetPageTitle(\\\"文件管理\\\");\\nlet path = getPath(String(MY_PARAMS.cpath)).replace(\\\"file://\\\", \\\"\\\");\\nlet fileSelect = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\nfileSelect.fileSelection({\\n    callback: $.toString(() => {\\n        return \\\"editFile://file://\\\" + PATH;\\n    }),\\n    memory: \\\"filepath\\\",\\n    fileType: \\\".js\\\",\\n    exitSearchRefresh: true,\\n    pattern: 0,\\n    rootDirPath: path,\\n    initialPath: path,\\n}, MY_PARAMS.newWindow ? [] : [{\\n    title: \\\"新窗口打开\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://page/LocalDir#noRecordHistory##noHistory#\\\",\\n    extra: {\\n        cpath: MY_PARAMS.cpath,\\n        newWindow: true,\\n        windowId: MY_RULE.title + \\\"@editfile\\\",\\n        lineVisible: false,\\n        pageTitle: \\\"文件管理\\\"\\n    }\\n}]);\"},{\"col_type\":\"movie_3\",\"name\":\"默认保存选择\",\"path\":\"sharedefaultpath\",\"rule\":\"js:\\nsetPageTitle(\\\"保存路径\\\");\\nlet layout = [];\\nlet f = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\naddListener(\\\"onClose\\\", () => {\\n    clearMyVar(\\\"drpyHiker_share_input\\\");\\n});\\n\\nlet path = joinUrl(getPath(\\\"hiker://files/\\\"), \\\"../\\\".repeat(5)).slice(7);\\nlayout.push({\\n    title: \\\"选择\\\",\\n    url: JSON.stringify(f.fileSelectionUri({\\n        callback: $.toString(() => {\\n            let target = findItem(\\\"drpyHiker_share_input\\\").extra;\\n            updateItem(\\\"drpyHiker_share_input\\\", {\\n                extra: Object.assign(target, {\\n                    defaultValue: PATH\\n                })\\n            });\\n            return true;\\n        }),\\n        rootDirPath: path,\\n        initialPath: path,\\n        pattern: 1\\n    })),\\n    col_type: \\\"input\\\",\\n    desc: \\\"储存路径\\\",\\n    extra: {\\n        defaultValue: getMyVar(\\\"drpyHiker_share_input\\\", getPublicItem(\\\"DrpyHiker@input_path\\\", \\\"\\\")),\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"drpyHiker_share_input\\\", input);\\n        }),\\n        id: \\\"drpyHiker_share_input\\\"\\n    }\\n});\\n\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"确认\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((id) => {\\n        let path = getMyVar(\\\"drpyHiker_share_input\\\", \\\"\\\");\\n\\n        if (!path) {\\n            return \\\"toast://不可为空\\\";\\n        }\\n        setPublicItem(\\\"DrpyHiker@input_path\\\", path);\\n        back(false);\\n        return \\\"toast://设置成功\\\";\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"小说\",\"path\":\"novel\",\"rule\":\"js:\\nlet drpy = GM.defineModule(\\\"DrpyManage\\\").getBySource(MY_PARAMS.source);\\nlet play = JSON.parse(drpy.play(MY_PARAMS.from, MY_PARAMS.id, []));\\n\\nlet data = JSON.parse(play.url.replace(\\\"novel://\\\", \\\"\\\"));\\nlet layout = [];\\nlet content = \\\"　　\\\" + data.content.split(/(\\\\n|\\\\r)+/).filter(it => it.trim().length > 1).map(it => it.trim()).join(\\\"<br>　　\\\");\\nlayout.push({\\n    col_type: \\\"rich_text\\\",\\n    title: (\\\"<strong>\\\" + (data.title||getPageTitle()) + \\\"</strong>\\\").big(),\\n});\\n\\nlayout.push({\\n    title: content,\\n    col_type: 'rich_text',\\n    extra: {\\n        textSize: 18,\\n        click: true\\n    }\\n});\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"主页\",\"path\":\"mian\",\"rule\":\"js:\\nfunction load(d, drpy, source, hasHaed) {\\n    let page = MY_PAGE;\\n    let categorys = $.require(\\\"categorys\\\");\\n    categorys.getcategorys(d, drpy, page, hasHaed);\\n    let {\\n        cate,\\n        homelist\\n    } = categorys.getcatelist();\\n    if (getMyVar(\\\"links\\\", \\\"\\\") == \\\"1\\\" && !hasHaed) {\\n        setPreResult(d);\\n        d.length = 0;\\n    }\\n    let fl = categorys.getfl();\\n    let deCol = drpy.getRule(cate == \\\"home\\\" ? \\\"hikerListCol\\\" : \\\"hikerClassListCol\\\");\\n    let homeListCol = getItem(\\\"homeListCol\\\", \\\"\\\") || deCol || \\\"movie_3_marquee\\\";\\n    \\n    let list = [];\\n    if (cate == \\\"home\\\") {\\n        if (page == 1) {\\n            list = homelist;\\n        }\\n        if (list === undefined) {\\n            list = [];\\n            clearMyVar(\\\"ishome\\\");\\n        }\\n        if (list.length > 0 && !list.at(0).vod_pic && !list.at(-1).vod_pic && !deCol) {\\n            homeListCol = \\\"text_1\\\";\\n        }\\n    } else {\\n        list = JSON.parse(drpy.category(String(cate), page, true, fl)).list;\\n    }\\n\\n    if (list.length) {\\n        for (let it of list) {\\n            let id = String(it.vod_id);\\n            //log(it)\\n            let name = it.vod_name;\\n            url = \\\"hiker://page/detailed#immersiveTheme#\\\";\\n            if (typeof id === \\\"string\\\" && id.includes(\\\"msearch:\\\") || id == undefined) {\\n                url = $(\\\"\\\").lazyRule((name) => {\\n                    putMyVar(\\\"temsmode\\\", \\\"1\\\");\\n                    return \\\"hiker://search?rule=\\\" + MY_RULE.title + \\\"&s=\\\" + name;\\n                }, name)\\n            }\\n            d.push({\\n                title: name,\\n                desc: it.vod_remarks,\\n                url: url,\\n                pic_url: it.vod_pic,\\n                col_type: homeListCol,\\n                extra: {\\n                    img: it.vod_pic,\\n                    vodId: id,\\n                    sname: source.name,\\n                    skey: source.key,\\n                    longClick: [{\\n                        title: \\\"聚合搜索\\\",\\n                        js: \\\"putMyVar('temsmode', '1');'hiker://search?rule=' + MY_RULE.title + '&s=\\\" + name + \\\"';\\\"\\n                    }]\\n                }\\n            });\\n        }\\n    }\\n    deleteItem(MY_RULE.title + \\\"load\\\");\\n}\\n\\nfunction setDrpyPath(d) {\\n    d.push({\\n        title: \\\"缺少运行库\\\\n该小程序不能通过云剪贴板分享，只能通过打包分享\\\",\\n        desc: \\\"将运行库放入\\\" + getPath(\\\"hiker://files/data/\\\" + MY_RULE.title + \\\"/libs_hiker/drpy2.js\\\"),\\n        col_type: \\\"text_center_1\\\",\\n        url: \\\"hiker://empty\\\"\\n    });\\n}\\n\\nfunction setHied(d, name, config) {\\n    let fileSelect = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=5099\\\");\\n    d.push({\\n        title: name || \\\"换源\\\",\\n        col_type: 'icon_round_small_4',\\n        img: 'https://hikerfans.com/tubiao/system/130.png',\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            $.require(\\\"ChangeSourcePop\\\").show();\\n            return \\\"hiker://empty\\\";\\n        }),\\n        extra: {\\n            cpath: config.path,\\n            longClick: [{\\n                title: \\\"更换配置\\\",\\n                js: JSON.stringify(\\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\")\\n            }, {\\n                title: \\\"刷新源\\\",\\n                js: $.toString(() => {\\n                    let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n                    let source = runtimeConfig.getCurrentSource();\\n                    let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n                    DrpyManage.get(source.key).init(runtimeConfig.getAbsolutePath(source.ext));\\n                    refreshPage();\\n                })\\n            }, {\\n                title: \\\"完全刷新源\\\",\\n                js: $.toString(() => {\\n                    let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n                    let source = runtimeConfig.getCurrentSource();\\n                    let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n                    DrpyManage.del(source.key);\\n                    refreshPage();\\n                })\\n            }].concat(config.type === \\\"localDir\\\" ? [{\\n                title: \\\"本地管理\\\",\\n                js: \\\"'hiker://page/LocalDir#noRecordHistory##noHistory#'\\\"\\n            }] : [])\\n        }\\n    });\\n\\n\\n\\n    let smode = Number(getItem(\\\"smode\\\", \\\"0\\\"));\\n    d.push({\\n        title: [\\\"仅选中\\\", \\\"聚合\\\"][smode],\\n        url: $('#noLoading#').lazyRule(() => {\\n            let smode = Number(getItem(\\\"smode\\\", \\\"0\\\"));\\n            return $([\\\"仅选中\\\", \\\"聚合\\\"], 1, \\\"搜索模式\\\", smode).select((t) => {\\n                setItem(\\\"smode\\\", \\\"\\\" + MY_INDEX);\\n                updateItem(t + \\\"@search_mode\\\", {\\n                    title: [\\\"仅选中\\\", \\\"聚合\\\"][MY_INDEX],\\n                })\\n                return \\\"hiker://empty\\\";\\n                //refreshPage();\\n            }, MY_RULE.title)\\n        }),\\n        pic_url: \\\"https://hikerfans.com/tubiao/system/41.png\\\",\\n        col_type: \\\"icon_round_small_4\\\",\\n        extra: {\\n            id: MY_RULE.title + \\\"@search_mode\\\",\\n            longClick: [{\\n                title: \\\"指定搜索源\\\",\\n                js: $.toString(() => {\\n                    $.require(\\\"SearchAllowPop\\\").show();\\n                })\\n            }]\\n        }\\n    });\\n    d.push({\\n        title: \\\"我的\\\",\\n        url: $([{\\n            title: \\\"历史\\\",\\n            icon: 'https://hikerfans.com/tubiao/system/136.png'\\n        }, {\\n            title: \\\"收藏\\\",\\n            icon: 'https://hikerfans.com/tubiao/system/139.png'\\n        }, {\\n            title: \\\"书架-小说\\\",\\n            icon: 'https://hikerfans.com/tubiao/q/13.png'\\n        }, {\\n            title: \\\"书架-漫画\\\",\\n            icon: 'https://hikerfans.com/tubiao/q/34.png'\\n        }], 2, \\\"我的\\\").select(() => {\\n            if (MY_INDEX === 0) {\\n                return \\\"hiker://history?rule=\\\" + MY_RULE.title;\\n            } else if (MY_INDEX === 1) {\\n                return \\\"hiker://collection?rule=\\\" + MY_RULE.title;\\n            } else if (MY_INDEX === 2) {\\n                return 'hiker://page/Bookrack.view#noRecordHistory#?rule=本地资源管理&type=novel&ruleName=' + MY_RULE.title;\\n            } else if (MY_INDEX === 3) {\\n                return 'hiker://page/Bookrack.view#noRecordHistory#?rule=本地资源管理&type=comic&ruleName=' + MY_RULE.title;\\n            }\\n        }),\\n        pic_url: \\\"https://hikerfans.com/tubiao/system/132.png\\\",\\n        col_type: \\\"icon_round_small_4\\\",\\n\\n    });\\n    d.push({\\n        title: \\\"设置\\\",\\n        url: $([\\\"解析管理\\\", \\\"官方弹幕\\\", \\\"支持作者\\\", \\\"调试日志:\\\" + (getItem(\\\"useLog\\\", \\\"\\\") == \\\"\\\" ? \\\"关闭\\\" : \\\"开启\\\"), \\\"分享导入路径\\\", \\\"创建订阅地址\\\", \\\"切换列表样式\\\", \\\"更换配置\\\"], 1, \\\"设置\\\").select(() => {\\n            if (\\\"解析管理\\\" == input) {\\n                return \\\"hiker://page/ruleManage#noRecordHistory##noHistory#\\\";\\n            } else if (\\\"官方弹幕\\\" === input) {\\n                let useDanmu = !!getItem(\\\"useDanmu\\\", \\\"\\\");\\n                return $(\\\"当为官源时匹配弹幕(需要danmu盒子支持)\\\\n当前:\\\" + useDanmu + \\\"\\\\n点击确定即可\\\" + (useDanmu ? \\\"关闭\\\" : \\\"开启\\\")).confirm((useDanmu) => {\\n                    setItem(\\\"useDanmu\\\", useDanmu ? \\\"\\\" : \\\"1\\\");\\n                    return \\\"toast://\\\" + (useDanmu ? \\\"已关闭\\\" : \\\"已开启\\\");\\n                }, useDanmu);\\n            } else if (input.includes(\\\"调试日志\\\")) {\\n                let useLog = !!getItem(\\\"useLog\\\", \\\"\\\");\\n                return $(\\\"开启日志辅助调试，普通使用不需要开启\\\\n当前:\\\" + useLog + \\\"\\\\n点击确定即可\\\" + (useLog ? \\\"关闭\\\" : \\\"开启\\\")).confirm((useLog) => {\\n                    setItem(\\\"useLog\\\", useLog ? \\\"\\\" : \\\"1\\\");\\n                    let runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\n                    let source = runtimeConfig.getCurrentSource();\\n                    if (source) {\\n                        let DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\n                        DrpyManage.del(source.key);\\n                    }\\n                    refreshPage();\\n                    return \\\"toast://\\\" + (useLog ? \\\"已关闭\\\" : \\\"已开启\\\");\\n                }, useLog);\\n            } else if (input === \\\"创建订阅地址\\\") {\\n                return \\\"hiker://page/createSubscription#noRecordHistory##noHistory#\\\";\\n            } else if (input === \\\"切换列表样式\\\") {\\n                let collist = [\\\"默认\\\", \\\"movie_3_marquee\\\", \\\"movie_3\\\", \\\"movie_2\\\", \\\"movie_1\\\", \\\"text_1\\\"];\\n                let homeListCol = getItem(\\\"homeListCol\\\", \\\"\\\");\\n                let index = homeListCol ? collist.indexOf(homeListCol) : 0;\\n                return $(collist, 1, \\\"选择样式\\\", index).select(() => {\\n                    if (MY_INDEX === 0) {\\n                        setItem(\\\"homeListCol\\\", \\\"\\\");\\n                    } else {\\n                        setItem(\\\"homeListCol\\\", input);\\n                    }\\n                    refreshPage();\\n                });\\n            } else if (input === \\\"更换配置\\\") {\\n                return \\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\";\\n            } else if (\\\"支持作者\\\" == input) {\\n                return \\\"hiker://page/Donate.v#noRecordHistory##noHistory#\\\";\\n            } else {\\n                return \\\"hiker://page/sharedefaultpath#noRecordHistory##noHistory#\\\";\\n            }\\n        }),\\n        pic_url: \\\"https://hikerfans.com/tubiao/messy/30.svg\\\",\\n        col_type: \\\"icon_round_small_4\\\",\\n    });\\n\\n    d.push({\\n        title: '搜索',\\n        //desc: '',\\n        desc: '要搜点什么',\\n        url: $.toString(() => {\\n            return 'hiker://search?rule=' + MY_RULE.title + \\\"&s=\\\" + input;\\n        }),\\n        col_type: 'input',\\n        extra: {\\n            defaultValue: getMyVar(\\\"keyword\\\", \\\"\\\"),\\n            onChange: $.toString(() => {\\n                putMyVar(\\\"keyword\\\", input)\\n            })\\n        }\\n    });\\n}\\nlet d = [];\\n\\nlet runtimeConfig = GM.defineModule(\\\"runtimeConfig\\\");\\nlet DrpyManage = GM.defineModule(\\\"DrpyManage\\\");\\nDrpyManage.initPage(\\\"home\\\");\\naddListener(\\\"onClose\\\", () => {\\n    clearMyVar(\\\"links\\\");\\n});\\ntry {\\n    if (android.os.Build.VERSION.SDK_INT >= 30 && !android.os.Environment.isExternalStorageManager()) {\\n        d.push({\\n            title: \\\"‘‘提示’’\\\",\\n            desc: \\\"当前没有文件管理权限无法正常使用请打开海阔设置=>更多设置=>内部文件管理=>右上角\\\",\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\"\\n        });\\n    } else if (!runtimeConfig.isPrepared()) {\\n        d.push({\\n            title: \\\"还没有配置视频源\\\",\\n            url: \\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\",\\n            col_type: \\\"text_center_1\\\",\\n        });\\n    } else if (fileExist(\\\"hiker://files/data/\\\" + MY_RULE.title + \\\"/libs_hiker/drpy2.js\\\")) {\\n        let source = runtimeConfig.getCurrentSource();\\n        if (MY_PAGE === 1) {\\n            if (source == undefined) {\\n                setHied(d)\\n            } else {\\n                setHied(d, source.name, runtimeConfig.getCurrentConfig() || {});\\n            }\\n        }\\n        //log(DrpyManage.get(source.key))\\n        let hasHaed = false;\\n        if (getMyVar(\\\"links\\\", \\\"\\\") == \\\"\\\") {\\n            d.push({\\n                title: '加载中...',\\n                col_type: 'text_center_1',\\n                url: \\\"hiker://empty\\\",\\n                extra: {\\n                    lineVisible: false,\\n                    id: MY_RULE.title + \\\"load\\\"\\n                }\\n            });\\n            setPreResult(d);\\n            d.length = 0;\\n            hasHaed = true;\\n        }\\n        if (source) {\\n            load(d, DrpyManage.get(source.key), source, hasHaed);\\n        }\\n    } else {\\n        setDrpyPath(d);\\n    }\\n\\n} catch (e) {\\n\\n    d.push({\\n        title: \\\"““\\\" + e.toString() + \\\"””\\\",\\n        desc: e.lineNumber,\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\"\\n    });\\n    d.push({\\n        title: \\\"更换配置\\\",\\n        url: \\\"hiker://page/createConfig#noRecordHistory##noHistory#\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n    deleteItem(MY_RULE.title + \\\"load\\\");\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"主页处理\",\"path\":\"MianLoad\",\"rule\":\"if (getItem(\\\"firstopen\\\") == MY_RULE.version) {\\n    $.require(\\\"mian\\\");\\n} else if (MY_PAGE === 1) {\\n    let d = []\\n    let time = getItem(\\\"firstopen\\\", \\\"\\\") ? 6 : 20;\\n    let id = Date.now();\\n    let content = `\\n    1. 本小程序所有代码全部开源，且本规则为学习目的，请于导入24小时内删除！！！\\n    2. 本小程序<b>完全免费</b>，如果你是付费购买的恭喜你被骗了。\\n    当然如果有能力想鼓励作者的可以${\\\"支持一下\\\".link(\\\"hiker://page/Donate.v#noHistory##noRecordHistory#\\\")}</a>(<small>点击可进入捐赠，可在主页菜单进入</small>)。\\n    3. 本小程序只支持道长的drpy[js]视频源，其他一概不支持。\\n    \\n    <b>开始使用本规则即代表遵守规则条例</b>\\n    当前版本：${MY_RULE.version}\\n    `;\\n    d.push({\\n        title: \\\"““””<strong>使用前须知</strong>\\\".big(),\\n        col_type: \\\"text_center_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n    d.push({\\n        title: content.trim().replace(/\\\\n\\\\s*?/g, \\\"<br>\\\"),\\n        \\\"col_type\\\": \\\"rich_text\\\"\\n    }, {\\n        col_type: \\\"line\\\"\\n    }, {\\n        title: time + \\\"秒后继续\\\",\\n        url: \\\"toast://请认真阅读以上内容\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: id + \\\"timer\\\"\\n        }\\n    });\\n\\n    setResult(d);\\n    while (time != 0) {\\n        java.lang.Thread.sleep(1000);\\n        time -= 1;\\n        updateItem(id + \\\"timer\\\", {\\n            title: time + \\\"秒后继续\\\"\\n        });\\n    }\\n    updateItem(id + \\\"timer\\\", {\\n        title: \\\"““我同意以上要求””\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((v) => {\\n            setItem(\\\"firstopen\\\", String(v));\\n            refreshPage();\\n            return \\\"toast://感谢您的理解\\\";\\n        }, MY_RULE.version),\\n        col_type: \\\"text_center_1\\\"\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"捐赠\",\"path\":\"Donate.v\",\"rule\":\"js:\\nlet d = [];\\nsetPageTitle(\\\"捐赠/支持\\\");\\nd.push({\\n    title: \\\"捐赠/支持\\\",\\n    desc: \\\"这个捐赠不能为你带来特权，但您的支持会提高我更新创作的动力。\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"toast://感谢您的支持\\\"\\n});\\nd.push({\\n    title: \\\"十分感谢α大佬的参与开发，以及道长大佬对本程序开发上的指导。\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"toast://感谢您的支持\\\"\\n});\\nd.push({\\n    col_type: \\\"pic_1_full\\\",\\n    url: \\\"https://gitee.com/LoyDgIk/LoyDgIk_Rule/raw/master/67d8f0187f0186c1.png\\\",\\n    pic_url: \\\"https://gitee.com/LoyDgIk/LoyDgIk_Rule/raw/master/67d8f0187f0186c1.png\\\"\\n});\\nd.push({\\n    col_type: \\\"text_center_1\\\",\\n    title: \\\"““””\\\" + \\\"图片加载缓慢请稍等\\\".small().fontcolor(\\\"Gray\\\"),\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"LocalProxy\",\"path\":\"LocalProxy\",\"rule\":\"function proxy() {\\n    function parseVideo(MY_PARAMS, title) {\\n        function toPath(value) {\\n            if (typeof value !== 'string') {\\n                return [];\\n            }\\n            let path = [];\\n            let current = '';\\n            let inBrackets = false;\\n            let escape = false;\\n            for (let i = 0; i < value.length; i++) {\\n                let char = value[i];\\n                if (escape) {\\n                    current += char;\\n                    escape = false;\\n                } else if (char === '\\\\\\\\') {\\n                    escape = true;\\n                } else if (char === '.' && !inBrackets) {\\n                    path.push(current);\\n                    current = '';\\n                } else if (char === '[') {\\n                    inBrackets = true;\\n                } else if (char === ']') {\\n                    inBrackets = false;\\n                } else {\\n                    current += char;\\n                }\\n            }\\n            if (current) {\\n                path.push(current);\\n            }\\n            return path;\\n        }\\n\\n        function getJson(obj, path) {\\n            if (!obj || !Array.isArray(path)) {\\n                return undefined;\\n            }\\n            if (path.length === 0) {\\n                return obj;\\n            }\\n            let current = obj;\\n            for (let i = 0; i < path.length; i++) {\\n                let key = path[i];\\n                if (current === null || current === undefined || typeof current !== 'object') {\\n                    return undefined;\\n                }\\n                current = current[key];\\n            }\\n            return current;\\n        }\\n        try {\\n            let runType = MY_PARAMS.runType[0];\\n            let url = decodeURIComponent(base64Decode(MY_PARAMS.url[0]));\\n            if (runType == \\\"JSON\\\") {\\n\\n                let param = JSON.parse(decodeURIComponent(base64Decode(MY_PARAMS.param[0])));\\n                let json = JSON.parse(request(url, {\\n                    headers: param.headers || {},\\n                    method: param.method || void 0\\n                }));\\n                return JSON.stringify({\\n                    statusCode: 302,\\n                    headers: Object.assign({}, param.headers || {}, {\\n                        \\\"Location\\\": getJson(json, toPath(param.jsonPath)),\\n                    })\\n                });\\n            } else if (runType == \\\"JS\\\") {\\n\\n                let parse;\\n                if (MY_PARAMS.index) {\\n                    parse = $.require(\\\"configs?rule=\\\" + title).getJson()[MY_PARAMS.index[0]];\\n                } else {\\n                    parse = JSON.parse(decodeURIComponent(base64Decode(MY_PARAMS.param[0])));\\n                }\\n                let res = new Function(\\\"url\\\", \\\"self\\\", parse.js)(url, parse);\\n                if (typeof res === \\\"string\\\") {\\n                    return JSON.stringify({\\n                        statusCode: 302,\\n                        headers: {\\n                            \\\"Location\\\": res\\n                        }\\n                    });\\n                } else if ($.type(res) === \\\"object\\\") {\\n                    return JSON.stringify({\\n                        statusCode: 302,\\n                        headers: res\\n                    });\\n                }\\n            }\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n\\n    function doJs(MY_PARAMS, title, gkey) {\\n        let {\\n            GM\\n        } = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6916&auth=1d35e8f0-22e8-5270-a9d1-826f53f177ad\\\");\\n        GM.setSelfKey(gkey);\\n        let DrpyManage = GM.defineModule(\\\"DrpyManage\\\", \\\"DrpyManage?rule=\\\" + title);\\n        let drpy = DrpyManage.get(decodeURIComponent(MY_PARAMS.hikerSkey[0]));\\n        let params = {};\\n        for (let key in MY_PARAMS) {\\n            params[key] = String(MY_PARAMS[key][0]);\\n        }\\n        \\n        \\n        //let result = drpy.proxy(params);\\n        let result = DrpyManage.runProxy(drpy, [params]);\\n       \\n        let [code, media_type, data, headers, isReturnBytes] = result;\\n        headers = Object.assign({}, {\\n            'Content-Type': media_type,\\n        }, headers);\\n        if(typeof data===\\\"string\\\"&&data.startsWith(\\\"data:\\\")&&data.includes(\\\"base64,\\\")){\\n            data = data.split(\\\"base64,\\\")[1];\\n            const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n            data = CryptoUtil.Data.parseBase64(data).toBytes();\\n        }\\n        return {\\n            statusCode: code,\\n            body: data,\\n            headers: headers,\\n        };\\n    }\\n\\n    function entrance(MY_PARAMS, title, gkey) {\\n        if (MY_PARAMS.do && MY_PARAMS.do[0] === \\\"js\\\") {\\n            try {\\n                return doJs(MY_PARAMS, title, gkey);\\n            } catch (e) {\\n                log(e.toString());\\n                return;\\n            }\\n        } else {\\n            return parseVideo(MY_PARAMS, title);\\n        }\\n    }\\n    this.entrance = entrance;\\n}\\n\\nfunction startProxy(title, gkey) {\\n    return startProxyServer($.toString((proxy, title, gkey) => {\\n        return new proxy().entrance(MY_PARAMS, title, gkey);\\n    }, proxy, title, gkey));\\n}\\n$.exports.startProxy = startProxy;\"}]","icon":"","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!