Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@聚直播.改@{"last_chapter_rule":"","title":"聚直播.改","author":"小棉袄🌞&Joker","url":"hiker://empty","version":20240320,"col_type":"avatar","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\neval(JSON.parse(request(\"hiker://page/config\")).rule); //getConfig\n\nlet data = [],\n    config = getConfig();\nconfig.data = config.data.filter(v => !v.inVisible);\nif (config.data.length <= 0) {\n    data = $.require('hiker://page/renderSetting').renderSetting();\n} else {\n    let select = getItem(\"live-select\", config.data[0].name),\n        has = config.data.map(i => i.name).includes(select);\n    if (!has) {\n        select = config.data[0].name;\n    }\n\n    data.push({\n       // title: '聚直播.改'.bold() + ' &nbsp &nbsp ' + '⚙ 设置 ⚙'.small(),\n        title: '订阅：⚙ 设置 ⚙',\n        col_type: \"icon_2_round\",\n        pic_url: \"https://hikerfans.com/tubiao/system/23.png\",//MY_RULE.icon,\n        url: $(\"hiker://empty#noLoading#\").rule(() => {\n            addListener('onClose', 'refreshPage()')\n            setResult($.require('hiker://page/renderSetting').renderSetting())\n        })\n    })\n\nlet openMode = getItem(\"openMode\",\"海阔视界\");\n        if (openMode === \"海阔视界\") {\n            var icon = \"https://img.vinua.cn/images/ONBkk.png\";\n        } else if (openMode === \"幻影下载\") {\n            var icon = \"https://img.vinua.cn/images/zNeV0.png\";\n        }else if (openMode === \"二驴下载\") {\n            var icon = \"https://img.vinua.cn/images/zNujv.png\";\n        } else if (openMode === \"小白下载\") {\n            var icon = \"https://img.vinua.cn/images/zNGP7.png\";\n        }else if (openMode === \"迅雷下载\") {            \n            var icon = \"https://img.vinua.cn/images/XKHOV.png\";\n        } else if (openMode === \"PIKPAK\") {            \n            var icon = \"https://img.123798.xyz/file/e0486509845b8c533ae07.png\";\n        } else if (openMode === \"悟空下载\") {\n            var icon = \"https://img.vinua.cn/images/zNiww.png\";\n        } else {\n            var icon = \"https://hikerfans.com/tubiao/ke/69.png\";\n        }\n    data.push({\n        title: \"模式：\" + openMode,\n        url: \"select://\" + JSON.stringify({\n            title: \"磁力下载设置\",\n            options: [\"模式：海阔视界\", \"模式：迅雷下载\",\"模式：PIKPAK\",\"模式：幻影下载\",\"模式：二驴下载\", \"模式：小白下载\",\"模式：悟空下载\", \"模式：其他下载\"],\n            col: 2,\n            js: $.toString(() => {\n                input = input.replace(\"模式：\", \"\");\n                setItem(\"openMode\", input);\n                refreshPage();\n                if (input == \"迅雷下载\") {\n                    return \"toast://\\t\\t\\t\\t\\t\\t\\t\\t\\t修改成功\\n请确保有安装【迅雷下载】\";\n                }\n                if (input == \"PIKPAK\") {\n                    return \"toast://\\t\\t\\t\\t\\t\\t\\t\\t\\t修改成功\\n请确保有安装【PIKPAK】\";\n                }\n                if (input == \"二驴下载\") {\n                    return \"toast://\\t\\t\\t\\t\\t\\t\\t\\t\\t修改成功\\n请确保有安装【二驴下载】\";\n                }\n                if (input == \"幻影下载\") {\n                    return \"toast://\\t\\t\\t\\t\\t\\t\\t\\t\\t修改成功\\n请确保有安装【幻影下载】\";\n                }\n                if (input == \"小白下载\") {\n                    return \"toast://\\t\\t\\t\\t\\t\\t\\t\\t\\t修改成功\\n请确保有安装【小白下载】\";\n                }\n                if (input == \"悟空下载\") {\n                    return \"toast://\\t\\t\\t\\t\\t\\t\\t\\t\\t修改成功\\n请确保有安装【悟空下载】\";\n                }\n                if (input == \"其他下载\") {\n                    return \"toast://长按选择【下载资源】\";\n                }\n            })\n        }),\n        col_type: \"icon_2_round\",\n        desc: \"\",\n        pic_url: icon\n    });\n\n    data.push({\n        title: '🔎',\n        desc: '请输入搜索关键词',\n        extra: {\n            defaultValue: getVar('search_key', ''),\n            onChange: 'putVar(\"search_key\",input)'\n        },\n        col_type: 'input',\n        url: $.toString(() => {\n            return 'hiker://search?rule=' + getMyVar('title') + '&s=' + getVar('search_key', '')\n        })\n    })\n\n\n\n    for (source of config.data) {\n        data.push({\n            title: source.name == select ? \"““””<span style='color: #19B89D'>\" + select + \"</span>\" : source.name,\n            col_type: \"scroll_button\",\n            url: $('#noLoading#').lazyRule((a) => {\n                setItem(\"live-select\", a);\n                setItem('selectGroup', '');\n                refreshPage();\n                return \"hiker://empty\"\n            }, source.name)\n        })\n    }\n\n    data.push({\n        col_type: 'blank_block'\n    })\n\n    for (source of config.data) {\n        if (source.name == select) {\nvar col;\n            try {\n                let items = $.require('hiker://page/renderData').renderLiveData(source.url,source.ua);\n                let groups = Object.keys(items);\n                //groups.push(groups.splice(groups.indexOf(0), 1)[0]);\n\n                let selectGroup = getItem('selectGroup', groups[0]);\n                if (selectGroup == \"\" || !groups.includes(selectGroup)) selectGroup = groups[0];\n\n    if(selectGroup==\"📺短視頻\") {\n            col=\"movie_3\"\n        }else if(selectGroup==\"📺珍藏品\"){\n            col=\"pic_2_card\"\n        }else {\n            col = getItem( select, 'movie_2')\n         }\n                groups.forEach((group) => {\n                    if (group) {\n                        data.push({\n                            title: group == selectGroup ? \"““””<span style='color: #19B89D'>\" + group + \"</span>\" : group,\n                            url: $('#noLoading#').lazyRule((group) => {\n                                setItem('selectGroup', group);\n                                refreshPage();\n                                return 'hiker://empty'\n                            }, group),\n                            col_type: 'scroll_button',\n                            extra: {\n                                lineVisible: false\n                            }\n                        })\n                    }\n                })\n                \n                for (let title in items[selectGroup]) {\n                            let surls = items[selectGroup][title].url;                           \n                ssurls = surls.filter(function(item) {\n                    return !/^ed2k|^magnet|^thunder|^ftp|^hiker|\\.torrent$/.test(item)\n                     });\nif(ssurls.length>0){\n                    data.push({\n                        title: title,\n                        img: items[selectGroup][title].img,\n                        url: $().lazyRule((sourceurl,selectGroup,title) => {\n                            let items = $.require('hiker://page/renderData').renderLiveData(sourceurl);\n                            let surls = items[selectGroup][title].url;\n                            let sheaders = items[selectGroup][title].headers;\n                surls = surls.filter(function(item) {\n                    return !/^ed2k|^magnet|^thunder|^ftp|^hiker|\\.torrent$/.test(item)\n                     });\n                            surls = Array.from(new Set(surls));\n                            sheaders = Array.from(new Set(sheaders));\n                            return JSON.stringify({\n                                urls: surls,\n                                headers: sheaders\n                            })\n                        },source.url,selectGroup,title),\n                        col_type: col,\n                    })\n}\n\n              smurls = surls.filter(function(item) {\n                    return /^ed2k|^magnet|^thunder|^ftp|\\.torrent$/.test(item)\n                     });\nif(smurls.length>0){\n\n         for(var i=0;i<smurls.length;i++){\n\n        if (openMode === \"海阔视界\") {\n            var ciliUrl = smurls[i];\n        }else if (openMode === \"迅雷下载\") {\n           var ciliUrl = smurls[i] + $().lazyRule(()=>{\nopenAppIntent('com.xunlei.downloadprovider', 'com.xunlei.downloadprovider.launch.LaunchActivity2', {intentData: input})\n          return 'toast://【迅雷下载】'\n})\n        } else if (openMode === \"PIKPAK\") {\n           var ciliUrl = \"pikpakapp://mypikpak.com/xpan/main_tab?tab=1&add_url=\" + smurls[i]\n        } else if (openMode === \"幻影下载\") {\n           var ciliUrl = smurls[i] + $().lazyRule(()=>{\n openAppIntent('com.xingsu.downloader', 'com.e4a.runtime.android.mainActivity', {intentData: input})\n          return 'toast://【幻影下载】'\n})\n        }else if (openMode === \"二驴下载\") {\n           var ciliUrl = smurls[i] + $().lazyRule(()=>{\n          openAppIntent('com.qikcloud.qik', 'com.e4a.runtime.android.mainActivity', {intentData: input})\n          return 'toast://【二驴下载】'\n})\n        }else if (openMode === \"小白下载\") {\n           var ciliUrl = smurls[i] + $().lazyRule(()=>{\n          openAppIntent('xb.download.com', 'io.dcloud.PandoraEntry', {intentData: input})\n          return 'toast://【小白下载】'\n})\n        }else if (openMode === \"悟空下载\") {\n           var ciliUrl = smurls[i] + $().lazyRule(()=>{\nopenAppIntent('com.yfoo.wkDownloader', 'com.yfoo.wkDownloader.MainActivity', {intentData: input})\n          return 'toast://【悟空下载】'\n})\n        } else {var ciliUrl = smurls[i];}\n               data.push({\n                        title: '🧲' + title,\n                        pic_url: items[selectGroup][title].img,\n                        url: ciliUrl,\n                        col_type: col,\n                    })\n                 }\n                }     \n\n              shurls = surls.filter(function(item) {\n                    return item.includes('hiker:')\n                     });\nif(shurls.length>0){\n\n         for(var i=0;i<shurls.length;i++){\n               data.push({\n                        title: title.includes('#')? '🌺““””' + title.split('#')[0].fontcolor('#E12653') : '🌺““””' + title.fontcolor('#E12653'),\n                        desc: !title.includes('#') ? '' : '🎒““””' + title.split('#')[1].fontcolor('#F3221D'),\n                        pic_url: items[selectGroup][title].img,\n                        url: shurls[i].replace('javdb','javdb525'),\n                        col_type: 'movie_1_vertical_pic',\n                    })\n                 }\n                }     \n      }     \n            } catch (e) {\n                data.push({\n                    title: \"数据加载失败\\n\" + JSON.stringify(e),\n                    col_type: \"long_text\"\n                })\n            }\n            break;\n        }\n    }\n\n\n}\nsetResult(data);","search_url":"hiker://empty?key=**","group":"🌈直播","searchFind":"js:\neval(JSON.parse(request(\"hiker://page/config\")).rule);\nlet config = getConfig();\nlet rules = config.data.map((source) => {\n    return {\n        title: source.name,\n        search_url: 'hiker://empty?key=**',\n        searchFind: 'js:' + $.toString((url, rule_title) => {\n            let d = [],\n                key = getParam('key');\n            let items = $.require('hiker://page/renderData?rule=' + rule_title).renderLiveData(url);\n            for (let group in items) {\n                for (let title in items[group]) {\n                    if (title.indexOf(key) >= 0 || title.toLowerCase().indexOf(key) >= 0) {\n                        d.push({\n                            title: title,\n                            img: items[group][title].img,\n                            url: JSON.stringify({\n                                urls: items[group][title].url,\n                                headers: items[group][title].headers\n                            })\n                        })\n                    }\n                }\n            }\n            setResult(d);\n        }, source.url, getMyVar('title'))\n    };\n})\nsetResult([{\n    title: \"点我开始聚搜\",\n    url: \"hiker://search?s=\" + getParam(\"key\"),\n    extra: {\n        rules: $.toString((rules) => {\n            return JSON.stringify(rules)\n        }, rules)\n    }\n}])","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"putMyVar('title',MY_RULE.title);","pages":"[{\"col_type\":\"movie_3\",\"name\":\"加载数据\",\"path\":\"config\",\"rule\":\"function getConfig() {\\n    try {\\n        let config = fetch(\\\"hiker://files/rules/apollo/config.json\\\");\\n        if (!config || config == \\\"\\\") {\\n            return {\\n                data: [],\\n                version: 0\\n            }\\n        } else {\\n            return JSON.parse(config)\\n        }\\n    } catch (e) {\\n        try {\\n            toast(\\\"配置文件格式有误\\\")\\n        } catch (e) {}\\n        return {\\n            data: [],\\n            version: 0\\n        }\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"批量导入\",\"path\":\"batchIm\",\"rule\":\"function batchImport(input, rule) {\\n    input = input.trim();\\n    if (input.length < 3 || input[0] != \\\"{\\\") {\\n        return \\\"toast://请输入正确的格式\\\"\\n    }\\n    let im = JSON.parse(input);\\n    if (im.data == null || im.data.length < 1) {\\n        return \\\"toast://请输入正确的格式\\\"\\n    }\\n    eval(JSON.parse(request(\\\"hiker://page/config?rule=\\\" + rule)).rule);\\n    let config = getConfig();\\n    let count = 0;\\n    let all = config.data.map(it => it.url + \\\"&&&\\\").join();\\n    for (let i of im.data) {\\n        if (all.indexOf(i.url + \\\"&&&\\\") >= 0) {\\n            //重复的不要\\n            continue;\\n        }\\n        count++;\\n        config.data.push(i)\\n    }\\n    writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n    refreshPage();\\n    return \\\"toast://已导入\\\" + count + \\\"条订阅源\\\";\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"直播数据\",\"path\":\"renderData\",\"rule\":\"function renderLiveData(url,ua) {\\n    let m3u = \\\"\\\";\\n    if (url.startsWith('hiker://') || url.startsWith('file://')) {\\n        m3u = fetch(url);\\n    } else {\\n        let interval = Number(getItem('interval', '24')),\\n            oldData = fetch('hiker://files/libs/' + md5(url) + '.js'),\\n            remoteData = '';\\n        try {\\n            remoteData = fetchCache(url, interval, {\\n                headers:{\\n                    'User-Agent' : ua || MOBILE_UA\\n                },\\n                timeout: 50000\\n            });\\n        } catch (e) {}\\n        if (!remoteData.includes('http') || remoteData.includes('<body>')) { \\n            log('更新失败');\\n            if (oldData) writeFile('hiker://files/libs/' + md5(url) + '.js', oldData);\\n            m3u = oldData;\\n        } else {\\n            m3u = remoteData;\\n        }\\n    }\\n\\n    let mode =  m3u.indexOf('#EXTM3U') == 0 , re;\\n    if(mode){\\n        re = /(.*),(.*)\\\\s*?((?:http|rtmp)[^#\\\\s]*)/g;\\n    }else{\\n        re = /()(?:\\\\B\\\\$c_start|\\\\B#{1,2})?(.*?),?(##|头#|\\\\$c_end|,?#genre#|(?:http|rtmp|magnet|hiker|ed2k|ftp|thunder)[^\\\\s]*)/g;\\n    }\\n        \\n    let items = {},\\n        group = '未分组';\\n    for (let i = re.exec(m3u); i != null; i = re.exec(m3u)) {\\n        if (mode) {\\n            group = (i[1].match(/group-title=\\\"(.*?)\\\"/) || [null, group])[1];\\n            img = (i[1].match(/tvg-logo=\\\"(.*?)\\\"/) || [null, group])[1];\\n        } else if (['#genre#','##','头#','$c_end'].includes(i[3])) {\\n            group = i[2];\\n            continue;\\n        }\\n        let title = i[2],\\n            url = i[3].includes('#') ? i[3].split('#').map(u=>u.split(',')[0]) : [i[3].split(',')[0]]\\n            img = (i[1].match(/tvg-logo=\\\"(.*?)\\\"/) || [null, /(jpg|jpeg|png|gif|webp|ico|svg)/i.test(i[3].split('#')[0].split(',')[1]) ? i[3].split('#')[0].split(',')[1] : 'https://img.vinua.cn/images/zRLdJ.webp'])[1] \\n//https://thumbsnap.com/i/79ZPXaqP.gif\\n            headers = [];\\n        if(!url[url.length-1]) url.pop();\\n        url.forEach((v,index,array)=>{\\n\\n    if (v.includes('https://surrit.com')) {\\n        v = v + `;{Origin@https://thisav.com&&Cookie@user_uuid=7496eb05-9408-4ee6-a858-9a64d6a0735e；； _ga_2LJZ32G4ME=GS1.1.1710578064.2.0.1710578064.0.0.0；； _ga=GA1.2.899921556.1710394524；； XSRF-TOKEN=eyJpdiI6IkNseHArZEEzZ2dPVkNhWXp2c01kcnc9PSIsInZhbHVlIjoiSVIyTU5IQkpyZW5NQXd3M0ZnL3dtQWpPOGhjcVhqOWR5VnR0RmZwOWhFV3UxUU5JbzhKdldVeVJHL1k5cXlmSzExaTF3TUpxTE1FMjlNVzhRR2lBRit3TE1Dd09IaTNhZWFERzE2UkVDV2dKTDBhYmlPUk85bTlSSjkxQlllVjgiLCJtYWMiOiI5MDA1Njc1MjVkNjE1OGRlMWJiY2MyY2IyZTcwMmFhM2YyOTIyYzUyYTZiZDM0NDdmOTQ3ZjVlMmU5MGYwY2Q1IiwidGFnIjoiIn0%3D；； missav_session=eyJpdiI6IjZHL0N2dmo0TEhVSXBSV0NwR2laYXc9PSIsInZhbHVlIjoiaWdGcy9TbEsvbzlPTEM3V3IvNGg2Nm9kZnpTNnVlSHhob0N5MlRmNXgyNnA5Q0Q3NWROM2lzN21SUW9LcVVZUXdNT0FTTWRzK0QwN3hUelJHaTlkeXpHNmhtdFhTb0JQN1lrQkVvbmVXM1RRN1RuLzRHbXNxZFRXVzZYNk1sb2EiLCJtYWMiOiI5MmZiZmE3ZTE5MDJkMmZkNjllYTlhZTExYjZiOWQ1NGI3ZjYyMzc0YTAwN2RlYWFkMGFmNmU1N2I1YTUzMGU4IiwidGFnIjoiIn0%3D；； BCKQITVMRh3dcys17hir1LiK0kNjk4zeL09SY0UG=eyJpdiI6IkpMTHljRk9jTXk2ci81VXp4UVBMS0E9PSIsInZhbHVlIjoiWDNKRnhRUzJSY3c4Q1FUVnhkLzVsQ3dzUm1KRjc3R01LUFdCRjcvSkhwVlhUWm9vTGFGZENPUXdYZ1lFcnhpYjNHUTU3eUVYOU1aYTI5aStXR2VCU1FXUVBTbXRhYkFFTFFWb3dxYVM5R2JXUkhHTjJCM2lieW43aEdBZlhLT1FhVDN5aUFOS1VGWEt0ZnhoWUtKUFl3T0luYlRqUWxEY09PU1B5eFFuZUYvU1NLdkxBTUx4VllpNEFDTnliRDl2UVJ5QnNGZ2xlcUM0TDBZd1BPODd2Q0Q2bTBxZDlBOWJTbGpUNDZpZkJ6YWltZ2Z0cXpNdXJWUDg1bUhSUXhJTHVrdmFGeFh0RGJrRDh3azRZNlVQbWh3TnVTcEZSVUxGZHlKRjJHc2FpT1NVVGRQQlU3SDV4MnlFejMzQ1JIRUR3TzJhYllhNmVPZmFvQ05sSG9RTG5CRyt6d3ljaERWeEFXSU5wck9qTHVlMTZ2cXFXSmhLQ29tK2trbVhPaktPdzN1RWRjZlFSZlFDWVRRRU9VSTRyZz09IiwibWFjIjoiNWEwNGQxOWU2NzdmZjBiNDRkNDMwNDMyNGE1NTdiMmZlM2Q2NmIyNDIyOGI2YTc5MjlhOGZhYTgwYTY0NjRjYSIsInRhZyI6IiJ9&&sec-ch-ua@\\\"Chromium\\\"；；v=\\\"122\\\", \\\"Not(A:Brand\\\"；；v=\\\"24\\\", \\\"Android WebView\\\"；；v=\\\"122\\\"&&sec-ch-ua-mobile@?1&&sec-ch-ua-platform@\\\"Android\\\"&&User-Agent@Mozilla/5.0 (Linux；； Android 12；； SM-G9750 Build/SP1A.210812.016；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/122.0.6261.119 Mobile Safari/537.36&&Referer@https://thisav.com/}`;\\n    }\\n\\n            if(/;\\\\{(.*)\\\\}/.test(v)){\\n                let obj = {},\\n                     con = v.match(/;\\\\{(.*)\\\\}/)[1],\\n                     arr = con.split('&&');\\n                arr.forEach((i)=>{\\n                    let [key,value] = i.split('@');\\n                    obj[key] = value.replace(/;/g,'；；');\\n                })\\n                array[index] = v.match(/^([^;]*);\\\\{/)[1]\\n                headers.push(obj);\\n            }else{\\n                headers.push({'User-Agent' : MOBILE_UA.replace(/;/g,'；；')});\\n            }\\n            array[index] = array[index].replace(/;/g,'；；');\\n           array[index] = array[index].startsWith('hiker')||array[index].startsWith('magnet')?array[index]:array[index]+'#isVideo=true#';\\n        });\\n        if (items[group]) {\\n            if (items[group][title]) {\\n                items[group][title].img = items[group][title].img;\\n                items[group][title].url = items[group][title].url.concat(url);\\n                items[group][title].headers = items[group][title].headers.concat(headers);\\n            } else {\\n                items[group][title] = {img:img,url:url,headers:headers};\\n            }\\n        } else {\\n            items[group] = {};\\n            items[group][title] = {img:img,url:url,headers:headers};\\n        };\\n    }\\n    return items;\\n}\\n\\n$.exports = {\\n    renderLiveData: renderLiveData\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"设置页\",\"path\":\"renderSetting\",\"rule\":\"function renderSetting() {\\n    function getColoredText(text) {\\n        return '““””<span style=\\\"color: #19B89D\\\">' + text + '</span>';\\n    }\\n    const d = [];\\n\\n    //  var file = new java.io.File(\\\"/storage/emulated/0/Android/data/com.example.hikerviewR/files/Documents/tu/pic/\\\");\\n\\n    var file = new java.io.File(getPath(\\\"hiker://files/tu/pic/\\\").replace('file:/', ''));\\n    try{\\n    var fileList = file.listFiles().filter(h=>h.isFile() && /\\\\.(jpg|jpeg|png|gif|webp)$/.test(h));\\n      }catch{\\n    var fileList = [\\\"https://img.vinua.cn/images/zTPLb.webp\\\"]\\n}\\n    var i = Math.floor(Math.random() * fileList.length);\\n    var img = fileList[i];\\n    d.push({\\n        title: \\\"\\\",\\n        col_type: \\\"card_pic_1\\\",\\n        desc: \\\"0\\\",\\n        pic_url: img,\\n        url: $(\\\"hiker://empty#noLoading#\\\").rule(() => {\\n            \\n        })\\n    })\\n\\n    let interval = getItem('interval', '24');\\n    d.push({\\n        title: interval == -1 ? '已禁止自动更新'.fontcolor(\\\"#19B89D\\\").bold() : ('更新间隔:' + interval + '小时').fontcolor(\\\"#19B89D\\\").bold(),\\n        url: $(interval, '输入n为正整数时，每隔n小时自动更新\\\\n为0时，每次打开都会更新\\\\n为-1时，禁止自动更新').input(() => {\\n            if (parseInt(input) >= -1) {\\n                setItem('interval', input);\\n            }\\n            refreshPage();\\n            return 'hiker://empty'\\n        }),\\n        pic_url: 'https://thumbsnap.com/i/JrinF33j.jpg',\\n        col_type: \\\"avatar\\\"\\n    });\\n\\n    d.push({\\n        col_type: \\\"big_blank_block\\\"\\n    });\\n\\n    d.push({\\n        title: getColoredText(\\\"新建订阅\\\"),\\n        col_type: \\\"scroll_button\\\",\\n        desc: \\\"请输入直播源订阅地址\\\",\\n        url: $('', '请输入订阅地址\\\\n可以在地址后加ua\\\\n(使用$$$分割)').input((rule) => {\\n            if (input == \\\"\\\") {\\n                return \\\"toast://不能为空\\\"\\n            } else if (input.indexOf(\\\"http\\\") != 0 && input.indexOf(\\\"file\\\") != 0 && input.indexOf(\\\"hiker\\\") != 0) {\\n                return \\\"toast://链接格式有误\\\"\\n            } else {\\n                let [url,ua] = input.split('$$$');\\n                return $('', \\\"请输入订阅标题\\\").input((url, rule,ua) => {\\n                    eval(JSON.parse(request(\\\"hiker://page/config?rule=\\\" + rule)).rule);\\n                    let config = getConfig();\\n                    config.data.push({\\n                        name: input,\\n                        url: url,\\n                        ua: ua || ''\\n                    });\\n                    writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n                    refreshPage();\\n                    return \\\"toast://已保存\\\";\\n                }, url, rule,ua)\\n            }\\n        }, getMyVar('title'))\\n    });\\n\\n    d.push({\\n        title: getColoredText(\\\"导入订阅\\\"),\\n        col_type: \\\"scroll_button\\\",\\n        url: $('', '支持原始数据和云剪贴板分享链接').input((rule) => {\\n            eval(JSON.parse(request(\\\"hiker://page/batchIm?rule=\\\" + rule)).rule);\\n            if (input.startsWith('聚直播.改分享##')) {\\n                input = parsePaste(input.split('##\\\\n')[1]);\\n            }\\n            return batchImport(input, rule);\\n        }, getMyVar('title'))\\n    });\\n    d.push({\\n        title: getColoredText(\\\"导入本地源\\\"),\\n        col_type: \\\"scroll_button\\\",\\n        desc: \\\"请输入直播源名称\\\",\\n        url: $('', '请输入直播源名称').input((rule) => {\\n            if (input == \\\"\\\") {\\n                return \\\"toast://不能为空\\\"\\n            } else {\\n                return \\\"fileSelect://\\\" + $.toString((name) => {\\n                    let s = input.split(\\\"/\\\")\\n                    var url = \\\"hiker://files/rules/apollo/\\\" + name + \\\".m3u\\\"\\n                    var c = fetch(\\\"hiker://files/cache/\\\" + s[s.length - 1])\\n                    if (!c.includes('http')) {\\n                        return 'toast://非法文件'\\n                    }\\n                    writeFile(url, c)\\n                    eval(JSON.parse(request(\\\"hiker://page/config?rule=聚直播.改\\\")).rule);\\n                    let config = getConfig();\\n                    config.data.push({\\n                        name: name,\\n                        url: url\\n                    });\\n                    writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n                    refreshPage();\\n                    return 'toast://已保存'\\n                }, input)\\n            }\\n        })\\n    });\\n    d.push({\\n        title: getColoredText(\\\"分享订阅\\\"),\\n        col_type: \\\"scroll_button\\\",\\n        url: $([\\\"原始数据\\\", \\\"云剪贴板\\\", \\\"云口令\\\"], 3).select(() => {\\n            return $('确定导出？\\\\n(禁用订阅不会导出)').confirm((type) => {\\n                eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                config = getConfig();\\n                config.data = config.data.filter(v => !v.inVisible);\\n                if (type == \\\"云剪贴板\\\") {\\n                    var data = '聚直播.改分享##\\\\n' + sharePaste(JSON.stringify(config));\\n                } else if (type == \\\"云口令\\\") {\\n                    var data = '聚直播.改分享,复制后打开软件即可导入\\\\n' + sharePaste(JSON.stringify(config)) + '@import=js:eval(JSON.parse(fetch(\\\"hiker://page/cloud?rule=聚直播.改\\\")).rule)';\\n                } else {\\n                    var data = JSON.stringify(config);\\n                }\\n                return \\\"copy://\\\" + data;\\n            }, input)\\n        })\\n    });\\n    d.push({\\n        title: getColoredText(\\\"编辑全部\\\"),\\n        col_type: \\\"scroll_button\\\",\\n        url: \\\"editFile://hiker://files/rules/apollo/config.json\\\"\\n    });\\n\\n    d.push({\\n        col_type: \\\"blank_block\\\"\\n    });\\n\\n    eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n    config = getConfig();\\n    let editMode = getMyVar('editMode', '启用禁用');\\n    ['启用禁用', '删除订阅', '重新排序', '编辑订阅', '清除缓存'].forEach((v) => {\\n        d.push({\\n            title: v == editMode ? '““””' + v.bold().fontcolor('#19B89D') : v,\\n            url: v == editMode ? 'hiker://empty' : $('#noLoading#').lazyRule((v) => {\\n                putMyVar('editMode', v)\\n                refreshPage(false)\\n                return 'hiker://empty'\\n            }, v),\\n            col_type: 'scroll_button'\\n        })\\n    });\\n    config.data.forEach((v, i) => {\\n        let el = {\\n            title: v.name,\\n            col_type: \\\"text_2\\\"\\n        }\\n        switch (editMode) {\\n            case '启用禁用':\\n                el.title = (v.inVisible ? '🔴 ' : '🟢 ') + el.title\\n                el.url = $('#noLoading#').lazyRule((i) => {\\n                    eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                    config = getConfig();\\n                    config.data[i].inVisible = !config.data[i].inVisible;\\n                    writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n                    refreshPage(false);\\n                    return 'hiker://empty'\\n                }, i)\\n                break\\n            case '删除订阅':\\n                el.url = \\\"confirm://确认删除“\\\" + v.name + \\\"”订阅？.js:\\\" + $.toString((i) => {\\n                    eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                    config = getConfig();\\n                    config.data.splice(i, 1);\\n                    writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n                    refreshPage(false);\\n                    return \\\"toast://已删除\\\";\\n                }, i)\\n                break\\n            case '重新排序':\\n                let sortFlag = parseInt(getMyVar('sortFlag', '-1'))\\n                el.title = (sortFlag == i ? '🔃  ' : '') + el.title\\n                if (sortFlag == -1)\\n                    el.url = $('#noLoading#').lazyRule((i) => {\\n                        putMyVar('sortFlag', i.toString())\\n                        refreshPage(false)\\n                        return 'toast://选择要移动到的位置'\\n                    }, i)\\n                else\\n                    el.url = $('#noLoading#').lazyRule((oldIndex, newIndex) => {\\n                        eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                        config = getConfig();\\n                        config.data.splice(newIndex, 0, config.data.splice(oldIndex, 1)[0])\\n                        writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n                        putMyVar('sortFlag', '-1')\\n                        refreshPage(false)\\n                        return 'hiker://empty'\\n                    }, sortFlag, i)\\n                break\\n            case '编辑订阅':\\n                let arr = ['编辑名称', '编辑地址', '编辑内容', '选择样式']\\n                el.url = $(arr, 3).select((v, i) => {\\n                    if (input == '编辑名称') {\\n                        return $(v.name, '输入新名称').input((i) => {\\n                            eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                            config = getConfig();\\n                            if (input) {\\n                                config.data[i].name = input\\n                                writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n                                refreshPage(false)\\n                                return 'toast://修改成功'\\n                            } else {\\n                                return 'toast://不能为空'\\n                            }\\n                        }, i);\\n                    } else if (input == '编辑地址') {\\n                        return $(v.ua ? v.url + '$$$' + v.ua : v.url, '输入新地址').input((i) => {\\n                            eval(JSON.parse(request(\\\"hiker://page/config\\\")).rule);\\n                            config = getConfig();\\n                            if (input == \\\"\\\") {\\n                                return \\\"toast://不能为空\\\"\\n                            } else if (input.indexOf(\\\"http\\\") != 0 && input.indexOf(\\\"file\\\") != 0 && input.indexOf(\\\"hiker\\\") != 0) {\\n                                return \\\"toast://链接格式有误\\\"\\n                            } else {\\n                                let [url,ua] = input.split('$$$');\\n                                config.data[i].url = url;\\n                                config.data[i].ua = ua;\\n                                writeFile(\\\"hiker://files/rules/apollo/config.json\\\", JSON.stringify(config));\\n                                refreshPage(false)\\n                                return 'toast://修改成功'\\n                            }\\n                        }, i);\\n                    } else if (input == '编辑内容') {\\n                        if (v.url.startsWith('file://') || v.url.startsWith('hiker://files')) {\\n                            return 'editFile://' + v.url;\\n                        }\\n                        return 'editFile://hiker://files/libs/' + md5(v.url) + '.js'\\n                    }else if (input == '选择样式') {\\n                            return $([\\\"movie_2\\\",\\\"movie_3\\\",\\\"pic_1\\\",\\\"pic_1_full\\\",\\\"pic_1_card\\\",\\\"pic_2\\\",\\\"pic_2_card\\\",\\\"pic_3\\\",\\\"pic_3_square\\\",\\\"icon_2\\\",\\\"icon_2_round\\\",\\\"icon_small_3\\\",\\\"icon_3_fill\\\",\\\"icon_3_round_fill\\\",\\\"icon_4\\\",\\\"icon_4_card\\\",\\\"icon_small_4\\\",\\\"icon_round_4\\\",\\\"icon_round_small_4\\\",\\\"icon_5\\\",\\\"card_pic_1\\\",\\\"card_pic_2\\\",\\\"card_pic_2_2\\\",\\\"card_pic_2_2_left\\\",\\\"card_pic_3\\\",\\\"card_pic_3_center\\\",\\\"pic_1_center\\\",\\\"text_1\\\",\\\"text_2\\\",\\\"text_3\\\",\\\"text_4\\\",\\\"text_5\\\",\\\"text_center_1\\\",\\\"text_icon\\\",\\\"avatar\\\"], 2, '请选择').select((v) => {\\n                                setItem(v.name, input)\\n                            },v)\\n                        }\\n                    \\n                }, v, i);\\n                break;\\n            case '清除缓存':\\n                el.url = $('确定清除“' + v.name + '”订阅缓存？\\\\n(可立即更新)').confirm((url) => {\\n                    deleteCache(url);\\n                    return 'toast://清除成功'\\n                }, v.url)\\n                break;\\n        }\\n        d.push(el)\\n    });\\n    return d;\\n}\\n\\n$.exports = {\\n    renderSetting: renderSetting\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"云口令\",\"path\":\"cloud\",\"rule\":\"eval(JSON.parse(request(\\\"hiker://page/batchIm?rule=聚直播.改\\\")).rule);\\nlet content = parsePaste(input);\\nbatchImport(content, \\\"聚直播.改\\\");\"}]","icon":"https://img.vinua.cn/images/zLZai.png","proxy":""}
Add Comment
Please, Sign In to add comment
