API tools faq
paste
xiaomianao666

小程序：初学者写源工具

xiaomianao666
Jan 27th, 2024
111
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 112.47 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@初学者写源工具@{"last_chapter_rule":"","title":"初学者写源工具","author":"","url":"hiker://empty##fypage","version":0,"col_type":"movie_3","class_name":"","type":"tool","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar res = {};\nvar items = [];\n\nitems.push({\n    title: '<h5 style=\"text-align: center;\"><big><font color=\"#0099FF\">【初学者教程&模板&写源工具收集】</font></big></h5>',\n    col_type: \"rich_text\"\n});\n\nvar info=\"欢迎各位使用｜提建议\"\nvar r = $.require('notice');\nr.show(items, info,\"#99CCFF\");\n\nitems.push({\n    title: '““””<font color=\"\"><big><b>' + '小白神器' + '</font></b></big>',\n    desc: '点击导入/打开',\n    url: 'toast://' + '点击下方',\n    col_type: \"text_center_1\"\n});\n\n\nvar Title = ['DR模板', 'α', '道长仓库Pro']\n\nvar Page = ['4549', '6417', '1094']\n\nlet url;\n\nTitle.forEach(function(data, id) {\n    if (request('hiker://home@' + data) == 'null') {\n    url = \"海阔视界首页频道规则￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=\" + Page[id]\n} else {\n    url = 'hiker://home@' + data\n}\n    items.push({\n        title: '““””<font color=\"\">▐ </font><b>' + data + '<b>',\n        url: url,\n        col_type: \"text_2\"\n    });\n})\n\nitems.push({\n    title: '““””<font color=\"\">▐ </font><b>' + '一级动态分类·α' + '<b>',\n    url: \"hiker://page/dtzy#noHistory##noRecordHistory#\",\n    col_type: \"text_2\",\n    extra: {\n            newWindow: true,\n            windowId: MY_RULE.title,\n            pageTitle: '一级动态分类'\n        }\n});\n\nitems.push({\n    title: '““””<font color=\"#FFB4A7\"><big><b>' + '写源工具' + '</font></b></big>',\n    desc: '列表',\n    url: 'toast://' + '点击下方',\n    col_type: \"text_center_1\"\n});\n\n\nvar Title = ['海阔组件展示&复制',  'XYQ分类生成器', '源码工具', 'Json分类生成器', '请求测试工具', '获取Favicon·α']\n\nvar Page = ['ZJ', 'XYQ', 'ymtool', 'Json', 'Home', 'favicon']\n\nTitle.forEach(function(data, id) {\n    items.push({\n        title: '““””<font color=\"#FD113A\">▐ </font><b>' + data + '<b>',\n        url: \"hiker://page/\"+Page[id]+\"#noHistory##noRecordHistory#\",\n        col_type: \"text_2\",\n        extra: {\n            newWindow: true,\n            windowId: MY_RULE.title,\n            pageTitle: data\n        }\n    });\n})\n\nitems.push({\n    title: '““””<font color=\"#CCA4E3\"><big><b>' + '【写源教程&模板】' + '</font></b></big>',\n    desc: '汇总',\n    url: 'toast://' + '点击下方',\n    col_type: \"text_center_1\"\n});\n\n\nvar Title = ['常用写法', '常用语法']\n\nvar Page = [ 'XF', 'YF']\n\nTitle.forEach(function(data, id) {\n    items.push({\n        title: '““””<font color=\"#F3D3E8\">▐ </font><b>' + data + '<b>',\n        url: \"hiker://page/\"+Page[id]+\"#noHistory##noRecordHistory#\",\n        col_type: \"text_2\",\n        extra: {\n            newWindow: true,\n            windowId: MY_RULE.title,\n            pageTitle: data\n        }\n    });\n})\n\n\nres.data = items;\nsetHomeResult(res);","search_url":"","group":"我的小程序","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\":\"ZJ\",\"rule\":\"js:\\nlet d = [];\\nvar lists = ['movie_1', 'movie_2', 'movie_3', 'movie_3_marquee', 'text_1', 'text_center_1', 'text_2', 'text_3', 'text_4', 'text_5', 'flex_button', 'scroll_button', 'movie_1_left_pic', 'movie_1_vertical_pic_blur', 'pic_1' ,'pic_1_full', 'pic_1_center', 'pic_1_card', 'pic_2', 'pic_3', 'pic_2_card', 'pic_3_square', 'card_pic_1' ,'card_pic_2', 'card_pic_2_2', 'card_pic_2_2_left', 'card_pic_3', 'card_pic_3_center', 'icon_1_search', 'text_icon', 'avatar','icon_2', 'icon_2_round', 'icon_3', 'icon_small_3', 'icon_3_fill', 'icon_3_round_fill', 'icon_4' ,'icon_card_4', 'icon_small_4', 'icon_round_small_4', 'icon_round_4', 'icon_5'];\\n\\nd.push({\\n    title: '点击即复制',\\n    col_type: 'text_center_1',\\n    url: 'toast://点我干嘛？',\\n    desc:'相应的样式名',\\n})\\n\\nd.push({\\n    title: 'line分割线细',\\n    col_type: 'flex_button',\\n    url: 'copy://line',\\n}, {\\n    col_type: 'line',\\n}, {\\n    title: 'line_blank分割线粗',\\n    col_type: 'flex_button',\\n    url: 'copy://line_blank',\\n}, {\\n    col_type: 'line_blank',\\n}, {\\n    title: 'blank_block',\\n    col_type: 'flex_button',\\n    url: 'copy://blank_block',\\n}, {\\n    col_type: 'blank_block',\\n}, {\\n    title: 'big_blank_block',\\n    col_type: 'flex_button',\\n    url: 'copy://big_blank_block',\\n}, {\\n    col_type: 'big_blank_block',\\n}, {\\n    title: 'big_big_blank_block',\\n    col_type: 'flex_button',\\n    url: 'copy://big_big_blank_block',\\n}, {\\n    col_type: 'big_big_blank_block',\\n})\\n\\nlists.forEach(function(data) {\\n    d.push({\\n        title: data,\\n        img: 'hiker://images/home_late',\\n        desc: data,\\n        url: \\\"copy://\\\" + data,\\n        col_type: data\\n    });\\n})\\n\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"#XYQ分类生成器\",\"path\":\"XYQ\",\"rule\":\"js:\\nvar items = [];\\n\\nitems.push({\\n    title: \\\"取源码\\\",\\n    url: $.toString(() => {\\n        function btwaf(netpg, bturl, btua, chars) {\\n            //log(netpg);\\n            if (netpg.indexOf('检测中') != -1) {\\n                let cook = \\\"\\\";\\n                try {\\n                    let bthtml = JSON.parse(fetch(bturl, {\\n                        headers: {\\n                            'User-Agent': btua\\n                        },\\n                        withHeaders: true\\n                    }));\\n                    //log(bthtml);\\n                    netpg = bthtml.body;\\n                    if (bthtml.search(\\\"set-cookie\\\")) {\\n                        cook = JSON.parse(bthtml).headers['set-cookie'][0].join(';');\\n                    }\\n                } catch (e) {\\n                    cook = \\\"\\\";\\n                }\\n                log(\\\"Cookie值：\\\" + cook);\\n                if (cook == \\\"\\\") {\\n                    ghtml = fetch(bturl + \\\"/?btwaf\\\" + netpg.match(/btwaf(.*?)\\\\\\\"/)[1], {\\n                        headers: {\\n                            \\\"User-Agent\\\": btua\\n                        }\\n                    });\\n                } else {\\n                    ghtml = fetch(bturl + \\\"/?btwaf\\\" + netpg.match(/btwaf(.*?)\\\\\\\"/)[1], {\\n                        headers: {\\n                            \\\"User-Agent\\\": btua,\\n                            \\\"Cookie\\\": cook\\n                        }\\n                    });\\n                }\\n            }\\n        }\\n\\n        function gethtml(url, ua, chars) {\\n            if (ua == \\\"\\\") {\\n                ua = MOBILE_UA;\\n            } else if (ua == \\\"手机\\\") {\\n                ua = MOBILE_UA;\\n            } else if (ua == \\\"电脑\\\") {\\n                ua = PC_UA;\\n            } else {\\n                ua = ua.replace(/；；/g, ';');\\n            }\\n            if (chars == \\\"\\\") {\\n                ghtml = request(url, {\\n                    headers: {\\n                        \\\"User-Agent\\\": ua\\n                    }\\n                });\\n            } else {\\n                ghtml = request(url, {\\n                    headers: {\\n                        \\\"Content-Type\\\": \\\"text/html; charset=\\\" + chars,\\n                        \\\"User-Agent\\\": ua\\n                    }\\n                });\\n            }\\n            //log(html);\\n            btwaf(ghtml, url, ua, chars);\\n            return ghtml;\\n        }\\n        showLoading(\\\"正在获取网页源码，请稍候...\\\");\\n        var link = input.split(\\\";\\\");\\n        var html = \\\"\\\";\\n        if (link.length == 1) {\\n            html = gethtml(link[0], \\\"\\\", \\\"\\\");\\n        } else if (link.length == 2) {\\n            html = gethtml(link[0], link[1], \\\"\\\");\\n        } else if (link.length == 3) {\\n            html = gethtml(link[0], link[1], link[2]);\\n        }\\n\\n        //log(html);\\n        putMyVar('rescode', html);\\n        putMyVar('realrescode', html);\\n        //hideLoading();\\n        refreshPage(false);\\n        hideLoading();\\n        return \\\"hiker://empty\\\";\\n    }),\\n    extra: {\\n        type: 'textarea',\\n        height: -1,\\n        onChange: \\\"setItem('linktext',input)\\\",\\n        defaultValue: getItem(\\\"linktext\\\", \\\"https://zjdr.vip/vodshow/id/1/page/1.html;手机;utf-8\\\"),\\n        titleVisible: true\\n    },\\n    col_type: 'input'\\n});\\nif (getMyVar(\\\"linktext\\\", \\\"\\\") != \\\"\\\") {\\n    items.push({\\n        //title: getMyVar(\\\"rescode\\\", \\\"\\\"),\\n        col_type: \\\"input\\\",\\n        extra: {\\n            height: 3,\\n            defaultValue: getMyVar(\\\"linktext\\\", \\\"\\\"),\\n            type: 'textarea',\\n            highlight: true\\n        }\\n\\n    });\\n} else {\\n    items.push({\\n        title: '格式：链接;手机;utf-8',\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_1\\\"\\n    });\\n}\\n\\nif (getMyVar(\\\"contlist\\\", \\\"\\\") != \\\"\\\") {\\n    items.push({\\n        //title: getMyVar(\\\"rescode\\\", \\\"\\\"),\\n        col_type: \\\"input\\\",\\n        extra: {\\n            height: 3,\\n            defaultValue: getMyVar(\\\"contlist\\\", \\\"\\\"),\\n            type: 'textarea',\\n            highlight: true\\n        }\\n\\n    });\\n} else {\\n    items.push({\\n        title: '格式：数组;列表;标题;链接;切前缀;切后缀',\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_1\\\"\\n    });\\n}\\nvar classText = getItem(\\\"classtext\\\", \\\"body&&.module-class-items;.module-class-items&&a;a&&Text;a&&href;id/;.html\\\");\\nitems.push({\\n    title: \\\"生成\\\",\\n    url: $.toString(() => {\\n        putMyVar('筛选数量', \\\"0\\\");\\n        putMyVar('contlist', \\\"\\\");\\n        putMyVar('classlist', \\\"\\\");\\n\\n        putMyVar('contname', \\\"\\\");\\n        putMyVar('contvalue', \\\"\\\");\\n        showLoading(\\\"正在生成，请稍候...\\\");\\n\\n        function subcont(lin, star, end) {\\n            try {\\n                if (star == \\\"\\\" && end == \\\"\\\") {\\n                    return decodeURIComponent(lin);\\n                } else if (star.length > 0 && end == \\\"\\\") {\\n                    let nub = lin.indexOf(star);\\n                    //log(nub);\\n                    let valu = lin.substring(nub + star.length);\\n                    //log(valu);\\n                    return decodeURIComponent(valu);\\n                } else {\\n                    var str = star + \\\"(.*?)\\\" + end;\\n                    let valu = eval(lin.match(str));\\n                    return decodeURIComponent(valu[1])\\n                }\\n            } catch (e) {\\n                return decodeURIComponent(lin)\\n            }\\n        }\\n\\n\\n\\n        var spl = getItem(\\\"classtext\\\").split(\\\";\\\");\\n        //log(spl.length);\\n        if (getMyVar(\\\"realrescode\\\", \\\"\\\") == \\\"\\\") {\\n            //refreshPage();\\n            hideLoading();\\n            return 'toast://请先获取网页源码。';\\n        } else if (spl[0] == \\\"\\\") {\\n            refreshPage();\\n            hideLoading();\\n            return 'toast://规则格式填写错误，不能为空。';\\n        } else {\\n            var html = getMyVar(\\\"realrescode\\\", \\\"\\\");\\n            try {\\n                var cont = parseDomForArray(html, spl[0]);\\n                putMyVar('筛选数量', cont.length);\\n                //log(cont.length);\\n                for (let j = 0; j < cont.length; j++) {\\n                    putMyVar('classname' + j, \\\"\\\");\\n                    putMyVar('classvalue' + j, \\\"\\\");\\n\\n                    var list = parseDomForArray(cont[j], spl[1] + ':not(:matches(全部|首页|公告|头条|专题|明星|下载|app|APP|类型|分类|资讯|留言|消息|防走|通知|用户|今日|字母))');\\n\\n                    //log('列表：' + list.length);\\n\\n                    for (let i = 0; i < list.length; i++) {\\n                        var listt = getMyVar('classlist', '');\\n                        if (listt.length < 1) {\\n                            var lipt = list[i];\\n                        } else {\\n                            var lipt = listt + '\\\\n\\\\n' + list[i]\\n                        }\\n                        putMyVar('classlist', lipt);\\n\\n                        var title = parseDomForHtml(list[i], spl[2]);\\n                        var url = parseDomForHtml(list[i], spl[3]);\\n                        if (spl.length == 5) {\\n                            url = subcont(url, spl[4], \\\"\\\");\\n                        } else if (spl.length == 6) {\\n                            url = subcont(url, spl[4], spl[5]);\\n                        } else {\\n                            url = subcont(url, \\\"\\\", \\\"\\\");\\n                        }\\n                        var filet = getMyVar('classname' + j, '');\\n                        var file = getMyVar('classvalue' + j, '');\\n                        if (filet.length < 1) {\\n                            var typt = title;\\n                            var typh = url;\\n                        } else {\\n                            var typt = filet + '&' + title;\\n                            var typh = file + '&' + url\\n                        }\\n                        //log(file.length);\\n                        putMyVar('classname' + j, typt);\\n                        putMyVar('classvalue' + j, typh);\\n                    } //for i\\n\\n                    var cfilet = getMyVar('contname', '');\\n                    var cfile = getMyVar('contvalue', '');\\n\\n                    if (getMyVar('classname' + j, '') != '') {\\n                        if (j == 0) {\\n                            var ctypt = '名称：' + getMyVar('classname' + j, '') + '\\\\n替换词：' + getMyVar('classvalue' + j, '') + '\\\\n\\\\n';\\n                        } else {\\n                            var ctypt = cfilet + '名称：' + getMyVar('classname' + j, '') + cfile + '\\\\n替换词：' + getMyVar('classvalue' + j, '') + '\\\\n\\\\n';\\n                        }\\n\\n                        putMyVar('contname', ctypt);\\n                    }\\n                    var clistt = getMyVar('contlist', '');\\n                    if (j == 0) {\\n                        var clipt = cont[j];\\n                    } else {\\n                        var clipt = clistt + '\\\\n\\\\n' + cont[j]\\n                    }\\n                    //log(clipt);\\n                    putMyVar('contlist', clipt);\\n                    //log(getMyVar('contlist', ''));\\n                    //putMyVar('contlist', getMyVar('classlist', '')?getMyVar('contlist', ''):getMyVar('classlist', ''));\\n                    //putMyVar('contlist', getMyVar('classlist', '')?:getMyVar('classlist', ''));\\n                } //for j\\n\\n                putMyVar('contlist', getMyVar('classlist', '') == \\\"\\\" ? getMyVar('contlist', '') : getMyVar('classlist', ''));\\n\\n            } catch (e) {\\n                //putMyVar('判断', \\\"0\\\");\\n                log(\\\"生成报错咯\\\");\\n            }\\n            refreshPage(false);\\n            hideLoading();\\n            return 'hiker://empty';\\n        }\\n    }),\\n    extra: {\\n        type: 'textarea',\\n        height: -1,\\n        onChange: \\\"setItem('classtext',input)\\\",\\n        defaultValue: classText,\\n        titleVisible: true\\n    },\\n    col_type: 'input'\\n});\\n\\n\\nlet contda = getMyVar('筛选数量', '0');\\nif (contda != '0' && getMyVar('classlist', '') != \\\"\\\") {\\n    for (let i = 0; i < contda; i++) {\\n        if (getMyVar('classname' + i, '') != '') {\\n            items.push({\\n                title: \\\"复制\\\" + getMyVar('classname' + i, '').split('&')[0] + \\\"行\\\",\\n                //desc: getVar(\\\"frdtvcode\\\",\\\"\\\"),\\n                url: \\\"confirm://是否需要复制当前内容。.js:\\\" + $.toString((i) => {\\n                    var jieguo = getMyVar('classname' + i, '');\\n                    if (jieguo == '') {\\n                        return 'toast://内容为空,复制失败。';\\n                    } else if (jieguo.length < 1) {\\n                        return 'toast://内容长度不够,复制失败。';\\n                    } else {\\n                        return 'copy://' + getMyVar('classname' + i)\\n                    }\\n                }, i),\\n                col_type: \\\"flex_button\\\"\\n            });\\n\\n            items.push({\\n                title: \\\"复制\\\" + getMyVar('classname' + i, '').split('&')[0] + \\\"行\\\" + \\\"替换词\\\",\\n                //desc: getVar(\\\"frdtvcode\\\",\\\"\\\"),\\n                url: \\\"confirm://是否需要复制当前内容。.js:\\\" + $.toString((i) => {\\n                    var jieguo = getMyVar('classvalue' + i, '');\\n                    if (jieguo == '') {\\n                        return 'toast://内容为空,复制失败。';\\n                    } else if (jieguo.length < 1) {\\n                        return 'toast://内容长度不够,复制失败。';\\n                    } else {\\n                        return 'copy://' + getMyVar('classvalue' + i)\\n                    }\\n                }, i),\\n                col_type: \\\"flex_button\\\"\\n            });\\n        }\\n    }\\n}\\n\\nitems.push({\\n    title: '恢复默认',\\n    url: $('hiker://empty').lazyRule(() => {\\n        clearMyVar('rescode');\\n        clearMyVar('realrescode');\\n\\n        clearMyVar('classname');\\n        clearMyVar(\\\"classvalue\\\");\\n        clearMyVar('contname');\\n        clearMyVar(\\\"contvalue\\\");\\n\\n        clearMyVar('classlist')\\n        clearMyVar('contlist');\\n        clearItem('linktext');\\n        clearItem('classtext');\\n        clearMyVar('筛选数量');\\n        refreshPage(false);\\n        return 'hiker://empty'\\n    }),\\n    col_type: \\\"flex_button\\\"\\n});\\n\\nif (getMyVar('contname', \\\"\\\") != \\\"\\\") {\\n    items.push({\\n        //title: getMyVar(\\\"rescode\\\", \\\"\\\"),\\n        col_type: \\\"input\\\",\\n        extra: {\\n            height: 3,\\n            defaultValue: getMyVar(\\\"contname\\\", \\\"\\\"),\\n            type: 'textarea',\\n            highlight: true\\n        }\\n\\n    });\\n}\\nitems.push({\\n    //title: getMyVar(\\\"rescode\\\", \\\"\\\"),\\n    col_type: \\\"input\\\",\\n    extra: {\\n        height: 5,\\n        onChange: \\\"putMyVar('rescode',input)\\\",\\n        defaultValue: getMyVar(\\\"rescode\\\", \\\"\\\") == \\\"\\\" ? getMyVar(\\\"realrescode\\\", \\\"当前未获取源码。\\\") : getMyVar(\\\"rescode\\\", \\\"\\\"),\\n        type: 'textarea',\\n        highlight: true\\n    }\\n\\n});\\nsetHomeResult(items);\"},{\"col_type\":\"movie_3\",\"name\":\"#Json分类生成器\",\"path\":\"Json\",\"rule\":\"js:\\nvar res = {};\\nvar items = [];\\nitems.push({\\n    title: 'json数据',\\n    url: 'hiker://empty',\\n    col_type: 'text_1'\\n});\\n\\nitems.push({\\n    title: getVar('myjson', ''),\\n    url: \\\"input://\\\" + getVar('myjson', '') + \\\".js:putVar('myjson',input);refreshPage()\\\",\\n    col_type: 'icon_1_search'\\n});\\n\\n\\nitems.push({\\n    title: '定位(list.type)',\\n    url: 'hiker://empty',\\n    col_type: 'text_1'\\n});\\nitems.push({\\n    title: getVar('mytree', ''),\\n    url: \\\"input://\\\" + getVar('mytree', '') + \\\".js:putVar('mytree',input);refreshPage()\\\",\\n    col_type: 'icon_1_search'\\n});\\n\\nitems.push({\\n    title: '取值(type_name&&type_id)',\\n    url: 'hiker://empty',\\n    col_type: 'text_1'\\n});\\nitems.push({\\n    title: getVar('myval', ''),\\n    url: \\\"input://\\\" + getVar('myval', '') + \\\".js:putVar('myval',input);refreshPage()\\\",\\n    col_type: 'icon_1_search'\\n});\\n//log(list);\\nitems.push({\\n    title: '生成',\\n    url: $('').lazyRule(() => {\\n        var tpjson = JSON.parse(getVar('myjson', '[]'));\\n        var list = 'tpjson.' + getVar('mytree', '');\\n        var spl = getVar('myval', '').split('&&');\\n        var one = 'typec[j].' + spl[0];\\n        var two = 'typec[j].' + spl[1];\\n        //var tpjson = JSON.parse(json);\\n        //log(tpjson);\\n        var typec = eval(list);\\n        //log(typec);\\n        var typet = \\\"\\\",\\n            typel = \\\"\\\";\\n        for (var j = 0; j < typec.length; j++) {\\n            typet += eval(one);\\n            typel += eval(two);\\n            if (j < typec.length - 1) {\\n                typet += \\\"&\\\";\\n                typel += \\\"&\\\";\\n            }\\n        }\\n\\n        putVar('jsontypet', typet);\\n        putVar('jsontypel', typel);\\n        refreshPage();\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'text_3'\\n});\\n\\nitems.push({\\n    title: \\\"复制名称\\\",\\n    url: \\\"confirm://是否需要复制当前内容。.js:\\\" + $.toString(() => {\\n        var jieguo = getVar('jsontypet', '');\\n        if (jieguo == '') {\\n            return 'toast://内容为空,复制失败。';\\n        } else {\\n            return 'copy://' + getVar('jsontypet')\\n        }\\n    }),\\n    col_type: \\\"text_3\\\"\\n});\\n\\nitems.push({\\n    title: \\\"复制替换词\\\",\\n    url: \\\"confirm://是否需要复制当前内容。.js:\\\" + $.toString(() => {\\n        var jieguo = getVar('jsontypel', '');\\n        if (jieguo == '') {\\n            return 'toast://内容为空,复制失败。';\\n        } else {\\n            return 'copy://' + getVar('jsontypel')\\n        }\\n    }),\\n    col_type: \\\"text_3\\\"\\n});\\n\\nitems.push({\\n    title: getVar(\\\"jsontypet\\\", \\\"\\\") + '<br>' + getVar(\\\"jsontypel\\\", \\\"\\\"),\\n    col_type: 'rich_text'\\n});\\n\\nres.data = items;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"*请求测试工具\",\"path\":\"home\",\"rule\":\"var methods = [\\\"GET\\\", \\\"POST\\\", \\\"PUT\\\", \\\"DELETE\\\"]\\nvar d = [{\\n    desc: \\\"请求链接\\\",\\n    col_type: \\\"input\\\",\\n    extra: {\\n        titleVisible: false,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"url\\\", input)\\n        }),\\n        defaultValue: getMyVar(\\\"url\\\", \\\"https://piyao.kepuchina.cn/h5/ajaxGetGossip\\\")\\n    }\\n}, {\\n    title: \\\"请求方式:\\\" + (getMyVar(\\\"method\\\", \\\"'POST\\\")),\\n    col_type: \\\"text_1\\\",\\n    url: $(methods).select(() => {\\n        putMyVar(\\\"method\\\", input)\\n        refreshPage()\\n    })\\n}, {\\n    col_type: \\\"line_blank\\\"\\n}, {\\n    title: \\\"添加headers\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: $(\\\"\\\", \\\"键值\\\").input(() => {\\n        return $(\\\"\\\", \\\"值\\\").input((a) => {\\n            var old = storage0.getMyVar(\\\"headers\\\", {})\\n            old[a] = input\\n            storage0.putMyVar(\\\"headers\\\", old)\\n            refreshPage()\\n        }, input)\\n    })\\n}]\\nvar headers = storage0.getMyVar(\\\"headers\\\", {})\\nObject.keys(headers).forEach(item => {\\n    d.push({\\n        title: item,\\n        desc: headers[item],\\n        url: $(\\\"确认删除该项？\\\").confirm((key) => {\\n            var old = storage0.getMyVar(\\\"headers\\\", {})\\n            delete old[key]\\n            storage0.putMyVar(\\\"headers\\\", old)\\n            refreshPage()\\n        }, item),\\n        col_type: \\\"text_1\\\"\\n    })\\n})\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n}, {\\n    title: \\\"添加body\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: $(\\\"\\\", \\\"键值\\\").input(() => {\\n        return $(\\\"\\\", \\\"值\\\").input((a) => {\\n            var old = storage0.getMyVar(\\\"body\\\", {})\\n            old[a] = input\\n            storage0.putMyVar(\\\"body\\\", old)\\n            refreshPage()\\n        }, input)\\n    })\\n})\\nvar body = storage0.getMyVar(\\\"body\\\",{\\\"page\\\":\\\"1\\\",\\\"type\\\":\\\"2\\\"})\\nObject.keys(body).forEach(item => {\\n    d.push({\\n        title: item,\\n        desc: body[item],\\n        url: $(\\\"确认删除该项？\\\").confirm((key) => {\\n            var old = storage0.getMyVar(\\\"body\\\", {})\\n            delete old[key]\\n            storage0.putMyVar(\\\"body\\\", old)\\n            refreshPage()\\n        }, item),\\n        col_type: \\\"text_1\\\"\\n    })\\n})\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n}, {\\n    title: \\\"发送请求\\\",\\n    url: \\\"hiker://page/report\\\",\\n    col_type: \\\"text_center_1\\\"\\n})\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"*请求报告\",\"path\":\"report\",\"rule\":\"js:\\nvar d = [];\\nvar a = JSON.parse(request(getMyVar(\\\"url\\\", \\\"hiker://empty\\\"), {\\n    method: getMyVar(\\\"method\\\", \\\"GET\\\"),\\n    withHeaders: true,\\n    headers: storage0.getMyVar(\\\"headers\\\", {}),\\n    body: storage0.getMyVar(\\\"body\\\", {})\\n}))\\nvar qingqiu = \\\"request('\\\" + getMyVar(\\\"url\\\", \\\"hiker://empty\\\") + \\\"', {method: '\\\" + getMyVar(\\\"method\\\", \\\"GET\\\") + \\\"',withHeaders: true,headers:\\\" + JSON.stringify(storage0.getMyVar(\\\"headers\\\", {})) + \\\",body: \\\" + JSON.stringify(storage0.getMyVar(\\\"body\\\", {})) + \\\"})\\\"\\n\\nd.push({\\n    title: '请求' + qingqiu,\\n    url: qingqiu + $(\\\"\\\").lazyRule(() => {\\n        return \\\"copy://\\\" + input\\n    }),\\n    col_type: \\\"text_1\\\",\\n    desc: \\\"\\\",\\n    pic_url: \\\"\\\"\\n});\\n\\nif (a.error) {\\n    d.push({\\n        title: \\\"错误~~  代码:\\\" + a.statusCode,\\n        desc: a.error\\n    })\\n    log(a)\\n    setPageTitle(\\\"请求失败\\\")\\n} else {\\n    setPageTitle(\\\"请求成功\\\")\\n    Object.keys(a).forEach(item => {\\n        d.push({\\n            title: item + \\\":\\\" + (typeof(a[item]) == \\\"string\\\" ? a[item] : JSON.stringify(a[item])),\\n            col_type: \\\"text_1\\\",\\n            url: a[item] + $(\\\"\\\").lazyRule(() => {\\n                return \\\"copy://\\\" + input\\n            })\\n        })\\n    })\\n}\\n\\n\\nd.push({\\n    title: \\\"点击进入JSON编辑器\\\",\\n    url: 'hiker://page/interface#noRefresh##noHistory##noRecordHistory#?rule=JSON编辑器',\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        Json: JSON.stringify(a['body'])\\n    }\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"$favicon\",\"path\":\"favicon\",\"rule\":\"js:\\nvar d = []\\naddListener('onClose', () => {\\n    refreshPage(false)\\n    //log('页面关闭')\\n})\\n\\n\\nsetPageTitle(MY_RULE.title)\\ninfs = [\\\"直连\\\", \\\"https://api.xinac.net/icon/?url=${url}\\\", \\\"https://api.btstu.cn/getfav/api.php?url=${url}\\\", \\\"https://api.cxr.cool/get.php?url=${url}\\\", \\\"https://ico.di8du.com/get.php?url=${url}\\\",\\\"Google##https://t1.gstatic.com/faviconV2?client=SOCIAL&type=FAVICON&fallback_opts=TYPE,SIZE,URL&url=${url}&size=32\\\",\\\"yandex##https://favicon.yandex.net/favicon/v2/${url}?size=32&stub=1\\\"]\\n\\nd.push({\\n    title: '  请在下方输入链接[必须有http] 然后点确认',\\n    url: 'hiker://empty',\\n    col_type: 'text_1',\\n    extra: {\\n        id: 'lab',\\n    }\\n})\\n\\n\\n\\nd.push({\\n    title: '清空',\\n    url: $('#noLoading#').lazyRule(() => {\\n        updateItem('text', {\\n            extra: {\\n                type: 'textarea',\\n                height: -1,\\n                defaultValue: ''\\n            }\\n        });\\n        putMyVar('keyword', '')\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'flex_button',\\n    extra: {}\\n})\\n\\n//require('hiker://page/btn')\\n\\n\\n\\nd.push({\\n    title: '粘贴',\\n    url: $('#noLoading#').lazyRule(() => {\\n        let test = $(\\\"{{clipboard}}\\\", \\\"\\\").input(() => {\\n            updateItem('text', {\\n                extra: {\\n                    type: 'textarea',\\n                    height: -1,\\n                    defaultValue: input\\n                }\\n            });\\n            return 'hiker://empty'\\n        })\\n\\n        return test\\n    }),\\n    col_type: 'flex_button',\\n    extra: {}\\n})\\n\\nd.push({\\n    title: '清除',\\n    url: $('#noLoading#').lazyRule(() => {\\n        storage0.setItem('arr', [])\\n        toast('清除记录')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'flex_button',\\n    extra: {}\\n})\\n\\nd.push({\\n    title: '样式:' + storage0.getItem('按钮样式', 'icon_4_card'),\\n    url: $('#noLoading#').lazyRule(() => {\\n        let all_cols = [''].concat(getColTypes());\\n        all_cols = all_cols.filter(item => /(ico|ava)/.test(item) && !item.includes('mov'))\\n        let col = (storage0.getItem('按钮样式', 'icon_4_card') || '');\\n        let 按钮样式 = all_cols.map((it) => {\\n            return it === col ? '➡️' + it : it;\\n        });\\n        let tips = '请选择样式';\\n        return $(按钮样式, 2, tips).select(() => {\\n            input = input.replace(/➡️/g, '');\\n            storage0.setItem('按钮样式', input);\\n            // config.按钮样式 = input;\\n            initConfig({\\n                按钮样式: input\\n            });\\n            // refreshPage(true);\\n            let oldIds = (findItemsByCls('img')).map(it => it.extra.id);\\n            updateItem('style', {\\n                title: '样式:' + storage0.getItem('按钮样式', 'icon_4_card')\\n            });\\n            oldIds.forEach(x => {\\n\\n                updateItem(x, {\\n                    col_type: input\\n                });\\n            });\\n            return 'toast://已切换样式为:' + input;\\n        });\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'flex_button',\\n    extra: {\\n        id: 'style'\\n    }\\n})\\n\\nd.push({\\n    title: '接口:' + storage0.getItem('接口', '直连'),\\n    url: $('#noLoading#').lazyRule((inf) => {\\n        let all_cols = inf\\n        let col = (storage0.getItem('接口', '直连') || '');\\n        let 接口 = all_cols.map((it) => {\\n            return it === col ? '➡️' + it : it;\\n        });\\n        let tips = '请选择样式';\\n        return $(接口, 1, tips).select(() => {\\n            input = input.replace(/➡️/g, '');\\n            storage0.setItem('接口', input);\\n            // config.按钮样式 = input;\\n            initConfig({\\n                接口: input\\n            });\\n            // refreshPage(true);\\n\\n            updateItem('inf', {\\n                title: '接口:' + storage0.getItem('接口', '直连')\\n            });\\n            return 'toast://已切接口为:' + input;\\n        });\\n        return 'hiker://empty'\\n    }, infs),\\n    col_type: 'text_1',\\n    extra: {\\n        id: 'inf'\\n    }\\n})\\n\\nd.push({\\n    col_type: 'text_2',\\n    title: '打开新窗口',\\n    url: 'hiker://page/home',\\n    extra: {\\n        newWindow: true,\\n        windowId: MY_RULE.title\\n    }\\n})\\n\\nd.push({\\n    title: '类型:' + storage0.getItem('类型', 'img'),\\n    url: $('#noLoading#').lazyRule(() => {\\n        let col = storage0.getItem('类型', 'img');\\n        if(col=='img'){\\n            storage0.setItem('类型', 'base64')\\n        }else{\\n            storage0.setItem('类型', 'img')\\n        }\\n        toast('请重新获取')\\n        updateItem('type', {\\n            title: '类型:' + storage0.getItem('类型', 'img')\\n        });\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'text_2',\\n    extra: {\\n        id: 'type'\\n    }\\n})\\n\\n\\nd.push({\\n    url: $.toString(() => {\\n        putMyVar('keyword', input)\\n        if (input == '') {\\n            toast('输入为空')\\n            return ''\\n        }\\n        updateItem('lab', {\\n            title: '  获取中请稍等',\\n        });\\n        var r = $.require('hiker://page/fun');\\n        var inf = storage0.getItem('接口', '直连')\\n        var list = r.gfav(input, inf)\\n        //log(list)\\n\\n\\n        if (list != undefined && list.length > 0) {\\n            for (let l of list) {\\n                var tl = l.substring(l.lastIndexOf('/') + 1)\\n                if (l.includes('?')) {\\n                    tl = l.split('=')[1]\\n                }\\n                var type = storage0.getItem('类型', 'img')\\n                var c = l\\n                if (type == 'base64') {\\n                    c=convertBase64Image(l)\\n                }\\n                addItemAfter('text', {\\n                    title: tl,\\n                    img: l,\\n                    url: 'copy://' + c,\\n                    col_type: storage0.getItem('按钮样式', 'icon_4_card'),\\n                    extra: {\\n                        cls: 'img',\\n                        id: l\\n                    }\\n                });\\n            }\\n            storage0.setItem('arr', list)\\n        }\\n        updateItem('lab', {\\n            title: '  请在下方输入链接[必须有http] 然后点确认',\\n        });\\n        return ''\\n    }),\\n    col_type: 'input',\\n    title: '确定',\\n    extra: {\\n        type: 'textarea',\\n        height: -1,\\n        id: 'text',\\n        defaultValue: getMyVar('keyword', '') || \\\"\\\"\\n    }\\n})\\n\\n\\nsetResult(d);\\n\\nif (MY_TYPE == 'home') {\\n    \\n    var list = storage0.getItem('arr', [])\\n\\n    if (list.length > 0) {\\n        for (let l of list) {\\n            var tl = l.substring(l.lastIndexOf('/') + 1)\\n            if (l.includes('?')) {\\n                tl = l.split('=')[1]\\n            }\\n            addItemAfter('text', {\\n                title: tl,\\n                img: l,\\n                url: 'copy://' + l,\\n                col_type: storage0.getItem('按钮样式', 'icon_4_card'),\\n                extra: {\\n                    cls: 'img',\\n                    id: l\\n                }\\n            });\\n        }\\n    }\\n    \\n}\"},{\"col_type\":\"movie_3\",\"name\":\"$获取Favicon·α方法\",\"path\":\"fun\",\"rule\":\"js:\\nfunction getFav(url, inf) {\\n    if (!/http[s]?/.test(url)) {\\n        toast('不是网址')\\n        return\\n    }\\n    var javai = JavaImporter(java.net.URL, org.jsoup.Jsoup)\\n\\n    var list = []\\n\\n    with(javai) {\\n        try {\\n            var u = new URL(url);\\n        } catch (e) {\\n            log('错误信息：' + e)\\n            toast('错误信息：' + e)\\n            return\\n        }\\n        var pl = u.getProtocol();\\n        var hs = u.getHost();\\n        var newUrl = u.getProtocol().concat(\\\"://\\\").concat(u.getHost());\\n        log(newUrl)\\n        \\n        if (inf != '直连') {\\n            if (inf.includes('##')) {\\n                inf = inf.split('##')[1]\\n            }\\n            list.push(inf.replace('${url}', newUrl))\\n            return list\\n        }\\n\\n        var fav = newUrl + '/favicon.ico'\\n        var res = fetch(fav, {\\n            withStatusCode: true\\n        })\\n        log(res)\\n        var code = 0\\n        if (res != '') {\\n            var mes = JSON.parse(res)\\n        }\\n\\n        if (mes.error != null) {\\n            if (mes.error.includes('Unable to resolve host')) {\\n                log('错误信息：' + mes.error)\\n                toast('错误信息：' + mes.error)\\n                return\\n            }\\n\\n        }\\n        code = mes.statusCode\\n        if (code == 200 && !mes.body.includes('html')) {\\n            list.push(fav)\\n        }\\n\\n        try {\\n            var document = Jsoup.parse(fetch(newUrl));\\n        } catch (e) {\\n            log('错误信息：' + e)\\n            toast('错误信息：' + e)\\n            return\\n        }\\n\\n\\n        var imgs = document.select(\\\"link[type=image/x-icon]\\\");\\n        log(imgs)\\n        imgs = Object.keys(imgs).length > 0 ? imgs : document.select(\\\"link[rel$=icon]\\\")\\n        imgs = Object.keys(imgs).length > 0 ? imgs : document.select(\\\"meta[itemprop=image]\\\")\\n        //log(JSON.stringify(imgs))\\n\\n        var isweb = /(com|cn)/\\n        var isimg = /.*?(svg|jpg|ico|png|gif|jpeg)$/gm\\n        for (let x of imgs) {\\n\\n            var link = x.attr(\\\"href\\\")\\n            if (link == '') {\\n                link = x.attr('content')\\n            }\\n            if (isweb.test(link) && isimg.test(link)) {\\n                if (link.startsWith('//')) {\\n                    link = `${pl}:${link}`\\n                }\\n            }\\n            if (link.startsWith('/')) {\\n                link = `${pl}://${hs}${link}`\\n            } else if (!link.includes(pl)) {\\n                link = `${pl}://${hs}/${link}`\\n            }\\n\\n            list.push(link)\\n        }\\n\\n\\n       /* imgs.forEach((x) => {\\n\\n        })*/\\n\\n    }\\n\\n    function unique(arr) {\\n        var obj = {};\\n        return arr.filter(function(item, index, arr) {\\n            return obj.hasOwnProperty(typeof item + item) ? false : (obj[typeof item + item] = true)\\n        })\\n    }\\n\\n\\n\\n    alist = unique(list)\\n\\n    return alist\\n}\\n\\n$.exports.gfav = getFav\"},{\"col_type\":\"movie_3\",\"name\":\"$获取Favicon·α按钮\",\"path\":\"btn\",\"rule\":\"js:\\n\\nd.push({\\n    title: '保存',\\n    url: $('#noLoading#').lazyRule(() => {\\n        var lists = (findItemsByCls('img') || [])\\n        var list = []\\n        if (lists.length > 0) {\\n            for (let item of lists) {\\n                list.push(item.pic)\\n            }\\n            storage0.setItem('arr', list)\\n            toast('保存成功')\\n        } else {\\n            toast('当前为空')\\n        }\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'flex_button',\\n    extra: {\\n\\n    }\\n})\\n\\nd.push({\\n    title: '加载',\\n    url: $('#noLoading#').lazyRule(() => {\\n        var list = storage0.getItem('arr', [])\\n\\n        if (list.length > 0) {\\n            for (let l of list) {\\n                var tl = l.substring(l.lastIndexOf('/') + 1)\\n                addItemAfter('text', {\\n                    title: tl,\\n                    img: l,\\n                    url: 'copy://' + l,\\n                    col_type: storage0.getItem('按钮样式', 'icon_4_card'),\\n                    extra: {\\n                        cls: 'img',\\n                        id: l\\n                    }\\n                });\\n            }\\n        } else {\\n            toast('记录为空')\\n        }\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'flex_button',\\n    extra: {\\n\\n    }\\n})\"},{\"col_type\":\"rich_text\",\"name\":\"常用写法¹\",\"path\":\"XF\",\"rule\":\"js:\\nvar d = [];\\nvar Title = ['一级&二级常用写法', 'POST写法']\\nvar json = JSON.parse(JSON.parse(request('hiker://page/xf')).rule)\\nvar Page = [json.text, json.post]\\nvar P = ['ymtool', 'Home']\\n\\nTitle.forEach(function(data, id) {\\n    d.push({\\n        title: '““””<font color=\\\"#FD113A\\\">▐ </font><b>' + data + '「' + '点击此处测试」' + '<b>',\\n        url: \\\"hiker://page/\\\" + P[id] + \\\"#noHistory##noRecordHistory#\\\",\\n        col_type: 'text_center_1'\\n    })\\n    d.push({\\n        title: Page[id],\\n        col_type: json.type\\n    })\\n})\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"#源码工具\",\"path\":\"ymtool\",\"rule\":\"js:\\nvar d = [];\\n\\nlet api = \\\"hiker://empty\\\";\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    for (let it of listMyVarKeys()) {\\n        clearMyVar(it);\\n    }\\n}));\\nd.push({\\n    title: \\\"源码工具\\\",\\n    url: api,\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nd.push({\\n    title: \\\"输入源码\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入源码或者http开头链接\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 2,\\n        highlight: true,\\n        defaultValue: getMyVar(\\\"html\\\", \\\"\\\"),\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"html\\\", input);\\n\\n        })\\n    }\\n});\\nd.push({\\n    title: \\\"输入列表规则\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入列表规则\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 1,\\n        highlight: true,\\n        defaultValue: getMyVar(\\\"list\\\", \\\"\\\"),\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"list\\\", input);\\n        })\\n    }\\n});\\n\\nd.push({\\n    title: \\\"输入节点规则\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入节点规则\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 1,\\n        highlight: true,\\n        defaultValue: getMyVar(\\\"point\\\", \\\"\\\"),\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"point\\\", input);\\n        })\\n    }\\n});\\nd.push({\\n    title: \\\"点击生成元素\\\",\\n    url: $('#noLoading#').lazyRule(() => {\\n        let html = getMyVar(\\\"html\\\", \\\"\\\");\\n        if (html == \\\"\\\") return \\\"toast://代码不能为空\\\"\\n        else if (html.startsWith(\\\"http\\\")) {\\n            html = request(html)\\n\\n            putMyVar(\\\"html\\\", html);\\n        }\\n        let list = getMyVar(\\\"list\\\", \\\"\\\");\\n        if (list == \\\"\\\") return \\\"toast://列表不能为空\\\"\\n        let point = getMyVar(\\\"point\\\", \\\"\\\");\\n        if (point == \\\"\\\") return \\\"toast://节点不能为空\\\"\\n\\n        let 列表 = pdfa(html, list)\\n\\n        putMyVar(\\\"列表输出\\\", 列表)\\n        let 节点 = []\\n        列表.forEach(item => {\\n            节点.push(pdfh(item, point))\\n        })\\n        putMyVar(\\\"节点输出\\\", 节点)\\n\\n        refreshPage();\\n        return \\\"hiker://empty\\\";\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n    desc: \\\"\\\",\\n    pic_url: \\\"\\\",\\n    extra: {newWindow: true, windowId: MY_RULE.title,\\n       // pageTitle: \\\"结果\\\",\\n        //cls: \\\"playlist\\\"\\n    }\\n});\\n\\n\\nd.push({\\n    title: \\\"列表输出内容\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"列表输出内容\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 2,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"input\\\", input);\\n        }),\\n        defaultValue: getMyVar(\\\"列表输出\\\", \\\"\\\")\\n    }\\n});\\n\\n\\nd.push({\\n    title: \\\"节点输出内容\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"节点输出内容\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 2,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"input\\\", input);\\n        }),\\n        defaultValue: getMyVar(\\\"节点输出\\\", \\\"\\\")\\n    }\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"*请求测试主页\",\"path\":\"Home\",\"rule\":\"js:$.require(\\\"hiker://page/home\\\")\"},{\"col_type\":\"movie_3\",\"name\":\"常用语法¹\",\"path\":\"YF\",\"rule\":\"js:\\nvar d = [];\\nvar Title = ['字符用法', '方法汇总']\\nvar json = JSON.parse(JSON.parse(request('hiker://page/grammar')).rule)\\nvar Page = [json.char, json.method]\\n\\nTitle.forEach(function(data, id) {\\n    d.push({\\n        title: Page[id],\\n        col_type: json.type\\n    })\\n})\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"※语法汇总\",\"path\":\"grammar\",\"rule\":\"{\\n    \\\"char\\\": \\\"<h2 id=\\\\\\\"字符用法\\\\\\\">字符用法</h2>\\\\n<pre><code>+ •拼接字符\\\\nMY_URL + pdfh(html, 'a&&href')\\\\n•拼接链接\\\\npdfh(html, 'body&&.more.text-muted+h3')\\\\n•定位紧跟\\\\\\\"more.text-muted\\\\\\\"的h3标签\\\\n\\\\n, •位置字符\\\\npdfh(html, 'body&&a,1&&Text')\\\\n•定位第二个a标签\\\\n\\\\n| •或字符\\\\npdfh(html, 'body&&a|b')\\\\npdfa(html, 'body&&a')|pdfa(html, 'body&&b')\\\\n•两者取一\\\\npdfa(body&&a|b)\\\\n•两者皆取\\\\n\\\\n--  •排除标签\\\\nmodule-tab-item--small&&Text •排除small\\\\n\\\\nbody--a&&a\\\\n•如body--a&&a&&href代表排除第一个a标签后取剩下的第一个a标签的href属性\\\\n\\\\n: •定位从开始位置:结束位置\\\\nbody&&p,0:3 •定位第一个到第三个p标签\\\\n\\\\n*&& •跳过标签\\\\n\\\\\\\".content_thumb‖.eclazy&&a‖*&&data-original\\\\\\\"</code></pre>\\\\n\\\",\\n    \\\"method\\\": \\\"<h2 id=\\\\\\\"方法汇总\\\\\\\">方法汇总</h2>\\\\n<pre><code>:has(a)•必须含有标签a\\\\n\\\\n:not(a)•必须不含标签a\\\\n\\\\n:not(:matches(正则))•matches可以写正则\\\\n\\\\n:not(:contains(首页))•contains只能包含一个词\\\\n\\\\n:has(a:nth-child(n+2))\\\\n忽略a长度只有1的\\\\n\\\\nbody&&.title:nth-child(2)+ul&&li\\\\nnth-child(n+a)•选择第 a 个之后的元素。\\\\n\\\\n.cdes1:matchText,1&&Text\\\\n•定位第二个含有文本的标签\\\\n\\\\nbody&&tr[valign=\\\\\\\"top\\\\\\\"]•用[特殊标签的值]\\\\n\\\\n•栗子如下\\\\n\\\\n'#__layout&&.container&&a[href*=\\\\\\\"/posts\\\\\\\"]:not(.comment_3HBAQ)'\\\\n\\\\nbody&&.clearfix[class*=\\\\\\\"content__playlist\\\\\\\"]\\\\n\\\\nbody&&.title[style*=\\\\\\\"display\\\\\\\"]\\\\n\\\\nbody&&.mb:has([href*=tv])\\\\n\\\\n\\\\npdfa().slice(1,-1)\\\\n\\\\n•slice(start,end)：方法可从已有数组中返回选定的元素，返回一个新数组，包含从start到end（不包含该元素）的数组元素。(不会改变原数组)\\\\n\\\\n\\\\na.concat(b)\\\\n\\\\n•concat方法用于连接ab两个数组。\\\\n\\\\n\\\\n.test()\\\\n\\\\n\\\\n.replace()•替换\\\\n\\\\n.replace(/v(\\\\\\\\/\\\\\\\\w+)\\\\\\\\.html/, 'show$1------.html')\\\\n\\\\n$1表示引用前面括号内的\\\\\\\\/\\\\\\\\w+\\\\n\\\\n\\\\n.reverse()•列表倒序\\\\n\\\\n\\\\n.match()•正则\\\\n\\\\n\\\\n传页码url\\\\n\\\\n例子：url: pd(x, 'a&&href')+\\\\\\\"?page=fypage\\\\\\\"\\\\n\\\\n例子：url: pd(it, '.category-post-list&&a:matches(More)&&href')+'page/fypage/[firstPage='+pd(it, '.category-post-list&&a:matches(More)&&href')+']',\\\\n\\\\n这个写复杂了，地址用\\\\n\\\\nurl:'hiker:•empty##' + pd(list, 'a,-1&&href') + '/page/fypage/'\\\\n\\\\n传进去之后\\\\n\\\\nMY_URL = MY_URL.split('##')[1].replace('page/1/', '');</code></pre>\\\\n\\\",\\n    \\\"type\\\": \\\"rich_text\\\"\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"※常用写法\",\"path\":\"xf\",\"rule\":\"{\\n    \\\"text\\\": \\\"<h2 id=\\\\\\\"基础调用方法\\\\\\\">基础调用方法</h2>\\\\n<pre><code>js:\\\\nvar d = []\\\\nvar code = getResCode()\\\\n//定位填在\\\\\\\"\\\\\\\"或''中，不可重复使用同一种符号\\\\npdfa(code, 列表定位).forEach(function(data) {\\\\n    d.push({\\\\n        title: pdfh(data, 标题定位),\\\\n        desc: pdfh(data, 详情定位),\\\\n        //content: pdfh(data, 搜索栏详情定位),//搜索解析才会显示\\\\n        url: pd(data, 链接定位),\\\\n        pic_url: pd(data, 图片定位),\\\\n        //如图片需重定向可加Referer\\\\n        //pic_url: pd(data, 图片定位)+\\\\\\\"@Referer=\\\\\\\",\\\\n        col_type: \\\\\\\"movie_3\\\\\\\" //显示样式\\\\n    });\\\\n});\\\\nsetResult(d);</code></pre>\\\\n\\\",\\n    \\\"post\\\": \\\"<h2 id=\\\\\\\"基础POST写法\\\\\\\">基础POST写法</h2>\\\\n<pre><code>{\\\\n    \\\\\\\"data\\\\\\\": {\\\\n        \\\\\\\"firstHeader\\\\\\\": null,\\\\n        \\\\\\\"list\\\\\\\": \\\\\\\"[\\\\\\\"1.png\\\\\\\",\\\\\\\"2.png\\\\\\\",\\\\\\\"3.png\\\\\\\"]\\\\\\\",\\\\n        \\\\\\\"params\\\\\\\": \\\\\\\"{\\\\\\\"newWindow\\\\\\\":true,\\\\\\\"windowId\\\\\\\":\\\\\\\"初学者写源工具\\\\\\\"}\\\\\\\",\\\\n        \\\\\\\"title\\\\\\\": \\\\\\\"初学者写源工具\\\\\\\"\\\\n    }\\\\n\\\\n}\\\\n//以上为：post返回数据常见格式，data.list//定位列表，data.title//定位标题\\\\n\\\\n//POST代码如下\\\\njs:\\\\n    var d = [];\\\\n    var json = JSON.parse(fetch('链接', {\\\\n    headers: { //请求参数\\\\n        'Origin': '',\\\\n        'Referer': '', //重定向\\\\n        'User-Agent': '', //请求UA\\\\n        'Cookie': '' //请求所需Cookie\\\\n    },\\\\n    body: '',\\\\n    method: 'POST'\\\\n}));\\\\n//定位填在\\\\\\\"\\\\\\\"或''中，不可重复使用同一种符号\\\\npdfa(json, 列表定位).forEach(function(data) {\\\\n    d.push({\\\\n        title: pdfh(data, 标题定位),\\\\n        url: pd(data, 链接定位),\\\\n        pic_url: pd(data, 图片定位),\\\\n        //如图片需重定向可加Referer\\\\n        //pic_url: pd(data, 图片定位)+\\\\\\\"@Referer=\\\\\\\",\\\\n        desc: pdfh(data, 详情定位),\\\\n        col_type: \\\\\\\"movie_3\\\\\\\" //显示样式\\\\n    });\\\\n});\\\\nsetResult(d);</code></pre>\\\\n\\\",\\n    \\\"type\\\": \\\"rich_text\\\"\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"￥一级动态分类\",\"path\":\"yjdt\",\"rule\":\"js:\\nvar d=[];\\r\\nconst page = MY_PAGE;\\r\\naddListener(\\\"onClose\\\",\\r\\n  $.toString(() => {\\r\\n    clearMyVar('mode');\\r\\n  })\\r\\n);\\r\\n\\r\\nif (page == 1) {\\r\\n  d.push({\\r\\n    title: '\\\\t' + getMyVar('折叠状态', '展开'),\\r\\n    img: getMyVar('折叠状态', '展开') == '展开' ? 'https://hikerfans.com/tubiao/messy/60.svg' : 'https://hikerfans.com/tubiao/messy/59.svg',\\r\\n    col_type: 'text_icon',\\r\\n    url: $('#noLoading#').lazyRule((t) => {\\r\\n      var st = getMyVar('折叠状态', '展开');\\r\\n      if (st == \\\"展开\\\") {\\r\\n        putMyVar('折叠状态', '折叠');\\r\\n        var clsx = findItemsByCls(t+'Options');\\r\\n        storage0.putMyVar('clsx', clsx);\\r\\n        deleteItemByCls(t+'Options');\\r\\n      } else {\\r\\n        putMyVar('折叠状态', '展开');\\r\\n        var clsx = storage0.getMyVar('clsx', []).map(x => {\\r\\n          x['col_type'] = x['col_type'] ? x['col_type'] : x['type'];\\r\\n          return x;\\r\\n        });\\r\\n        addItemAfter(t+'addres', clsx);\\r\\n      }\\r\\n      updateItem(t+'exp', {\\r\\n        title: '\\\\t' + getMyVar('折叠状态', '展开'),\\r\\n        img: getMyVar('折叠状态', '展开') == '展开' ? 'https://hikerfans.com/tubiao/messy/60.svg' : 'https://hikerfans.com/tubiao/messy/59.svg',\\r\\n      })\\r\\n\\r\\n      //refreshPage();\\r\\n      return 'hiker://empty';\\r\\n    },MY_RULE.title),\\r\\n    extra: {\\r\\n      id:MY_RULE.title+'exp',\\r\\n    }\\r\\n  })\\r\\n\\r\\n  var st = getMyVar('折叠状态', '展开');\\r\\n\\r\\n  d.push({\\r\\n    title: '网址',\\r\\n    col_type: 'input',\\r\\n    url: $.toString((page) => {\\r\\n      toast('加载网页中...');\\r\\n      var url = input.replace('fypage', page)\\r\\n      var html = fetch(url);\\r\\n      putMyVar('html', html);\\r\\n      setItem('url', url);\\r\\n      putMyVar('url', url);\\r\\n      clearMyVar(\\\"head.cate\\\")\\r\\n      toast(url);\\r\\n      refreshPage();\\r\\n    }, page),\\r\\n    extra: {\\r\\n      id: MY_RULE.title+'addres',\\r\\n      defaultValue: getItem('url', \\\"\\\"),\\r\\n      onChange: $.toString(() => {\\r\\n        putMyVar('url', input)\\r\\n      })\\r\\n    }\\r\\n  })\\r\\n}\\r\\n\\r\\n\\r\\nlet html = getMyVar(\\\"html\\\", \\\"\\\");\\r\\nlet url = getItem('url', \\\"\\\");\\r\\n\\r\\n\\r\\nvar 定义 = {\\r\\n  分类颜色: { value: getMyVar('分类颜色', 'red') },\\r\\n  大类定位: { value: getMyVar('大类定位', '') },\\r\\n  拼接分类: { value: getMyVar('拼接分类', ''),desc:'多个按按;隔开' },\\r\\n  小类定位: { value: getMyVar('小类定位', 'body&&a:not(:matches(首页))') },\\r\\n  分类标题: { value: getMyVar('分类标题', 'a&&Text') },\\r\\n  分类链接: { value: getMyVar('分类链接', 'a&&href') },\\r\\n  一级分类处理: {\\r\\n    value: getMyVar(\\\"一级分类处理\\\", $.toString(() => {\\r\\n      let u = input;\\r\\n      //log(u);\\r\\n      return u;\\r\\n    }))\\r\\n  }\\r\\n}\\r\\n\\r\\nvar opts = [];\\r\\nif (page == 1) {\\r\\n  Object.entries(定义).forEach(function ([key, obj]) {\\r\\n    if (key == \\\"一级分类处理\\\") {\\r\\n      key = \\\"一级处理\\\";\\r\\n    }\\r\\n\\r\\n    opts.push({\\r\\n      title: key,\\r\\n      col_type: 'input',\\r\\n      desc: obj.desc,\\r\\n      url: $.toString((key) => {\\r\\n        if (!input && key != '拼接分类') return 'toast://输入为空';\\r\\n        if (key == \\\"一级处理\\\") {\\r\\n          \\r\\n        }\\r\\n        if (key == \\\"分类颜色\\\") {\\r\\n          let all_cols = [':随机颜色']\\r\\n          all_cols.unshift('当前' + ':' + input)\\r\\n          return $(all_cols, 1, '分类颜色').select(() => {\\r\\n            var r = input.split(':')[1];\\r\\n            putMyVar('分类颜色', r);\\r\\n            refreshPage(false);\\r\\n            return 'hiker://empty'\\r\\n          })\\r\\n        }\\r\\n\\r\\n        putMyVar(key, input);\\r\\n        refreshPage()\\r\\n        return 'toast://' + key + \\\":\\\" + input;\\r\\n      }, key),\\r\\n      extra: {\\r\\n        onChange:$.toString((k)=>{\\r\\n          if(k=='一级处理'){\\r\\n            putMyVar('一级分类处理',input)\\r\\n          }\\r\\n        },key),\\r\\n        cls: MY_RULE.title+'Options',\\r\\n        defaultValue: obj.value,\\r\\n        highlight: key=='一级处理'?true:false,\\r\\n        type: 'textarea',\\r\\n        height: -1,\\r\\n      }\\r\\n    })\\r\\n  });\\r\\n}\\r\\n\\r\\nif (st == \\\"展开\\\") {\\r\\n  d = d.concat(opts);\\r\\n} else {\\r\\n  storage0.putMyVar('clsx', opts);\\r\\n}\\r\\n\\r\\nif (page == 1) {\\r\\n  d.push({\\r\\n    title: '列表规则',\\r\\n    desc: '列表 标题 图片 描述 链接 ;号隔开',\\r\\n    col_type: 'input',\\r\\n    url: $.toString(() => {\\r\\n      if (!input) return 'toast://输入为空';\\r\\n      storage0.putMyVar(\\\"lists\\\", input)\\r\\n      refreshPage(false);\\r\\n      return 'toast://' + input;\\r\\n    }),\\r\\n    extra: {\\r\\n      defaultValue: storage0.getMyVar(\\\"lists\\\", \\\"\\\"),\\r\\n      type: 'textarea',\\r\\n      height: -1,\\r\\n    }\\r\\n  }, {\\r\\n    title: '下一页',\\r\\n    desc: '下一页pd或者pdfh',\\r\\n    col_type: 'input',\\r\\n    url: $.toString(() => {\\r\\n      let all_cols = ['空::', '例1::pd(html,\\\"a:matches(下[一]?页)&&href\\\")', '例2::pd(html,\\\"a:matches(>)&&href\\\")','例3::pd(html,\\\"a[title=下一页]&&href\\\")'];\\r\\n      all_cols.unshift('当前' + '::' + input)\\r\\n      return $(all_cols, 1, '下一页规则').select(() => {\\r\\n        var r = input.split('::')[1];\\r\\n        log(r)\\r\\n        storage0.putMyVar('下一页', r);\\r\\n        refreshPage(false);\\r\\n        return 'hiker://empty'\\r\\n      })\\r\\n    }),\\r\\n    extra: {\\r\\n      defaultValue: storage0.getMyVar(\\\"下一页\\\", \\\"\\\"),\\r\\n      type: 'textarea',\\r\\n      height: -1,\\r\\n    }\\r\\n  })\\r\\n}\\r\\n\\r\\n\\r\\nfor (var propName in 定义) {\\r\\n  eval('var ' + propName + ' = 定义[propName][\\\"value\\\"];');\\r\\n}\\r\\n\\r\\nvar getRangeColors = function () {\\r\\n  return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\r\\n}\\r\\n\\r\\nif (分类颜色 == \\\"随机颜色\\\") {\\r\\n  分类颜色 = getRangeColors();\\r\\n}\\r\\n\\r\\nif (page == 1) {\\r\\n  d.push({\\r\\n    title: '预览',\\r\\n    col_type: 'flex_button',\\r\\n    url: $('#noLoading#').lazyRule(() => {\\r\\n      putMyVar('折叠状态', '折叠');\\r\\n      putMyVar('mode', 'Pre');\\r\\n      clearMyVar('yi_firstpage');\\r\\n      clearMyVar(MY_RULE.url);\\r\\n      clearMyVar(\\\"head.cate\\\");\\r\\n      refreshPage()\\r\\n      return 'toast://预览'\\r\\n    })\\r\\n  }, {\\r\\n    title: '取消',\\r\\n    col_type: 'flex_button',\\r\\n    url: $('#noLoading#').lazyRule(() => {\\r\\n      clearMyVar('mode')\\r\\n      refreshPage()\\r\\n      return 'toast://取消预览'\\r\\n    })\\r\\n  },{\\r\\n    title:'列表',\\r\\n    col_type:'flex_button',\\r\\n    url:$('hiker://empty##').rule(()=>{\\r\\n      addListener(\\\"onClose\\\",\\r\\n       $.toString(() => {\\r\\n         clearMyVar('listi');\\r\\n         //refreshPage();\\r\\n        })\\r\\n      );\\r\\n      \\r\\n      var d=[];\\r\\n      var rlist=[];\\r\\n      d.push({\\r\\n        title:'确认修改并返回',\\r\\n        img:'https://hikerfans.com/tubiao/messy/179.svg',\\r\\n        url:$('#noLoading#').lazyRule(()=>{\\r\\n          back(true);\\r\\n          return 'hiker://empty';\\r\\n        }),\\r\\n        col_type:'avatar',\\r\\n      })\\r\\n      var listrule = storage0.getMyVar(\\\"lists\\\", \\\"\\\");\\r\\n      if (listrule != \\\"\\\" && listrule.includes(\\\";\\\")){\\r\\n        rlist = listrule.split(';');\\r\\n      }\\r\\n      var listurl=getMyVar('listurl','');\\r\\n      var url=getMyVar('url', '');\\r\\n      if(listurl!=''){\\r\\n        url=listurl;\\r\\n      }\\r\\n      MY_URL=url;\\r\\n      d.push({\\r\\n        title:'网址',\\r\\n        col_type:'input',\\r\\n        url:$.toString(()=>{\\r\\n          toast('获取网页中...');\\r\\n          var html=fetch(input);\\r\\n          putMyVar('listurl',input);\\r\\n          putMyVar('listhtml',html);\\r\\n          refreshPage();\\r\\n          return \\\"hiker://empty\\\";\\r\\n        }),\\r\\n        extra:{\\r\\n          defaultValue:url,\\r\\n        }\\r\\n      })\\r\\n      var html=getMyVar('html','');\\r\\n      var listhtml=getMyVar('listhtml','');\\r\\n      if(html==''&&listhtml==''){\\r\\n        html=fetch(url);\\r\\n        toast('获取网页中...');\\r\\n        putMyVar('listhtml',html);\\r\\n      }else if(listhtml!=''){\\r\\n        html=listhtml;\\r\\n      }\\r\\n      \\r\\n      var ts=['列表','标题','图片','描述','链接'];\\r\\n      ts.forEach((item,i)=>{\\r\\n        d.push({\\r\\n          title:item,\\r\\n          col_type:'input',\\r\\n          url:$.toString((ts,rl,i)=>{\\r\\n            rl[i]=input;\\r\\n            storage0.putMyVar(\\\"lists\\\", rl.join(';'));\\r\\n            refreshPage(false);\\r\\n            return 'toast://'+ts[i]+':'+input;\\r\\n          },ts,rlist,i),\\r\\n          extra:{\\r\\n            defaultValue:rlist[i]\\r\\n          }\\r\\n        })\\r\\n      })\\r\\n      \\r\\n      var list = pdfa(html, rlist[0]);\\r\\n      var index=getMyVar('listi','');\\r\\n      \\r\\n      if(index!=''){\\r\\n        var tsobj={\\r\\n         title:pdfh(list[index],rlist[1]),\\r\\n         desc:pdfh(list[index],rlist[3]),\\r\\n         img:pd(list[index],rlist[2])+'@Referer=',\\r\\n         url:pd(list[index],rlist[4]),\\r\\n        }\\r\\n        \\r\\n        d.push({\\r\\n          title:tsobj.title,\\r\\n          desc:tsobj.desc,\\r\\n          img:tsobj.img,\\r\\n          url:tsobj.url,\\r\\n          col_type:'movie_1_vertical_pic',\\r\\n        })\\r\\n        \\r\\n        d.push({\\r\\n          desc:'调试窗口',\\r\\n          col_type:'input',\\r\\n          extra:{\\r\\n            defaultValue:list[index],\\r\\n            titleVisible: false,\\r\\n            type:'textarea',\\r\\n            highlight: true,\\r\\n            height:-1,\\r\\n          }\\r\\n        })\\r\\n      }\\r\\n      \\r\\n      d.push({\\r\\n          title:'““””'+(index==''?'All'.fontcolor('#3CB371'):'All'),\\r\\n          col_type:'flex_button',\\r\\n          url:$('#noLoading#').lazyRule(()=>{\\r\\n            clearMyVar('listi');\\r\\n            refreshPage(false);\\r\\n            setPageTitle('全部');\\r\\n            return 'toast://全部';\\r\\n          })\\r\\n      })\\r\\n      \\r\\n      list.forEach((item,i)=>{\\r\\n        d.push({\\r\\n          title:'““””'+(index!=''&&parseInt(index)==i?(i+'').fontcolor('#3CB371'):i),\\r\\n          col_type:'flex_button',\\r\\n          url:$('#noLoading#').lazyRule((i)=>{\\r\\n            putMyVar('listi',i+'');\\r\\n            refreshPage(false);\\r\\n            setPageTitle('第'+i+'个');\\r\\n            return 'toast://当前调试第'+i+'个';\\r\\n          },i)\\r\\n        })\\r\\n      })\\r\\n      \\r\\n      if(index==''){\\r\\n      for (var i in list) {\\r\\n      var img = pd(list[i], rlist[2]) + \\\"@Referer=\\\";\\r\\n        d.push({\\r\\n         title: pdfh(list[i], rlist[1]),\\r\\n         img: img,\\r\\n         desc: pdfh(list[i], rlist[3]),\\r\\n         url: pd(list[i], rlist[4]),\\r\\n         extra: {\\r\\n           img: img\\r\\n          }\\r\\n         })\\r\\n        }\\r\\n       } \\r\\n      \\r\\n      setResult(d);\\r\\n    }),\\r\\n  }, {\\r\\n    title: '生成',\\r\\n    col_type: 'flex_button',\\r\\n    url: $('#noLoading#').lazyRule(() => {\\r\\n      var 处理 = getMyVar('一级分类处理', '');\\r\\n      处理 = 处理.replace(/[\\\\r\\\\n](\\\\(\\\\))/, '$1').replace(/[\\\\r\\\\n]\\\\)\\\\(\\\\)$/m, \\\")\\\");\\r\\n      var list = \\\"\\\";\\r\\n      var listrule = storage0.getMyVar(\\\"lists\\\", \\\"\\\");\\r\\n      if (listrule != \\\"\\\" && listrule.includes(\\\";\\\")) {\\r\\n        var rlist = listrule.split(';');\\r\\n        var list = `\\r\\nvar list = pdfa(html,\\\"${rlist[0]}\\\");\\r\\nfor (var i in list) {\\r\\n  var img = pd(list[i], \\\"${rlist[2]}\\\") + \\\"@Referer=\\\";\\r\\n  d.push({\\r\\n      title: pdfh(list[i], \\\"${rlist[1]}\\\"),\\r\\n      img: img,\\r\\n      desc: pdfh(list[i], \\\"${rlist[3]}\\\"),\\r\\n      url: pd(list[i], \\\"${rlist[4]}\\\"),\\r\\n      extra: {\\r\\n        img: img\\r\\n      }\\r\\n    })\\r\\n  }`\\r\\n      }\\r\\n      var trueurl = \\\"\\\";\\r\\n      var auto = \\\"\\\";\\r\\n      var next = \\\"\\\";\\r\\n      if (getMyVar(\\\"下一页\\\", \\\"\\\") != \\\"\\\") {\\r\\n        trueurl = `eval(JSON.parse(request('hiker://page/autoPage')).rule); \\r\\nlet true_url = getTruelink(MY_RULE.url, MY_URL,page);`\\r\\n        auto = \\\"autoPage();\\\"\\r\\n        next = `const 下一页='${getMyVar(\\\"下一页\\\", \\\"\\\")}';`\\r\\n      } else {\\r\\n        trueurl = \\\"let true_url = getMyVar(MY_RULE.url, MY_URL);\\\"\\r\\n      }\\r\\n      var color = `${getMyVar('分类颜色', 'red')}`\\r\\n      if (color == \\\"随机颜色\\\") {\\r\\n        color = `getRangeColors()`;\\r\\n      } else {\\r\\n        color = `\\\"${getMyVar('分类颜色', 'red')}\\\"`\\r\\n      }\\r\\n\\r\\n      var str = `js:\\r\\nvar d = [];\\r\\nvar getRangeColors = function() {\\r\\n  return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);\\r\\n}\\r\\nconst page = MY_PAGE;\\r\\nconst 分类颜色 = ${color};\\r\\nconst 大类定位 = \\\"${getMyVar('大类定位', '')}\\\";\\r\\nconst 拼接分类 = \\\"${getMyVar('拼接分类', '')}\\\";\\r\\nconst 小类定位 = \\\"${getMyVar('小类定位', 'body&&a:not(:matches(首页))')}\\\";\\r\\nconst 分类标题 = \\\"${getMyVar('分类标题', 'a&&Text')}\\\";\\r\\nconst 分类链接 = \\\"${getMyVar('分类链接', 'a&&href')}\\\";\\r\\nconst 一级分类处理 = $.toString${处理};\\r\\n${next}\\r\\nMY_URL = MY_URL.replace('hiker://empty##', '');\\r\\n${trueurl}\\r\\nlog(true_url);\\r\\nvar html=fetch(true_url);\\r\\nMY_URL=true_url;\\r\\neval(JSON.parse(request('hiker://page/dtfl')).rule);\\r\\n${list}\\r\\n${auto}\\r\\nsetResult(d);`\\r\\n      var rule = MY_RULE;\\r\\n      const now = new Date();\\r\\n      var time = `${now.getMonth() + 1}-${now.getDate()}`;\\r\\n      rule.title = '测试' + time;\\r\\n      rule.url = 'hiker://empty##' + getMyVar('url', '');\\r\\n      log(rule.url)\\r\\n      rule.find_rule = str;\\r\\n      return \\\"rule://\\\" + base64Encode(\\\"海阔视界￥home_rule￥\\\" + JSON.stringify(rule));\\r\\n    }),\\r\\n  }, {\\r\\n    title: '删除',\\r\\n    col_type: 'flex_button',\\r\\n    url: $('#noLoading#').lazyRule(() => {\\r\\n      let all_cols = listMyVarKeys();\\r\\n      let tips = '请选择删除临时变量 ';\\r\\n      return $(all_cols, 2, tips).select(() => {\\r\\n        clearMyVar(input);\\r\\n        refreshPage(true);\\r\\n        return 'toast://已删除临时变量:' + input;\\r\\n      });\\r\\n    }),\\r\\n  })\\r\\n}\\r\\n\\r\\nvar mode = getMyVar(\\\"mode\\\", \\\"\\\");\\r\\neval(JSON.parse(request('hiker://page/autoPage')).rule);\\r\\n\\r\\nlet 下一页 = \\\"\\\";\\r\\nif (getMyVar(\\\"下一页\\\", \\\"\\\") != \\\"\\\") {\\r\\n  下一页 = getMyVar(\\\"下一页\\\", \\\"\\\")\\r\\n}\\r\\nvar 动态返回=false;\\r\\n//var 开启折叠=false;\\r\\n\\r\\nlet true_url = '';\\r\\nif (mode == 'Pre') {\\r\\n  if (下一页 != \\\"\\\") {\\r\\n    true_url = getTruelink(MY_RULE.url, url, page);\\r\\n  } else {\\r\\n    true_url = getMyVar(MY_RULE.url, url);\\r\\n  }\\r\\n  log('true_url:'+true_url);\\r\\n  MY_URL = true_url;\\r\\n  html = fetch(true_url);\\r\\n} else {\\r\\n  MY_URL = url;\\r\\n}\\r\\nlog('MY_URL: ' + MY_URL);\\r\\ntry {\\r\\n  if (大类定位 == '') {\\r\\n    toast('当前大类定位为空将不会执行')\\r\\n  } else {\\r\\n    eval(fetch('file:///storage/emulated/0/Download/web/dt.js'))\\r\\n  }\\r\\n} catch (e) {\\r\\n  toast(e.message)\\r\\n}\\r\\n\\r\\nvar listrule = storage0.getMyVar(\\\"lists\\\", \\\"\\\");\\r\\n\\r\\nif (listrule != \\\"\\\" && listrule.includes(\\\";\\\")) {\\r\\n  var rlist = listrule.split(';');\\r\\n  var list = pdfa(html, rlist[0]);\\r\\n  for (var i in list) {\\r\\n    var img = pd(list[i], rlist[2]) + \\\"@Referer=\\\";\\r\\n    d.push({\\r\\n      title: pdfh(list[i], rlist[1]),\\r\\n      img: img,\\r\\n      desc: pdfh(list[i], rlist[3]),\\r\\n      url: pd(list[i], rlist[4]),\\r\\n      extra: {\\r\\n        img: img\\r\\n      }\\r\\n    })\\r\\n  }\\r\\n}\\r\\nif (下一页 != \\\"undefined\\\"&&下一页!='') {\\r\\n  autoPage();\\r\\n}\\r\\n\\r\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"￥一级动态分类主页\",\"path\":\"dtzy\",\"rule\":\"js:$.require(\\\"hiker://page/yjdt\\\")\"},{\"col_type\":\"movie_3\",\"name\":\"￥动态分类改\",\"path\":\"dtfl\",\"rule\":\"js:\\n/*\\nVer 2023-10-28 1.0\\n备注：不要用海阔代码格式化 内容会出错\\n必须参数：\\n分类颜色 大类定位 \\n小类定位 分类标题 分类链接\\nhtml =>源码 page =>页码\\n可选参数：\\n拼接分类 折叠标记 展开标记 排除\\n大类链接 大类标题 清除键 开启折叠\\n附加定位\\n说明：\\n外面用getMyVar(MY_RULE.url) 或者 状态 取链接\\n魔改:α\\n*/\\n\\nlet empty = \\\"hiker://empty\\\";\\nlet categories = [];\\nif (typeof (拼接分类) != 'undefined' && 拼接分类 != '') {\\n    categories = [pdfa(html, 大类定位).join('\\\\n')];\\n    if (拼接分类.includes(';')) {\\n        拼接分类 = 拼接分类.split(';');\\n    }\\n    if (拼接分类.constructor == Array) {\\n        拼接分类.forEach(item => {\\n            categories = categories.concat(pdfa(html, item));\\n        })\\n    } else {\\n        categories = [pdfa(html, 大类定位).join('\\\\n')].concat(pdfa(html, 拼接分类));\\n    }\\n    if (typeof (附加定位) != 'undefined' && 附加定位.length > 0) {\\n        附加定位.forEach(x => {\\n            var 一级 = pdfa(html, x.一级定位).map(s => {\\n                var 定位 = pdfa(s, x.小类).map(q => {\\n                    var title = pdfh(q, x.标题);\\n                    var url = 'a'\\n                    if (x.链接.includes('@@')) {\\n                        state = x.链接.split('@@')[0]\\n                        value = pdfh(q, x.链接.split('@@')[1]);\\n                        if (x.转换 == true) {\\n                            return `<li data-type=\\\"${state}\\\" data-val=\\\"${value}\\\"><a href=\\\"\\\">${title}</a></li>`\\n                        } else {\\n                            return `<a type=\\\"@extra\\\" state=\\\"${state}\\\" value=\\\"${value}\\\">${title}</a>`;\\n                        }\\n                    } else {\\n                        href = pd(q, x.链接);\\n                        return `<a href=\\\"${href}\\\">${title}</a>`;\\n                    }\\n                });\\n                return 定位;\\n            });\\n            categories.push(一级.join('\\\\n'));\\n        });\\n    }\\n} else {\\n    categories = [pdfa(html, 大类定位).join('\\\\n')];\\n}\\n\\nlet items = [];\\nlet cates = [];\\nlet init_cate = new Array(20).fill(\\\"0\\\");\\nconst fold = getMyVar(MY_RULE.group, \\\"0\\\");\\nconst cate_temp = JSON.parse(getMyVar(\\\"head.cate\\\", JSON.stringify(init_cate)));\\nvar 折叠状态 = (typeof (开启折叠) != 'undefined') ? 开启折叠 : true;\\nvar 折叠 = (typeof (折叠标记) != 'undefined' && 折叠标记 != '') ? 折叠标记 : '““””' + '∨'.fontcolor(\\\"#FF0000\\\");\\nvar 展开 = (typeof (展开标记) != 'undefined' && 展开标记 != '') ? 展开标记 : '““””' + '∧'.fontcolor(\\\"#1aad19\\\");\\nvar 清除 = (typeof (清除键) != 'undefined' && 清除键 != '') ? 清除键 : [];\\nvar 状态 = (typeof (状态标记) != 'undefined' && 状态标记 != '') ? 状态标记 : MY_RULE.url;\\nvar 大类处理 = typeof (一级分类处理) != 'undefined' ? true : false;\\n\\nvar _动态返回=true;\\nif(typeof 动态返回!='undefined'&&typeof 动态返回 === \\\"boolean\\\"){\\n    _动态返回=动态返回;\\n}\\n\\nvar 搜索 = typeof (开启搜索) != 'undefined' ? 开启搜索 : false;\\nvar 全清 = (typeof (全清键) != 'undefined' && 全清键 != '') ? 全清键 : [];\\n全清.unshift('yi_firstpage');\\n\\n\\nif (parseInt(page) === 1) {\\n    if (搜索) {\\n        d.push({\\n            title: \\\"\\\",\\n            url: \\\"'hiker://search?rule=\\\" + MY_RULE.title + \\\"&s='+input\\\",\\n            desc: \\\"搜索关键词\\\",\\n            col_type: \\\"input\\\",\\n            extra: {\\n                defaultValue: getMyVar('keyword', ''),\\n                onChange: $.toString(() => {\\n                    putMyVar('keyword', input);\\n                })\\n            }\\n        })\\n    }\\n    if (page == 1 ) {\\n    if (折叠状态) {\\n          items.push({\\n                title: fold === '1' ? 折叠 : 展开,\\n                url: $(\\\"#noLoading#\\\").lazyRule((title, fold, u, all, exps) => {\\n                    var fold = getMyVar(MY_RULE.group, fold);\\n                    if(getMyVar('cate_empty','empty')=='empty'){\\n                      return 'toast://拼接部分为空';\\n                    }\\n                    \\n                    var [展开, 折叠] = exps;\\n                    if (fold == 1) {\\n                        var cx = findItemsByCls(title + 'cate_button');\\n                        storage0.putMyVar('cate_button', cx);\\n                        deleteItemByCls(title + 'cate_button');\\n                    } else {\\n                        var cx = storage0.getMyVar('cate_button', []).map(x => {\\n                            x['col_type'] = x['col_type'] ? x['col_type'] : x['type'];\\n                            return x;\\n                        });\\n                        addItemAfter(title + 'cate_line', cx)\\n                    }\\n                    /*all.forEach((item) => {\\n                      clearMyVar(item);\\n                    });*/\\n                    updateItem(title + 'cate_exp', {\\n                        title: fold == 1 ? 展开 : 折叠,\\n                    })\\n                    putMyVar(MY_RULE.group, fold === \\\"1\\\" ? \\\"0\\\" : \\\"1\\\");\\n                    return \\\"hiker://empty\\\";\\n                }, MY_RULE.title, fold, 状态, 全清, [展开, 折叠]),\\n                col_type: 'scroll_button',\\n                extra: {\\n                    id: MY_RULE.title + 'cate_exp',\\n                    longClick: [{\\n                        title: '清除状态',\\n                        js: $.toString((x, all, cl) => {\\n                            clearMyVar(x);\\n                            clearMyVar('head.cate');\\n                            all.forEach((item) => {\\n                                clearMyVar(item)\\n                            })\\n                            cl.forEach((item) => {\\n                                clearMyVar(item)\\n                            })\\n                            refreshPage();\\n                        }, 状态, 全清, 清除)\\n                    }]\\n                }\\n            })\\n    }else{\\n       var bo=JSON.parse(getMyVar('head.cate','[]')).every(x=>x===\\\"0\\\");\\n       if(!bo){\\n       items.push({\\n         title:'““””'+'♻'.fontcolor('#3CB371'),\\n         col_type:'scroll_button',\\n         url:$('#noLoading#').lazyRule((x, all, cl)=>{\\n           clearMyVar(x);\\n           clearMyVar('head.cate');\\n           all.forEach((item) => {\\n             clearMyVar(item)\\n          })\\n            cl.forEach((item) => {\\n             clearMyVar(item)\\n           })\\n           refreshPage(false);\\n           return 'hiker://empty';\\n         }, 状态, 全清, 清除),\\n       })\\n      }}\\n    }\\n    let setTitle = (k, i, t) => {\\n        return k == i ? \\\"““””\\\" + t.fontcolor(分类颜色) : t\\n    }\\n    categories.forEach((category, index) => {\\n        let sub_categories = [];\\n        if (小类定位.includes(';')) {\\n            sub_categories = pdfa(category, 小类定位.split(';')[0]);\\n            if (sub_categories.length == 0) {\\n                sub_categories = pdfa(category, 小类定位.split(';')[1]);\\n            }\\n        } else {\\n            sub_categories = pdfa(category, 小类定位);\\n        }\\n        if (index === 0) {\\n            sub_categories.forEach((item, key) => {\\n                let _大类链接 = (typeof (大类链接) != 'undefined' && 大类链接 != '') ? 大类链接 : 分类链接;\\n\\n                let _大类标题 = (typeof (大类标题) != 'undefined' && 大类标题 != '') ? 大类标题 : 分类标题;\\n\\n                let title = pdfh(item, _大类标题);\\n                if (typeof (排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n                }\\n                let params = {\\n                    cate_temp: cate_temp, key: key, page: page, clears: 清除, state: 状态, allclears: 全清\\n                }\\n\\n                let url = pd(item, _大类链接);\\n                if (大类处理) {\\n                    //log(一级分类处理)\\n                    //log($.stringify(一级分类处理))\\n                    let input = url;\\n                    eval(\\\"result = \\\" + 一级分类处理);\\n                    //log(result)\\n                    url = result;\\n                }\\n                items.push({\\n                    title: setTitle(key.toString(), cate_temp[index], title),\\n                    col_type: 'scroll_button',\\n                    url: $(url + '#noLoading#').lazyRule((params) => {\\n                        let new_cate = [];\\n                        params.clears.forEach((item) => {\\n                            clearMyVar(item)\\n                        })\\n                        params.allclears.forEach((item) => {\\n                            clearMyVar(item)\\n                        })\\n\\n                        params.cate_temp.forEach((cate, index) => {\\n                            new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\")\\n                        })\\n                        putMyVar(\\\"head.cate\\\", JSON.stringify(new_cate));\\n                        putMyVar(params.state, input);\\n                        refreshPage(true);\\n                        return \\\"hiker://empty\\\";\\n                    }, params)\\n                });\\n            });\\n            items.push({\\n                col_type: \\\"blank_block\\\",\\n                extra: {\\n                    id: MY_RULE.title + 'cate_line',\\n                }\\n            })\\n        } else {\\n            sub_categories.forEach((item, key) => {\\n                var extrapos = false;\\n                if (item.includes('type=\\\"@extra\\\"')) {\\n                    extrapos = true;\\n                    //log('附加定位')\\n                }\\n\\n                if (extrapos) {\\n                    var title = pdfh(item, 'a&&Text');\\n                    if (typeof (排除) != 'undefined' && 排除 != '') {\\n                        title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n                    }\\n                    var json = {\\n                        type: pdfh(item, 'a&&state'),\\n                        value: pdfh(item, 'a&&value'),\\n                    }\\n                } else {\\n\\n                    var title = pdfh(item, 分类标题);\\n                    if (typeof (排除) != 'undefined' && 排除 != '') {\\n                        title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n                    }\\n\\n                    var json = '';\\n                    switch (true) {\\n                        case 分类链接.includes('@@@'):\\n                            json = {\\n                                type: pdfh(item, 分类链接.split('@@@')[0]),\\n                                value: pdfh(item, 分类链接.split('@@@')[1]),\\n                            }\\n                            break;\\n                        case 分类链接.includes('@@'):\\n                            json = {\\n                                type: 分类链接.split('@@')[0],\\n                                value: pdfh(item, 分类链接.split('@@')[1]),\\n                            }\\n                            break;\\n                        default:\\n                            json = pd(item, 分类链接);\\n                            break;\\n                    }\\n                    /*var json=分类链接.includes('@@@')?{\\n                         type:pdfh(item,分类链接.split('@@@')[0]),\\n                         value:pdfh(item,分类链接.split('@@@')[1]),\\n                     }:pd(item,分类链接);\\n                     \\n                     json=分类链接.includes('@@')?{\\n                         type:分类链接.split('@@')[0],\\n                         value:pdfh(item,分类链接.split('@@')[1]),\\n                     }:pd(item,分类链接);*/\\n\\n                }\\n\\n                let params = {\\n                    cate_temp: cate_temp, index: index, key: key, page: page, json: json, state: 状态, allclears: 全清\\n                }\\n                cates.push({\\n                    title: setTitle(key.toString(), cate_temp[index], title),\\n                    url: $('hiker://empty' + '#noLoading#').lazyRule((params) => {\\n                        params.allclears.forEach((item) => {\\n                            clearMyVar(item)\\n                        })\\n                        params.cate_temp[params.index] = params.key.toString();\\n                        putMyVar(\\\"head.cate\\\", JSON.stringify(params.cate_temp));\\n                        if (params.json.constructor === Object) {\\n                            putMyVar('dt_' + params.json.type, params.json.value);\\n                        } else {\\n                            putMyVar(params.state, params.json);\\n                        }\\n                        refreshPage(true);\\n                        return \\\"hiker://empty\\\";\\n                    }, params),\\n                    col_type: 'scroll_button',\\n                    extra: {\\n                        cls: MY_RULE.title + 'cate_button',\\n                    }\\n                });\\n            });\\n            cates.push({\\n                col_type: \\\"blank_block\\\",\\n                extra: {\\n                    cls: MY_RULE.title + 'cate_button',\\n                }\\n            });\\n        }\\n    })\\n}\\n\\n\\nif (fold === \\\"1\\\" || 折叠状态 == false) {\\n    items = items.concat(cates);\\n}\\nif (fold === \\\"0\\\") {\\n    storage0.putMyVar('cate_button', cates)\\n}\\nif(cates.length==0){\\n     putMyVar('cate_empty','empty');\\n}else{\\n     putMyVar('cate_empty','noempty');\\n}\\n\\nif (typeof setPreResult != 'undefined'&&_动态返回) {\\n    items = d.concat(items);\\n    //清空继承数组\\n    d.length = 0;\\n    setPreResult(items);\\n} else {\\n    items.forEach(item => {\\n        d.push(item);\\n    })\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"￥自动下一页\",\"path\":\"autoPage\",\"rule\":\"js:\\nvar 状态 =\\r\\ntypeof 状态标记 != \\\"undefined\\\" && 状态标记 != \\\"\\\" ? 状态标记: MY_RULE.url;\\n\\nfunction getTruelink(mark, url, page) {\\r\\n  var p = getMyVar(mark, url).replace(\\\"fypage\\\", page);\\r\\n  if (page == 1) {\\r\\n    return getMyVar(\\\"yi_firstpage\\\", p);\\r\\n  } else if (p != \\\"\\\") {\\r\\n    return p;\\r\\n  } else {\\r\\n    return url;\\r\\n  }\\r\\n}\\n\\nfunction autoPage() {\\r\\n  if (page == 1) {\\r\\n    putMyVar(\\\"yi_firstpage\\\", true_url);\\r\\n  }\\r\\n  try {\\r\\n    var next = eval(下一页);\\r\\n    //log(\\\"next\\\");\\r\\n    //log('next:'+next);\\r\\n  } catch {\\r\\n    log(\\\"可能不存在下一页或者下一页定位有问题\\\");\\r\\n    next = \\\"\\\";\\r\\n  }\\r\\n  if (next != \\\"\\\") {\\r\\n    putMyVar(状态, next);\\r\\n  }\\r\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"#公告\",\"path\":\"notice\",\"rule\":\"js:\\nlet getHtml = (text, color) => `\\n<!DOCTYPE html>\\n<html>\\n<head>\\n<meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0\\\">\\n<style>\\n.marquee {\\n  width: 100%;\\n  text-overflow: ellipsis;\\n  overflow: hidden;\\n  color: ${color};\\n  font-size: 16px;\\n  white-space: nowrap;\\n}\\n\\n.marquee span {\\n  user-select:none;\\n  display: inline-block;  \\n  padding-left: 100%;\\n  animation: marquee 25s linear infinite;\\n}\\n\\n@keyframes marquee {\\n  0% { transform: translateX(0%); }\\n  100% { transform: translateX(-100%); }\\n}\\n\\n@media (prefers-color-scheme: dark) {\\n    body {\\n    background-color: #1B1B1B;\\n     }\\n     .text,.scroll{\\n       color:#Fff;\\n       }\\n    }\\n\\n@media (prefers-color-scheme: light) {\\n    body {\\n    background-color: transparent;\\n      }\\n    }\\n\\n</style>\\n</head>\\n<body>\\n<div class=\\\"marquee\\\">\\n  <span id=\\\"textContainer\\\">${text}</span>\\n</div>\\n</body>\\n</html>`;\\n\\n$.exports.show = function(arr, text, color, url, content) {\\n    var html = getHtml(text || '这是跑马灯默认的文字，可以自行替换。', color || 'red');\\n    arr.push({\\n        col_type: \\\"x5_webview_single\\\",\\n        url: \\\"about:blank\\\",\\n        desc: \\\"50&&list\\\",\\n        extra: {\\n            js: $.toString((h, url) => {\\n                var html = document.documentElement;\\n                html.innerHTML = h;\\n\\n                const textContainer = document.getElementById('textContainer');\\n                const text = textContainer.innerHTML;\\n                textContainer.onclick=function(){\\n                    window.location.href = url||\\\"about:blank/notice\\\";\\n                }\\n                // 设置文本容器宽度为文本内容的宽度\\n                textContainer.style.width = `${textContainer.offsetWidth}px`;\\n\\n                // 复制文本内容并追加到文本容器后面\\n                textContainer.innerHTML += ' ' + text;\\n\\n                // 动态计算动画持续时间\\n                const duration = (textContainer.offsetWidth / textContainer.parentElement.offsetWidth) * 10;\\n\\n                var styleElements = document.head.getElementsByTagName('style');\\n\\n\\n                styleElements[2].innerHTML = `.marquee span {\\n                    display: inline-block;\\n                    padding-left: 100%;\\n                    animation: marquee ${duration}s linear infinite\\n                }`;\\n\\n            }, html, url),\\n            urlInterceptor: $.toString((content) => {\\n                if (input===\\\"about:blank/notice\\\") {\\n                    return $.toString((content) => {\\n                        fba.open(JSON.stringify({\\n                            title: \\\"公告\\\",\\n                            url: 'hiker://empty#noRecordHistory##noHistory#',\\n                            findRule: \\\"js:\\\" + $$$.toString((content) => setResult([{\\n                                title: content,\\n                                col_type: \\\"rich_text\\\",\\n                            }]),content)\\n                        }));\\n                    }, content);\\n                }\\n            }, content || text),\\n        }\\n    });\\n}\"}]","icon":"hiker://images/rule_type_tool","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!