API tools faq
paste
xiaomianao666

小程序：道长仓库Pro

xiaomianao666
Sep 17th, 2024
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 230.72 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@道长仓库Pro@{"firstHeader":"sort","last_chapter_rule":"","title":"道长仓库Pro","author":"@LoyDgIk","url":"hiker://empty","version":164,"col_type":"icon_2_round","class_name":"","type":"tool","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nconst {\n    getApi,\n    color,\n    small,\n    getFile,\n    htmlTag,\n    api,\n    md\n} = $.require(\"hiker://page/utiliy\");\nvar r = $.require('hiker://page/notice');\n\n\nconst lsg = $.require(\"hiker://page/localStorage?rule=道长仓库Pro\");\nlet classA = getVar(\"Warehouse.class\", \"0\");\nlet listUrl = getApi(\"usersUrl\") + classA,\n    myUrl = getApi(\"devSelf\"),\n    noticeUrl = getApi(\"noticeUrl\");\n// myUrl = getApi(\"rulesAllUrl\");\nputVar(\"Warehouse.filter\", \"\");\nvar noWait = true; //无需重试\nvar timeout = 500;\nvar tmp_headers = {\n    timeout: timeout\n};\ntry {\n    var userList = JSON.parse(request(listUrl, tmp_headers)).result,\n    notices=JSON.parse(request(noticeUrl, tmp_headers)).result,\n        nowCon = 0,\n        ruleCount = JSON.parse(request(getApi(\"ruleCountUrl\"), tmp_headers)).result;\n} catch (e) {\n    noWait = false;\n    setResult([{\n        title: '仓库同时访问量过大或网络差，繁忙中...\\n请耐心等待稍后再试',\n        desc: '点击尝试重新访问',\n        col_type: 'text_1',\n        url: $('#noLoading#').lazyRule(() => {\n            refreshPage(false);\n            return 'toast://已刷新'\n        })\n    }]);\n}\nif (noWait) {\n    let data = [];\n    //log(notices);\n    if(notices.length>0){\n    // let info = '道长仓库预计于2024年3月中旬下架停止运营，请各位开发者大佬妥善备份好自己的规则，插件，主题等数据';\n   // let msg=info;\n    //msg=info.slice(0,20)+'...';\n    let msg='🔔'+notices[0].name+':'+notices[0].content_text;\n    let notice_color=notices[0].color||'#ff7000';\n    let info=notices.map(it=>`<h2>${it.name} ${it.publish_time}</h2>`+it.content).join('\\n');\n    r.show(data, msg, notice_color,null,info);\n    \n    //r.show(data, msg,\"red\");\n//r.show(data, msg,\"red\",undefined, \"详细公告\");\n\n//r.show(d, msg,\"red\", \"web://https://baidu.com\");\n    }\n    \n  \n    let classTab = [\n        [\"上次活跃\", \"0\"],\n        [\"规则数\", \"1\"],\n        [\"注册时间\", \"-1\"]\n    ]\n    for (let item of classTab) {\n        data.push({\n            title: item[1] === classA ? \"““\" + item[0] + \"””\" : item[0],\n            url: $(\"#noLoading#\").lazyRule((key) => {\n                putVar(\"Warehouse.class\", key);\n                refreshPage(false);\n                return \"hiker://empty\";\n            }, item[1]),\n            col_type: \"scroll_button\"\n        });\n    }\n    data.push({\n        title: \"全部规则\",\n        url: \"hiker://page/AllPublicRule?url=hiker://empty#fypage#noHistory##noRecordHistory#\",\n        col_type: \"scroll_button\"\n    });\n    data.push({\n        title: \"刷新依赖\",\n        url: $('#noLoading#').lazyRule((jsonUrl) => {\n            jsonUrl = jsonUrl + '2505';\n            // log(jsonUrl);\n            let text = request(jsonUrl);\n            if (!/version/.test(text)) {\n                return 'toast://服务器正忙,请稍候再试...'\n            }\n            deleteCache(jsonUrl);\n            try {\n                require(jsonUrl);\n                confirm({\n                    title: '刷新成功提示',\n                    content: \"toast://已刷新,当前版本信息:\\n\" + JSON.stringify(version)\n                })\n                return 'hiker://empty'\n            } catch (e) {\n                return 'toast://糟糕，本地缓存插件被清除了，但是服务器通讯失败!'\n            }\n        }, getApi(\"importUrl\")),\n        col_type: \"scroll_button\"\n    });\n    data.push({\n        title: \"通免:\" + color(lsg.getItem(\"通免\", \"X5\"), \"#ff7000\"),\n        col_type: \"scroll_button\",\n        url: $('#noLoading#').lazyRule(() => {\n            const lsg = $.require(\"hiker://page/localStorage?rule=道长仓库Pro\");\n            if (lsg.getItem(\"通免\", \"X5\") == \"X5\") {\n                lsg.setItem(\"通免\", \"WEB\");\n            } else {\n                lsg.setItem(\"通免\", \"X5\");\n            }\n            refreshPage(false);\n            return \"toast://已设置仓库通免模式为:\" + lsg.getItem(\"通免\");\n        })\n    });\n    data.push({\n        title: \"排序:\" + color(getItem(\"排序\", \"时间优先\"), \"#ff7000\"),\n        col_type: \"scroll_button\",\n        url: $('#noLoading#').lazyRule((color) => {\n            let next = getItem(\"排序\", \"时间优先\") === '时间优先' ? '新版优先' : '时间优先';\n            setItem(\"排序\", next);\n            //refreshPage(false);\n            updateItem('sort', {\n                title: \"排序:\" + color(next, \"#ff7000\")\n            })\n            return \"toast://已设置仓库开发者规则排序模式为:\" + next;\n        }, color),\n        extra: {\n            id: 'sort'\n        }\n    });\n    data.push({\n        title: color(\"仓库公告\", \"#ff7000\"),\n        col_type: \"scroll_button\",\n        url: $('hiker://empty#noHistory##noRecordHistory#').rule((md) => {\n            require(md);\n            let d = [];\n            let 仓库公告 = \"暂无公告\";\n            try {\n                仓库公告 = fetch('https://gitcode.net/qq_32394351/dr/-/raw/master/js/仓库公告.md');\n            } catch (e) {}\n            if (仓库公告) {\n                d.push({\n                    title: marked.parse(仓库公告),\n                    col_type: 'rich_text',\n                    url: 'hiker://empty'\n                });\n            }\n            setResult(d);\n        }, md)\n    });\n\n    data.push({\n        title: color(\"升级仓库\", \"#15ab21\"),\n        col_type: \"scroll_button\",\n        url: $('#noLoading#').lazyRule(() => {\n            const {\n                getApi\n            } = $.require(\"hiker://page/utiliy\");\n            let ruleHead = '海阔视界首页频道规则【道长仓库Pro】￥home_rule_url￥';\n            let url = getApi('importUrl') + \"1094\";\n            let importUrl = 'rule://' + base64Encode(ruleHead + url);\n            return importUrl\n        })\n    });\n\n    data.push({\n        title: color(\"升级$扩展\", \"#15ab21\"),\n        col_type: \"scroll_button\",\n        url: $('#noLoading#').lazyRule(() => {\n            const {\n                getApi\n            } = $.require(\"hiker://page/utiliy\");\n            let ruleHead = '海阔视界，网页插件￥js_url￥$hiker@';\n            let url = getApi('importUrl') + \"5111\";\n            let importUrl = 'rule://' + base64Encode(ruleHead + url);\n            return importUrl\n        })\n    });\n\n    addListener('onClose', $.toString(() => {\n        clearVar(\"Warehouse.class\");\n    }));\n    let {\n        username,\n        password,\n        user\n    } = getFile();\n\n    let is_login = false;\n    let is_manager = false;\n    if (username !== void 0 && password !== void 0) {\n        myUrl += '?qq=' + username + '&password=' + password;\n        let code_str = request(myUrl, tmp_headers);\n        let code = {};\n        try {\n            code = JSON.parse(code_str);\n        } catch (e) {}\n        if (code.status === 0 && code.result.active) {\n            is_login = true;\n            if (code.result.is_manager) {\n                is_manager = true;\n                putVar('house.is_manager', '真');\n                putVar('house.username', username);\n                putVar('house.password', password);\n            } else {\n                putVar('house.is_manager', '');\n                clearVar('house.username');\n                clearVar('house.password');\n            }\n        }\n    }\n    if (is_login) {\n        try {\n            nowCon = JSON.parse(request(getApi(\"nowConUrl\"), tmp_headers)).result;\n        } catch (e) {\n            nowCon = '未知';\n        }\n        let devData = userList.find(item => item.qq === username);\n        data.push({\n            title: '<strong><span style=\"color: #ff7000\">' + devData.name + '</span></strong>&nbsp;&nbsp;&nbsp;&nbsp;<small><u>规则管理 ></u></small>',\n            pic_url: devData.avatar,\n            col_type: \"avatar\",\n            url: \"hiker://page/devManage#noHistory##noRecordHistory#\",\n            extra: {\n                //username: username,\n                //password: password,\n                dev: devData\n            }\n        });\n        data.push({\n            col_type: 'text_1',\n            title: small(\"现有 \" + color(userList.length, \"#ff7000\") + \" 名开发者，\" + color(ruleCount[0], \"#ff7000\") + \" 条公开规则，\" + color(ruleCount[1], \"#ff7000\") + \" 条集芳阁规则。在线:\" + color(nowCon, \"#ff7000\")),\n            url: \"toast://喵喵喵?\",\n        });\n    } else {\n        data.push({\n            title: small(color(\"开发者登录\", \"#00BFFF\")),\n            col_type: 'text_center_1',\n            desc: small(\"现有\" + color(userList.length, \"#ff7000\") + \"名开发者，\" + color(ruleCount[0], \"#ff7000\") + \"条公开规则，\" + color(0, \"#ff7000\") + \"条集芳阁规则。\"),\n            url: \"hiker://page/devLogin\"\n        });\n    }\n    if (Array.isArray(user) && user.length === 2) {\n        let userlogin = request(api.dis_login, {\n            headers: {\n                'content-type': 'application/json'\n            },\n            body: JSON.stringify({\n                \"params\": {\n                    \"qq\": user[0],\n                    \"auth_code\": user[1]\n                }\n            }),\n            method: 'POST',\n            timeout: timeout\n        });\n        userlogin = JSON.parse(userlogin).result;\n        if (userlogin.status === 0) {\n            userlogin = userlogin.result\n            data.push({\n                title: userlogin.name + \"&nbsp;&nbsp;\" + userlogin.qq + \"&nbsp;&nbsp;&nbsp;&nbsp;<small><u>更换账号 ></u></small>\",\n                col_type: 'avatar',\n                pic_url: userlogin.avatar_url,\n                url: \"hiker://page/Userregistration\"\n            });\n            data.splice(3, 0, {\n                title: userlogin.has_reply ? \"🆕回复\" : \"🔔回复\",\n                url: \"hiker://page/MyReply?url=hiker://empty#fypage#noHistory##noRecordHistory#\",\n                col_type: \"scroll_button\",\n                extra: {\n                    auth_code: user[1],\n                    qq: user[0]\n                }\n            });\n        } else {\n            data.push({\n                title: userlogin.detail,\n                col_type: 'text_center_1',\n                desc: \"““””<small><u>重新获取验证码 ></u></small>\",\n                url: \"hiker://page/Userregistration\"\n            });\n        }\n    } else {\n        data.push({\n            title: \"评论登录/注册\",\n            col_type: 'text_center_1',\n            desc: \"\",\n            url: \"hiker://page/Userregistration\"\n        });\n    }\n    for (var item of userList) {\n        data.push({\n            title: item.name + \"(\" + item.rule_num + \")\",\n            desc: item.id + ':' + item.nick_name,\n            pic_url: item.avatar,\n            url: \"hiker://page/rules#noHistory#\",\n            extra: {\n                avatarUrl: item.avatar,\n                qq: item.qq,\n                id: item.id,\n                can_upload: item.can_upload\n            }\n        });\n    }\n\n    data.push({\n        col_type: 'long_text'\n    });\n    setResult(data);\n    try {\n        let img = [\n            [\n                \"hiker://files/icon/赞.svg\", \"http://hiker.nokia.press/hikerule/rulelist.json?id=6756\"\n            ],\n            [\n                \"hiker://files/icon/踩.svg\", \"http://hiker.nokia.press/hikerule/rulelist.json?id=6757\"\n            ],\n            [\n                \"hiker://files/icon/评论.svg\", \"http://hiker.nokia.press/hikerule/rulelist.json?id=6758\"\n            ]\n        ];\n        for (let item of img) {\n            if (!fileExist(item[0])) {\n                downloadFile(item[1], item[0]);\n            }\n        }\n    } catch (e) {\n\n    }\n}","search_url":"hiker://empty#**","group":"a仓库","searchFind":"js:\nvar d = [];\nconst {\n    api,\n    getApi,\n    localRuleVer    \n} = $.require(\"hiker://page/utiliy\");\nvar html = request(getApi(\"search\") + \"?key=\" + MY_URL.replace(\"hiker://empty#\", \"\")); // 获取源码\nvar rule_list = JSON.parse(html).result;\nlet filter = getVar(\"Warehouse.filter\", \"\");\nif (filter !== \"\") {\n    rule_list = rule_list.filter(item => item.author === filter);\n}\nif (rule_list.length === 0) {\n    d.push({\n        title: '共搜索到' + rule_list.length + \"条记录\",\n        desc: '详情请找道长,qq 434857005',\n        url: \"hiker://empty\",\n        col_type: 'text_center_1'\n    });\n}\nlet homeList = JSON.parse(request(api.home));\n\nfor (let item of rule_list) {\n    //let lver=localRuleVer(homeList, item);\n    let label = \"\",\n        lver = -2;\n    if (item.data_type === \"home_rule_url\") {\n        lver = localRuleVer(homeList, item);\n        if (lver === -1) {\n            label = \"🆕\";\n        } else if (lver < item.ver) {\n            label = \"🆙\";\n        }\n    }\n    d.push({\n        title: label+item.name,\n        desc: item.type,\n        content: item.author/*+\"\\n本地版本:\"+lver+\"\\t\\t云端版本:\"+item.ver*/+ '\\n更新于:' + item.last_update,\n        url: \"hiker://page/ruleDetail#noHistory##noRecordHistory#\",\n        extra: {\n            lver: lver,\n            id: item.id\n        },\n        pic_url: item.pic_url\n    });\n\n}\n\nsetResult(d);","detail_col_type":"text_1","detail_find_rule":"","sdetail_col_type":"text_1","sdetail_find_rule":"","ua":"mobile","preRule":"$.require('hiker://page/libs?rule=道长仓库Pro');","pages":"[{\"col_type\":\"movie_3\",\"name\":\"工具\",\"path\":\"utiliy\",\"rule\":\"js:\\nlet host = \\\"http://hiker.nokia.press\\\";\\n//let host = \\\"http://192.168.31.49:8079\\\";\\nlet home = base64Decode(\\\"aGlrZXI6Ly9ob21l\\\");\\nvar api = {\\n    host: host+\\\"/hikerule\\\",\\n    noticeUrl:\\\"/notice/get\\\",//获取仓库公告\\n    usersUrl: \\\"/dev/users?order=\\\", //用户列表\\n    ruleCountUrl: \\\"/dev/rulecount\\\", //获取规则数量\\n    rulesUrl: \\\"/dev/get\\\", //用户对应的规则列表仅仅获取公开\\n    rulesAllUrl: \\\"/dev/getall\\\", //开发者对应的规则列表可获取私有\\n    devSelf:'/dev/getself',//获取开发者信息\\n    manCanUpload:'/set_can_upload/',//超管设置开发者是否可上传\\n    manRuleSafe:'/set_rule_safe/',//超管设置规则安全性\\n    manRuleGood:'/set_rule_good/',//超管设置规则优质性\\n    importUrl: \\\"/rulelist.json?id=\\\", //规则详情可导入\\n    infoSetUrl: \\\"/dev/set_info\\\",\\n    nowConUrl: \\\"/sql_info/get_now_con\\\",\\n    infoGetUrl: \\\"/dev/get_info?name=\\\",\\n    settingsGetUrl: \\\"/dev/get_settings?name=\\\",\\n    gupload: \\\"/dev/gupload\\\",\\n    gtimeover: \\\"/dev/gtimeover\\\",\\n    getbyid: \\\"/dev/getbyid\\\",\\n    ruleListJson: \\\"/rulelist.json\\\",\\n    auth: \\\"/dev/get_auth\\\",\\n    timeover: \\\"/dev/timeover\\\",\\n    share: \\\"/dev/share\\\",\\n    genAuth: \\\"/dev/gen_auth\\\",\\n    deleteUrl: \\\"/dev/delete\\\",\\n    jsonList: \\\"/dev/json_list\\\",\\n    search: \\\"/dev/search\\\",\\n    new_dev: \\\"/dev_regist/new\\\",\\n    new_getId: \\\"/dev_regist/get_id\\\",\\n    new_confirm: \\\"/dev_regist/confirm\\\",\\n    modify_pwd: \\\"/modify/password\\\",\\n    modify_name: \\\"/modify/name\\\",\\n    modify_ava: \\\"/modify/avatar\\\",\\n    user: \\\"/dev/user/\\\",\\n    get_rule_note: \\\"/modify/get_rule_note/\\\",\\n    set_rule_pic: \\\"/modify/rule_pic/\\\",\\n    set_rule_note: \\\"/modify/rule_note/\\\"\\n}\\n$.exports.range = function(m, n) {\\n    return Math.floor(Math.random() * (m - n + 1) + n);\\n}\\n$.exports.mapColType = function(target, type, n) {\\n    for (let i = 0; i < n; i++) {\\n        target.push({\\n            col_type: type\\n        });\\n    }\\n}\\nvar getApi = function(k) {\\n    return api.host + api[k];\\n};\\n$.exports.getApi=getApi;\\n$.exports.md=getApi('importUrl')+\\\"3187\\\";\\n$.exports.localRuleVer = function(localRuleList, rule) {\\n    let localRule;\\n    for (let i = 0; i < localRuleList.length; i++) {\\n        let item = localRuleList[i];\\n        let au = item.author || \\\"\\\";\\n        let sameAu=au.length > 0 && rule.author.includes(au);\\n        sameAu=true;//不判断作者默认为true\\n        if (item.title === rule.name && sameAu) {\\n            localRule = item;\\n            break;\\n        }\\n    }\\n    if (localRule === void 0) {\\n        return -1;\\n    } else {\\n        return localRule.version;\\n    }\\n}\\n$.exports.color = function(text, color) {\\n    text += \\\"\\\";\\n    if (text.indexOf(\\\"““””\\\") === 0) {\\n        text.replace(\\\"““””\\\", \\\"\\\");\\n    }\\n    return \\\"““””<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n}\\n\\n$.exports.sleep = function(timeout){\\n    java.lang.Thread.sleep(timeout);\\n}\\nfunction htmlTag(tag, text) {\\n    text += \\\"\\\";\\n    if (text.indexOf(\\\"““””\\\") === 0) {\\n        text.replace(\\\"““””\\\", \\\"\\\");\\n    }\\n    return \\\"““””\\\" + \\\"<\\\" + tag + \\\">\\\" + text + \\\"</\\\" + tag + \\\">\\\";\\n\\n}\\n\\nfunction getNowFormatDate() {\\n            let date = new Date();\\n            let seperator1 = \\\"-\\\";\\n            let seperator2 = \\\":\\\";\\n            let month = date.getMonth() + 1;\\n            let strDate = date.getDate();\\n            let strHours = date.getHours();\\n            let strMinutes = date.getMinutes();\\n            let strSeconds = date.getSeconds()+1;\\n            if (month >= 1 && month <= 9) {\\n                month = \\\"0\\\" + month\\n            }\\n            if (strDate >= 0 && strDate <= 9) {\\n                strDate = \\\"0\\\" + strDate\\n            }\\n            if (strHours >= 0 && strHours <= 9) {\\n                strHours = \\\"0\\\" + strHours\\n            }\\n            if (strMinutes >= 0 && strMinutes <= 9) {\\n                strMinutes = \\\"0\\\" + strMinutes\\n            }\\n            if (strSeconds >= 0 && strSeconds <= 9) {\\n                strSeconds = \\\"0\\\" + strSeconds\\n            }\\n            //let currentdate = date.getFullYear() + seperator1 + month + seperator1 + strDate + \\\" \\\" + strHours + seperator2 + strMinutes + seperator2 + strSeconds;\\n            let currentdate = (date.getFullYear()-2020)+''+ month +''+ strDate +''+ strHours+'' + strMinutes +''+ Math.ceil(strSeconds/7);\\n            return parseInt(currentdate)\\n        }\\n$.exports.getNowFormatDate = getNowFormatDate;\\n$.exports.htmlTag = htmlTag;\\n$.exports.small = function(text) {\\n    return htmlTag(\\\"small\\\", text);\\n}\\n$.exports.getFile = function() {\\n    var File = request(\\\"hiker://files/WarehouseUSER.json\\\") || \\\"{}\\\";\\n    try {\\n        return JSON.parse(File);\\n    } catch (e) {\\n        writeFile(\\\"hiker://files/WarehouseUSER.json\\\", \\\"{}\\\");\\n        return {};\\n    }\\n}\\n$.exports.getUserDate =function(){\\n    var File = request(\\\"hiker://files/WarehouseUSERA.json\\\") || \\\"[]\\\";\\n    try {\\n        return JSON.parse(File);\\n    } catch (e) {\\n        writeFile(\\\"hiker://files/WarehouseUSERA.json\\\", \\\"[]\\\");\\n        return [];\\n    }\\n}\\n$.exports.existFile = function(spath, ipath, headers) {\\n    let scode = request(spath);\\n    if (!scode) {\\n        writeFile(spath, request(ipath, headers));\\n    }\\n}\\n\\nlet newApi = {\\n    \\\"dis_new\\\": \\\"/hikerule/new_rule_discuss/\\\",\\n    \\\"dis_verify\\\": \\\"/hikerule/rule_discuss/get_yzm\\\",\\n    \\\"dis_get\\\": \\\"/hikerule/rule_discuss/\\\",\\n    \\\"dis_set\\\": \\\"/hikerule/modify/can_discuss/\\\",\\n    \\\"dis_new_user\\\": \\\"/hikerule/rule_discuss/new_user\\\",\\n    \\\"dis_login\\\":\\\"/hikerule/rule_discuss/user_login\\\",\\n    \\\"dis_dev_discuss\\\":\\\"/hikerule/modify/dev_can_discuss\\\",\\n    \\\"dis_dev_control\\\":\\\"/hikerule/rule_discuss/remove/\\\",\\n    \\\"all_rule\\\":\\\"/hikerule/get_rules\\\",\\n    \\\"dis_get_reply\\\":\\\"/hikerule/get_reply_rule_discuss\\\",\\n    \\\"dis_reply\\\":\\\"/hikerule/dev_new_rule_discuss/\\\",\\n}\\n\\nfunction setApi(object) {\\n    let target = {};\\n    for (let key in object) {\\n        target[key]=host+object[key]\\n    }\\n    return target;\\n}\\n\\n$.exports.api = setApi(newApi);\\n$.exports.api.host=host;\\n$.exports.api.home=home;\"},{\"col_type\":\"movie_3\",\"name\":\"开发者登录\",\"path\":\"devLogin\",\"rule\":\"js:\\nsetPageTitle(\\\"开发者登录\\\");\\nconst {\\n    getApi,\\n    htmlTag,\\n    mapColType,\\n    small,\\ngetFile\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nvar data = [];\\naddListener('onClose', $.toString(()=>{\\n    clearVar(\\\"WarehouseUsername\\\");\\n    clearVar(\\\"WarehousePassword\\\");\\n}))\\ndata.push({\\n    title: '账号',\\n    col_type: 'input',\\n    extra: {\\n        defaultValue: getVar('WarehouseUsername',''),\\n        type:\\\"number\\\",\\n        onChange: 'putVar(\\\"WarehouseUsername\\\",input)'\\n    }\\n}, {\\n    title: '密码',\\n    col_type: 'input',\\n    extra: {\\n        defaultValue: getVar('WarehousePassword', ''),\\n        type: \\\"password\\\",\\n        onChange: 'putVar(\\\"WarehousePassword\\\",input)'\\n    }\\n});\\n\\ndata.push({\\n    title:\\\"&nbsp;&nbsp;<a href='hiker://page/Register'>注册</a>\\\",\\n    col_type:\\\"rich_text\\\"\\n});\\nmapColType(data, \\\"line_blank\\\", 1);\\nlet user = getFile();\\ndata.push({\\n    title: htmlTag(\\\"b\\\", \\\"登录\\\"),\\n    url: $().lazyRule((url, f)=> {\\n        let username = getVar('WarehouseUsername', ''),\\n            password = getVar('WarehousePassword', '');\\n        if(username === \\\"\\\" && password ===\\\"\\\"){\\n            return \\\"toast://账号和密码不能为空\\\"\\n        }\\n        let myUrl = url + '?qq=' + username + '&password=' + password;\\n        let code_str = request(myUrl);\\n        let code = JSON.parse(code_str);\\n        if (code.status == 0) {\\n            f.username=username;\\n            f.password=password\\n            writeFile('hiker://files/WarehouseUSER.json', JSON.stringify(f));\\n            back();\\n            return \\\"toast://登录成功\\\";\\n        }else{\\n            return \\\"toast://账号或密码错误\\\";\\n        }\\n    }, getApi(\\\"rulesAllUrl\\\"),user),\\n    col_type: 'text_center_1'\\n});\\nsetResult(data);\"},{\"col_type\":\"icon_2_round\",\"name\":\"开发者管理\",\"path\":\"devManage\",\"rule\":\"js:\\nsetPageTitle(\\\"规则管理\\\");\\n\\nconst {\\n    getApi,\\n    color,\\n    small,\\n    getFile,\\n    existFile,\\n    mapColType,\\n    api\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    dev\\n} = MY_PARAMS;\\nlet {\\n    username,\\n    password,\\n} = getFile();\\n//existFile(\\\"hiker://files/rules/dzHouse/html/开发者分享.html\\\", \\\"https://erp.scwinbao.com/hikerule/rulelist.json?id=539\\\");\\nlet ruleList = JSON.parse(request(getApi(\\\"rulesAllUrl\\\") + '?qq=' + username + '&password=' + password)).result;\\nlet MOBILE_UA = 'Mozilla/5.0 (Linux; Android 5.0; SM-G900P Build/LRX21T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Mobile Safari/537.36';\\nlet infoSetUrl = getApi(\\\"infoSetUrl\\\");\\nlet infoGetUrl = getApi(\\\"infoGetUrl\\\") + username;\\nlet settingsGetUrl = getApi(\\\"settingsGetUrl\\\") + username;\\nputMyVar(\\\"dev_set_info\\\", [username, password, infoSetUrl, MOBILE_UA, infoGetUrl].join(\\\"$$\\\"));\\nlet data = [];\\ndata.push({\\n    title: '““””<big>仓库设置</big>&nbsp;&nbsp;&nbsp;<small><u>（ 个人资料 >）</u></small>',\\n    desc: '““””您共有 <span style=\\\"color: #ff7000\\\">' + ruleList.length + '</span>' + \\\" 条规则。\\\\n点击规则可进行分享、删除、导入操作及查看详情\\\",\\n    url: \\\"hiker://page/PersonalData#noHistory##noRecordHistory#\\\",\\n    extra:{id:dev.id},\\n    col_type: 'text_1'\\n});\\nmapColType(data, \\\"line\\\", 2);\\ndata.push({\\n    title: small(color(\\\"更改公告✍\\\", \\\"#34b1ff\\\")),\\n    // url: \\\"x5://file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/rules/dzHouse/html/dev_info_edit.html\\\",\\n    url: \\\"hiker://page/devInfoEdit\\\",\\n    col_type: 'text_3'\\n});\\ndata.push({\\n    title: small(color(\\\"更多分享📲\\\", \\\"#34b1ff\\\")),\\n    //url: \\\"x5://file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/rules/dzHouse/html/开发者分享.html\\\",\\n    url: \\\"hiker://page/moreShare\\\",\\n    col_type: 'text_3'\\n});\\ndata.push({\\n    title: small(color(\\\"升级依赖📥\\\", \\\"#34b1ff\\\")),\\n    url: $(\\\"升级会重新从仓库拉取相关的静态页面到本地\\\\n确认升级吗?\\\").confirm((host) => {\\n        writeFile(\\\"hiker://files/rules/dzHouse/html/开发者分享.html\\\", request(host+'/hikerule/rulelist.json?id=539'));\\n        writeFile(\\\"hiker://files/rules/dzHouse/html/dev_info_edit.html\\\", request(host+'/hikerule/rulelist.json?id=402'));\\n        writeFile(\\\"hiker://files/rules/dzHouse/html/dev_info_get.html\\\", request(host+'/hikerule/rulelist.json?id=404'));\\n        refreshPage(false);\\n        return \\\"toast://已重置开发者分享,简介查看,简介编辑等静态文件\\\";\\n    },api.host),\\n    col_type: 'text_3'\\n});\\nlet devSetBack;\\ntry {\\n    devSetBack = JSON.parse(request(settingsGetUrl));\\n} catch (e) {\\n    devSetBack = {};\\n}\\n\\nfunction setSettingItem(basic) {\\n    let temp = {\\n        title: basic.title,\\n        col_type: basic.col_type,\\n        url: $(basic.confirm).confirm((url, msg) => {\\n            let back = request(url);\\n            let ret = JSON.parse(back);\\n            if (ret.status == 0) {\\n                refreshPage(true);\\n                return \\\"toast://\\\" + msg[0];\\n            } else {\\n                refreshPage(false);\\n                return \\\"toast://\\\" + msg[1] + \\\"\\\\n\\\" + ret.detail;\\n            }\\n        }, basic.url, basic.msg)\\n    };\\n    return temp;\\n}\\nif (devSetBack.status == 0) {\\n    let devSettings = devSetBack.result;\\n    let share = {\\n        col_type: \\\"text_3\\\"\\n    };\\n    if (devSettings.share_public) {\\n        share.title = small(color(\\\"公开上传\\\", \\\"green\\\") + color(\\\"(私藏)\\\", \\\"#00bfff\\\"));\\n        share.url = getApi(\\\"gupload\\\") + \\\"?qq=\\\" + username + \\\"&password=\\\" + password + \\\"&flag=1\\\";\\n        share.confirm = \\\"是否确认私藏以后提交的规则?\\\";\\n        share.msg = [\\\"已私藏\\\", \\\"私藏失败\\\"];\\n    } else {\\n        share.title = small(color(\\\"私密上传\\\", \\\"red\\\") + color(\\\"(公开)\\\", \\\"#adff2f\\\"));\\n        share.url = getApi(\\\"gupload\\\") + \\\"?qq=\\\" + username + \\\"&password=\\\" + password;\\n        share.confirm = \\\"是否确认公开以后提交的规则?\\\";\\n        share.msg = [\\\"已公开\\\", \\\"公开失败\\\"];\\n    }\\n    data.push(setSettingItem(share));\\n    let timeOver = {\\n        col_type: \\\"text_3\\\"\\n    };\\n    if (devSettings.time_over) {\\n        timeOver.title = small(color(\\\"短时秘钥\\\", \\\"green\\\") + color(\\\"(永久)\\\", \\\"#00bfff\\\"));\\n        timeOver.url = getApi(\\\"gtimeover\\\") + \\\"?qq=\\\" + username + \\\"&password=\\\" + password + \\\"&flag=1\\\";\\n        timeOver.confirm = \\\"是否确认以后的私藏规则分享不过期?\\\";\\n        timeOver.msg = [\\\"已设为永久\\\", \\\"设为永久失败\\\"];\\n    } else {\\n        timeOver.title = small(color(\\\"永久秘钥\\\", \\\"red\\\") + color(\\\"(过期)\\\", \\\"#adff2f\\\"));\\n        timeOver.url = getApi(\\\"gtimeover\\\") + \\\"?qq=\\\" + username + \\\"&password=\\\" + password;\\n        timeOver.confirm = \\\"确认要以后分享的私藏规则自动到期?\\\";\\n        timeOver.msg = [\\\"已设为过期\\\", \\\"设为过期失败\\\"];\\n    }\\n    data.push(setSettingItem(timeOver));\\n    let discuss = {\\n        col_type: \\\"text_3\\\"\\n    };\\n    if (devSettings.can_discuss) {\\n        discuss.title = small(color(\\\"允许评论\\\", \\\"red\\\") + color(\\\"(不许)\\\", \\\"#adff2f\\\"));\\n        discuss.url = api.dis_dev_discuss + \\\"?qq=\\\" + username + \\\"&password=\\\" + password+ \\\"&flag=1\\\";\\n        discuss.confirm = \\\"是否确认以后上传的规则允许评论?\\\";\\n        discuss.msg = [\\\"已设为不许\\\", \\\"设置失败\\\"];\\n\\n    } else {\\n        discuss.title = small(color(\\\"不许评论\\\", \\\"green\\\") + color(\\\"(允许)\\\", \\\"#00bfff\\\"));\\n        discuss.url = api.dis_dev_discuss + \\\"?qq=\\\" + username + \\\"&password=\\\" + password;\\n        discuss.confirm = \\\"是否确认以后上传的规则允许评论?\\\";\\n        discuss.msg = [\\\"已设为允许\\\", \\\"设置失败\\\"];\\n    }\\n    data.push(setSettingItem(discuss));\\n}\\nmapColType(data, \\\"line\\\", 2);\\nfor (let item of ruleList) {\\n    let my_t_excode1 = '';\\n    let my_t_excode2 = '';\\n    if (item.state != 'public') {\\n        my_t_excode1 += '㊙️';\\n    } else {\\n        my_t_excode1 += '';\\n    }\\n    data.push({\\n        title: my_t_excode1 + item.name + my_t_excode2,\\n        url: \\\"hiker://page/manageRule#noHistory##noRecordHistory#\\\",\\n        extra: {\\n            id: item.id,\\n            //username: username,\\n            //password: password\\n        },\\n        pic_url: item.pic,\\n    })\\n}\\nif (ruleList.length === 0) {\\n    data.push({\\n        title: \\\"<h5 style='text-align:center'>快来上传你的第一条规则吧！</h5>\\\",\\n        col_type: \\\"rich_text\\\"\\n    });\\n}\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"规则详细-dev\",\"path\":\"manageRule\",\"rule\":\"js:\\n    const {\\n        getApi,\\n        color,\\n        small,\\n        getFile,\\n        existFile,\\n        mapColType,\\n        htmlTag,\\n        api,\\n        md,\\n    } = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    id\\n} = MY_PARAMS;\\nlet {\\n    username,\\n    password,\\n} = getFile();\\naddListener('onClose', $.toString(() => {\\n    refreshPage(false);\\n}));\\nlet dataItem = JSON.parse(request(getApi(\\\"getbyid\\\") + \\\"?id=\\\" + id)).result;\\nsetPageTitle(\\\"编辑「\\\" + dataItem.name + \\\"」\\\");\\nlet reqByGet = \\\"?id=\\\" + dataItem.id + \\\"&qq=\\\" + username + \\\"&password=\\\" + password;\\nlet ruleListJson = getApi(\\\"ruleListJson\\\") + \\\"?id=\\\";\\nlet data = [];\\ndata.push({\\n    title: htmlTag(\\\"big\\\", \\\"版本\\\"),\\n    desc: \\\"““””云端版本:\\\" + color(dataItem.ver, \\\"#5cff2c\\\") + \\\"\\\\n上次提交于: [\\\" + color(dataItem.last_update, \\\"#ff7000\\\") + \\\"]\\\",\\n    url: $(\\\"<开发者>\\\\n\\\" + dataItem.author + \\\"\\\\n<名称>\\\\n\\\" + dataItem.name + \\\"\\\\n<云端版本>\\\\n\\\" + dataItem.ver + \\\"\\\\n<更新时间>\\\\n[\\\" + dataItem.last_update + \\\"]\\\").confirm(() => {}),\\n    col_type: 'text_1'\\n});\\nlet dataType = {\\n    home_rule_url: '首页云规则',\\n    publish: '提交云仓库规则',\\n    js_url: '网页插件规则',\\n    html: '静态页面',\\n    config: '主页配置'\\n};\\n\\nlet basic = {\\n    col_type: \\\"text_1\\\",\\n    url: \\\"hiker://empty\\\"\\n};\\nlet dataTypeTips = dataType[dataItem.data_type] || '未知规则:' + dataItem.data_type;\\n\\nbasic.title = htmlTag(\\\"big\\\", \\\"类型\\\") + \\\"\\\\t\\\\t\\\\t\\\" + small(\\\"(id:\\\" + dataItem.id + \\\")\\\");\\nbasic.desc = \\\"数据类型：\\\" + color(dataTypeTips, \\\"#cb54ff\\\") + \\\"\\\\n分享状态为：\\\" + dataItem.state;\\nif ([\\\"html\\\", \\\"config\\\", \\\"js_url\\\"].includes(dataItem.data_type)) {\\n    basic.desc += \\\"\\\\n““”” =>\\\" + small(\\\"点此预览\\\");\\n    basic.url = ruleListJson + dataItem.id;\\n}\\nlet auth = \\\"\\\";\\nif (dataItem.state == \\\"private\\\") {\\n    let auth_back = JSON.parse(request(getApi(\\\"auth\\\") + reqByGet));\\n    basic.title = basic.title + \\\"\\\\n\\\" + small(color(auth_back.result, \\\"grey\\\"));\\n    auth = '&auth=' + auth_back.result;\\n    basic.url = basic.url === \\\"hiker://empty\\\" ? basic.url : basic.url + auth;\\n}\\ndata.push(basic);\\nlet notes = request(getApi(\\\"get_rule_note\\\") + id);\\nnotes = JSON.parse(notes).result;\\nrequire(md);\\nlet notesHtml=\\\"\\\"\\ntry{\\n    notesHtml=marked.parse(notes);\\n}catch(e){}\\nif (notes !== false) {\\n    data.push({\\n        title: htmlTag(\\\"big\\\", \\\"备注\\\") + \\\"\\\\t\\\\t\\\\t\\\" + small(htmlTag(\\\"u\\\", \\\"查看完整公告 >\\\")),\\n        desc: notes,\\n        col_type: \\\"text_1\\\",\\n        url: \\\"hiker://page/info\\\",\\n        extra: {\\n            text: notesHtml,\\n            name: dataItem.name,\\n            // type: \\\"long_text\\\"\\n            type: \\\"rich_text\\\"\\n        }\\n    });\\n}\\ndata.push({\\n    title: htmlTag(\\\"big\\\", \\\"操作\\\"),\\n    col_type: \\\"text_1\\\",\\n    url: \\\"toast://你才是最帅的那个人！\\\"\\n});\\nlet importUrl, ruleCode, shareUrl, backCode = \\\"\\\";\\nlet subUrl = ruleListJson + dataItem.id + auth;\\nif (!dataItem.is_json) {\\n    backCode = request(subUrl);\\n}\\nswitch (dataItem.data_type) {\\n    case \\\"home_rule_url\\\":\\n        ruleCode = \\\"海阔视界首页频道规则【\\\" + dataItem.name + \\\"】￥home_rule_url￥\\\" + ruleListJson + dataItem.id + auth;\\n        importUrl = \\\"rule://\\\" + base64Encode(ruleCode)\\n        break;\\n    case 'publish':\\n        ruleCode = '海阔视界规则分享，当前分享的是：' + dataItem.name + '￥publish￥' + base64Encode(backCode);\\n        importUrl = 'rule://' + base64Encode(ruleCode);\\n        break;\\n    case 'js_url':\\n        ruleCode = '海阔视界规则分享，当前分享的是：网页插件￥js_url￥' + dataItem.name + '@base64://' + base64Encode(backCode);\\n        importUrl = 'rule://' + base64Encode(ruleCode);\\n        break;\\n    case 'html':\\n        let file_tmp = dataItem.name.split('.');\\n        let file_path = file_tmp.length > 1 ? file_tmp[file_tmp.length - 1] + \\\"/\\\" + dataItem.name : dataItem.name;\\n        ruleCode = \\\"海阔视界本地文件分享￥file_url￥hiker://files/rules/dzHouse/\\\" + file_path + \\\"@\\\" + ruleListJson + dataItem.id + auth;\\n        importUrl = 'rule://' + base64Encode(ruleCode);\\n        break\\n    case \\\"config\\\":\\n        importUrl = $().rule(password => {\\n            eval(fetch(\\\"hiker://assets/home.js\\\"));\\n            HikerHome.load(\\\"import\\\", password);\\n        }, backCode);\\n        break;\\n}\\nlet my_col_type = \\\"text_2\\\";\\nif (importUrl) {\\n    data.push({\\n        title: \\\"导入规则\\\",\\n        url: importUrl,\\n        col_type: my_col_type\\n    });\\n    if(dataItem.is_json_list&&/home_rule_url|html/.test(dataItem.data_type)){\\n        data.push({\\n            title: '““””<span style=\\\"color: #ff7000\\\">导入道德经</span>',\\n            url: $().lazyRule((dataItem,subUrl)=>{\\n                // let title = \\\"H-\\\"+dataItem.name+\\\".\\\"+dataItem.author;\\n                let title = \\\"J-\\\"+dataItem.name.split('.')[0];\\n                let subObj = {\\n                    title: title,\\n                    url: subUrl,\\n                    desc: \\\"hiker://files/rules/dzHouse/ruleCache/\\\"+title+\\\".json\\\",\\n                    code: \\\"\\\",\\n                    active: false,//禁用并发更新\\n                }\\n                let shareText = base64Encode(JSON.stringify(subObj));\\n                var pastes = getPastes();\\n                var url = sharePaste(shareText,pastes.slice(-1)[0]);\\n                let import_rule= \\\"轻合集订阅：\\\"+title+'\\\\n'+url;\\n                copy(import_rule);\\n                const path = 'hiker://files/rules/dzHouse/ruleCache/sub.json';\\n                $.rc(config.lib.sub);\\n                return 订阅导入(path)\\n            },dataItem,subUrl),\\n            col_type: my_col_type\\n        });\\n    }\\n}\\nif (ruleCode) {\\n    data.push({\\n        title: \\\"分享规则\\\",\\n        url: \\\"copy://\\\" + ruleCode,\\n        col_type: my_col_type\\n    });\\n}\\n\\nfunction setSettingItem(basic, pattern) {\\n    let temp = {\\n        title: basic.title,\\n        col_type: basic.col_type,\\n        url: $(basic.confirm).confirm((url, msg, pattern) => {\\n            let backA = request(url);\\n            let ret = JSON.parse(backA);\\n            if (ret.status == 0) {\\n                pattern ? back() : refreshPage(false);\\n                return \\\"toast://\\\" + msg[0];\\n            } else {\\n                pattern ? back() : refreshPage(false);\\n                return \\\"toast://\\\" + msg[1] + \\\"\\\\n\\\" + ret.detail;\\n            }\\n        }, basic.url, basic.msg, pattern)\\n    };\\n    return temp;\\n}\\nif (dataItem.state == 'private') {\\n    data.push({\\n        title: \\\"设为公开\\\",\\n        url: $(getApi(\\\"share\\\") + reqByGet + \\\"&flag\\\" + \\\"#noLoading#\\\").lazyRule(() => {\\n            request(input);\\n            refreshPage(false);\\n            return \\\"toast://已设为公开\\\";\\n        }),\\n        col_type: my_col_type\\n    }, {\\n        title: \\\"随机密钥\\\",\\n        col_type: my_col_type,\\n        url: $(getApi(\\\"genAuth\\\") + reqByGet + \\\"#noLoading#\\\").lazyRule(() => {\\n            let back = request(input);\\n            let ret = JSON.parse(back);\\n            if (ret.status == 0) {\\n                refreshPage(false);\\n                return \\\"toast://已生成随机密码\\\\n\\\" + ret.result\\n            } else {\\n                refreshPage(true);\\n                return \\\"toast://随机密码生成失败\\\"\\n            }\\n        })\\n    });\\n    let timeOver = {\\n        col_type: my_col_type\\n    };\\n    if (dataItem.time_over) {\\n        timeOver.title = small(color(\\\"短时密钥\\\", \\\"green\\\") + color(\\\"(→永久)\\\", \\\"red\\\"));\\n        timeOver.url = getApi(\\\"timeover\\\") + reqByGet + \\\"&flag=1\\\";\\n        timeOver.confirm = \\\"是否确认以后的私藏规则分享不过期?\\\";\\n        timeOver.msg = [\\\"已设为永久\\\", \\\"设为永久失败\\\"];\\n    } else {\\n        timeOver.title = small(color(\\\"永久密钥\\\", \\\"red\\\") + color(\\\"(→短时)\\\", \\\"green\\\"));\\n        timeOver.url = getApi(\\\"timeover\\\") + reqByGet;\\n        timeOver.confirm = \\\"确认要以后分享的私藏规则自动到期?\\\";\\n        timeOver.msg = [\\\"已设为过期\\\", \\\"设为过期失败\\\"];\\n    }\\n    data.push(setSettingItem(timeOver));\\n} else if (dataItem.state == 'public') {\\n    data.push({\\n        title: \\\"设为私有\\\",\\n        url: $(getApi(\\\"share\\\") + reqByGet + \\\"&flag=1#noLoading#\\\").lazyRule(() => {\\n            request(input);\\n            refreshPage(false);\\n            return \\\"toast://已设为私有\\\";\\n        }),\\n        col_type: my_col_type\\n    });\\n}\\ndata.push(setSettingItem({\\n    title: \\\"删除数据\\\",\\n    confirm: \\\"是否确认删除\\\",\\n    msg: [\\\"已删除\\\", \\\"删除失败\\\"],\\n    url: getApi(\\\"deleteUrl\\\") + reqByGet,\\n    col_type: my_col_type\\n}, true));\\ndata.push({\\n    title: \\\"设置图标\\\",\\n    url: $(dataItem.pic_url, \\\"输入图标地址\\\").input(api => {\\n        if (input === \\\"\\\") {\\n            return \\\"toast://你在逗我链接哪?\\\"\\n        }\\n        let result = request(api + \\\"&rule_pic=\\\" + input);\\n        result = JSON.parse(result);\\n        if (result.status !== 0) {\\n            return \\\"toast://\\\" + result.detail;\\n        }\\n        return \\\"toast://修改成功\\\";\\n    }, getApi(\\\"set_rule_pic\\\") + dataItem.id + reqByGet),\\n    col_type: my_col_type\\n});\\n\\ndata.push({\\n    title: dataItem.can_discuss ? \\\"禁止评论\\\" : \\\"开启评论\\\",\\n    url: $(api.dis_set + dataItem.id + reqByGet + \\\"&state=\\\" + (dataItem.can_discuss ? \\\"\\\" : 1)).lazyRule((can_discuss) => {\\n        request(input);\\n        refreshPage(false);\\n        return can_discuss ? \\\"toast://已禁止评论\\\" : \\\"toast://已开启评论\\\";\\n    }, dataItem.can_discuss),\\n    col_type: my_col_type\\n});\\nMY_PARAMS.name = dataItem.name;\\nMY_PARAMS.username=username;\\nMY_PARAMS.password=password;\\ndata.push({\\n    title: \\\"设置备注\\\",\\n    url: \\\"hiker://page/set_rule_notes\\\",\\n    extra: MY_PARAMS,\\n    col_type: my_col_type\\n});\\nif (dataItem.is_json && dataItem.data_type === \\\"home_rule_url\\\" && !dataItem.is_json_list) {\\n    data.push({\\n        title: '进入频道',\\n        url: $( \\\"#noLoading#\\\" ).lazyRule((name,home) => {\\n            let hasRule = request('hiker://home@'+name) != 'null';\\n            if (hasRule) {\\n                backToHome();\\n                return home+\\\"s@\\\" + name;\\n            } else {\\n                return \\\"toast://未安装\\\";\\n            }\\n        }, dataItem.name,api.home),\\n        col_type: my_col_type\\n    });\\n}\\ndata.push({\\n    col_type: \\\"line_blank\\\"\\n});\\ndata.push({\\n    title: dataItem.good_num,\\n    pic_url: \\\"hiker://files/icon/赞.svg\\\",\\n    col_type: \\\"icon_small_3\\\",\\n    url: \\\"hiker://empty\\\"\\n});\\ndata.push({\\n    title: dataItem.bad_num,\\n    pic_url: \\\"hiker://files/icon/踩.svg\\\",\\n    col_type: \\\"icon_small_3\\\",\\n    url: \\\"hiker://empty\\\"\\n});\\ndata.push({\\n    title: \\\"评论\\\",\\n    pic_url: \\\"hiker://files/icon/评论.svg\\\",\\n    col_type: \\\"icon_small_3\\\",\\n    url: \\\"hiker://page/Reply#noHistory##noRecordHistory#\\\",\\n    extra: {\\n        ruleId: dataItem.id,\\n        name: dataItem.author,\\n        password: password,\\n        username: username\\n    }\\n});\\nlet totalSum = dataItem.good_num + dataItem.bad_num;\\n\\ndata.push({\\n    title: htmlTag(\\\"big\\\", \\\"评论(\\\" + totalSum + \\\")\\\") + \\\"\\\\t\\\\t\\\\t\\\" + small(htmlTag(\\\"u\\\", \\\"查看全部评论(控评) >\\\")),\\n    col_type: \\\"text_1\\\",\\n    url: \\\"hiker://page/Comment\\\",\\n    extra: {\\n        url: \\\"hiker://empty#fypage#noHistory##noRecordHistory#\\\",\\n        id: dataItem.id,\\n        totalSum: totalSum,\\n        no_active: true,\\n        username: username,\\n        password: password\\n    }\\n});\\n//const longestSum=120;\\nlet icon = {\\n    \\\"good\\\": \\\"👍\\\",\\n    \\\"bad\\\": \\\"👎\\\",\\n    \\\"reply\\\": \\\"开发者🗣\\\"\\n}\\nif (totalSum === 0) {\\n    data.push({\\n        title: \\\"<h5 style='text-align:center'>一条评论也没有，快来抢沙发吧！</h5>\\\",\\n        col_type: \\\"rich_text\\\"\\n    });\\n} else {\\n    let commentList = JSON.parse(request(api.dis_get + dataItem.id + \\\"?limit=5\\\")).result;\\n    for (let item of commentList) {\\n        let Reply = item.discuss_type===\\\"reply\\\"&&item.reply_to_name!==false&&item.reply_to_id!==false?\\\"‘‘回复@\\\"+item.reply_to_name+\\\" #\\\"+item.discuss_id+\\\"’’\\\\n\\\":\\\"\\\";\\n        data.push({\\n            title: item.name + \\\"&nbsp;&nbsp;<font color='gray'><small>#\\\" + item.id + \\\"</small><font>\\\",\\n            col_type: \\\"avatar\\\",\\n            url: \\\"hiker://page/Reply\\\",\\n            extra:{\\n                ruleId: dataItem.id,\\n                name: item.name,\\n                password: password,\\n                username: username,\\n                replyId:item.id\\n            },\\n            pic_url: item.avatar_url\\n        });\\n        data.push({\\n            title: item.discuss_text,\\n            desc: Reply+item.create_date + \\\"·\\\" + icon[item.discuss_type],\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/info\\\",\\n            extra: {\\n                name: item.name,\\n                type: \\\"long_text\\\",\\n                text: item.discuss_text\\n            },\\n            pic_url: item.avatar_url\\n        });\\n    }\\n}\\ndata.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nsetResult(data);\"},{\"col_type\":\"icon_2_round\",\"name\":\"规则列表\",\"path\":\"rules\",\"rule\":\"js:\\naddListener('onClose', $.toString(() => {\\n    clearVar(\\\"Warehouse.filter\\\");\\n    clearVar(\\\"Warehouse.type\\\");\\n    if (getVar('Warehouse.can_upload', '')) {\\n        log('操作过禁止上传:' + getVar('Warehouse.can_upload'));\\n        clearVar(\\\"Warehouse.can_upload\\\");\\n        refreshPage(true);\\n    }\\n}));\\n\\n\\nconst {\\n    getApi,\\n    api,\\n    color,\\n    small,\\n    localRuleVer,\\n    htmlTag,\\n    md\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nconst {\\n    normalSort\\n} = $.require(\\\"hiker://page/sort\\\");\\nlet {\\n    avatarUrl,\\n    qq,\\n    id,\\n    can_upload\\n} = MY_PARAMS;\\nlet dataType = getVar(\\\"Warehouse.type\\\", \\\"\\\");\\nlet backCode = JSON.parse(request(getApi(\\\"rulesUrl\\\") + \\\"?name=\\\" + qq + \\\"&data_type=\\\" + dataType));\\nlet devName = backCode.dev_name;\\nputVar(\\\"Warehouse.filter\\\", devName);\\nlet ruleList = backCode.result;\\nlet subUrl = getApi(\\\"jsonList\\\") + \\\"?name=\\\" + qq;\\nlet hasSub = hasHomeSub(subUrl);\\nlet devInfo = \\\"这个人很懒,什么都没写哦~\\\";\\nlet tmpJson = JSON.parse(request(getApi(\\\"infoGetUrl\\\") + qq));\\nif (tmpJson.status == 0) {\\n    devInfo = tmpJson.result || devInfo;\\n}\\nlet subFlag = hasSub ? '🆗' : '📡';\\nlet data = [];\\nrequire(md);\\ndevInfo = marked.parse(devInfo);\\ndata.push({\\n    title: \\\"““””\\\" + devName + \\\"\\\\n\\\\n\\\" + small(htmlTag(\\\"u\\\", \\\"点击查看完整公告\\\")),\\n    desc: small(devInfo),\\n    url: 'hiker://page/info',\\n    extra: {\\n        text: devInfo,\\n        name: devName,\\n        type: \\\"rich_text\\\"\\n    },\\n    pic_url: avatarUrl,\\n    col_type: 'movie_1_vertical_pic'\\n});\\ndata.push({\\n    title: \\\"<big>订阅管理</big>&nbsp;&nbsp;<small>(当前\\\" + (hasSub ? \\\"已订阅\\\" : \\\"未订阅\\\") + \\\")</small>\\\",\\n    col_type: \\\"rich_text\\\"\\n});\\n\\nlet sub_code = '海阔视界合集规则订阅￥home_sub￥' + devName + \\\"合集@@\\\" + subUrl;\\nlet rulesCode = '海阔视界合集规则￥home_rule_url￥' + subUrl;\\ndata.push({\\n    title: '““””<span style=\\\"color: #ff7000\\\">一键订阅</span>',\\n    desc: '订阅““””<span style=\\\"color: #5cff2c\\\">' + devName + '</span>的所有单规则，合集需单独订阅',\\n    url: sub_code,\\n    col_type: 'text_2'\\n});\\ndata.push({\\n    title: '““””<span style=\\\"color: #ff7000\\\">导入全部</span>',\\n    url: rulesCode,\\n    col_type: 'text_2'\\n});\\ndata.push({\\n    title: '““””<span style=\\\"color: #ff7000\\\">导入轻合集</span>',\\n    url: $().lazyRule((devName, subUrl, avatarUrl) => {\\n        const {\\n            genRule\\n        } = $.require(\\\"hiker://page/genApi\\\");\\n        log(\\\"轻合集图标链接:\\\" + avatarUrl);\\n        let import_rule = genRule(\\\"轻合集.\\\" + devName, subUrl, avatarUrl);\\n        //copy(import_rule);\\n        let ruleCode = parsePaste(import_rule.split(\\\"\\\\n\\\")[0]);\\n        //return \\\"hiker://empty\\\"\\n        importUrl = 'rule://' + base64Encode(ruleCode);\\n        return importUrl\\n    }, devName, subUrl, avatarUrl),\\n    col_type: 'text_2'\\n});\\ndata.push({\\n    title: '““””<span style=\\\"color: #ff7000\\\">导入道德经</span>',\\n    url: $().lazyRule((devName, subUrl, avatarUrl) => {\\n        let title = \\\"H-\\\" + devName;\\n        let subObj = {\\n            title: title,\\n            url: subUrl,\\n            desc: \\\"hiker://files/rules/dzHouse/ruleCache/\\\" + title + \\\".json\\\",\\n            code: \\\"\\\",\\n            active: false, //禁用并发更新\\n        }\\n        let shareText = base64Encode(JSON.stringify(subObj));\\n        var pastes = getPastes();\\n        var url = sharePaste(shareText, pastes.slice(-1)[0]);\\n        let import_rule = \\\"轻合集订阅：\\\" + title + '\\\\n' + url;\\n        copy(import_rule);\\n        const path = 'hiker://files/rules/dzHouse/ruleCache/sub.json';\\n        $.rc(config.lib.sub);\\n        return 订阅导入(path)\\n    }, devName, subUrl, avatarUrl),\\n    col_type: 'text_2'\\n});\\nlet can_upload_api = getApi(\\\"manCanUpload\\\") + id;\\nif (getVar('house.is_manager')) {\\n    let tips = can_upload ? '能' : '否';\\n    // log('tips:'+tips);\\n    // log('can_upload:'+can_upload);\\n    data.push({\\n        title: '⚠能否上传:' + (getVar('Warehouse.can_upload') || tips),\\n        col_type: 'scroll_button',\\n        url: 'hiker://empty'\\n    });\\n\\n    function setUpload(flag, can_upload_api) {\\n        flag = flag || '';\\n        try {\\n            let code = fetch(can_upload_api, {\\n                headers: {\\n                    \\\"User-Agent\\\": MOBILE_UA\\n                },\\n                body: {\\n                    \\\"params\\\": {\\n                        \\\"username\\\": getVar('house.username'),\\n                        \\\"password\\\": getVar('house.password'),\\n                        \\\"can_upload\\\": !!flag\\n                    }\\n                }\\n            });\\n            code = JSON.parse(code).result;\\n            if (code.status === 0) {\\n                return code.detail\\n            } else {\\n                return '操作失败:' + code.detail\\n            }\\n        } catch (e) {\\n            return '操作失败:' + e.message\\n        }\\n    }\\n    data.push({\\n        title: '🚫禁止上传',\\n        col_type: 'scroll_button',\\n        url: $('禁止该开发者上传规则?你的操作将被系统记录').confirm((id, can_upload_api, setUpload) => {\\n            let ret = setUpload(false, can_upload_api);\\n            if (!/操作失败/.test(ret)) {\\n                putVar('Warehouse.can_upload', '否');\\n                refreshPage(false);\\n            }\\n            return 'toast://' + ret\\n        }, id, can_upload_api, setUpload)\\n    });\\n    data.push({\\n        title: '✅允许上传',\\n        col_type: 'scroll_button',\\n        url: $('允许该开发者上传规则?你的操作将被系统记录').confirm((id, can_upload_api, setUpload) => {\\n            let ret = setUpload(true, can_upload_api);\\n            if (!/操作失败/.test(ret)) {\\n                putVar('Warehouse.can_upload', '是');\\n                refreshPage(false);\\n            }\\n            return 'toast://' + ret\\n        }, id, can_upload_api, setUpload)\\n    });\\n}\\ndata.push({\\n    title: \\\"<small>提示：开发者单独分享的合集文件只能单独导入。</small>\\\",\\n    col_type: \\\"rich_text\\\"\\n});\\ndata.push({\\n    title: \\\"<big>规则列表</big>&nbsp;&nbsp;<small>(共\\\" + ruleList.length + \\\"条)</small>\\\",\\n    col_type: \\\"rich_text\\\"\\n});\\nlet dataTypeList = {\\n    \\\"\\\": \\\"全部\\\",\\n    \\\"home_rule_url\\\": '小程序',\\n    //\\\"publish\\\": '提交云仓库规则',\\n    \\\"js_url\\\": '网页插件',\\n    \\\"html\\\": '静态页面',\\n    \\\"config\\\": '主题'\\n};\\nfor (let key in dataTypeList) {\\n    data.push({\\n        title: dataType === key ? \\\"““\\\" + dataTypeList[key] + \\\"””\\\" : dataTypeList[key],\\n        url: $(\\\"#noLoading#\\\").lazyRule((key) => {\\n            putVar(\\\"Warehouse.type\\\", key);\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, key),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n}\\nif (ruleList.length > 20) {\\n    data.push({\\n        title: \\\"搜索\\\",\\n        url: $.toString(name => \\\"hiker://search?s=\\\" + input + \\\"&rule=\\\" + name, MY_RULE.title),\\n        col_type: \\\"input\\\",\\n        desc: \\\"搜索当前开发者的规则\\\"\\n    });\\n}\\nlet homeList = JSON.parse(request(api.home));\\nlet mRuleList = [];\\nfor (var item of ruleList) {\\n    var name = item.name;\\n    if (item.is_tap) {\\n        let location = JSON.parse(request(getApi(\\\"ruleListJson\\\") + \\\"?id=\\\" + item.id));\\n        item.id = location.id;\\n        item.name = location.name;\\n        item.author = location.author;\\n        item.data_type = location.data_type;\\n        item.ver = location.ver\\n    }\\n    item.version = item.ver;\\n    let label = \\\"\\\",\\n        lver = -2;\\n    if (item.is_json && item.data_type === \\\"home_rule_url\\\") {\\n        lver = localRuleVer(homeList, item);\\n        if (lver === -1) {\\n            label = \\\"🆕\\\";\\n        } else if (lver < item.ver) {\\n            label = \\\"🆙\\\";\\n        }\\n    }\\n    mRuleList.push({\\n        title: label + name,\\n        url: \\\"hiker://page/ruleDetail#noHistory##noRecordHistory#\\\",\\n        extra: {\\n            lver: lver,\\n            id: item.id\\n        },\\n        pic_url: item.pic,\\n    });\\n}\\n/* 归并排序 Start */\\nif (getItem(\\\"排序\\\", \\\"时间优先\\\") === '新版优先') {\\n    mRuleList = normalSort(mRuleList);\\n}\\n/* 归并排序 End */\\ndata.push.apply(data, mRuleList)\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"规则详细-user\",\"path\":\"ruleDetail\",\"rule\":\"js:\\n    const {\\n        getApi,\\n        color,\\n        small,\\n        htmlTag,\\n        api,\\n        md\\n    } = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    id,\\n    lver,\\n    isAll\\n} = MY_PARAMS;\\nif(getParam(\\\"id\\\")){\\n    isAll = true;\\n    id = getParam(\\\"id\\\");\\n    lver = lver || \\\"未获取版本号\\\";\\n}\\naddListener('onClose', $.toString((isAll) => {\\n    if(!isAll){\\n        refreshPage(false);\\n    }\\n},isAll));\\nlet dataItem = JSON.parse(request(getApi(\\\"getbyid\\\") + \\\"?id=\\\" + id)).result;\\nsetPageTitle(\\\"「\\\" + dataItem.name + \\\"」\\\")\\nlet ruleListJson = getApi(\\\"ruleListJson\\\") + \\\"?id=\\\";\\nlet data = [];\\nvar hasSub = false;\\n\\nif (dataItem.is_json_list) {\\n    hasSub = hasHomeSub(ruleListJson + dataItem.id);\\n} else if (!dataItem.is_json_list && dataItem.data_type == 'home_rule_url') {\\n    hasSub = hasHomeSub(ruleListJson + dataItem.id + '&debug=true');\\n}\\n\\ndata.push({\\n    title: htmlTag(\\\"big\\\", \\\"版本\\\"),\\n    desc: \\\"““””开发者：\\\" + color(dataItem.author, \\\"#228BE6\\\") + \\\"\\\\n云端版本：\\\" + color(dataItem.ver, \\\"#5cff2c\\\") + \\\"\\\\t\\\\t本地版本：\\\" + color(lver, \\\"#5cff2c\\\") + \\\"\\\\n更新于: [\\\" + color(dataItem.last_update, \\\"#ff7000\\\") + \\\"]\\\",\\n    url: $(\\\"<开发者>\\\\n\\\" + dataItem.author + \\\"\\\\n<名称>\\\\n\\\" + dataItem.name + \\\"\\\\n<云端版本>\\\\n\\\" + dataItem.ver + \\\"\\\\n<本地版本>\\\\n\\\" + lver + \\\"\\\\n<更新时间>\\\\n[\\\" + dataItem.last_update + \\\"]\\\").confirm(() => {}),\\n    col_type: 'text_1'\\n});\\nlet dataType = {\\n    home_rule_url: '首页云规则',\\n    publish: '提交云仓库规则',\\n    js_url: '网页插件规则',\\n    html: '静态页面',\\n    config: '主页配置'\\n};\\n\\nlet basic = {\\n    col_type: \\\"text_1\\\",\\n    url: \\\"hiker://empty\\\"\\n};\\nlet dataTypeTips = dataType[dataItem.data_type] || '未知规则：' + dataItem.data_type;\\n\\nlet safe_tip=dataItem.is_safe?\\\"安全\\\":\\\"危险\\\";\\nlet good_tip = dataItem.is_good?small(color(\\\"【优质规则】\\\",'#ff7000')):\\\"\\\";\\nlet not_safe_note=dataItem.not_safe_note;\\nbasic.title = htmlTag(\\\"big\\\", \\\"类型\\\") + \\\"\\\\t\\\\t\\\\t\\\" + small(\\\"(id:\\\" + dataItem.id + \\\")\\\")+\\\"\\\\t\\\\t\\\\t\\\" + small(\\\"(风险检测:\\\" +safe_tip+\\\")\\\")+good_tip;\\nbasic.desc = \\\"数据类型：\\\" + color(dataTypeTips, \\\"#cb54ff\\\") + \\\"\\\\n分享状态为：\\\" + dataItem.state;\\nif ([\\\"html\\\", \\\"config\\\", \\\"js_url\\\"].includes(dataItem.data_type)) {\\n    basic.desc += \\\"\\\\n““”” =>\\\" + small(\\\"点此预览\\\");\\n    basic.url = ruleListJson + dataItem.id;\\n}\\n\\ndata.push(basic);\\nlet hasSubs = \\\"\\\";\\nif (hasSub) {\\n    hasSubs = \\\"\\\\t\\\\t\\\\t\\\" + small(\\\"已订阅\\\")\\n}\\n\\nlet notes = request(getApi(\\\"get_rule_note\\\") + id);\\nnotes = JSON.parse(notes).result;\\nrequire(md);\\nlet notesHtml=\\\"\\\"\\ntry{\\n    notesHtml=marked.parse(notes);\\n}catch(e){}\\n\\nif (notes !== false) {\\n    data.push({\\n        title: htmlTag(\\\"big\\\", \\\"备注\\\") + \\\"\\\\t\\\\t\\\\t\\\" + small(htmlTag(\\\"u\\\", \\\"查看完整公告 >\\\")),\\n        desc: notes,\\n        col_type: \\\"text_1\\\",\\n        url: \\\"hiker://page/info\\\",\\n        extra: {\\n            text: notesHtml,\\n            name: dataItem.name,\\n            // type: \\\"long_text\\\"\\n            type: \\\"rich_text\\\"\\n        }\\n    });\\n}\\ndata.push({\\n    title: htmlTag(\\\"big\\\", \\\"操作(分享详细页)\\\") + hasSubs,\\n    col_type: \\\"text_1\\\",\\n    url: \\\"copy://道长仓库「\\\"+dataItem.name+\\\"」\\\\n\\\"+id+'@import=js:$.require(\\\"hiker://page/ruleDetailImport?rule=道长仓库Pro\\\", input)'\\n});\\nlet importUrl, ruleCode, shareUrl, backCode = \\\"\\\";\\nif (!dataItem.is_json) {\\n    backCode = request(ruleListJson + dataItem.id);\\n}\\nswitch (dataItem.data_type) {\\n    case \\\"home_rule_url\\\":\\n        ruleCode = \\\"海阔视界首页频道规则【\\\" + dataItem.name + \\\"】￥home_rule_url￥\\\" + ruleListJson + dataItem.id;\\n        importUrl = \\\"rule://\\\" + base64Encode(ruleCode)\\n        break;\\n    case 'publish':\\n        ruleCode = '海阔视界规则分享，当前分享的是：' + dataItem.name + '￥publish￥' + base64Encode(backCode);\\n        importUrl = 'rule://' + base64Encode(ruleCode);\\n        break;\\n    case 'js_url':\\n        ruleCode = '海阔视界规则分享，当前分享的是：网页插件￥js_url￥' + dataItem.name + '@base64://' + base64Encode(backCode);\\n        importUrl = 'rule://' + base64Encode(ruleCode);\\n        break;\\n    case 'html':\\n        let file_tmp = dataItem.name.split('.');\\n        let file_path = file_tmp.length > 1 ? file_tmp[file_tmp.length - 1] + \\\"/\\\" + dataItem.name : dataItem.name;\\n        ruleCode = \\\"海阔视界本地文件分享￥file_url￥hiker://files/rules/dzHouse/\\\" + file_path + \\\"@\\\" + ruleListJson + dataItem.id;\\n        importUrl = 'rule://' + base64Encode(ruleCode);\\n        break\\n    case \\\"config\\\":\\n        importUrl = $().rule(password => {\\n            eval(fetch(\\\"hiker://assets/home.js\\\"));\\n            HikerHome.load(\\\"import\\\", password);\\n        }, backCode);\\n        break;\\n}\\nlet my_col_type = \\\"text_2\\\";\\nlet my_col_type2 = \\\"text_3\\\";\\nif (importUrl) {\\n    data.push({\\n        title: \\\"导入规则\\\",\\n        url: dataItem.is_safe?importUrl:'toast://风险规则禁止导入!!!',\\n        col_type: my_col_type\\n    });\\n}\\nif (ruleCode) {\\n    data.push({\\n        title: \\\"分享口令\\\",\\n        url: \\\"copy://\\\" + ruleCode,\\n        col_type: my_col_type\\n    });\\n}\\n\\nif (importUrl) {\\n    if (dataItem.is_json_list && !hasSub) {\\n        let sub_rule_code = '海阔视界合集规则订阅￥home_sub￥' + dataItem.name + \\\"@@\\\" + ruleListJson + dataItem.id;\\n        let sub_url = 'rule://' + base64Encode(sub_rule_code);\\n        data.push({\\n            title: '订阅合集',\\n            url: sub_url,\\n            col_type: my_col_type2\\n        });\\n        data.push({\\n            title: '““””<span style=\\\"color: #ff7000\\\">导入轻合集</span>',\\n            url: $().lazyRule((dataItem,subUrl)=>{\\n                const {genRule}=$.require(\\\"hiker://page/genApi\\\");\\n                let import_rule=genRule(dataItem.name+\\\".\\\"+dataItem.author,subUrl);\\n                //copy(import_rule);\\n                let ruleCode=parsePaste(import_rule.split(\\\"\\\\n\\\")[0]);\\n                //return \\\"hiker://empty\\\"\\n                importUrl = 'rule://' + base64Encode(ruleCode);\\n                return importUrl\\n            },dataItem,ruleListJson + dataItem.id),\\n            col_type: my_col_type2\\n        });\\n        data.push({\\n            title: '““””<span style=\\\"color: #ff7000\\\">导入道德经</span>',\\n            url: $().lazyRule((dataItem,subUrl)=>{\\n                // let title = \\\"H-\\\"+dataItem.name+\\\".\\\"+dataItem.author;\\n                let title = \\\"J-\\\"+dataItem.name.split('.')[0];\\n                let subObj = {\\n                    title: title,\\n                    url: subUrl,\\n                    desc: \\\"hiker://files/rules/dzHouse/ruleCache/\\\"+title+\\\".json\\\",\\n                    code: \\\"\\\",\\n                    active: false,//禁用并发更新\\n                }\\n                let shareText = base64Encode(JSON.stringify(subObj));\\n                var pastes = getPastes();\\n                var url = sharePaste(shareText,pastes.slice(-1)[0]);\\n                let import_rule= \\\"轻合集订阅：\\\"+title+'\\\\n'+url;\\n                copy(import_rule);\\n                const path = 'hiker://files/rules/dzHouse/ruleCache/sub.json';\\n                $.rc(config.lib.sub);\\n                return 订阅导入(path)\\n            },dataItem,ruleListJson + dataItem.id),\\n            col_type: my_col_type2\\n        });\\n        data.push({\\n            title: \\\"<small>提示：开发者单独分享的合集文件只能单独导入。</small>\\\",\\n            col_type: \\\"rich_text\\\"\\n        });\\n    } else if (!dataItem.is_json_list && !hasSub && dataItem.data_type == 'home_rule_url') {\\n        let sub_rule_code = '海阔视界单规则订阅￥home_sub￥' + dataItem.name + \\\"@@\\\" + ruleListJson + dataItem.id + '&debug=true';\\n        let sub_url = 'rule://' + base64Encode(sub_rule_code);\\n        data.push({\\n            title: '订阅规则',\\n            url: sub_url,\\n            col_type: my_col_type\\n        })\\n    }\\n}\\nif (dataItem.is_json && dataItem.data_type === \\\"home_rule_url\\\" && !dataItem.is_json_list) {\\n    data.push({\\n        title: '进入频道',\\n        url: $( \\\"#noLoading#\\\").lazyRule((name,home) => {\\n            let hasRule = request('hiker://home@'+name) != 'null';\\n            if (hasRule) {\\n                backToHome();\\n                return home+\\\"s@\\\" + name;\\n            } else {\\n                return \\\"toast://未安装\\\";\\n            }\\n        }, dataItem.name,api.home),\\n        col_type: my_col_type\\n    })\\n}\\nlet man_rule_safe = getApi(\\\"manRuleSafe\\\")+dataItem.id;\\nlet man_rule_good = getApi(\\\"manRuleGood\\\")+dataItem.id;\\n// dataItem.is_safe;\\nif(getVar('house.is_manager')){\\n    function setIsSafe(flag,man_rule_safe) {\\n        flag = flag || '';\\n        try {\\n            let code = fetch(man_rule_safe, {\\n                headers: {\\\"User-Agent\\\": MOBILE_UA},\\n                body: {\\n                    \\\"params\\\":\\n                        {\\n                            \\\"username\\\": getVar('house.username'),\\n                            \\\"password\\\": getVar('house.password'),\\n                            \\\"is_safe\\\": !!flag\\n                        }\\n                }\\n            });\\n            code = JSON.parse(code).result;\\n            if (code.status === 0) {\\n                return code.detail\\n            } else {\\n                return '操作失败:' + code.detail\\n            }\\n        } catch (e) {\\n            return '操作失败:' + e.message\\n        }\\n    }\\n    function setIsGood(flag,man_rule_good) {\\n        flag = flag || '';\\n        try {\\n            let code = fetch(man_rule_good, {\\n                headers: {\\\"User-Agent\\\": MOBILE_UA},\\n                body: {\\n                    \\\"params\\\":\\n                        {\\n                            \\\"username\\\": getVar('house.username'),\\n                            \\\"password\\\": getVar('house.password'),\\n                            \\\"is_good\\\": !!flag\\n                        }\\n                }\\n            });\\n            code = JSON.parse(code).result;\\n            if (code.status === 0) {\\n                return code.detail\\n            } else {\\n                return '操作失败:' + code.detail\\n            }\\n        } catch (e) {\\n            return '操作失败:' + e.message\\n        }\\n    }\\n    data.push({\\n        title:'🚫风险',\\n        col_type:'scroll_button',\\n        url:$('标记该规则为风险?风险规则无法被导入').confirm((id,man_rule_safe,setIsSafe)=>{\\n            let ret = setIsSafe(false,man_rule_safe);\\n            if(!/操作失败/.test(ret)){\\n                refreshPage(false);\\n            }\\n            return 'toast://'+ret\\n        },dataItem.id,man_rule_safe,setIsSafe)\\n    });\\n    data.push({\\n        title:'✅正常',\\n        col_type:'scroll_button',\\n        url:$('标记该规则为正常?').confirm((id,man_rule_safe,setIsSafe)=>{\\n            let ret = setIsSafe(true,man_rule_safe);\\n            if(!/操作失败/.test(ret)){\\n                refreshPage(false);\\n            }\\n            return 'toast://'+ret\\n        },dataItem.id,man_rule_safe,setIsSafe)\\n    });\\n    data.push({\\n        title:'♥非优质',\\n        col_type:'scroll_button',\\n        url:$('标记该规则为非优质?').confirm((id,man_rule_good,setIsGood)=>{\\n            let ret = setIsGood(false,man_rule_good);\\n            if(!/操作失败/.test(ret)){\\n                refreshPage(false);\\n            }\\n            return 'toast://'+ret\\n        },dataItem.id,man_rule_good,setIsGood)\\n    });\\n    data.push({\\n        title:'💖优质',\\n        col_type:'scroll_button',\\n        url:$('标记该规则为优质?').confirm((id,man_rule_good,setIsGood)=>{\\n            let ret = setIsGood(true,man_rule_good);\\n            if(!/操作失败/.test(ret)){\\n                refreshPage(false);\\n            }\\n            return 'toast://'+ret\\n        },dataItem.id,man_rule_good,setIsGood)\\n    });\\n}\\n\\ndata.push({\\n    col_type: \\\"line_blank\\\"\\n});\\ndata.push({\\n    title: dataItem.good_num,\\n    pic_url: \\\"hiker://files/icon/赞.svg\\\",\\n    col_type: \\\"icon_small_3\\\",\\n    url: \\\"hiker://page/MakeAcomment#noHistory##noRecordHistory#\\\",\\n    extra: {\\n        id: dataItem.id,\\n        name: dataItem.name\\n    }\\n});\\ndata.push({\\n    title: dataItem.bad_num,\\n    pic_url: \\\"hiker://files/icon/踩.svg\\\",\\n    col_type: \\\"icon_small_3\\\",\\n    url: \\\"hiker://page/MakeAcomment#noHistory##noRecordHistory#\\\",\\n    extra: {\\n        id: dataItem.id,\\n        name: dataItem.name,\\n        defaultType:\\\"bad\\\"\\n    }\\n});\\ndata.push({\\n    title: \\\"评论\\\",\\n    pic_url: \\\"hiker://files/icon/评论.svg\\\",\\n    col_type: \\\"icon_small_3\\\",\\n    url: \\\"hiker://page/MakeAcomment#noHistory##noRecordHistory#\\\",\\n    extra: {\\n        id: dataItem.id,\\n        name: dataItem.name\\n    }\\n});\\nlet totalSum = dataItem.good_num + dataItem.bad_num;\\n\\ndata.push({\\n    title: htmlTag(\\\"big\\\", \\\"评论(\\\" + totalSum + \\\")\\\") + \\\"\\\\t\\\\t\\\\t\\\" + small(htmlTag(\\\"u\\\", \\\"查看全部评论 >\\\")),\\n    col_type: \\\"text_1\\\",\\n    url: \\\"hiker://page/Comment\\\",\\n    extra: {\\n        url: \\\"hiker://empty#fypage#noHistory##noRecordHistory#\\\",\\n        id: dataItem.id,\\n        totalSum: totalSum,\\n        no_active: false\\n    }\\n});\\n//const longestSum=120;\\nlet icon = {\\n    \\\"good\\\": \\\"👍\\\",\\n    \\\"bad\\\": \\\"👎\\\",\\n    \\\"reply\\\":\\\"开发者🗣\\\"\\n}\\nif (totalSum === 0) {\\n    data.push({\\n        title: \\\"<h5 style='text-align:center'>一条评论也没有，快来抢沙发吧！</h5>\\\",\\n        col_type: \\\"rich_text\\\"\\n    });\\n} else {\\n    let commentList = JSON.parse(request(api.dis_get + dataItem.id + \\\"?limit=5\\\")).result;\\n    for (let item of commentList) {\\n        let Reply = item.discuss_type===\\\"reply\\\"&&item.reply_to_name!==false&&item.reply_to_id!==false?\\\"‘‘回复@\\\"+item.reply_to_name+\\\" #\\\"+item.discuss_id+\\\"’’\\\\n\\\":\\\"\\\";\\n        data.push({\\n            title: item.name + \\\"&nbsp;&nbsp;<font color='gray'><small>#\\\" + item.id + \\\"</small><font>\\\",\\n            col_type: \\\"avatar\\\",\\n            //url: \\\"toast://\\\" + item.qq,\\n            url:\\\"mqqwpa://im/chat?chat_type=wpa&uin=\\\"+item.qq,\\n            pic_url: item.avatar_url\\n        });\\n        data.push({\\n            title: item.discuss_text,\\n            desc: Reply+item.create_date + \\\"·\\\" + icon[item.discuss_type],\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/info\\\",\\n            extra:{\\n                name:item.name,\\n                type:\\\"long_text\\\",\\n                text:item.discuss_text\\n            },\\n            pic_url: item.avatar_url\\n        });\\n    }\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n}\\n\\nsetResult(data);\"},{\"col_type\":\"rich_text\",\"name\":\"查看\",\"path\":\"info\",\"rule\":\"js:\\nsetPageTitle(\\\"查看「\\\"+MY_PARAMS.name+\\\"」\\\")\\nsetResult([{\\n    title: MY_PARAMS.text,\\n    col_type:MY_PARAMS.type\\n}]);\"},{\"col_type\":\"movie_3\",\"name\":\"开发者注册\",\"path\":\"Register\",\"rule\":\"js:\\nsetPageTitle(\\\"开发者注册\\\");\\nconst {\\n    getApi,\\n    htmlTag,\\n    mapColType,\\n    small\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nvar data = [];\\naddListener('onClose', $.toString(() => {\\n    clearVar(\\\"Warehouse.Password\\\");\\n    clearVar(\\\"Warehouse.Username\\\");\\n    clearVar(\\\"Warehouse.Description\\\");\\n    clearVar(\\\"Warehouse.UserAddress\\\");\\n}));\\naddListener('onRefresh', $.toString(()=>{\\n    putVar(\\\"Warehouse.Wait\\\", \\\"\\\");\\n}));\\ndata.push({\\n    title: '账号',\\n    desc: \\\"请输入账号(必填)\\\",\\n    col_type: 'input',\\n    extra: {\\n        defaultValue: getVar('Warehouse.Username', ''),\\n        type: \\\"number\\\",\\n        onChange: 'putVar(\\\"Warehouse.Username\\\",input)'\\n    }\\n}, {\\n    title: '密码',\\n    desc: \\\"请输入密码(必填)\\\",\\n    col_type: 'input',\\n    extra: {\\n        defaultValue: getVar('Warehouse.Password', ''),\\n        type: \\\"password\\\",\\n        onChange: 'putVar(\\\"Warehouse.Password\\\",input)'\\n    }\\n});\\nmapColType(data, \\\"line_blank\\\", 1);\\ndata.push({\\n    title: '昵称',\\n    desc: \\\"请输入昵称(必填)\\\",\\n    col_type: 'input',\\n    extra: {\\n        defaultValue: getVar('Warehouse.UserAddress', ''),\\n        onChange: 'putVar(\\\"Warehouse.UserAddress\\\",input)'\\n    }\\n}, {\\n    title: '描述',\\n    desc: \\\"说说为什么要注册吧\\\\n(可以增加通过概率,选填)\\\",\\n    col_type: 'input',\\n    extra: {\\n        defaultValue: getVar('Warehouse.Description', ''),\\n        type: \\\"textarea\\\",\\n        onChange: 'putVar(\\\"Warehouse.Description\\\",input)'\\n    }\\n})\\n\\nmapColType(data, \\\"line_blank\\\", 1);\\n\\ndata.push({\\n    title: htmlTag(\\\"b\\\", \\\"注册\\\"),\\n    url: $(getApi(\\\"new_dev\\\")+\\\"#noLoading#\\\").lazyRule((getId, confirm) => {\\n        let username = getVar('Warehouse.Username', \\\"\\\"),\\n            password = getVar('Warehouse.Password', \\\"\\\"),\\n            description = getVar('Warehouse.Description', \\\"\\\"),\\n            name = getVar(\\\"Warehouse.UserAddress\\\", \\\"\\\");\\n        if ([username, password, name].includes(\\\"\\\")) {\\n            return \\\"toast://账号,密码和昵称不能为空\\\";\\n        }\\n        showLoading(\\\"正在提交申请表\\\");\\n        let result = request(input, {\\n            headers: {\\n                'content-type': 'application/json'\\n            },\\n            body: JSON.stringify({\\n                \\\"params\\\": {\\n                    \\\"reason\\\": description,\\n                    \\\"name\\\": name,\\n                    \\\"password\\\": password,\\n                    \\\"qq\\\": username\\n                }\\n            }),\\n            method: 'post'\\n        });\\n        result = JSON.parse(result).result;\\n        hideLoading();\\n        if (result.status !== 0) {\\n            return \\\"toast://\\\" + result.detail;\\n        }\\n        let idresult = JSON.parse(request(getId + \\\"?qq=\\\" + username));\\n        if (idresult.status !== 0) {\\n            return \\\"toast://\\\" + idresult.detail;\\n        }\\n        \\n        return $(\\\"\\\", \\\"输入邮箱验证码\\\\n\\\" + result.detail).input((confirm, id, account) => {\\n            showLoading(\\\"请耐心等待\\\");\\n            try {\\n                let result = request(confirm, {\\n                    headers: {\\n                        'content-type': 'application/json'\\n                    },\\n                    body: JSON.stringify({\\n                        \\\"params\\\": {\\n                            \\\"regist_id\\\": id,\\n                            \\\"yzm\\\": input\\n                        }\\n                    }),\\n                    method: 'POST'\\n                });\\n                result = JSON.parse(result).result;\\n                if (result.status !== 0) {\\n                    hideLoading();\\n                    return \\\"toast://\\\" + result.detail;\\n                } else {\\n                    putVar(\\\"WarehouseUsername\\\", account[0]);\\n                    putVar(\\\"WarehousePassword\\\", account[1]);\\n                    hideLoading();\\n                    back();\\n                    return \\\"toast://成功提交注册注册\\\\n\\\"+result.detail;\\n                }\\n            } catch (e) {\\n                hideLoading();\\n                return \\\"toast://出错了呐\\\";\\n            }\\n        }, confirm, idresult.result, [username, password]);\\n    }, getApi(\\\"new_getId\\\"), getApi(\\\"new_confirm\\\")),\\n    col_type: 'text_center_1'\\n});\\nsetResult(data);\"},{\"col_type\":\"text_1\",\"name\":\"个人资料\",\"path\":\"PersonalData\",\"rule\":\"js:\\nsetPageTitle(\\\"个人资料\\\");\\nvar data=[];\\nconst {\\n    getApi,\\n    getFile,\\n    api\\n} = $.require(\\\"hiker://page/utiliy\\\");\\n\\ndata.push({\\n    col_type:\\\"line_blank\\\"\\n});\\n\\nlet {username,password} = getFile();\\nlet dev = JSON.parse(request(getApi(\\\"user\\\")+MY_PARAMS.id)).result;\\ndata.push({\\n    title:\\\"头像\\\",\\n    desc:dev.avatar,\\n    url:\\\"hiker://page/modify_PersonalData#noHistory##noRecordHistory#\\\",\\n    extra:{\\n        dev:dev,\\n        username:username,\\n        password:password,\\n        Pattern:0\\n    },\\n    col_type:\\\"text_1\\\"\\n});\\n\\n\\ndata.push({\\n    title:\\\"昵称\\\",\\n    desc:dev.name,\\n    url:\\\"hiker://page/modify_PersonalData#noHistory##noRecordHistory#\\\",\\n    extra:{\\n        dev:dev,\\n        username:username,\\n        password:password,\\n        Pattern:1\\n    },\\n    col_type:\\\"text_1\\\"\\n});\\n\\ndata.push({\\n    title:\\\"密码\\\",\\n    url:\\\"hiker://page/modify_PersonalData#noHistory##noRecordHistory#\\\",\\n    extra:{\\n        dev:dev,\\n        username:username,\\n        password:password,\\n        Pattern:2\\n    },\\n    col_type:\\\"text_1\\\"\\n});\\ndata.push({\\n    col_type:\\\"line_blank\\\"\\n});\\ndata.push({\\n    title:\\\"账号：\\\"+username,\\n    url:\\\"copy://\\\"+username,\\n    col_type:\\\"text_1\\\"\\n});\\ndata.push({\\n    title:\\\"UID：\\\"+dev.id,\\n    url:\\\"copy://\\\"+dev.id,\\n    col_type:\\\"text_1\\\"\\n});\\ndata.push({\\n    col_type:\\\"line_blank\\\"\\n});\\ndata.push({\\n    title:\\\"提交云仓库规则\\\",\\n    url:$(\\\"#noLoading#\\\").lazyRule((host)=>{\\n        let code=request(host+\\\"/hikerule/rulelist.json?id=145\\\");\\n        let word=\\\"￥publish￥\\\"+base64Encode(code);\\n        return \\\"rule://\\\"+base64Encode(word);\\n    },api.host),\\n    col_type:\\\"text_1\\\"\\n});\\ndata.push({\\n    title:\\\"同步提交云仓库账号密码\\\",\\n    url:\\\"rule://\\\"+base64Encode(\\\"￥publish_account￥\\\"+username+\\\"@\\\"+password),\\n    col_type:\\\"text_1\\\"\\n});\\ndata.push({\\n    col_type:\\\"line_blank\\\"\\n});\\ndata.push({\\n    title:\\\"你一共发布了「\\\"+dev.rule_num+\\\"」条规则\\\",\\n    url:\\\"hiker://empty\\\",\\n    col_type:\\\"text_1\\\"\\n});\\ndata.push({\\n    col_type:\\\"line_blank\\\"\\n});\\nlet user = getFile();\\ndata.push({\\n    title:\\\"注销登录\\\",\\n    url:$(\\\"确认注销登录?\\\").confirm(f => {\\n        f.username=\\\"\\\";\\n        f.password=\\\"\\\";\\n        writeFile('hiker://files/WarehouseUSER.json', JSON.stringify(f));\\n        putVar(\\\"Warehouse.back\\\",\\\"1\\\");\\n        back();\\n        return \\\"toast://已注销\\\";\\n    },user),\\n    col_type:\\\"text_center_1\\\"\\n});\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"更改个人资料\",\"path\":\"modify_PersonalData\",\"rule\":\"js:\\nconst {\\n    getApi,\\n    color,\\n    small,\\n    getFile,\\n    htmlTag\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    dev,\\n    username,\\n    password,\\n    Pattern\\n} = MY_PARAMS;\\nvar data = [];\\nlet path = \\\"?qq=\\\" + username + \\\"&password=\\\" + password;\\naddListener('onClose', $.toString(() => {\\n    clearVar(\\\"Warehouse.m.petName\\\");\\n    clearVar(\\\"Warehouse.m.avatar\\\");\\n    clearVar(\\\"Warehouse.m.Password.c\\\");\\n    clearVar(\\\"Warehouse.m.Password.x\\\");\\n    clearVar(\\\"Warehouse.m.Password.y\\\");\\n}));\\nfunction m_petName() {\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    data.push({\\n        col_type: 'input',\\n        desc: \\\"请输入新昵称\\\",\\n        extra: {\\n            titleVisible: false,\\n            defaultValue: getVar('Warehouse.m.petName', '')||dev.name,\\n            onChange: 'putVar(\\\"Warehouse.m.petName\\\",input)'\\n        }\\n    });\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    data.push({\\n        title: \\\"保存\\\",\\n        url: $(getApi(\\\"modify_name\\\") + path).lazyRule(() => {\\n            let newPetName = getVar('Warehouse.m.petName', '');\\n            if (newPetName == \\\"\\\") {\\n                return \\\"toast://你还什么都没填啊!\\\";\\n            }\\n            let result = request(input + \\\"&name=\\\" + encodeURIComponent(newPetName));\\n            result = JSON.parse(result);\\n            if (result.status === 0) {\\n                back();\\n                return \\\"toast://修改成功\\\";\\n            } else {\\n                return \\\"toast://\\\" + result.detail;\\n            }\\n        }),\\n        col_type: 'text_center_1'\\n    });\\n}\\n\\nfunction m_avatar() {\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    data.push({\\n        col_type: 'input',\\n        desc: \\\"请输入新的头像链接\\\",\\n        extra: {\\n            titleVisible: false,\\n            defaultValue: getVar('Warehouse.m.avatar', '') || dev.avatar,\\n            onChange: 'putVar(\\\"Warehouse.m.avatar\\\",input)'\\n        }\\n    });\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    data.push({\\n        title: \\\"保存\\\",\\n        url: $(getApi(\\\"modify_ava\\\") + path).lazyRule(() => {\\n            let newAvatar = getVar('Warehouse.m.avatar', '');\\n            \\n            let result = request(input + \\\"&avatar_url=\\\" + encodeURIComponent(newAvatar));\\n            result = JSON.parse(result);\\n            if (result.status === 0) {\\n                back();\\n                return \\\"toast://修改成功\\\";\\n            } else {\\n                return \\\"toast://\\\" + result.detail;\\n            }\\n        }),\\n        col_type: 'text_center_1'\\n    });\\n}\\n\\nfunction m_pwd() {\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    data.push({\\n        title:\\\"原密码\\\",\\n        col_type: 'input',\\n        desc: \\\"请输入原密码\\\",\\n        extra: {\\n            type:\\\"password\\\",\\n            defaultValue: getVar('Warehouse.m.Password.y', ''),\\n            onChange: 'putVar(\\\"Warehouse.m.Password.y\\\",input)'\\n        }\\n    });\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    data.push({\\n        title:\\\"新密码\\\",\\n        col_type: 'input',\\n        desc: \\\"请输入新密码\\\",\\n        extra: {\\n            type:\\\"password\\\",\\n            defaultValue: getVar('Warehouse.m.Password.x', ''),\\n            onChange: 'putVar(\\\"Warehouse.m.Password.x\\\",input)'\\n        }\\n    });\\n    data.push({\\n        title:\\\"重复新密码\\\",\\n        col_type: 'input',\\n        desc: \\\"请重复新密码\\\",\\n        extra: {\\n            type:\\\"password\\\",\\n            titleVisible: false,\\n            defaultValue: getVar('Warehouse.m.Password.c', ''),\\n            onChange: 'putVar(\\\"Warehouse.m.Password.c\\\",input)'\\n        }\\n    });\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    data.push({\\n        title: \\\"保存\\\",\\n        url: $(getApi(\\\"modify_pwd\\\")+path).lazyRule((password,username) => {\\n            let old_password = getVar('Warehouse.m.Password.y', '');\\n            let new_password = getVar('Warehouse.m.Password.x', '');\\n            let new_password_again = getVar('Warehouse.m.Password.c', '');\\n            if (old_password!==password) {\\n                return \\\"toast://原密码错误\\\";\\n            }\\n            if(new_password===\\\"\\\"){\\n                return \\\"toast://请输入新密码\\\";\\n            }\\n            if(new_password!==new_password_again){\\n                return \\\"toast://两次密码不同\\\"\\n            }\\n            let result = request(input + \\\"&new_password=\\\" + new_password+\\\"&new_password_re=\\\"+new_password_again);\\n            result = JSON.parse(result);\\n            if (result.status === 0) {\\n                writeFile(\\\"hiker://files/WarehouseUSER.json\\\",JSON.stringify({\\n                    username:username,\\n                    password:new_password\\n                }));\\n                back();\\n                return \\\"toast://修改成功\\\";\\n            } else {\\n                return \\\"toast://\\\" + result.detail;\\n            }\\n        },password,username),\\n        col_type: 'text_center_1'\\n    });\\n}\\n\\nswitch (Pattern) {\\n    case 0:\\n        setPageTitle(\\\"修改头像\\\");\\n        m_avatar();\\n        break;\\n    case 1:\\n        setPageTitle(\\\"修改昵称\\\");\\n        m_petName();\\n        break;\\n    case 2:\\n        setPageTitle(\\\"修改密码\\\");\\n        m_pwd();\\n        break;\\n}\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"编辑规则备注\",\"path\":\"set_rule_notes\",\"rule\":\"js:\\nlet data = [];\\nconst {\\n    getApi\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    id,\\n    username,\\n    password,\\n    name\\n} = MY_PARAMS;\\nsetPageTitle(\\\"备注「\\\"+name+\\\"」\\\");\\naddListener('onClose',\\\"clearVar('Warehouse.rule.notes', '')\\\");\\nlet notes=request(getApi(\\\"get_rule_note\\\")+id);\\nnotes=JSON.parse(notes).result;\\ndata.push({\\n    desc: \\\"规则备注......\\\",\\n    col_type: 'input',\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getVar('Warehouse.rule.notes', '')||notes||\\\"\\\",\\n        type: \\\"textarea\\\",\\n        height:-1,\\n        onChange: 'putVar(\\\"Warehouse.rule.notes\\\",input)'\\n    }\\n});\\n\\ndata.push({\\n    title: \\\"保存\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: $(getApi(\\\"set_rule_note\\\") + id).lazyRule((username, password) => {\\n        let notes = getVar('Warehouse.rule.notes', '');\\n        let result = request(input, {\\n            headers: {\\n                'content-type': 'application/json'\\n            },\\n            body: JSON.stringify({\\n                \\\"params\\\": {\\n                    \\\"qq\\\": username,\\n                    \\\"password\\\": password,\\n                    \\\"note\\\":notes\\n                }\\n            }),\\n            method: 'POST'\\n        });\\n        result = JSON.parse(result).result;\\n        if (result.status !== 0) {\\n            return \\\"toast://\\\" + result.detail;\\n        }\\n        back(false);\\n        return \\\"toast://修改成功\\\";\\n    }, username, password)\\n});\\nsetResult(data);\"},{\"col_type\":\"line\",\"name\":\"评论列表\",\"path\":\"Comment\",\"rule\":\"js:\\nsetPageTitle(\\\"评论列表\\\");\\nconst {\\n    api\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet data = [];\\nlet {\\n    totalSum,\\n    id,\\n    no_active,\\n    username,\\n    password\\n} = MY_PARAMS;\\nlet page = parseInt(MY_URL.split(\\\"#\\\")[1]);\\nlet discuss_type = getVar(\\\"Warehouse.comment.discuss_type\\\", \\\"\\\");\\nif (page === 1) {\\n    data.push({\\n        col_type: \\\"line_blank\\\"\\n    });\\n    addListener('onClose', $.toString(() => {\\n        putVar(\\\"Warehouse.comment.discuss_type\\\", \\\"\\\");\\n    }));\\n    data.push({\\n        title: \\\"全部\\\" + (discuss_type === \\\"\\\" ? \\\"◉\\\" : \\\"○\\\"),\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            putVar(\\\"Warehouse.comment.discuss_type\\\", \\\"\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }),\\n        col_type: 'text_4'\\n\\n    });\\n    data.push({\\n        title: \\\"👍赞\\\" + (discuss_type === \\\"good\\\" ? \\\"◉\\\" : \\\"○\\\"),\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            putVar(\\\"Warehouse.comment.discuss_type\\\", \\\"good\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }),\\n        col_type: 'text_4'\\n\\n    });\\n    data.push({\\n        title: \\\"👎踩\\\" + (discuss_type === \\\"bad\\\" ? \\\"◉\\\" : \\\"○\\\"),\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            putVar(\\\"Warehouse.comment.discuss_type\\\", \\\"bad\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }),\\n        col_type: 'text_4'\\n    });\\n    data.push({\\n        title: \\\"回复\\\" + (discuss_type === \\\"reply\\\" ? \\\"◉\\\" : \\\"○\\\"),\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            putVar(\\\"Warehouse.comment.discuss_type\\\", \\\"reply\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }),\\n        col_type: 'text_4'\\n    });\\n}\\n\\n\\nlet icon = {\\n    \\\"good\\\": \\\"👍\\\",\\n    \\\"bad\\\": \\\"👎\\\",\\n    \\\"reply\\\":\\\"开发者🗣\\\"\\n}\\nlet control=(pid,active)=>void 0;\\nif(no_active){\\n    control=function(pid,active){\\n        data.push({\\n            title:active?\\\"隐藏评论\\\":\\\"展示评论\\\",\\n            url:$(api.dis_dev_control+pid+\\\"?qq=\\\" + username + \\\"&password=\\\" + password+\\\"#noLoading#\\\").lazyRule(()=>{\\n                let result=JSON.parse(request(input));\\n                refreshPage(false)\\n                return \\\"toast://\\\"+result.detail;\\n            }),\\n            col_type:\\\"text_2\\\"\\n        });\\n        data.push({\\n            title:\\\"删除评论\\\",\\n            url:$(\\\"确认删除该评论?\\\").confirm((input)=>{\\n                let result=JSON.parse(request(input));\\n                refreshPage(false)\\n                return \\\"toast://\\\"+result.detail;\\n            },api.dis_dev_control+pid+\\\"?qq=\\\" + username + \\\"&password=\\\" + password+\\\"&delete=1\\\"),\\n            col_type:\\\"text_2\\\"\\n        });\\n        data.push({\\n            col_type:\\\"line\\\"\\n        });\\n        data.push({\\n            col_type:\\\"line\\\"\\n        });\\n    }\\n}\\nif (totalSum === 0) {\\n    data.push({\\n        title: \\\"<h5 style='text-align:center'>一条评论也没有，快来抢沙发吧！</h5>\\\",\\n        col_type: \\\"rich_text\\\"\\n    });\\n} else {\\n    let commentList = JSON.parse(request(api.dis_get + id + \\\"?limit=5&page=\\\" + page + \\\"&no_active=\\\" + no_active + \\\"&discuss_type=\\\" + discuss_type)).result;\\n    for (let item of commentList) {\\n        let Reply = item.discuss_type===\\\"reply\\\"&&item.reply_to_name!==false&&item.reply_to_id!==false?\\\"‘‘回复@\\\"+item.reply_to_name+\\\" #\\\"+item.discuss_id+\\\"’’\\\\n\\\":\\\"\\\";\\n        data.push({\\n            title: item.name + \\\"&nbsp;&nbsp;<font color='gray'><small>#\\\" + item.id + \\\"</small><font>\\\",\\n            col_type: \\\"avatar\\\",\\n            //url: no_active?\\\"hiker://page/Reply\\\":\\\"toast://\\\" + item.qq,\\n\\t\\t       url:no_active?\\\"hiker://page/Reply\\\":\\\"mqqwpa://im/chat?chat_type=wpa&uin=\\\"+item.qq,\\n            extra:{\\n                ruleId: id,\\n                name: item.name,\\n                password: password,\\n                username: username,\\n                replyId:item.id\\n            },\\n            pic_url: item.avatar_url\\n        });\\n        data.push({\\n            title: item.discuss_text,\\n            desc: Reply+item.create_date + \\\"·\\\" + icon[item.discuss_type],\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/info\\\",\\n            extra:{\\n                name:item.name,\\n                type:\\\"long_text\\\",\\n                text:item.discuss_text\\n            },\\n            pic_url: item.avatar_url\\n        });\\n        control(item.id,item.active);\\n    }\\n    if (commentList.length === 0) {\\n        data.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n    }\\n}\\n\\nsetResult(data)\"},{\"col_type\":\"movie_3\",\"name\":\"发表评论\",\"path\":\"MakeAcomment\",\"rule\":\"js:\\nlet data = [];\\nconst {\\n    api,\\n    getFile\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    id,\\n    name,\\n    defaultType\\n} = MY_PARAMS;\\nlet user=getFile().user||[\\\"\\\",\\\"\\\"];\\n\\nsetPageTitle(\\\"评论(\\\" + name + \\\")\\\");\\naddListener('onClose', $.toString(() => {\\n    clearVar(\\\"Warehouse.comment.type\\\");\\n    clearVar(\\\"Warehouse.comment.text\\\");\\n    clearVar(\\\"Warehouse.comment.qq\\\");\\n    refreshPage(false);\\n}));\\nlet type = getVar(\\\"Warehouse.comment.type\\\") || defaultType||\\\"good\\\";\\ndata.push({\\n    desc: \\\"评论......\\\",\\n    col_type: 'input',\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getVar('Warehouse.comment.text', ''),\\n        type: \\\"textarea\\\",\\n        height:7,\\n        onChange: 'putVar(\\\"Warehouse.comment.text\\\",input)'\\n    }\\n});\\ndata.push({\\n    title:\\\"账号：\\\"+(user[0]||\\\"\\\"),\\n    desc:\\\"验证码：\\\"+(user[1]||\\\"\\\"),\\n    url:\\\"hiker://page/Userregistration\\\",\\n    col_type: 'text_1',\\n    \\n});\\n\\ndata.push({\\n    title:  (type === \\\"good\\\" ? \\\"◉\\\" : \\\"○\\\")+\\\" 👍\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        putVar(\\\"Warehouse.comment.type\\\", \\\"good\\\");\\n        refreshPage();\\n        return \\\"hiker://empty\\\";\\n    }),\\n    col_type: 'text_2'\\n\\n});\\ndata.push({\\n    title:  (type === \\\"bad\\\" ? \\\"◉\\\" : \\\"○\\\")+\\\" 👎\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        putVar(\\\"Warehouse.comment.type\\\", \\\"bad\\\");\\n        refreshPage();\\n        return \\\"hiker://empty\\\";\\n    }),\\n    col_type: 'text_2'\\n});\\n\\ndata.push({\\n    title: \\\"提交\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: $(api.dis_new + id).lazyRule((Account) => {\\n        let text = getVar('Warehouse.comment.text', '');\\n        let [qq,auth_code] = Account;\\n        let type = getVar('Warehouse.comment.type') || 'good';\\n        qq=qq||\\\"\\\";\\n        auth_code=auth_code||\\\"\\\";\\n        if(qq==\\\"\\\"||auth_code==\\\"\\\"){\\n            return \\\"toast://未登录账号\\\";\\n        }\\n        if(text==\\\"\\\"){\\n            return \\\"toast://你还什么都没写啊\\\";\\n        }\\n        function r(p) {\\n            let result = request(input, {\\n                headers: {\\n                    'content-type': 'application/json'\\n                },\\n                body: JSON.stringify(p),\\n                method: 'POST'\\n            });\\n            return JSON.parse(result).result;\\n        }\\n        let p = {\\n            \\\"params\\\": {\\n                \\\"discuss_text\\\": text,\\n                \\\"qq\\\": qq,\\n                \\\"discuss_type\\\": type,\\n                \\\"auth_code\\\": auth_code\\n            }\\n        }\\n        let result = r(p);\\n        if(result.status===0){\\n            back(false);\\n        }\\n        return \\\"toast://\\\"+result.detail;\\n\\n    },user)\\n});\\n\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"伪用户注册\",\"path\":\"Userregistration\",\"rule\":\"js:\\nconst {\\n    api,\\n    getFile,\\n    getUserDate\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet data = [];\\ndata.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nsetPageTitle(\\\"用户列表管理\\\");\\naddListener('onClose', $.toString(() => {\\n    clearVar(\\\"Warehouse.m.qq\\\");\\n    clearVar(\\\"Warehouse.m.yzm\\\");\\n}));\\nlet user = getFile();\\nlet userName = user.user || [\\\"\\\"];\\nuserName = userName[0];\\ndata.push({\\n    title: \\\"““””<big>(添加/验证)账号</big>\\\",\\n    col_type: \\\"text_1\\\",\\n    url: \\\"hiker://empty\\\"\\n});\\n\\ndata.push({\\n    title: \\\"获取\\\",\\n    col_type: 'input',\\n    desc: \\\"请输入qq\\\",\\n    url: $.toString((a, b) => {\\n        let qq = input;\\n        if (qq == \\\"\\\") {\\n            return \\\"toast://你还什么都没填啊!\\\";\\n        }\\n        showLoading(\\\"获取中...\\\")\\n        return $(\\\"#noLoading#\\\").lazyRule((qq, a, b) => {\\n        try {\\n            let result = request(a, {\\n                headers: {\\n                    'content-type': 'application/json'\\n                },\\n                body: JSON.stringify({\\n                    \\\"params\\\": {\\n                        \\\"qq\\\": qq\\n                    }\\n                }),\\n                method: 'POST'\\n            });\\n            result = JSON.parse(result).result;\\n            if (result.status === 0) {\\n                hideLoading();\\n                return \\\"toast://\\\" + result.detail;\\n            } else {\\n                let result2 = JSON.parse(request(b + \\\"?qq=\\\" + qq));\\n                hideLoading();\\n                return \\\"toast://\\\" + result2.detail;\\n            }\\n        } catch (e) {\\n            hideLoading();\\n            throw e;\\n        }\\n        }, qq, a, b);\\n\\n    }, api.dis_new_user, api.dis_verify),\\n    extra: {\\n        type: \\\"number\\\",\\n        defaultValue: getVar('Warehouse.m.qq', '') || userName,\\n        onChange: 'putVar(\\\"Warehouse.m.qq\\\",input)'\\n    }\\n});\\n\\ndata.push({\\n    col_type: 'input',\\n    desc: \\\"请输入验证码\\\",\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getVar('Warehouse.m.yzm', ''),\\n        onChange: 'putVar(\\\"Warehouse.m.yzm\\\",input)'\\n    }\\n});\\ndata.push({\\n    col_type: 'rich_text',\\n    title: \\\"<small>提示：1.每天只能获取5次验证码.<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;2.<s>验证码有效期持续一周左右</s>(暂时不会，忘记验证码可通过QQ号获取)</small>\\\"\\n});\\n\\nlet userList = getUserDate();\\ndata.push({\\n    title: \\\"验证/登录\\\",\\n    url: $(\\\"确定保存，验证码填错，无法评论哦\\\").confirm((f, l, login) => {\\n        let qq = getVar('Warehouse.m.qq', '');\\n        let yzm = getVar('Warehouse.m.yzm', '');\\n        if (qq == \\\"\\\" || yzm == \\\"\\\") {\\n            return \\\"toast://qq或验证码为空\\\";\\n        }\\n        let result = request(login, {\\n            headers: {\\n                'content-type': 'application/json'\\n            },\\n            body: JSON.stringify({\\n                \\\"params\\\": {\\n                    \\\"qq\\\": qq,\\n                    \\\"auth_code\\\": yzm\\n                }\\n            }),\\n            method: 'POST'\\n        });\\n        result = JSON.parse(result).result;\\n        if (result.status === 0) {\\n            f.user = [qq, yzm];\\n            writeFile(\\\"hiker://files/WarehouseUSER.json\\\", JSON.stringify(f));\\n            let index = l.findIndex(item => item[0] === qq);\\n            if (index > -1) {\\n                l.splice(index, 1, [qq, yzm]);\\n            } else if (l.length < 6) {\\n                l.push([qq, yzm]);\\n            } else {\\n                l.splice(0, 1);\\n                l.push([qq, yzm]);\\n            }\\n            writeFile(\\\"hiker://files/WarehouseUSERA.json\\\", JSON.stringify(l));\\n            back();\\n            return \\\"toast://验证成功\\\";\\n        }\\n        return \\\"toast://\\\" + result.detail;\\n    }, user, userList, api.dis_login),\\n    col_type: 'text_center_1'\\n});\\ndata.push({\\n    col_type: \\\"line_blank\\\"\\n});\\ndata.push({\\n    title: \\\"““””<big>账号列表</big>\\\\t\\\\t\\\\t<small>(保留5条记录)</small>\\\",\\n    col_type: \\\"text_1\\\",\\n    url: \\\"hiker://empty\\\"\\n});\\nuserList.reverse();\\n\\nfor (let item of userList) {\\n    data.push({\\n        title: \\\"账号：\\\" + item[0] + (userName === item[0] ? \\\"\\\\t\\\\t\\\\t““[当前账号]””\\\" : \\\"\\\"),\\n        desc: \\\"验证码：\\\" + item[1],\\n        url: $(\\\"是否切换为该[\\\" + item[0] + \\\"]账号\\\").confirm((f, item) => {\\n            f.user = item;\\n            writeFile(\\\"hiker://files/WarehouseUSER.json\\\", JSON.stringify(f));\\n            back();\\n            return \\\"toast://切换成功\\\";\\n        }, user, item),\\n        col_type: \\\"text_1\\\"\\n    });\\n}\\ndata.push({\\n    col_type: \\\"line_blank\\\"\\n});\\ndata.push({\\n    title: \\\"退出账号\\\",\\n    url: $(\\\"确认退出登录状态\\\").confirm((f) => {\\n        f.user = [];\\n        writeFile(\\\"hiker://files/WarehouseUSER.json\\\", JSON.stringify(f));\\n        back();\\n        return \\\"toast://退出成功\\\";\\n    }, user),\\n    col_type: 'text_center_1'\\n});\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"列表排序算法\",\"path\":\"sort\",\"rule\":\"js:\\n/* 规则列表排序 [ UP、NEW、无更新 ] 顺序 */\\n/* 归并排序 Start */\\n/*\\nfunction mergeSort(arr) {\\n    var len = arr.length;\\n    if (len < 2) {\\n        return arr;\\n    }\\n    var middle = Math.floor(len / 2),\\n        left = arr.slice(0, middle),\\n        right = arr.slice(middle);\\n    return merge(mergeSort(left), mergeSort(right));\\n}\\nfunction merge(left, right) {\\n    var result = [];\\n    var isThisVersionList = [];\\n\\n    while (left.length > 0 && right.length > 0) {\\n        if (left[0].title.includes(\\\"🆙\\\")) {\\n            result.push(left.shift());\\n        } else if (right[0].title.includes(\\\"🆙\\\")) {\\n            result.push(right.shift());\\n        } else if (left[0].title.includes(\\\"🆕\\\")) {\\n            result.push(left.shift());\\n        } else if (right[0].title.includes(\\\"🆕\\\")) {\\n            result.push(right.shift());\\n        } else {\\n            isThisVersionList.push(left.shift());\\n            isThisVersionList.push(right.shift());\\n        }\\n    }\\n\\n    while (isThisVersionList.length) result.push(isThisVersionList.shift());\\n\\n    while (left.length)\\n        result.push(left.shift());\\n\\n    while (right.length)\\n        result.push(right.shift());\\n\\n    return result;\\n}\\n$.exports.mergeSort = mergeSort;\\n*/\\n/* 归并排序 End */\\n/* 普通分类排序 Start */\\nfunction normalSort(arr) {\\n    var len = arr.length;\\n    if (len < 2) {\\n        return arr;\\n    }\\n    let upResult = [];\\n    let otherResult = [];\\n    while(arr.length) {\\n        let item = arr.shift();\\n        if(item.title.includes(\\\"🆙\\\")) {\\n            upResult.push(item)\\n        } else {\\n            otherResult.push(item)\\n        }\\n    }\\n    return upResult.concat(otherResult);\\n}\\n$.exports.normalSort = normalSort;\\n/* 普通分类排序 End */\"},{\"col_type\":\"icon_2_round\",\"name\":\"全部公开规则\",\"path\":\"AllPublicRule\",\"rule\":\"js:\\n    const {\\n        api,\\n        localRuleVer,\\n        getApi\\n    } = $.require(\\\"hiker://page/utiliy\\\");\\nconst {\\n    mergeSort\\n} = $.require(\\\"hiker://page/sort\\\");\\nlet dataType = getVar(\\\"Warehouse.type\\\", \\\"\\\");\\nlet order = getVar(\\\"Warehouse.order\\\", \\\"0\\\");\\nlet sort = getVar(\\\"Warehouse.sort\\\", \\\"0\\\");\\nlet good = getVar(\\\"Warehouse.good\\\", \\\"\\\");\\nlet page = MY_URL.split(\\\"#\\\")[1] || 1;\\nlet ruleList = JSON.parse(request(api.all_rule + \\\"?data_type=\\\" + dataType + \\\"&page=\\\" + page + \\\"&limit=20&order=\\\" + order + \\\"&sort=\\\" + sort+ \\\"&is_good=\\\" + good)).result;\\naddListener('onClose', $.toString(() => {\\n    clearVar(\\\"Warehouse.type\\\");\\n    clearVar(\\\"Warehouse.order\\\");\\n    clearVar(\\\"Warehouse.sort\\\");\\n    clearVar(\\\"Warehouse.good\\\");\\n    clearVar(\\\"Warehouse.back\\\");\\n}));\\nlet data = [];\\nif (getVar(\\\"Warehouse.back\\\") === \\\"1\\\") {\\n    back();\\n}\\nfunction tab(arr, type, contrast) {\\n    for (let item of arr) {\\n        data.push({\\n            title: item[1] === contrast ? \\\"““\\\" + item[0] + \\\"””\\\" : item[0],\\n            url: $(\\\"#noLoading#\\\").lazyRule((key, type) => {\\n                putVar(type, key);\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\";\\n            }, item[1], type),\\n            col_type: \\\"scroll_button\\\"\\n        });\\n    }\\n    data.push({\\n        col_type: \\\"blank_block\\\"\\n    });\\n}\\nif (page === \\\"1\\\") {\\n    tab([\\n        [\\\"全部\\\", \\\"\\\"],\\n        [\\\"小程序\\\", \\\"home_rule_url\\\"],\\n        [\\\"提交云仓库规则\\\", \\\"publish\\\"],\\n        [\\\"网页插件\\\", \\\"js_url\\\"],\\n        [\\\"静态页面\\\", \\\"html\\\"],\\n        [\\\"主题\\\", \\\"config\\\"]\\n    ], \\\"Warehouse.type\\\", dataType);\\n    tab([\\n        [\\\"时间\\\", \\\"0\\\"],\\n        [\\\"ID\\\", \\\"1\\\"],\\n        [\\\"好评度\\\", \\\"2\\\"],\\n        [\\\"差评度\\\", \\\"3\\\"],\\n        [\\\"回复数\\\", \\\"4\\\"]\\n    ], \\\"Warehouse.order\\\", order);\\n    tab([\\n        [\\\"倒序\\\", \\\"0\\\"],\\n        [\\\"正序\\\", \\\"1\\\"]\\n    ], \\\"Warehouse.sort\\\", sort);\\n    tab([\\n        [\\\"不论\\\", \\\"\\\"],\\n        [\\\"优质\\\", \\\"1\\\"]\\n    ], \\\"Warehouse.good\\\", good);\\n    data.push({\\n        title: \\\"搜索\\\",\\n        url: $.toString(name => \\\"hiker://search?s=\\\" + input + \\\"&rule=\\\" + name, MY_RULE.title),\\n        col_type: \\\"input\\\",\\n        desc: \\\"搜索全部规则\\\"\\n    });\\n}\\n\\nlet homeList = JSON.parse(request(api.home));\\nlet mRuleList = [];\\nfor (var item of ruleList) {\\n    var name = item.name;\\n    if (item.is_tap) {\\n        let location = JSON.parse(request(getApi(\\\"ruleListJson\\\") + \\\"?id=\\\" + item.id));\\n        item.id = location.id;\\n        item.name = location.name;\\n        item.author = location.author;\\n        item.data_type = location.data_type;\\n        item.ver = location.ver\\n    }\\n    item.version = item.ver;\\n    let label = \\\"\\\",\\n        lver = -2;\\n    if (item.is_json && item.data_type === \\\"home_rule_url\\\") {\\n        lver = localRuleVer(homeList, item);\\n        if (lver === -1) {\\n            label = \\\"🆕\\\";\\n        } else if (lver < item.ver) {\\n            label = \\\"🆙\\\";\\n        }\\n    }\\n    mRuleList.push({\\n        title: label + name,\\n        url: \\\"hiker://page/ruleDetail#noHistory##noRecordHistory#\\\",\\n        extra: {\\n            lver: lver,\\n            id: item.id,\\n            isAll:true\\n        },\\n        pic_url: item.pic,\\n    })\\n}\\n/* 归并排序 Start */\\n//mRuleList = mergeSort(mRuleList);\\n/* 归并排序 End */\\ndata.push.apply(data, mRuleList)\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"回复\",\"path\":\"Reply\",\"rule\":\"js:\\nlet data = [];\\nconst {\\n    api\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    replyId,\\n    ruleId,\\n    name,\\n    password,\\n    username\\n} = MY_PARAMS;\\n\\n\\nsetPageTitle(\\\"回复(\\\" + name + \\\")\\\");\\naddListener('onClose', $.toString(() => {\\n    clearVar(\\\"Warehouse.comment.text\\\");\\n    refreshPage(false);\\n}));\\n\\ndata.push({\\n    desc: \\\"回复......\\\",\\n    col_type: 'input',\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getVar('Warehouse.comment.text', ''),\\n        type: \\\"textarea\\\",\\n        height:7,\\n        onChange: 'putVar(\\\"Warehouse.comment.text\\\",input)'\\n    }\\n});\\n\\n\\ndata.push({\\n    title: \\\"提交\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: $(api.dis_reply + ruleId).lazyRule((password, username, ruleId) => {\\n        let text = getVar('Warehouse.comment.text', '');\\n        if (password == \\\"\\\" || username == \\\"\\\") {\\n            return \\\"toast://未登录账号\\\";\\n        }\\n        if (text == \\\"\\\") {\\n            return \\\"toast://你还什么都没写啊\\\";\\n        }\\n        let result = request(input, {\\n            headers: {\\n                'content-type': 'application/json'\\n            },\\n            body: JSON.stringify({\\n                \\\"params\\\": {\\n                    \\\"discuss_text\\\": text,\\n                    \\\"qq\\\": username,\\n                    \\\"password\\\": password,\\n                    \\\"discuss_id\\\": ruleId\\n                }\\n            }),\\n            method: 'POST'\\n        });\\n        result = JSON.parse(result).result;\\n        if (result.status === 0) {\\n            back(false);\\n        }\\n        return \\\"toast://\\\" + result.detail;\\n\\n    }, password, username, replyId)\\n});\\n\\nsetResult(data);\"},{\"col_type\":\"movie_3\",\"name\":\"我的回复\",\"path\":\"MyReply\",\"rule\":\"js:\\nconst {\\n    api\\n} = $.require(\\\"hiker://page/utiliy\\\");\\nlet {\\n    auth_code,\\n    qq\\n} = MY_PARAMS;\\nlet page = parseInt(MY_URL.split(\\\"#\\\")[1]);\\nlet data=[];\\nlet commentList = JSON.parse(request(api.dis_get_reply + \\\"?limit=5&page=\\\" + page + \\\"&qq=\\\" + qq + \\\"&auth_code=\\\" + auth_code)).result;\\nif (commentList.length === 0) {\\n    data.push({\\n        title: \\\"<h5 style='text-align:center'>别拉了一条也不剩了</h5>\\\",\\n        col_type: \\\"rich_text\\\"\\n    });\\n} else {\\n    for (let item of commentList) {\\n        data.push({\\n            title: item.name + \\\"&nbsp;&nbsp;<font color='gray'><small>#\\\" + item.id + \\\"</small><font>\\\",\\n            col_type: \\\"avatar\\\",\\n            url: \\\"hiker://page/ruleDetail#noHistory##noRecordHistory#\\\",\\n            extra: {\\n                lver: \\\"回复进入不支持查看\\\",\\n                id: item.rule_id[0]\\n            },\\n            pic_url: item.avatar_url\\n        });\\n        data.push({\\n            title: item.discuss_text,\\n            desc: item.create_date + \\\"·\\\"+item.rule_id[1]+\\\"·\\\"+\\\"开发者🗣\\\",\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/info\\\",\\n            extra:{\\n                name:item.name,\\n                type:\\\"long_text\\\",\\n                text:item.discuss_text\\n            },\\n            pic_url: item.avatar_url\\n        });\\n    }\\n    \\n}\\nsetResult(data);\\n\"},{\"col_type\":\"movie_3\",\"name\":\"更多分享\",\"path\":\"moreShare\",\"rule\":\"js:\\n    addListener('onClose', $.toString(()=>{\\n        clearVar(\\\"house.upload_code\\\");\\n    }));\\nconst {color,small,api, getFile} = $.require(\\\"hiker://page/utiliy\\\");\\nlet houseFile = getFile||false;\\nlet put_url = api.host+'/hikerule/dev/put';\\nif(!houseFile){\\n    setItem('is_house_vip', 'false');\\n}\\nlet house_data = houseFile();\\n// log(house_data.username+'-'+house_data.password);\\nvar canup = house_data.username.length >= 6 && house_data.password.length > 2;\\nlog('可以上传?'+canup);\\nlet d = [];\\nlet file_type = [{name:'静态文件',value:'html'},{name:'网页插件',value:'js_url'},{name:'主页配置',value:'config'}]; //上传类型\\nlet file_redirect = [{name:'本地',value:'false'},{name:'直链302',value:'true'}]; //是否重定向\\nlet file_ua = [{name:'电脑',value:'pc'},{name:'手机',value:'mobile'}];\\nlet file_type_title = file_type.map((item) => {\\n    let name = getItem('house.file_type','静态文件');\\n    if(item.name===name){\\n        return '👉'+item.name;\\n    }else{\\n        return item.name;\\n    }\\n});\\nlet file_redirect_title = file_redirect.map((item) => {\\n    let name = getItem('house.file_redirect','本地');\\n    if(item.name===name){\\n        return '👉'+item.name;\\n    }else{\\n        return item.name;\\n    }\\n});\\nlet file_ua_title = file_ua.map((item) => {\\n    let name = getItem('house.file_ua','电脑');\\n    if(item.name===name){\\n        return '👉'+item.name;\\n    }else{\\n        return item.name;\\n    }\\n});\\nd.push({col_type: 'x5_webview_single', extra: {js: 'console.log(\\\"我加载了\\\")'}});\\nd.push({\\n    title: '获取',\\n    desc: \\\"文件路径,支持hiker,file,http,主题\\\",\\n    extra: {\\n        onChange: \\\"putVar('house.web_url',input)\\\",\\n        titleVisible: true,\\n        id:'filePath',\\n        defaultValue:getVar('house.web_url')\\n    },\\n    url:$.toString(() => {\\n        let input = getVar('house.web_url','');\\n        if(input.length<2){\\n            return 'toast://链接不可以为空'\\n        } else if(/^hiker:|^file:|^http:|^https:|^\\\\/storage\\\\/|^\\\\/sdcard\\\\//.test(input)){\\n            if(/^\\\\/storage\\\\/|^\\\\/sdcard\\\\//.test(input)){\\n                input = 'file://'+input;\\n            }\\n            log('正常链接:'+input);\\n            let ua = getItem('house.file_ua')==='电脑'?'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36':'Mozilla/5.0 (Linux; Android 9; MI 6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Mobile Safari/537.36';\\n            let web_url_arr = input.split(';');\\n            let web_url = web_url_arr[0];\\n            let headers = {\\n                'Referer':'https://blog.csdn.net',\\n                'User-Agent':ua,\\n                'Accept':'application/json, text/javascript, */*; q=0.01',\\n                'Accept-Language':'zh-CN',\\n            };\\n            if(web_url_arr.length>=3&&web_url_arr[2].length>2){ //设置编码\\n                headers['content-type'] = 'charset='+web_url_arr[2].toUpperCase();\\n            }\\n            let params = {headers:headers,withHeaders:false,redirect:false};\\n            if(web_url_arr.length>=2&&web_url_arr[1].length>2){ // 设置请求方法\\n                params['method'] = web_url_arr[1].toUpperCase();\\n            }\\n            log('开始获取源码');\\n            try {\\n                /*\\n                requestAsync(web_url,params,function (key,code) {\\n                    let back_code = code;\\n                    if(back_code.length>20){\\n                        putVar('house.upload_code',back_code);\\n                        refreshPage(true);\\n                        return 'toast://源码已获取,并部分插入到文本区域'\\n                    }else{\\n                        return 'toast://错误，本次获取到空文本，疑似你没有此文件!';\\n                    }\\n                });\\n                */\\n                let back_code = getItem('house.file_ua')==='电脑'?fetch(web_url,params):request(web_url,params);\\n                if(back_code.length>20){\\n                    putVar('house.upload_code',back_code);\\n                    refreshPage(true);\\n                    return 'toast://源码已获取,并部分插入到文本区域'\\n                }else{\\n                    return 'toast://错误，本次获取到空文本，疑似你没有此文件!';\\n                }\\n            }catch (e) {\\n                log(e.message);\\n                return 'toast://发生了错误:\\\\n'+e.message;\\n            }\\n        }else if(/主题￥|元素￥/.test(input)){\\n            log('主题链接');\\n            let web_url_arr = input.split('￥');\\n            let web_url = web_url_arr[web_url_arr.length-1];\\n            let back_code = parsePaste(web_url);\\n            if(back_code.length>20) {\\n                putVar('house.upload_code',back_code);\\n                refreshPage(true);\\n                return 'toast://源码已获取,并部分插入到文本区域'\\n            }else{\\n                return 'toast://错误，本次获取返回为:\\\\n'+back_code;\\n            }\\n        }else{\\n            return 'toast://非法链接:\\\\n'+getVar('house.web_url');\\n        }\\n    }),\\n    col_type: \\\"input\\\"\\n});\\nd.push({\\n    title: \\\"选择文件路径\\\",\\n    url:$('#noLoading#').lazyRule(()=>{\\n        /*\\n        let fp = 'https://gitcode.net/qq_32394351/dr/-/raw/master/js/fileSelect.js';\\n        let f = require(fp);\\n        */\\n        let fp=config.lib.fileSelect;\\n        let f=$.rc(fp);\\n        return f.fileSelectionUri({\\n            callback: $.toString(() => {\\n                let target = findItem(\\\"filePath\\\").extra;\\n                updateItem(\\\"filePath\\\", {\\n                    extra: Object.assign(target, {\\n                        defaultValue: PATH\\n                    })\\n                });\\n                putVar('house.web_url',PATH);\\n                return true;\\n            }),\\n            onClickType:'confirm',\\n            fileType: \\\".js|.txt|.hiker|.json|.html\\\",\\n            pattern: 0,\\n            requireUrl:fp,\\n            initialPath:getPath('hiker://files/rules/dzHouse/').slice(7),\\n            memory:'true',\\n        });\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n});\\nd.push({\\n    title:'上传类型',\\n    desc:'上传文件的类型,当前为:'+color(getItem('house.file_type','静态文件'),'#ff7000'),\\n    col_type:'text_1',\\n    url:$(file_type_title,2).select(() => {\\n        setItem('house.file_type',input.replace('👉',''));\\n        refreshPage(true);\\n        return 'toast://你选择了:'+input;\\n    })\\n});\\n\\nd.push({\\n    title:'文件定位',\\n    desc:'文件是否属于重定向,当前为:'+color(getItem('house.file_redirect','本地'),'#ff7000'),\\n    col_type:'text_1',\\n    url:$(file_redirect_title,2).select(() => {\\n        setItem('house.file_redirect',input.replace('👉',''));\\n        refreshPage(true);\\n        return 'toast://你选择了:'+input;\\n    })\\n});\\n\\nd.push({\\n    title:'设备UA',\\n    desc:'发起网页请求头标识,当前为:'+color(getItem('house.file_ua','电脑'),'#ff7000'),\\n    col_type:'text_1',\\n    url:$(file_ua_title,2).select(() => {\\n        setItem('house.file_ua',input.replace('👉',''));\\n        refreshPage(true);\\n        return 'toast://你选择了:'+input;\\n    })\\n});\\nfunction compare(name) {\\n    return function(item) {\\n        return item.name === name;\\n    }\\n}\\nd.push({\\n    title:'🗄️环境',\\n    col_type:'flex_button',\\n    url:$().lazyRule((file_type,compare)=>{\\n        log('查看环境变量');\\n        try {\\n            let up_code = getVar('house.upload_code','');\\n            let ftype =  file_type.filter(compare(getItem('house.file_type','静态文件')))[0].value;\\n            let redirect = getItem('house.file_redirect','本地')!=='本地';\\n            let code = !redirect?up_code:input;\\n            let env = {\\n                web_url:getVar('house.web_url',''),\\n                device:getItem('house.file_ua','电脑'),\\n                ftype:ftype||\\\"\\\",\\n                redirect:redirect,\\n                code:code.substring(0,40)||\\\"\\\",\\n            }\\n            log(env);\\n            return 'toast://'+JSON.stringify(env);\\n            // alert(JSON.stringify(env));\\n        }catch (e) {\\n            return 'toast://'+e.message;\\n            // alert(e.message);\\n        }\\n    },file_type,compare)\\n});\\n\\nd.push({\\n    title:'📃教程',\\n    col_type:'flex_button',\\n    url:$().x5Rule(()=>{\\n        let msg = '欢迎使用开发者更多分享工具\\\\n1.输入网址为本地文件路径,hiker://或者file://开头\\\\n2.点击网址输入栏后面的按钮\\\\n3.看文本预览区是否正确\\\\n4.点击上传按钮提交到仓库';\\n        alert(msg);\\n    })\\n});\\n\\nd.push({\\n    title:'🗑️清空',\\n    col_type:'flex_button',\\n    url:$().lazyRule(()=>{\\n        clearVar('house.upload_code');\\n        refreshPage(true);\\n        return 'toast://已清除预览区域内容'\\n    })\\n});\\n\\nd.push({\\n    title:'📲示例',\\n    col_type:'flex_button',\\n    url:$().lazyRule(()=>{\\n        let demo_code = getItem('house.demo','0');\\n        if(demo_code=='0'){\\n            putVar('house.web_url','hiker://files/rules/dzHouse/html/资源网书签.html');\\n            demo_code = parseInt(demo_code)+1;\\n            setItem('house.demo',demo_code+'');\\n        }else{\\n            putVar('house.web_url','file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/rules/dzHouse/html/资源网书签.html');\\n            setItem('house.demo','0');\\n        }\\n        refreshPage(true);\\n        return 'toast://已设置示例地址'\\n    })\\n});\\n\\nd.push({\\n    title:'📤上传',\\n    col_type:'flex_button',\\n    url:$().lazyRule((canup,house_data,put_url,file_type) =>{\\n        function compare(name) {\\n            return function(item) {\\n                return item.name === name;\\n            }\\n        }\\n        const {getNowFormatDate}=$.require(\\\"hiker://page/utiliy\\\");\\n        let up_code = getVar('house.upload_code','');\\n        if(up_code.length < 2){\\n            return 'toast://源码区无内容，请先访问一个静态页面'\\n        }\\n        if(!canup){\\n            return 'toast://你不是开发者，没有提交到仓库的权利!'\\n        }\\n        let input = getVar('house.web_url','');\\n        let web_url = input.split(';')[0];\\n        let fileName = '';\\n        if(/^hiker:|^file:|^http:|^https:|^\\\\/storage\\\\/|^\\\\/sdcard\\\\//.test(web_url)){\\n            fileName = web_url.split('/')[web_url.split('/').length-1];\\n        }else if(/主题￥|元素￥/.test(input)){\\n            let bkarr = up_code.split('￥');\\n            if(bkarr.length<3){\\n                return 'toast://云剪贴板内容有误'\\n            }\\n            switch (bkarr[1]) {\\n                case 'my_home_theme':\\n                    fileName = up_code.split('「')[1].split('」')[0];\\n                    break;\\n                case 'my_home_single':\\n                    fileName = up_code.split('「')[1].split('」')[0];\\n                    break;\\n                case 'js_url':\\n                    fileName = up_code.split('￥')[2].split('@')[0];\\n                    break;\\n            }\\n        }else{\\n            return 'toast://错误，网页链接无内容!';\\n        }\\n        let ua = getItem('house.file_ua')==='电脑'?'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36':'Mozilla/5.0 (Linux; Android 9; MI 6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Mobile Safari/537.36';\\n        let headers = {\\n            'Referer':'https://blog.csdn.net',\\n            \\\"content-type\\\": \\\"application/json\\\",\\n            'User-Agent':ua,\\n            'Accept':'application/json, text/javascript, */*; q=0.01',\\n            'Accept-Language':'zh-CN',\\n        };\\n        let toCompare = '';\\n        if(fileName.endsWith('.html')){\\n            toCompare = '静态文件';\\n        }else if(/主题/.test(fileName)){\\n            toCompare = '主页配置'\\n        }\\n        let ftype =  file_type.filter(compare(toCompare||getItem('house.file_type','静态文件')))[0].value;\\n        let redirect = getItem('house.file_redirect','本地')!=='本地';\\n        if(redirect&&!web_url.startsWith('http')){\\n            return 'toast://直链302重定向网址链接必须http开头';\\n        }\\n        let code = !redirect?up_code:web_url;\\n        let data = {\\\"params\\\":\\n                {\\\"data\\\": {rule_name: fileName, \\\"rule_type\\\": '更多分享', \\\"version\\\":getNowFormatDate(),\\\"rule_value\\\": code,\\n                        data_type:ftype, is_redirect:redirect,deviceUa:getItem('house.file_ua'),\\n                    },\\n                    \\\"name\\\": house_data.username,\\n                    \\\"password\\\": house_data.password}\\n        };\\n        let upparams = {headers:headers,body:JSON.stringify(data),withHeaders:false,redirect:false,method:'POST'};\\n        let backmsg = getItem('house.file_ua')==='电脑'?fetch(put_url,upparams):request(put_url,upparams);\\n        try{\\n            let result = JSON.parse(backmsg).result;\\n            let detail = result.detail;\\n            return 'toast://'+detail;\\n        }catch (e) {\\n            log(e.message);\\n            return 'toast://发生了错误\\\\n'+e.message;\\n        }\\n    },canup,house_data,put_url,file_type)\\n});\\n\\nd.push({\\n    title:'长文本预览区域',\\n    col_type:'text_1',\\n    url:'hiker://empty',\\n    extra: {textSize: 11,lineVisible:false}\\n});\\n\\nd.push({\\n    title:getVar('house.upload_code','').substring(0,10240),\\n    col_type:'long_text',\\n    extra: {textSize: 11}\\n});\\nsetPageTitle(\\\"更多分享\\\");\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"轻合集生成接口\",\"path\":\"genApi\",\"rule\":\"js:\\nfunction genRule(name,url,icon){\\n    icon=icon||'https://z3.ax1x.com/2021/11/16/IWJhxf.png';\\n    const {getNowFormatDate,api,getApi}=$.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    String.prototype.replaceAll = function(old,new_str){\\n        return this.split(old).join(new_str);\\n    };\\n    let muban = getApi('importUrl')+\\\"1690\\\";\\n    let muban_word={name:\\\"@轻合集\\\",url:\\\"@地址\\\",ver:\\\"@版本\\\",icon:\\\"@图标\\\"};\\n    let muban_code = fetch(muban);\\n    muban_code=muban_code.replaceAll(muban_word.name,name).replaceAll(muban_word.ver,getNowFormatDate()).replaceAll(muban_word.url,url).replaceAll(muban_word.icon,icon);\\n    let import_code=\\\"海阔视界规则分享，当前分享的是：小程序，无根树，花正清，不断荤腥不戒淫￥home_rule_v2￥base64://@\\\"+name+\\\"@\\\"+base64Encode(muban_code);\\n    var pastes = getPastes();\\n    var url = sharePaste(import_code,pastes.slice(-1)[0]);\\n    let import_rule= url+\\\"\\\\n\\\\n小程序：\\\"+name;\\n    return import_rule;\\n}\\n$.exports.genRule=genRule;\"},{\"col_type\":\"movie_3\",\"name\":\"全局解析免嗅\",\"path\":\"globalParse\",\"rule\":\"js:\\n    function getHeaders(playUrl){\\n        let headers = {};\\n        let refer=playUrl.split(\\\"//\\\")[0]+\\\"//\\\"+playUrl.split(\\\"//\\\")[1].split(\\\"/\\\")[0];\\n        if(/lecloud\\\\.com|bilivideo\\\\.com/.test(playUrl)){\\n            headers = {\\\"Referer\\\": 'https://www.bilibili.com/',\\\"User-Agent\\\":\\\"Mozilla/5.0\\\"}\\n        }else if(/mgtv\\\\.com/.test(playUrl)){\\n            headers = {\\\"Referer\\\": refer,\\\"User-Agent\\\":\\\"Mozilla/5.0\\\"}\\n        }else if(/ixigua\\\\.com/.test(playUrl)){\\n            headers = {\\\"Referer\\\": 'https://www.ixigua.com/',\\\"User-Agent\\\":\\\"Mozilla/5.0\\\"}\\n        }else{\\n            // headers = {\\\"Referer\\\": refer,'User-Agent':'Dart/2.13 (dart:io)'}\\n            // headers = {\\\"Referer\\\": refer,'User-Agent':MOBILE_UA};\\n            headers = {'User-Agent':MOBILE_UA};\\n        }\\n        return headers\\n    }\\nfunction isPic(str){\\n    return /\\\\.(gif|jpg|jpeg|png|GIF|JPG|PNG)$/.test(str);\\n}\\nfunction isVideo(playUrl,rechange){\\n    //注意.php不可以被排除否则融兴解析不了 |.php$\\n    //如果是播放地址就直接返回地址加上UA，不是的话就返回false\\n    // let t1 = new Date().getTime();\\n    let cacheRegx = new RegExp('file:///storage/emulated/(.*?)\\\\\\\\.m3u8|hiker://files/(.*?)\\\\\\\\.m3u8');\\n    if(cacheRegx.test(playUrl)){\\n        return playUrl\\n    }\\n    function getHost(url){\\n        // fba的parseLazy太慢了千万别用\\n        try {\\n            return url.match(/^http(s)?:\\\\/\\\\/(.*?)\\\\//)[0].slice(0,-1);\\n        }catch (e) {\\n            return false\\n        }\\n        /*\\n        if(typeof(log)==='undefined'){\\n            return  fba.parseLazyRule($$$().lazyRule((url)=>{\\n                return getHome(url)\\n            },url))\\n        }else {\\n            return getHome(url)\\n        }\\n        */\\n    }\\n    let pUrl=playUrl.split(\\\";\\\")[0];//获取抠掉海阔ua等参数的网页播放链接\\n    let host = getHost(pUrl); // 获取域名\\n    if(!host){//判断无域名直接不是视频\\n        return false\\n    }\\n    function print(data){\\n        if(typeof(log)==='undefined'){\\n            return  fba.log(data)\\n        }else {\\n            return log(data)\\n        }\\n    }\\n    rechange=typeof(rechange)===\\\"function\\\"?rechange:function(playUrl){return playUrl};\\n    let exceptWords = '.js$|.css$|.ts$|.html$|.htm$|.gif$|.jpg$|.jpeg$|.png$|.ico$|.svg$|.txt$'.split('|').map(it=>'\\\\\\\\'+it).join('|');\\n    var exceptKeys = new RegExp(exceptWords);\\n    let exceptWords1 = 'referer=|url='.split('|').map(it=>it).join('|');\\n    var exceptKeys1 = new RegExp(exceptWords1);\\n    let replaceWords = 'playm3u8|m3u8\\\\.tv'.split('|').map(it=>it).join('|');\\n    let replaceKeys = new RegExp(replaceWords,'g');\\n    let videoWords = \\\"/video/tos|.mp4$|.m3u8$|.flv$|.avi$|.3gp$|.mpeg$|.wmv$|.mov$|rmvb|.dat$|.mp3$|.m4a$|qqBFdownload|mime=video%2F|mime_type=video_|type=m3u8|pt=m3u8\\\".split('|').map((it)=>{\\n        //type=mp4\\n        if(it.startsWith(\\\".\\\")){\\n            return '\\\\\\\\'+it\\n        }else{\\n            return it\\n        }\\n    }).join(\\\"|\\\");\\n    let videoKeys = new RegExp(videoWords);\\n    let rUrl = pUrl.replace(host,'');//获取除开域名的剩余链接\\n    let pUrl2=pUrl.split(\\\"&\\\")[0].split(\\\"?\\\")[0];//获取不带参数的网页链接\\n    let rurl2 = pUrl2.replace(host,'');//获取除开域名的剩余不带参数链接\\n    let hasKey = videoKeys.test(rUrl)||videoKeys.test(rurl2);\\n    let parUrl = pUrl.replace(pUrl.split(\\\"?\\\")[0],''); // 分割问号后剩余参数的完整链接\\n    let excKey = exceptKeys1.test(parUrl);\\n    if(rUrl.split('?').length>2){\\n        let rUrl3=rUrl.split(\\\"?\\\")[1];//获取?分割后的第一段\\n        hasKey = hasKey||videoKeys.test(rUrl3);\\n    }\\n    if(hasKey&&!excKey){\\n        let tips = '检测到疑似多媒体的地址:';\\n        print(\\\"js中\\\"+tips+pUrl);\\n        print(\\\"分割问号后:\\\"+parUrl);\\n    }\\n    // log('1:'+(videoKeys.test(pUrl)||videoKeys.test(pUrl2)||videoKeys.test(pUrl.replace(replaceKeys,\\\"\\\").split(\\\"&\\\")[0].split(\\\"?\\\")[0])));\\n    // log('2:'+!exceptKeys.test(pUrl.split(\\\"?\\\")[0].split('&')[0]));\\n    // log('3:'+!exceptKeys1.test(pUrl.replace(pUrl.split(\\\"?\\\")[0],'')));\\n    if ((hasKey||videoKeys.test(rUrl.replace(replaceKeys,\\\"\\\").split(\\\"&\\\")[0].split(\\\"?\\\")[0]) )&& !exceptKeys.test(pUrl2)&&!exceptKeys1.test(pUrl2)) {\\n        if(!(/User-Agent|Referer@/.test(playUrl))){\\n            if(/lecloud\\\\.com|bilivideo/.test(playUrl)){\\n                playUrl+=\\\";{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}\\\";\\n            }else if(/ixigua\\\\.com/.test(playUrl)){\\n                playUrl+=\\\"#isvideo=true#;{Referer@https://www.ixigua.com/&&User-Agent@Mozilla/5.0}\\\";\\n            }\\n            else if(/mgtv\\\\.com|byteamone/.test(playUrl)){\\n                playUrl+=\\\";{User-Agent@Mozilla/5.0}\\\";\\n            }else if(/ptwo\\\\.wkfile\\\\.com/.test(playUrl)&&/url=/.test(playUrl)){\\n                playUrl=playUrl.split(\\\"url=\\\")[1]+\\\";{Referer@https://fantuan.tv}\\\"\\n            }\\n            // 处理大师兄之类的app\\n            // else{\\n            //     playUrl+=\\\";{User-Agent@Mozilla/5.0}\\\";\\n            // }\\n        }\\n        playUrl=rechange(playUrl);\\n        if(!/#isVideo=true#/.test(playUrl)){\\n            playUrl+=\\\"#isVideo=true#\\\";\\n        }\\n        // let t2 = new Date().getTime();\\n        // print('判断isVideo耗时:'+(t2-t1));\\n        return playUrl;\\n    }else{\\n        // let t2 = new Date().getTime();\\n        // print('判断isVideo耗时:'+(t2-t1));\\n        return false;\\n    }\\n}\\nfunction comParse(parStr,ej,onlyback,html){\\n    //列表，标题，图片，描述，链接，内容\\n    ej = ej||false;//有二级\\n    onlyback=onlyback||false;//只返回数据\\n    html = html||getResCode();\\n    html = typeof(html)==='string'?html:html.html;\\n    return $.toString((parStr,ej,onlyback,html,isPic)=>{\\n        let t=parStr.split(\\\";\\\");\\n        let d=[];\\n        // let list=pdfa(getResCode(),t[0]);\\n        let list=pdfa(html,t[0]);\\n        let lazy = $('').lazyRule(()=>{\\n            const {lazyParse} = $.require('hiker://page/globalParse?rule=道长仓库Pro');\\n            return lazyParse(input)\\n        });\\n        for(let i in list){\\n            let _pic = t[2]?pd(list[i],t[2]):'';\\n            if(isPic(_pic)&&!/@Referer=/.test(_pic)){\\n                _pic+='@Referer='\\n            }\\n            let it={\\n                title:pdfh(list[i],t[1]),\\n                pic_url:_pic,\\n                desc:pdfh(list[i],t[3]),\\n                url:ej?pd(list[i],t[4]):pd(list[i],t[4])+lazy\\n            };\\n            if(t.length>5){//内容，用于搜索\\n                it.content=pdfh(list[i],t[5])\\n            }\\n            d.push(it);\\n        }\\n        if(onlyback){\\n            return d\\n        }else{\\n            setResult(d)\\n        }\\n    },parStr,ej,onlyback,html,isPic)\\n}\\n\\nfunction isBadVideo(videoUrl) {//是坏的视频\\n    let dmPath = 'hiker://files/cache/diaomao.txt';//吊毛模式过滤文件路径\\n    let dmUrls;\\n    try {\\n        dmUrls = request(dmPath).trim().split('\\\\n').filter(it => it && !it.startsWith('//'));\\n    } catch (e) {\\n        dmUrls = [];\\n    }\\n\\n    function hasDm(videoUrl, dmUrls) {//播放地址是否为吊毛视频\\n        if (dmUrls.length < 1) {\\n            return false\\n        }\\n        function print(str){\\n            if(typeof(log)!=='undefined'){\\n                log(str);\\n            }else{\\n                fba.log(str);\\n            }\\n        }\\n        for (let dmUrl of dmUrls) {\\n            if ((new RegExp(dmUrl)).test(videoUrl)) {//播放地址包含吊毛标志的地址\\n                print('吊毛视频,自动过滤:'+videoUrl);\\n                return true\\n            }\\n        }\\n        print('非吊毛视频,可播放:'+videoUrl);\\n        return false\\n    }\\n\\n    function isDm(ret) {\\n        if (!ret) {\\n            return true\\n        }\\n        return hasDm(ret.split('#')[0].split(';')[0], dmUrls)\\n    }\\n    return isDm(videoUrl)\\n}\\n\\nfunction lazyParse(playUrl,ms,tm,rechange){\\n    // log('调用仓库免嗅探传参超时为:'+ms);\\n    tm = parseInt(tm)||5000;\\n    const {isVideo,getHeaders,isBadVideo} = $.require('hiker://page/globalParse?rule=道长仓库Pro');\\n    let realUrl = isVideo(playUrl,rechange);\\n    //log(realUrl);\\n    if(typeof(realUrl)=='string'){//bool值就是失败\\n        try{\\n            let rurl=realUrl.split(\\\";\\\")[0].split(\\\"#\\\")[0];\\n            return JSON.parse(request(rurl,{timeout:tm})).url\\n        }catch(e){\\n            return realUrl\\n        }\\n        //return realUrl\\n    }\\n\\n    //log(\\\"访问超时:\\\"+tm);\\n    log(\\\"尝试道长仓库x5免嗅:\\\"+playUrl);\\n    clearVar(\\\"_x5jxUrl\\\");\\n    let bad=$(\\\"网络不佳或者疑似对方网站挂了，你要查看其网页吗？\\\").confirm((playUrl)=>{\\n        log(\\\"网站看起来挂了:\\\"+playUrl);\\n        return playUrl\\n    },playUrl);\\n    try{\\n        var back=request(playUrl,{headers: getHeaders(playUrl),timeout:tm});\\n        //var back=fetch(playUrl,{headers: {'User-Agent': PC_UA}});\\n        if(!back){\\n            log(\\\"网站\\\"+playUrl+\\\"确实啥也没返回\\\");\\n            return bad\\n        }else if(/#EXTINF/.test(back)){\\n            //let lcache=\\\"/storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/video.m3u8\\\";\\n            //writeFile(lcache,back);\\n            //return lcache+\\\"##\\\"+playUrl+\\\"#isVideo=true#\\\"\\n            playUrl=cacheM3u8(playUrl);\\n            return playUrl\\n        }else if((!/触发了防盗链|未授权|接口防盗/.test(back))&&(!/http|url/.test(back))&&(!/msg|code|html/.test(back))){\\n            log(back);\\n            return 'toast://疑似对方数据加密了，具体数据看日志'\\n        }\\n    }catch(e){\\n        log(e.message);\\n        return bad\\n    }\\n    try {\\n        back=JSON.parse(back);\\n        let realUrl=back.url;\\n        if(typeof(realUrl)==\\\"undefined\\\"||!realUrl){\\n            log(back);\\n            return \\\"toast://道长仓库解析失败！返回播放地址为空\\\"\\n        } else if(typeof(isVideo(realUrl,rechange))=='string'){\\n            return isVideo(realUrl,rechange);\\n        }else{\\n            return realUrl+\\\"#isVideo=true#\\\";\\n        }\\n        //else{\\n        //realUrl+=\\\";{User-Agent@Mozilla/5.0}\\\";\\n        // }\\n    }catch (e) {\\n        log(\\\"检测到解析口非json错误:\\\"+e.message+',开始x5免嗅探');\\n        // require('https://hjdhnx.coding.net/p/hiker/d/dr/git/raw/master/js/lsg.js');//引用本地储存插件\\n        const lsg=$.require(\\\"hiker://page/localStorage?rule=道长仓库Pro\\\");//引用子页面本地储存插件\\n        let local_ms = lsg.getItem('timeout');\\n        let ms = parseInt(ms)||parseInt(local_ms)||5000;\\n        let max_count=Math.ceil(ms/250);\\n        log(\\\"本次嗅探超时:\\\"+ms+\\\"共计待抓包:\\\"+max_count+\\\"次\\\");\\n        showLoading('嗅探中，若失败就切换web嗅探...');\\n        let _x5 = $.toString((isVideo,rechange,playUrl,max_count,PC_UA,isBadVideo)=>{\\n            try {\\n                if(typeof(fba)=='undefined'||!fba){\\n                    var fba = fy_bridge_app;\\n                }\\n                try {\\n                    if(typeof(request)=='undefined'||!request){\\n                        eval(fba.getInternalJs());\\n                    }\\n                }catch (e) {\\n                    fba.log(e.message);\\n                }\\n                fba.putVar(\\\"_x5jxUrl\\\",playUrl);\\n                if(window.count == null){\\n                    window.count=1;\\n                }\\n                let text='';\\n                try {\\n                    text=document.querySelector(\\\"body\\\").innerText;\\n                }catch (e) {fba.log(e.message)}\\n                if(/触发了防盗链|未授权|接口防盗/.test(text)&&window.count===1){\\n                    fba.log(\\\"检测到有授权，开始过授权\\\");\\n                    //location.reload();\\n                    location.href=fba.getVar(\\\"_x5jxUrl\\\");\\n                }\\n                window.count++;\\n                // fba.log('count:'+window.count+',max_count:'+max_count);\\n                if( window.count >= max_count){\\n                    fba.log(\\\"超过\\\"+max_count*250+\\\"毫秒未获取到资源地址，跳到源网页,以下是加载过的地址\\\");\\n                    try {\\n                        let text=document.querySelector(\\\"body\\\").innerText;\\n                        // fba.log(text);\\n                    }catch (e) {fba.log(e.message)}\\n                    fba.log(JSON.stringify(_getUrls()));\\n                    return fba.getVar(\\\"_x5jxUrl\\\");\\n                }\\n                function muteMe(elem) {\\n                    try {\\n                        elem.pause();\\n                    }\\n                    catch (e) {\\n                    }\\n                }\\n                var videos = document.querySelectorAll(\\\"video\\\"), audios = document.querySelectorAll(\\\"audio\\\"), v2 = document.querySelectorAll(\\\"embed\\\"), v3 = document.querySelectorAll(\\\"#player\\\");\\n                try {\\n                    [].forEach.call(videos, function (video) {\\n                        muteMe(video);\\n                    });\\n                } catch (e) {}\\n                try {\\n                    [].forEach.call(audios, function (audio) {\\n                        muteMe(audio);\\n                    });\\n                } catch (e) {}\\n                try {\\n                    [].forEach.call(v2, function (v) {\\n                        muteMe(v);\\n                    });\\n                } catch (e) {}\\n                try {\\n                    [].forEach.call(v3, function (v) {\\n                        muteMe(v);\\n                    });\\n                } catch (e) {}\\n                var urls = _getUrls();\\n                // fba.log(JSON.stringify(urls));\\n                try {\\n                    for(let i in urls) {\\n                        let u=urls[i];\\n                        try{u=decodeURIComponent(u);}catch(e){\\n                            u=unescape(u);\\n                        }\\n                        //\\n                        if(/url=http/.test(u)){\\n                            u = u.split(\\\"url=\\\").slice(-1)[0];\\n                            // fba.log(\\\"url分割:\\\"+u);\\n                        }else if(/url=\\\\//.test(u)&&/\\\\.m3u8/.test(u)){\\n                            let host = u.match(/(.*)\\\\/\\\\/(.*?)\\\\//)[0];\\n                            u = host+u.split(\\\"url=\\\").slice(-1)[0];\\n                            // fba.log(\\\"url分割:\\\"+u);\\n                        }\\n                        else if(/vid=http/.test(u)){\\n                            u = u.split(\\\"vid=\\\").slice(-1)[0];\\n                            fba.log(\\\"vid分割:\\\"+u);\\n                        }else if(/vid=\\\\//.test(u)&&/\\\\.m3u8/.test(u)){\\n                            let host = u.match(/(.*)\\\\/\\\\/(.*?)\\\\//)[0];\\n                            u = host+u.split(\\\"vid=\\\").slice(-1)[0];\\n                            fba.log(\\\"vid分割:\\\"+u);\\n                        }\\n                        else if(/\\\\?(.*)=http/.test(u)&&/\\\\.m3u8/.test(u)){\\n                            u = \\\"http\\\"+u.split(/\\\\?(.*)=http/).slice(-1)[0];\\n                            fba.log(\\\"其他分割:\\\"+u);\\n                        }\\n                        //|index\\\\.m3u8$\\n                        else if(/\\\\/1\\\\.m3u8/.test(u)){\\n                            continue;\\n                        }\\n                        u=u.replace(/&from=.*|&next=.*|&jump=.*/,'');\\n                        let realUrl = isVideo(u,rechange);\\n                        if(typeof(realUrl)=='string'&&!isBadVideo(u)){//过滤吊毛视频\\n                            //fy_bridge_app.setWebUa(PC_UA);\\n                            if(typeof(fba.getHeaderUrl)!=='undefined'&&typeof(rechange)!=='function'){\\n                                // let backUrl = fba.getHeaderUrl(u.replace(\\\";{\\\",\\\"#isVideo=true#;{\\\"));\\n                                let backUrl = fba.getHeaderUrl(urls[i]).replace(';{','#ignoreImg=true##isVideo=true#;{');\\n                                let u1 = backUrl.split('#ignoreImg')[0];\\n                                let u2 = '#ignoreImg'+backUrl.split('#ignoreImg')[1];\\n                                u1 = u1.replace(/&from=.*|&next=.*|&jump=.*/,'');\\n                                if(/url=http/.test(u1)){\\n                                    u1 = u1.split(\\\"url=\\\").slice(-1)[0];\\n                                }else if(/url=\\\\//.test(u1)&&/\\\\.m3u8/.test(u1)){\\n                                    let host1 = u1.match(/(.*)\\\\/\\\\/(.*?)\\\\//)[0];\\n                                    u1 = host1+u1.split(\\\"url=\\\").slice(-1)[0];\\n                                    // fba.log(\\\"url分割:\\\"+u);\\n                                }\\n                                else if(/vid=http/.test(u1)){\\n                                    u1 = u1.split(\\\"vid=\\\").slice(-1)[0];\\n                                }else if(/vid=\\\\//.test(u1)&&/\\\\.m3u8/.test(u1)){\\n                                    let host1 = u1.match(/(.*)\\\\/\\\\/(.*?)\\\\//)[0];\\n                                    u1 = host1+u1.split(\\\"vid=\\\").slice(-1)[0];\\n                                }\\n                                else if(/\\\\?(.*)=http/.test(u1)&&/\\\\.m3u8/.test(u1)){\\n                                    u1 = \\\"http\\\"+u1.split(/\\\\?(.*)=http/).slice(-1)[0];\\n                                }\\n                                backUrl = u1 + u2;\\n                                // fba.log('返回自动加cookie链接:'+backUrl);\\n                                fba.log('返回链接:'+u+'并自动加了cookie,具体cookie在视频播放处查看');\\n                                return backUrl;\\n                            }\\n                            else{\\n                                fba.log(\\\"返回仓库x5免嗅结果:\\\"+realUrl);\\n                                return realUrl\\n                            }\\n                        }\\n                    }\\n                }catch (e) {\\n                    fba.log(e.message)\\n                }\\n            }catch (e) {\\n                // fy_bridge_app.log('x5大范围错误:'+e.message);\\n                alert('x5大范围错误:'+e.message);\\n                return 'toast://报错结束x5'\\n            }\\n        },isVideo,rechange,playUrl,max_count,PC_UA,isBadVideo);\\n        let useWeb=lsg.getItem(\\\"通免\\\",\\\"X5\\\")===\\\"WEB\\\";\\n        //log(\\\"仓库使用web通免替代x5:\\\"+useWeb);\\n        let ruleHead=useWeb&&parseInt(getAppVersion())>=2339?\\\"webRule://\\\":\\\"x5Rule://\\\";\\n        let x5Url = ruleHead+playUrl+ '@' +_x5;\\n        return x5Url\\n    }\\n}\\n\\nfunction x5ParsePro(x5list,x5Timeout,isVideo){\\n    let bpath = 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/rules/dzHouse/html/海阔嗅探器.html';\\n    let bcode = fetch(bpath);\\n    if(!bcode||!/fy_bridge_app/.test(bcode)){\\n        log('本地未安装嗅探器，开始安装');\\n        const {api} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n        let html = fetch(api.host+'/rulelist.json?id=2055');\\n        if(/海阔视界/.test(html)){\\n            writeFile(bpath,html);\\n        }else{\\n            writeFile(bpath,fetch('https://hjdhnx.coding.net/p/hiker/d/dr/git/raw/master/html/getVideo.html'))\\n        }\\n    }\\n    x5Timeout = parseInt(x5Timeout)||5000;\\n    let max_count=(x5Timeout/250); //根据超时自动计算了可执行的次数\\n    putVar('x5List',JSON.stringify(x5list));\\n    let _x5 = $.toString((isVideo, max_count,x5Timeout,isBadVideo) => {\\n        //初始化fba和requst\\n        if (typeof (fba) == 'undefined' || !fba) {\\n            var fba = fy_bridge_app;\\n        }\\n        try {\\n            if (typeof (request) == 'undefined' || !request) {\\n                eval(fba.getInternalJs());\\n            }\\n        } catch (e) {\\n            fba.log(e.message);\\n        }\\n        //------------------\\n        try {\\n            if (window.count == null) {\\n                window.count = 1;\\n            }\\n            let text='';\\n            try {\\n                text=document.querySelector(\\\"body\\\").innerText;\\n            }catch (e) {fba.log(e.message)}\\n            if(/触发了防盗链|未授权|接口防盗/.test(text)&&window.count==1){\\n                location.reload();\\n                fba.log(\\\"检测到有授权，开始过授权\\\");\\n            }\\n            window.count++;\\n            // fba.log('count:' + window.count + ',max_count:' + max_count);\\n            if (window.count >= max_count) {\\n                fba.clearVar('x5List');\\n                fba.hideLoading();\\n                let fmsg = '道长仓库通免解析失败,原因:超时'+x5Timeout+'毫秒';\\n                fba.log(fmsg);\\n                return 'toast://'+fmsg;\\n            }\\n        }catch (e) {\\n            fba.log(e.message);\\n        }\\n\\n        function muteMe(elem) {\\n            try {\\n                elem.pause();\\n            } catch (e) {\\n            }\\n        }\\n\\n        var videos = document.querySelectorAll(\\\"video\\\"), audios = document.querySelectorAll(\\\"audio\\\"),\\n            v2 = document.querySelectorAll(\\\"embed\\\"), v3 = document.querySelectorAll(\\\"#player\\\");\\n        try {\\n            [].forEach.call(videos, function (video) {\\n                muteMe(video);\\n            });\\n        } catch (e) {\\n        }\\n        try {\\n            [].forEach.call(audios, function (audio) {\\n                muteMe(audio);\\n            });\\n        } catch (e) {\\n        }\\n        try {\\n            [].forEach.call(v2, function (v) {\\n                muteMe(v);\\n            });\\n        } catch (e) {\\n        }\\n        try {\\n            [].forEach.call(v3, function (v) {\\n                muteMe(v);\\n            });\\n        } catch (e) {\\n        }\\n        var urls = _getUrls();\\n        try {\\n            for (let i in urls) {\\n                let u=urls[i];\\n                //u=decodeURIComponent(u);\\n                try{u=decodeURIComponent(u);}catch(e){\\n                    u=unescape(u);\\n                }\\n                if(/url=http/.test(u)){\\n                    u = u.split(\\\"url=\\\").slice(-1)[0];\\n                }else if(/vid=http/.test(u)){\\n                    u = u.split(\\\"vid=\\\").slice(-1)[0];\\n                }else if(/\\\\?(.*)=http/.test(u)){\\n                    u = \\\"http\\\"+u.split(/\\\\?(.*)=http/).slice(-1)[0];\\n                    //fba.log(\\\"其他分割:\\\"+u);\\n                }else if(/\\\\/1\\\\.m3u8$/.test(u)){\\n                    continue;\\n                }\\n                u=u.replace(/&from=.*|&next=.*|&jump=.*/,'');\\n                let realUrl = isVideo(u);\\n                if (realUrl&&!isBadVideo(u)) {//过滤吊毛\\n                    fba.log(\\\"仓库x5免嗅结果:\\\" + realUrl);\\n                    fba.clearVar('x5List');\\n                    return realUrl\\n                }\\n            }\\n        } catch (e) {\\n            fba.log(e.message)\\n        }\\n    }, isVideo, max_count,x5Timeout,isBadVideo);\\n    const lsg=$.require(\\\"hiker://page/localStorage?rule=道长仓库Pro\\\");\\n    let useWeb=lsg.getItem(\\\"通免\\\",\\\"X5\\\")===\\\"WEB\\\";\\n    //log(\\\"仓库使用web通免替代x5:\\\"+useWeb);\\n    let ruleHead=useWeb&&parseInt(getAppVersion())>=2339?\\\"webRule://\\\":\\\"x5Rule://\\\";\\n    return ruleHead+bpath+'@' + _x5;\\n}\\n\\nfunction LazyParseFast(playUrlList,getTimeout,x5Timeout){\\n    const {isVideo,getHeaders,x5ParsePro} = $.require('hiker://page/globalParse?rule=道长仓库Pro');\\n    // log('开始执行'+playUrlList.length+'个地址的批量嗅探:'+playUrlList);\\n    log('开始执行'+playUrlList.length+'个地址的批量嗅探');\\n    let playUrls = playUrlList.map((it)=>{\\n        return {\\n            url:it.split(\\\";\\\")[0],\\n            options: {\\n                headers: {\\n                    //\\\"User-Agent\\\": \\\"Dart/2.13 (dart:io)\\\",\\n                    \\\"User-Agent\\\":\\\"Mozilla/5.0\\\"\\n                },\\n                timeout: getTimeout\\n            }\\n        }\\n    });\\n    let bhtml = batchFetch(playUrls);\\n    let videos = [];\\n    let x5list = [];\\n    for(let i in bhtml){\\n        let order = parseInt(i)+1;\\n        let tname=order+'号解析网址:';\\n        //log(tname);\\n        let turl=playUrlList[i].split(\\\";\\\")[0];\\n        let jname=playUrlList[i].split(\\\";\\\").length>1?playUrlList[i].split(\\\";\\\")[1]:\\\"\\\";\\n        tname+=jname;\\n        let backcode = bhtml[i];\\n        if((!/url|http/.test(backcode))&&(!/#EXTINF/.test(backcode))){\\n            log(tname+turl+'有问题,可能加密或者挂了');\\n            continue;\\n        }else if(/#EXTINF/.test(backcode)){\\n            //let lcache=\\\"/storage/emulated/0/Android/data/com.example.hikerview/files/Documents/cache/video_\\\"+tname+\\\".m3u8\\\";\\n            //writeFile(lcache,backcode);\\n            //videos.push(lcache);\\n            let pUrl=cacheM3u8(turl);\\n            videos.push(pUrl);\\n            continue;\\n        }\\n        try {\\n            let url = JSON.parse(backcode).url;\\n            if(/^http/.test(url)){\\n                let realVideo = isVideo(url);\\n                if(typeof(realVideo)=='string'){\\n                    log(tname+'已解析出视频:'+realVideo);\\n                    if(jname){\\n                        realVideo+=\\\"★\\\"+jname\\n                    }\\n                    videos.push(realVideo);\\n                }else{\\n                    log(tname+'解析出不知道什么东西:'+url);\\n                    url+=\\\"#isVideo=true#\\\";\\n                    if(jname){\\n                        url+=\\\"★\\\"+jname\\n                    }\\n                    videos.push(url);\\n                }\\n            }else{\\n                log(tname+'为json接口且无返回视频地址数据:'+playUrlList[i]+'\\\\n'+backcode);\\n            }\\n        }catch (e) {\\n            log(tname+'为x5接口,加入x5嗅探列表');\\n            x5list.push(playUrlList[i]);\\n        }\\n    }\\n    // log(videos);\\n    if(videos.length>0){\\n        if(getVar('dp.cacheVideo','true')==='true'&&parseInt(getAppVersion())>=2255)\\n        {\\n            log(\\\"尊敬的魔断用户，视频缓存已启用，请尽情享受看剧时光\\\");\\n            let videosCache=videos.map((it)=>{\\n                let headers={};\\n                if(it.split(\\\";\\\").length>1){\\n                    let head = it.split(';')[1];\\n                    if(/@/.test(head)&&/{|}/.test(head)){\\n//head = head.replace(/{|}/g,'');\\n                        head = head.split(\\\"{\\\")[1].split(\\\"}\\\")[0];\\n                        head = head.split('&&');\\n                        for(let i in head){\\n                            let key = head[i].split('@')[0];\\n                            let value =head[i].split('@')[1].replace(/;/,';');\\n                            headers[key] = value;\\n                        }\\n                    }\\n                }\\n                return {\\n                    url:it.split(\\\";\\\")[0].split(\\\"★\\\")[0],\\n                    options:{\\n                        headers:headers\\n                    }\\n                }\\n            });\\n            var data=batchCacheM3u8(videosCache);\\n            data=data.map((it,id)=>{\\n                let extra=\\\"\\\";\\n                if(videos[id].split(\\\";\\\").length>1){\\n                    extra=\\\";\\\"+videos[id].split(\\\";\\\")[1];\\n                }else if(videos[id].split(\\\"★\\\").length>1){\\n                    extra=\\\"★\\\"+videos[id].split(\\\"★\\\")[1];\\n                }\\n\\n                if(it+\\\"\\\"!=\\\"null\\\"){\\n                    return it+extra\\n                }else{\\n                    return videos[id]\\n                }\\n            });\\n            //log(data);\\n            return data\\n            //return videos\\n        }else{\\n            return videos\\n        }\\n    }\\n    log('共有'+x5list.length+'个x5地址进行轮流嗅探');\\n    //没有的话就开始依次x5嗅探\\n    showLoading('嗅探中，若失败就切换web嗅探...');\\n    return x5ParsePro(x5list,x5Timeout,isVideo);\\n}\\nvar lazy=$('').lazyRule(()=>{\\n    try{\\n        realUrl=input;\\n        eval(\\\"var config_dp =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n        eval(fetch(config_dp.cj));\\n        log(input+'->正在断插魔改版解析...');\\n        // 加入超时设置，建议在首页设置\\n        return aytmParse(realUrl)\\n    }catch(e){\\n        return input\\n    }\\n});\\n$.exports.isPic=isPic;\\n$.exports.isVideo=isVideo;\\n$.exports.isBadVideo=isBadVideo;\\n$.exports.comParse=comParse;\\n$.exports.getHeaders=getHeaders;\\n$.exports.lazyParse=lazyParse;\\n$.exports.x5ParsePro=x5ParsePro;\\n$.exports.LazyParseFast=LazyParseFast;\\n$.exports.lazy=lazy;\"},{\"name\":\"任务仓库接口\",\"path\":\"taskCall\",\"rule\":\"js:\\nString.prototype.strip = function () { return this.replace(/(^\\\\s*)|(\\\\s*$)/g, \\\"\\\"); };\\nfunction task_req(task_api,task) { // 通用发送仓库post调用任务请求\\n    const {getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let house_data = houseFile();\\n    let result = request(task_api, {\\n        headers: {\\n            'content-type': 'application/json'\\n        },\\n        body: JSON.stringify({\\n            \\\"params\\\": {\\n                \\\"data\\\": {\\n                    \\\"type\\\": task.mode||'run',\\n                    \\\"func\\\": task.func||'',\\n                    \\\"params\\\": task.params||[]\\n                },\\n                \\\"auth\\\": {\\n                    \\\"name\\\": house_data.username||\\\"\\\",\\n                    \\\"password\\\": house_data.password||\\\"\\\"\\n                }\\n            }\\n        }),\\n        method: 'POST'\\n    });\\n    return JSON.parse(result).result;\\n}\\n\\nfunction task_upload(task){ // 通用任务发布新增及修改功能\\n    const {api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let api_url = api.host+'/hikerule/task/add';\\n    let house_data = houseFile();\\n    let result = request(api_url, {\\n        headers: {\\n            'content-type': 'application/json'\\n        },\\n        body: JSON.stringify({\\n            \\\"params\\\": {\\n                \\\"data\\\": {\\n                    \\\"name\\\": task.name,\\n                    \\\"pycode\\\": task.pycode,\\n                    \\\"note\\\": task.note,\\n                    \\\"test_code\\\": task.test_code,\\n                },\\n                \\\"auth\\\": {\\n                    \\\"name\\\": house_data.username||\\\"\\\",\\n                    \\\"password\\\": house_data.password||\\\"\\\"\\n                }\\n            }\\n        }),\\n        method: 'POST'\\n    });\\n    return JSON.parse(result).result;\\n}\\n\\nfunction task_call(id,func,params){\\n    const {api} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let task_api = api.host+'/hikerule/task/run/'+id;\\n    let task = {\\n        mode:'call',\\n        func:func,\\n        params:params||[]\\n    };\\n    return task_req(task_api,task);\\n}\\n\\nfunction task_rename(id,new_task_name){\\n    const {api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let house_data = houseFile();\\n    let task_api = api.host+'/hikerule/task/rename/'+id;\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password+'&task_name='+new_task_name;\\n    try {\\n        let result = JSON.parse(fetch(task_api,{}));\\n        if(result.status==0){\\n            return  result.detail\\n        }else{\\n            return result.result+''+result.detail\\n        }\\n    }catch (e) {\\n        log(e.message);\\n        return ''+e.message\\n    }\\n}\\n\\nfunction task_change_state(id){\\n    const {api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let house_data = houseFile();\\n    let task_api = api.host+'/hikerule/task/change_state/'+id;\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password;\\n    try {\\n        let result = JSON.parse(fetch(task_api,{}));\\n        if(result.status==0){\\n            return  result.detail\\n        }else{\\n            return result.result+''+result.detail\\n        }\\n    }catch (e) {\\n        log(e.message);\\n        return ''+e.message\\n    }\\n}\\n\\nfunction task_run(id){\\n    const {api} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let task_api = api.host+'/hikerule/task/run/'+id;\\n    let task = {};\\n    return task_req(task_api,task);\\n}\\n\\n$.exports.taskCall = task_call;\\n$.exports.taskRun = task_run;\\n$.exports.taskReq = task_req;\\n$.exports.taskUpload = task_upload;\\n$.exports.taskRename = task_rename;\\n$.exports.taskChangeState = task_change_state;\"},{\"col_type\":\"movie_3\",\"name\":\"全局储存\",\"path\":\"localStorage\",\"rule\":\"let localStorage = (function() {\\n    evalPrivateJS(\\\"jwUKwNTiPGcWSLCXB5XtAXwb6LQbVyHD+0XJ7l07ce0=\\\");\\n    //pathto=undefined;\\n    evalPrivateJS(\\\"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\\\");\\n    return $.exports;\\n})();\"},{\"col_type\":\"movie_3\",\"name\":\"编辑公告\",\"path\":\"devInfoEdit\",\"rule\":\"js:\\naddListener('onClose', $.toString(()=>{\\n    putMyVar(\\\"devInfo\\\",''); //清除历史公告\\n}));\\nsetPageTitle('编辑公告');\\n// let {nowJx,MyJiexi,jxsRoute} = MY_PARAMS;\\nconst {color,small,api, getFile,getApi} = $.require(\\\"hiker://page/utiliy\\\");\\n// let houseFile = getFile||false;\\nvar dev_info_url = getApi('infoGetUrl');\\n// log(dev_info_url);\\nvar get_info = function(qq){\\n    qq = qq||'434857005';\\n    let dev_info_url = dev_info_url+qq;\\n    let back_code = JSON.parse(request(dev_info_url));\\n    let dev_info=back_code.result||back_code.detail;\\n    return dev_info;\\n};\\nvar before_refresh = function(){\\n    let dev_set_info = getMyVar(\\\"dev_set_info\\\").split('$$');\\n    let dev_info_url = dev_set_info.slice(-1)[0];\\n    let back_code = JSON.parse(request(dev_info_url));\\n    let dev_info=back_code.result||back_code.detail;\\n    putMyVar(\\\"devInfo\\\",dev_info);\\n    return dev_info\\n};\\nlet d = [];\\nd.push({\\n    title:'编辑公告',\\n    desc:'支持md语法,点击进入学习Md语法\\\\n保存公告按钮在文本框最下面',\\n    col_type:'text_1',\\n    url:'https://www.runoob.com/markdown/md-tutorial.html'\\n});\\nd.push({\\n    title:'返回',\\n    col_type:'text_2',\\n    url:$('#noLoading#').lazyRule(()=>{\\n        back(false);\\n        return 'hiker://empty'\\n    })\\n});\\nif(!getMyVar('devInfo')){\\n    before_refresh();\\n}\\nlet empty = 'hiker://empty';\\nd.push({\\n    title:'阅览查阅',\\n    col_type:'text_2',\\n    // url:$(getMyVar('devInfo')).confirm()\\n    url:$(empty).rule(()=>{\\n        require(\\\"https://gitlab.com/hjdhnx/hiker/-/raw/main/js/marked.min.js\\\");\\n       let devInfo=\\\"\\\";\\n       try{\\n          devInfo=marked.parse(getMyVar('devInfo'));\\n       }catch(e){}\\n        setResult([\\n            {\\n                title:devInfo,\\n                col_type:'rich_text',\\n            }\\n        ]);\\n    })\\n});\\nd.push({\\n    desc: \\\"快来编辑你的公告吧~\\\",\\n    col_type: 'input',\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getMyVar('devInfo', '')||\\\"\\\",\\n        type: \\\"textarea\\\",\\n        height:-1,\\n        onChange: 'putMyVar(\\\"devInfo\\\",input)'\\n    }\\n});\\nd.push({\\n    title:\\\"保存公告\\\",\\n    col_type: 'text_center_1',\\n    url:$('确认保存公告吗？将会与道长仓库服务器通讯').confirm(()=>{\\n        let dev_set_info = getMyVar(\\\"dev_set_info\\\").split('$$');\\n        let input_text = getMyVar('devInfo', '');\\n        if(input_text.length >= 4){\\n            let info_set_url= dev_set_info[2];\\n            let send_data = {\\\"params\\\":\\n                    {\\\"data\\\": {\\\"info\\\": input_text},\\n                        \\\"name\\\": dev_set_info[0],\\n                        \\\"password\\\": dev_set_info[1]}\\n            };\\n            // log(send_data);\\n            let par2 = {headers:{'content-type':'application/json;charset=UTF-8','User-Agent':dev_set_info[3]},body:JSON.stringify(send_data),method:'POST'};\\n            // par2 = JSON.stringify(par2); //x5里面请求才需要编码\\n            try {\\n                let back_ret = request(info_set_url, par2);\\n                back_ret = JSON.parse(back_ret).result;\\n                if(back_ret.status===0){\\n                    // refreshPage();\\n                    return 'toast://保存成功\\\\n'+back_ret.detail;\\n                }else{\\n                    return 'toast://保存失败\\\\n'+back_ret.detail;\\n                }\\n            }catch (e) {\\n                return 'toast://错误\\\\n'+e.message;\\n            }\\n        }else{\\n            confirm({title:'道长提示',content:'虽然你很懒，但是公告至少写4个字吧！'});\\n            return 'hiker://empty'\\n        }\\n    })\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"预处理依赖文件\",\"path\":\"libs\",\"rule\":\"if(getAppVersion()>=3200){\\n    try{\\n        rc(\\\"hiker://files/rules/js/$hiker.js\\\", -1);\\n        //$.setRoot('https://hjdhnx.coding.net/public/hiker/hiker/git/files/master/js/');\\n        $.setRoot();\\n        $.setLib({\\n            lsg: \\\"lsg.js\\\", //本地储存\\n            file: \\\"file.js\\\", //文件os\\n            fileSelect: \\\"fileSelect.js\\\", //文件选择器\\n            dt: \\\"dt.js\\\", //动态分类\\n            dr: \\\"dr.js\\\", //dr模板依赖\\n            drpre: \\\"drpre.js\\\", //dr模板预处理\\n            drup: \\\"drup.js\\\", //dr模板自动更新\\n            drmatch: \\\"drmatch.js\\\", //dr模板自动模板匹配\\n            drm: \\\"drm.js\\\", //dr模板小程序\\n            cms: \\\"cms.js\\\", //cms模板依赖\\n            cmspre: \\\"cmspre.js\\\", //cms预处理\\n            cmsm: \\\"cmsm.js\\\", //cms模板小程序\\n            libcheck: \\\"libcheck.js\\\", //dr检测依赖\\n            ruleEditor: \\\"ruleEditor.js\\\", //写页源神器小程序\\n            houseLazy: \\\"houseLazy.js\\\", //仓库通免\\n            lazy: \\\"lazy.js\\\", //香免\\n            sub: \\\"sub.js\\\", //道德经订阅\\n            hikerUi: \\\"hikerUi.js\\\", //海阔组件依赖\\n            hikerLibs: \\\"hikerLibs.js\\\", //海阔全能依赖\\n        });\\n    }catch(e){\\n        //toast('请尝试点击仓库主页的升级仓库旁边的按钮升级$扩展，否则某些功能不能正常使用');\\n        confirm({\\n            title: '提示-点击确定可以导入',\\n            content: '请尝试点击仓库主页的升级仓库旁边的按钮升级$扩展，否则某些功能不能正常使用',\\n            confirm: $.toString(()=>{\\n                const {getApi} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n                let ruleHead = '海阔视界，网页插件￥js_url￥$hiker@';\\n                let url = getApi('importUrl')+\\\"5111\\\";\\n                let importUrl = 'rule://'+base64Encode(ruleHead+url);\\n                return importUrl\\n            }),\\n            cancel: $.toString(()=>{\\n\\n            }),\\n        })\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"Import详细\",\"path\":\"ruleDetailImport\",\"rule\":\"js:\\n$.exports = \\\"hiker://page/ruleDetail?rule=道长仓库Pro&id=\\\" + $.importParam;\\n\"},{\"col_type\":\"movie_3\",\"name\":\"跑马灯公告\",\"path\":\"notice\",\"rule\":\"js:\\nlet getHtml = (text, color) => `\\n<!DOCTYPE html>\\n<html>\\n<head>\\n<meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0\\\">\\n<style>\\n.marquee {\\n  width: 100%;\\n  text-overflow: ellipsis;\\n  overflow: hidden;\\n  color: ${color};\\n  font-size: 16px;\\n  white-space: nowrap;\\n}\\n\\n.marquee span {\\n  user-select:none;\\n  display: inline-block;  \\n  padding-left: 100%;\\n  animation: marquee 25s linear infinite;\\n}\\n\\n@keyframes marquee {\\n  0% { transform: translateX(0%); }\\n  100% { transform: translateX(-100%); }\\n}\\n\\n@media (prefers-color-scheme: dark) {\\n    body {\\n    background-color: #1B1B1B;\\n     }\\n     .text,.scroll{\\n       color:#Fff;\\n       }\\n    }\\n\\n@media (prefers-color-scheme: light) {\\n    body {\\n    background-color: transparent;\\n      }\\n    }\\n\\n</style>\\n</head>\\n<body>\\n<div class=\\\"marquee\\\">\\n  <span id=\\\"textContainer\\\">${text}</span>\\n</div>\\n</body>\\n</html>`;\\n\\n$.exports.show = function(arr, text, color, url, content) {\\n    var html = getHtml(text || '这是跑马灯默认的文字，可以自行替换。', color || 'red');\\n    arr.push({\\n        col_type: \\\"x5_webview_single\\\",\\n        url: \\\"about:blank\\\",\\n        desc: \\\"50&&list\\\",\\n        extra: {\\n            js: $.toString((h, url) => {\\n                var html = document.documentElement;\\n                html.innerHTML = h;\\n\\n                const textContainer = document.getElementById('textContainer');\\n                const text = textContainer.innerHTML;\\n                textContainer.onclick=function(){\\n                    window.location.href = url||\\\"about:blank/notice\\\";\\n                }\\n                // 设置文本容器宽度为文本内容的宽度\\n                textContainer.style.width = `${textContainer.offsetWidth}px`;\\n\\n                // 复制文本内容并追加到文本容器后面\\n                textContainer.innerHTML += ' ' + text;\\n\\n                // 动态计算动画持续时间\\n                const duration = (textContainer.offsetWidth / textContainer.parentElement.offsetWidth) * 10;\\n\\n                var styleElements = document.head.getElementsByTagName('style');\\n\\n\\n                styleElements[2].innerHTML = `.marquee span {\\n                    display: inline-block;\\n                    padding-left: 100%;\\n                    animation: marquee ${duration}s linear infinite\\n                }`;\\n\\n            }, html, url),\\n            urlInterceptor: $.toString((content) => {\\n                if (input===\\\"about:blank/notice\\\") {\\n                    return $.toString((content) => {\\n                        fba.open(JSON.stringify({\\n                            title: \\\"公告\\\",\\n                            url: 'hiker://empty#noRecordHistory##noHistory#',\\n                            findRule: \\\"js:\\\" + $$$.toString((content) => setResult([{\\n                                title: content,\\n                                col_type: \\\"rich_text\\\",\\n                            }]),content)\\n                        }));\\n                    }, content);\\n                }\\n            }, content || text),\\n        }\\n    });\\n}\"}]","icon":"https://lanmeiguojiang.com/tubiao/other/30.svg","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!