小程序：动漫花园同步站

海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@动漫花园同步站@{"last_chapter_rule":"","title":"动漫花园同步站","author":"@LoyDgIk","url":"hiker://empty#noRefresh#","version":5,"col_type":"movie_3","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nlet layout = [];\nlayout.push({\n    col_type:\"big_blank_block\"\n});\nlayout.push({\n    col_type:\"big_blank_block\"\n});\nlayout.push({\n    col_type:\"big_blank_block\"\n});\nlayout.push({\n    col_type:\"big_blank_block\"\n});\n\nlayout.push({\n    title: '<h1 style=\"text-align: center;\"><big><font color=\"#FEBD6F\">動漫花園同步站</font></big><br><small><font color=\"#FB6C73\">動漫愛好者的资源平台</font></small></h1>',\n    col_type: \"rich_text\"\n});\nlayout.push({\n    col_type: \"icon_1_search\",\n    url: \"hiker://page/搜索#noRecordHistory##noHistory#\",\n    pic_url:\"hiker://images/search\",\n    title: \"搜索\"\n});\n\nconst id = Date.now() + MY_RULE.title;\nlayout.push({\n    title: \"👻大家都在搜\",\n    url: $(\"#noLoading#\").lazyRule((id)=>{\n        let data = storage0.getMyVar(\"data\",{});\n        if(!data.keywords) return \"toast://未获取列表\";\n        $.require(\"推荐\").recommendWord(id, data.keywords);\n        return \"hiker://empty\";\n    }, id),\n    col_type: \"text_2\",\n    extra:{\n        id: id + \"Text1\"\n    }\n});\nlayout.push({\n    title: \"📆动漫日历\",\n    url: $(\"#noLoading#\").lazyRule((id)=>{\n        let data = storage0.getMyVar(\"data\",{});\n        if(!data.dayData) return \"toast://未获取列表\";\n        $.require(\"推荐\").recommendCalendar(id, data.dayData);\n        return \"hiker://empty\";\n    },id),\n    col_type: \"text_2\",\n    extra:{\n        id: id + \"Text2\"\n    }\n});\nlayout.push({\n    title:\"⏳正在加载 ҉\",\n    url: \"hiker://empty\",\n    col_type: \"text_center_1\",\n    extra: {\n        id: id + \"lb\",\n        lineVisible: false\n    }\n});\n\nsetResult(layout);\n\ntry {\n    let data = JSON.parse(request(\"https://dongmanhuayuan.myheartsite.com/api/acg/index\"));\n    if(data.msg!==\"success\"){\n        throw new Error(data.msg);\n    }\n    storage0.putMyVar(\"data\", data.data);\n    updateItem(id + \"lb\", {\n        col_type: \"line_blank\"\n    });\n    $.require(\"推荐\").recommendWord(id, data.data.keywords);\n}catch(e){\n    log(e.toString());\n    updateItem(id + \"lb\", {\n        title: \"加载失败\",\n        url:$(\"#noLoading#\").lazyRule(()=>{\n            refreshPage();\n            return \"hiker://empty\";\n        })\n    });\n}\n\n","search_url":"","group":"2⃣🔎动漫","searchFind":"","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"","pages":"[{\"col_type\":\"movie_3\",\"name\":\"推荐\",\"path\":\"推荐\",\"rule\":\"js:\\n$.exports.recommendWord = function(id, data) {\\n    deleteItemByCls(\\\"lb\\\");\\n    let keyList = [];\\n    keyList.push({\\n        title: \\\"<strong>🎈近期热门关键词：</strong>\\\",\\n        col_type: \\\"rich_text\\\",\\n        extra: {\\n            cls: \\\"lb\\\"\\n        }\\n    });\\n    data.forEach(key => {\\n        keyList.push({\\n            title: key,\\n            col_type: \\\"flex_button\\\",\\n            url: \\\"hiker://page/搜索结果#noRecordHistory##noHistory#?page=fypage&keyword=\\\" + encodeURIComponent(key),\\n            extra: {\\n                cls: \\\"lb\\\"\\n            }\\n        });\\n    });\\n    addItemAfter(id + \\\"lb\\\", keyList);\\n}\\n$.exports.recommendCalendar = function(id, data) {\\n    deleteItemByCls(\\\"lb\\\");\\n    //let week = (new Date().getDay() || 7) - 1;\\n    let week = new Array(\\\"一\\\", \\\"二\\\", \\\"三\\\", \\\"四\\\", \\\"五\\\", \\\"六\\\", \\\"日\\\");\\n    //data.unshift(data.splice(week, 1));\\n    let keyList = [];\\n    let count = 0;\\n    for (let weeks of data) {\\n        keyList.push({\\n            title: \\\"<strong>🎈星期\\\"+week[count]+\\\"</strong>\\\",\\n            col_type: \\\"rich_text\\\",\\n            extra: {\\n                cls: \\\"lb\\\"\\n            }\\n        });\\n        count++;\\n        weeks.forEach(day => {\\n            keyList.push({\\n                title: day.name,\\n                col_type: \\\"flex_button\\\",\\n                url: \\\"hiker://page/搜索结果#noRecordHistory##noHistory#?page=fypage&keyword=\\\" + encodeURIComponent(decodeURIComponent(day.searchName.replace(\\\"encodeURIComponent(\\\",\\\"\\\").replace(/\\\\)$/,\\\"\\\"))),\\n                extra: {\\n                    cls: \\\"lb\\\"\\n                }\\n            });\\n        });\\n    }\\n\\n\\n    addItemAfter(id + \\\"lb\\\", keyList);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"搜索\",\"rule\":\"js:\\n//keyword=&page=1&searchType=0&serverType=server1\\nlet layout = [];\\nlet searchTypeList = $.require(\\\"searchType\\\"),\\n    serverTypeList = $.require(\\\"serverType\\\");\\nlet keyword = getMyVar(\\\"keyword\\\", \\\"\\\"),\\n    searchType = getMyVar(\\\"searchType\\\") || searchTypeList[0].value,\\n    serverType = getMyVar(\\\"serverType\\\") || serverTypeList[0].value;\\nlet id = Date.now() + MY_RULE.title;\\naddListener(\\\"onClose\\\", () => {\\n    clearMyVar(\\\"keyword\\\");\\n    clearMyVar(\\\"serverType\\\");\\n    clearMyVar(\\\"searchType\\\");\\n});\\nlayout.push({\\n    title: \\\"？\\\",\\n    url: $.toString(() => {\\n        confirm({\\n            title: '高级搜索',\\n            content: `高级搜索使用了正则表达式的形式，花园原站也使用的是这种方式。\\n符号包括：(空格、竖线|、左括号(、右括号))。\\n空格代表后面匹配0-N个字符,|代表匹配选择匹配，左右括号代表分组和我们数学中的括号同理。\\n例子:\\n1. (巨人 (第一季|第二季)) 等同于 (巨人 第一季) 和 (巨人 第二季)\\n2. (巨人 简体) 将会展示 巨人XXXX简体XXXX 的匹配结果\\n3. (火影|巨人) 等同于 (火影) 和 (巨人) 将会展示内容中包括 火影 和 巨人 的所有匹配结果`,\\n            confirm: \\\"\\\",\\n            cancel: \\\"\\\"\\n        });\\n    }),\\n    col_type: \\\"input\\\",\\n    desc: \\\"关键词\\\",\\n    extra: {\\n        id: id + \\\"ss\\\",\\n        defaultValue: keyword,\\n        //titleVisible: false,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"keyword\\\", input);\\n        })\\n    }\\n});\\nlayout.push({\\n    title: \\\"搜索:\\\" + searchTypeList.find(v => v.value === searchType).key,\\n    url: $(searchTypeList.map(v => v.key), 2, \\\"搜索类型\\\").select((id) => {\\n        let searchTypeList = $.require(\\\"searchType\\\");\\n        let value = searchTypeList.find(v => v.key === input).value;\\n        putMyVar(\\\"searchType\\\", value);\\n        updateItem(id + \\\"Text1\\\", {\\n            title: \\\"搜索:\\\" + input\\n        });\\n    }, id),\\n    col_type: \\\"text_2\\\",\\n    extra: {\\n        id: id + \\\"Text1\\\"\\n    }\\n});\\nlayout.push({\\n    title: \\\"服务器:\\\" + serverTypeList.find(v => v.value === serverType).key,\\n    url: $(serverTypeList.map(v => v.key), 1, \\\"服务器类型\\\").select((id) => {\\n        let serverTypeList = $.require(\\\"serverType\\\");\\n        let value = serverTypeList.find(v => v.key === input).value;\\n        putMyVar(\\\"serverType\\\", value);\\n        updateItem(id + \\\"Text2\\\", {\\n            title: \\\"服务器:\\\" + input\\n        });\\n    }, id),\\n    col_type: \\\"text_2\\\",\\n    extra: {\\n        id: id + \\\"Text2\\\"\\n    }\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlayout.push({\\n    col_type: \\\"blank_block\\\"\\n});\\nlayout.push({\\n    title: \\\"<strong>‘‘搜索’’</strong>\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((searchType0, serverType0) => {\\n        let keyword = encodeURIComponent(getMyVar(\\\"keyword\\\").trim()),\\n            searchType = getMyVar(\\\"searchType\\\") || searchType0,\\n            serverType = getMyVar(\\\"serverType\\\") || serverType0;\\n        if (!keyword) return \\\"toast://关键词不能为空\\\";\\n        return buildUrl(\\\"hiker://page/搜索结果#noRecordHistory##noHistory#\\\", {\\n            keyword: keyword,\\n            page: \\\"fypage\\\",\\n            searchType: searchType,\\n            serverType: serverType\\n        });\\n    }, searchType, serverType),\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n        lineVisible: false,\\n        isRefresh: true\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    title: \\\"<strong><big>📋历史记录</big></strong> \\\" + \\\"清除全部\\\".link($(\\\"#noLoading#\\\").b64(\\\"'\\\").lazyRule((id) => {\\n        return $(\\\"确定清除全部搜索记录？\\\").confirm((id) => {\\n            $.require(\\\"搜索记录\\\").clearHistory();\\n            deleteItemByCls(id + \\\":key\\\");\\n        }, id);\\n    }, id)),\\n    col_type: \\\"rich_text\\\"\\n});\\nlet history = $.require(\\\"搜索记录\\\").getHistory().reverse();\\nfor (let key of history) {\\n    layout.push({\\n        title: key,\\n        url: $(\\\"#noLoading#\\\").lazyRule((id, key) => {\\n            let extra = findItem(id + \\\"ss\\\").extra;\\n            extra.defaultValue = key;\\n            updateItem({\\n                extra: extra\\n            });\\n            return \\\"hiker://empty\\\";\\n        }, id, key),\\n        col_type: \\\"flex_button\\\",\\n        extra: {\\n            id: id + \\\":key:\\\" + key,\\n            cls: id + \\\":key\\\",\\n            longClick: [{\\n                title: \\\"删除关键词:\\\" + key,\\n                js: $.toString((id, key) => {\\n                    $.require(\\\"搜索记录\\\").deleteHistory(key);\\n                    deleteItem(id + \\\":key:\\\" + key);\\n                    //toast();\\n                }, id, key)\\n            }]\\n        }\\n    });\\n}\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"搜索类型\",\"path\":\"searchType\",\"rule\":\"let searchTypeList = [{\\n        \\\"key\\\": \\\"全部\\\",\\n        \\\"value\\\": \\\"0\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"動畫\\\",\\n        \\\"value\\\": \\\"2\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"季度全集\\\",\\n        \\\"value\\\": \\\"31\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"漫畫\\\",\\n        \\\"value\\\": \\\"3\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"港台原版\\\",\\n        \\\"value\\\": \\\"41\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"日文原版\\\",\\n        \\\"value\\\": \\\"42\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"音樂\\\",\\n        \\\"value\\\": \\\"4\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"動漫音樂\\\",\\n        \\\"value\\\": \\\"43\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"同人音樂\\\",\\n        \\\"value\\\": \\\"44\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"流行音樂\\\",\\n        \\\"value\\\": \\\"15\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"日劇\\\",\\n        \\\"value\\\": \\\"6\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"ＲＡＷ\\\",\\n        \\\"value\\\": \\\"7\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"遊戲\\\",\\n        \\\"value\\\": \\\"9\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"電腦遊戲\\\",\\n        \\\"value\\\": \\\"17\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"電視遊戲\\\",\\n        \\\"value\\\": \\\"18\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"掌機遊戲\\\",\\n        \\\"value\\\": \\\"19\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"網絡遊戲\\\",\\n        \\\"value\\\": \\\"20\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"遊戲周邊\\\",\\n        \\\"value\\\": \\\"21\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"特攝\\\",\\n        \\\"value\\\": \\\"12\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"其他\\\",\\n        \\\"value\\\": \\\"1\\\"\\n    }\\n];\\n$.exports = searchTypeList;\\n\"},{\"col_type\":\"movie_3\",\"name\":\"服务器类型\",\"path\":\"serverType\",\"rule\":\"js:\\n$.exports = [\\n    {\\n        \\\"key\\\": \\\"主服务器(延迟10分钟)\\\",\\n        \\\"value\\\": \\\"server1\\\"\\n    },\\n    {\\n        \\\"key\\\": \\\"原服务器(实时抓去|速度慢)\\\",\\n        \\\"value\\\": \\\"server2\\\"\\n    }\\n];\"},{\"col_type\":\"movie_3\",\"name\":\"搜索记录\",\"path\":\"搜索记录\",\"rule\":\"js:\\nlet history;\\ntry {\\n    history = JSON.parse(readFile(\\\"WordHistory.json\\\", 0) || \\\"[]\\\");\\n} catch (e) {\\n    history = [];\\n}\\n\\nfunction setHistory(title) {\\n    if (history.length >= 20) {\\n        history.splice(0, 1);\\n    }\\n    let index = history.indexOf(title);\\n\\n    if (index > -1) {\\n        history.splice(index, 1);\\n    }\\n    history.push(title);\\n    saveFile(\\\"WordHistory.json\\\", JSON.stringify(history), 0);\\n}\\n\\nfunction deleteHistory(title) {\\n    let index = history.indexOf(title);\\n    if (index > -1) {\\n        history.splice(index, 1);\\n        saveFile(\\\"WordHistory.json\\\", JSON.stringify(history), 0);\\n    }\\n}\\n\\nfunction getHistory() {\\n    return history;\\n}\\nfunction clearHistory() {\\n    saveFile(\\\"WordHistory.json\\\", \\\"[]\\\", 0);\\n}\\n$.exports = {\\n    setHistory: setHistory,\\n    getHistory: getHistory,\\n    clearHistory: clearHistory,\\n    deleteHistory: deleteHistory\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索结果\",\"path\":\"搜索结果\",\"rule\":\"js:\\nlet layout = [];\\nlet searchTypeList = $.require(\\\"searchType\\\"),\\n    serverTypeList = $.require(\\\"serverType\\\");\\n\\nlet keyword = decodeURIComponent(getParam(\\\"keyword\\\")),\\n    searchType = getParam(\\\"searchType\\\") || searchTypeList[0].value,\\n    serverType = getParam(\\\"serverType\\\") || serverTypeList[0].value;\\nlet page = Number(getMyVar(\\\"page\\\", \\\"0\\\")) + MY_PAGE;\\n$.require(\\\"搜索记录\\\").setHistory(keyword);\\nif (MY_PARAMS.isRefresh) {\\n    addListener(\\\"onClose\\\", () => {\\n        refreshPage();\\n    });\\n}\\naddListener(\\\"onClose\\\",()=>{\\n    clearMyVar(\\\"page\\\");\\n});\\nfunction load() {\\n    let data = JSON.parse(post(\\\"https://dongmanhuayuan.myheartsite.com/api/acg/search\\\", {\\n        body: buildUrl(\\\"\\\", {\\n            keyword: keyword,\\n            page: page,\\n            searchType: searchType,\\n            serverType: serverType\\n        }),\\n        timeout:8000\\n    }));\\n    let list = data.data.searchData;\\n    if (MY_PAGE === 1) {\\n        layout.push({\\n            col_type: \\\"text_2\\\",\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"总计\\\" + data.data.totalNum,\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n        let pageNum = Math.ceil(data.data.totalNum / 80);\\n        layout.push({\\n            col_type: \\\"text_2\\\",\\n            url: $(\\\"\\\", \\\"最大:\\\" + pageNum).input((m) => {\\n                let n = Number(input);\\n                if (Number.isNaN(n)) {\\n                    return \\\"toast://请输入数字\\\";\\n                }\\n                if (n > m || n < 1) {\\n                    return \\\"toast://数字不对哦\\\";\\n                }\\n                putMyVar(\\\"page\\\", (n - 1) + \\\"\\\");\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n            }, pageNum),\\n            title: \\\"共\\\" + pageNum + \\\"页\\\",\\n        });\\n\\n    }\\n    for (let item of list) {\\n        layout.push({\\n            title: \\\"‘‘\\\" + (item.group || \\\"\\\") + \\\"’’\\\\t\\\" + item.title,\\n            desc: \\\"““””<strong>时间：</strong>\\\" + item.date + \\\"\\\\n<strong>类型：</strong>\\\" + item.type + \\\"\\\\t\\\\t<strong>大小：</strong>\\\" + item.size,\\n            col_type: \\\"text_1\\\",\\n            url: \\\"hiker://page/详细\\\",\\n            extra: {\\n                body: \\\"link=\\\" + item.link + \\\"&id=\\\" + (item.id || \\\"\\\"),\\n                pageTitle: item.title,\\n            }\\n        });\\n    }\\n    if (list.length === 0) {\\n        layout.push({\\n            title: \\\"““””<font color='gray'>没有了哦<font>\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n        });\\n    }else{\\n        setPageTitle(\\\"「\\\" + keyword + \\\"」#\\\" + page);\\n    }\\n}\\ntry {\\n    if(MY_PAGE===1){\\n        showLoading(\\\"正在检索服务器...\\\");\\n        setPageTitle(\\\"正在检索:\\\" + keyword);\\n    }\\n    load();\\n        \\n    hideLoading();\\n} catch (e) {\\n    hideLoading();\\n    log(e.toString());\\n    layout.push({\\n        title: \\\"““””<font color='gray'>没有了哦<font>\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: \\\"hiker://empty\\\",\\n    });\\n}\\n\\nsetResult(layout);\"},{\"col_type\":\"movie_3\",\"name\":\"详细\",\"path\":\"详细\",\"rule\":\"js:\\nlet data = JSON.parse(post(\\\"https://dongmanhuayuan.myheartsite.com/api/acg/detail\\\", {\\n    body: MY_PARAMS.body\\n})).data;\\nsetPageTitle(data.title);\\nlet layout = [];\\n\\nlayout.push({\\n    title: data.title,\\n    col_type: \\\"text_center_1\\\"\\n});\\nlayout.push({\\n    title: \\\"““””<small><small><font color='gray'>↓长按更多选项↓<font></small></small>\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://empty\\\",\\n    extra:{\\n        lineVisible:false\\n    }\\n});\\nlet torrent = \\\"https://dongmanhuayuan.myheartsite.com/api/acg/download?date=\\\" + data.fileDate + \\\"&hash=\\\" + data.fileHash;\\nlayout.push({\\n    title: \\\"torrent\\\",\\n    url: torrent + \\\"#.torrent\\\",\\n    col_type: \\\"text_3\\\",\\n    extra: {\\n        longClick: [{\\n            title: \\\"下载\\\",\\n            js: JSON.stringify(\\\"download://\\\" + torrent),\\n        }, {\\n            title: \\\"复制链接\\\",\\n            js: JSON.stringify(\\\"copy://\\\" + torrent),\\n        }, {\\n            title: \\\"其他应用打开\\\",\\n            js: JSON.stringify(\\\"magnet://\\\" + torrent),\\n        }]\\n    }\\n});\\nlayout.push({\\n    title: \\\"magnet1\\\",\\n    url: data.magnetLink1,\\n    col_type: \\\"text_3\\\",\\n    extra: {\\n        longClick: [{\\n            title: \\\"复制磁力\\\",\\n            js: JSON.stringify(\\\"copy://\\\" + data.magnetLink1),\\n        }, {\\n            title: \\\"其他应用打开\\\",\\n            js: JSON.stringify(\\\"magnet://\\\" + data.magnetLink1),\\n        }]\\n    }\\n});\\nlayout.push({\\n    title: \\\"magnet2\\\",\\n    url: data.magnetLink2,\\n    col_type: \\\"text_3\\\",\\n    extra: {\\n        longClick: [{\\n            title: \\\"复制磁力\\\",\\n            js: JSON.stringify(\\\"copy://\\\" + data.magnetLink2),\\n        }, {\\n            title: \\\"其他应用打开\\\",\\n            js: JSON.stringify(\\\"magnet://\\\" + data.magnetLink2),\\n        }]\\n    }\\n});\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nlayout.push({\\n    col_type: \\\"text_center_1\\\",\\n    title: \\\"⚡文件列表⚡\\\",\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\ndata.fileList.forEach(v => {\\n    layout.push({\\n        title: v,\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_1\\\"\\n    });\\n});\\n\\n\\nlayout.push({\\n    col_type: \\\"line_blank\\\"\\n});\\n\\nlayout.push({\\n    col_type: \\\"text_center_1\\\",\\n    title: \\\"⚡主题⚡\\\",\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nlayout.push({\\n    col_type: \\\"line\\\"\\n});\\nlet rtext = \\\"\\\";\\ndata.detailTopic.forEach(v => {\\n    rtext += v + \\\"<br>\\\";\\n});\\nlayout.push({\\n    title: rtext,\\n    col_type: \\\"rich_text\\\"\\n});\\nsetResult(layout);\"}]","icon":"https://share.dmhy.org/favicon.ico","proxy":""}