API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：「宅男女神」

xiaomianao666
Oct 20th, 2024
225
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 472.81 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥「宅男女神」@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"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}\"}],\"params\":\"{\\\"id\\\":3925,\\\"isAll\\\":true,\\\"lver\\\":-1}\",\"saved\":false,\"title\":\"道长仓库Pro\",\"version\":0,\"url\":\"hiker://page/ruleDetail#noHistory##noRecordHistory#\",\"col_type\":\"movie_3\",\"find_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);\",\"group\":\"①推荐\",\"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}\\\"}]\",\"proxy\":\"\"}","picUrl":"https://lanmeiguojiang.com/tubiao/movie/30.svg","title":"「宅男女神」"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!