更新 'SrcAuto.js'

SrcAuto.js

@@ -0,0 +1,904 @@
+//============自动挡处理逻辑、仅用于个人学习使用============
+//========感谢@断念大佬========
+
+var SrcVersion = 7.09;
+
+//载入断插主控js
+eval(fetch('hiker://files/cache/Parse_Dn.js'));
+
+//------参数设置------
+var defaultconfig = {
+    "printlog": 1,//是否开启打印日志：0关闭/1开启
+    "x5timeout": 5,//设置X5嗅探解析超时时间：秒
+    "autoselect": 1,//是否开启智能优选解析接口：0关闭/1开启
+    "failcount": 3,//设置失败几次的片源剔除解析
+    "fromcount": 12,//当开启自动选择解析时，失败片源达多少个，提示删除
+    "multiline": 2,//设置解析多线程数
+    "testcheck": 0,//进入测试检测模式：0关闭/1开启
+    "disorder": 1,//是否开启乱序模式
+    "parsereserve": 0,//是否强制保留用户配置的解析口
+    "jstoweb": 0,//是否允许js解析中跳转x5或web
+    "cachem3u8": 1,//m3u8是否使用缓存方式播放
+    "iscustom": 0,//是否开启远程关怀模式，自定义解析设置开关：0关闭/1开启
+    "remotepath": ""//远程在线文件地址
+}
+var cfgfile = "hiker://files/rules/Src/Auto/config.json";
+var Autocfg=fetch(cfgfile);
+if(Autocfg){
+    eval("var userconfig=" + Autocfg+ ";");//加载用户参数
+}
+
+if(!userconfig){var SAconfig = defaultconfig}else{var SAconfig = userconfig}//没有取到用户参数时调用默认参数
+var testcheck = SAconfig.testcheck;
+var printlog = SAconfig.printlog;
+if(getMyVar('Stitle','0').indexOf("帅助手") == -1){testcheck=0}
+putMyVar('SrcM3U8',SAconfig.cachem3u8);
+
+//加载远程自定义设置
+if(SAconfig.iscustom==1){
+    try{
+        let remotefile = fetchCache(SAconfig.remotepath, 24);
+        if(remotefile.indexOf("ParseZ") != -1){
+            eval(remotefile);
+            Object.assign(ParseS, ParseZ);
+        }else{
+            if(printlog==1){log("√远程关怀自定义解析为空，走本地配置文件")};
+            SAconfig.iscustom = 0;        
+        }
+    }catch(e){
+        if(printlog==1){log("√远程关怀自定义加载失败，走本地配置文件")};
+        SAconfig.iscustom = 0;
+    }
+}else{var resetsort = 0};
+
+var sortlist = []; //排序降权临时存放数组
+var sortfile = "hiker://files/rules/Src/Auto/SrcSort.json";
+var isresetsort = resetsort || 0;
+if (isresetsort==0&&fileExist(sortfile)){
+    let sorts = fetch(sortfile);
+    if(sorts){
+        eval("var newsort=" + sorts);
+        Object.assign(sortlist, newsort);
+    }
+}
+
+//自动解析入口
+var aytmParse = function (vipUrl,parseStr) {
+    if(printlog==1){
+        log("√影片地址："+vipUrl);
+        if(SAconfig.iscustom==1){log("√已开启远程关怀模式")};  
+        if(parseStr){
+            log("√指定解析>"+parseStr);
+        }else{
+            if(SAconfig.autoselect==1){log("√开启智能优选")}else{log("√关闭智能优选")};  
+            if(SAconfig.disorder==1){log("√开启乱序模式")}else{log("√关闭乱序模式")}; 
+            if(SAconfig.parsereserve==1){log("√开启强制优先断插配置")}; 
+        }
+        if(testcheck==1){log("√当前为检测模式")};  
+    };
+    var str = "";
+    var from = "";
+    try {
+        var host = vipUrl.match(/\.(.*?)\//)[1];
+        from = host.split('.')[0];
+    } catch (e) {
+        from = "切片源";
+    }
+    if (from&&from!="切片源"){
+        //其他网址域名格式的地址
+        switch (mySet.qju) {
+            case "默认":
+            case "智能优选":
+            case "":
+                switch (host) {
+                    case "qq.com":
+                        str = mySet.tx;
+                        break;
+                    case "iqiyi.com":
+                        str = mySet.qy;
+                        break;
+                    case "youku.com":
+                        str = mySet.yk;
+                        break;
+                    case "mgtv.com":
+                        str = mySet.mg;
+                        break;
+                    case "bilibili.com":
+                        str = mySet.bl;
+                        break;
+                    case "le.com":
+                        str = mySet.le;
+                        break;
+                    case "sohu.com":
+                        str = mySet.sh;
+                        break;
+                    case "pptv.com":
+                        str = mySet.pp;
+                        break;
+                    case "ixigua.com":
+                        str = mySet.xg;
+                        break;
+                    case "miguvideo.com":
+                        str = mySet.mi;
+                        break;
+                    case "1905.com":
+                        str = mySet.one;
+                        break;
+                    case "fun.tv":
+                        str = mySet.fun;
+                        break;
+                    default:
+                        str = mySet.oth;
+                        break;
+                }
+                break;
+            default:
+                str = mySet.qju;
+                break;
+        }
+    } 
+    
+    if (str == undefined || str == "") {if(mySet.qju==""||mySet.qju=="默认"){str = mySet.oth;}else{if(mySet.qju!="智能优选"){str = mySet.qju;}}}
+    var strlist = [];//解析口载入临时数组
+    var prior = [];//处理用户手工配置项的临时数组
+    if (parseStr) {
+        strlist = parseStr.split(/,|，/); //字符分割
+    }else{
+        //自动列出所有接口
+        var excludeParse = ['defaultParse', 'maoss', 'CityIP', 'cacheM3u8', 'pcUA', 'parseLc', 'gparse', 'nparse', '道长仓库通免', 'defaultParseWeb', '智能优选', '默认'];
+        if(mySet.qju=="智能优选"){SAconfig.autoselect=1}
+        if(SAconfig.autoselect==1){
+             //全局排除的追加到排除列表
+            for(var j=0;j<sortlist.length;j++){
+                try{
+                    if(sortlist[j].Globalexclude==1){ 
+                        excludeParse.push(sortlist[j].name);
+                    }
+                }catch(e){}
+            } 
+
+            if(str&&str!="默认"){
+                //如开启了智能优先时，优先取单项指定解析
+                prior = str.split(/,|，/); //字符分割
+                for (var i in prior) {
+                    if(excludeParse.indexOf(prior[i]) == -1){
+                        //配置项接口未被排除，优先加入候选列表
+                        strlist.push(prior[i]);
+                    }
+                }
+            }
+            var parsetmplist = [];//用于取配置文件的解析口临时数组
+            if(SAconfig.iscustom==1){
+                //远程关怀模式只取在线解析接口
+                for( var key in ParseZ ){
+                    if(excludeParse.indexOf(key)==-1 && prior.indexOf(key)==-1){
+                        parsetmplist.push(key);
+                    }
+                }
+            }else{
+                //取本地配置文件中非隐藏解析接口
+                for(var i = 0; i < parseFile.title.length; i++){
+                    if(excludeParse.indexOf(parseFile.title[i])==-1 && prior.indexOf(parseFile.title[i])==-1){
+                        parsetmplist.push(parseFile.title[i]);
+                    }
+                }
+            }
+            if(SAconfig.disorder==1){
+                //乱序模式
+                function randArr (arr) {
+                    return arr.sort(() => {
+                        return (Math.random() - 0.5);
+                    });
+                }
+                randArr(parsetmplist);
+            }
+            strlist = strlist.concat(parsetmplist);
+            parsetmplist=[];//清空临时
+        }else{
+            //关闭智能优选时
+            if(str&&str!="默认"){
+                prior = str.split(/,|，/); //字符分割
+                for (var i in prior) {
+                    if(excludeParse.indexOf(prior[i]) == -1){
+                        //配置项接口未被排除，加入候选列表
+                        strlist.push(prior[i]);
+                    }
+                }
+            }
+        }
+    }
+
+    if (strlist.length==0) {hideLoading();return 'toast://好像没有配置解析接口，解个寂寞吗';}
+    if(printlog==1){
+        log("√影片来源标识："+from)
+        log("√选择的解析接口组："+strlist);
+    };
+    
+    //定义排序函数
+    function sortData(a, b) {
+        if(a.sort!=b.sort){
+            return a.sort - b.sort
+        }else{
+            return a.id - b.id;
+        }
+    };
+    //将选择的解析接口，带上类型、排序
+    var parsename = "";
+    var parseurl = "";
+    var parselx = "";
+    var parselist = [];//待解析列表
+    var Jparsenum = 0;//JS解析数
+    var Uparsenum = 0;//URL解析数
+    var x5jxlist = [];//x5嗅探接口url
+    var x5nmlist = [];//x5嗅探接口name
+    var dellist = [];//建议删除的
+    var faillist = [];//失败列表
+    var issort = 0;//排序是否有变化
+    for (var i in strlist) {
+        if(strlist[i].includes("http")){
+            parsename = strlist[i];
+            parseurl = strlist[i];
+            parselx = "U";
+        }else{
+            if(typeof ParseS[strlist[i]] == 'string'){
+                parsename = strlist[i];
+                parseurl = ParseS[strlist[i]];
+                parselx = "U";
+            }else if(typeof ParseS[strlist[i]] == 'function'){
+                parsename = strlist[i];
+                parseurl = "0";
+                parselx = "J";    
+            }else{
+                dellist.push(strlist[i]);
+            }
+        } 
+        let sort = -2;
+        let stopfrom = [];
+        for(var j=0;j<sortlist.length;j++){
+            if(sortlist[j].name == parsename){ 
+                sort = sortlist[j].sort;
+                if(sortlist[j].stopfrom == undefined){
+                    sortlist[j].stopfrom = [];
+                }else{
+                    if(sortlist[j].stopfrom.length > 0){ Object.assign(stopfrom, sortlist[j].stopfrom); };
+                }
+                if(SAconfig.autoselect==1&&prior.includes(parsename)==true&&SAconfig.parsereserve==1){
+                    //开启了强制优先并保留用户配置的解析
+                    sort = 0;
+                    stopfrom = [];
+                }
+                break;
+            }
+        } 
+        //新的接口，加入到排序数组
+        if(sort==-2){
+            sort = 0;
+            let arr  = { "sort" : sort, "name" : parsename, "stopfrom" : [] };
+            if(parsename!=""){
+                sortlist.push(arr);
+                issort = 1;
+            }
+        }
+
+        if(parsename==""||parseurl==""){
+            //无效的解析，直接加入提示删除数组
+            if(dellist.indexOf(strlist[i])==-1){dellist.push(strlist[i])};
+        }else{
+            //解析接口存在
+            if(SAconfig.autoselect==1){
+                if(stopfrom.indexOf(from)==-1){
+                    //自动筛选模式时，sort只做排序使用，不包含停用片源的解析，则加入解析接口组
+                    if(parselx=="J"){
+                        let arr  = { "id": i,"sort": sort, "name": parsename, "lx": parselx };
+                        parselist.push(arr); 
+                        Jparsenum ++;
+                    }
+                    if(parselx=="U"){
+                        let arr  = { "id": i,"sort": sort, "name": parsename, "url": parseurl, "lx": parselx };
+                        parselist.push(arr); 
+                        Uparsenum ++;
+                    }
+                }else{
+                    if(stopfrom.length>=SAconfig.fromcount&&stopfrom.indexOf(from)>-1){
+                        //此解析接口大于多少片源失败，且已排除片源，加入提示删除数组
+                        dellist.push(strlist[i]);
+                    }
+                }
+            }else{
+                if(sort>=SAconfig.failcount&&stopfrom.indexOf(from)>-1){
+                    //此接口已失败大于设置的次数，且已排除片源，加入提示删除数组
+                    dellist.push(strlist[i]);
+                }else{
+                    //非自动筛选解析时按失败次数，小于设置的次数、且解析接口名有效，加入解析接口组
+                    if(parselx=="J"){
+                        let arr  = { "id": i,"sort": sort, "name": parsename, "lx": parselx };
+                        parselist.push(arr); 
+                        Jparsenum ++;
+                    }
+                    if(parselx=="U"){
+                        let arr  = { "id": i,"sort": sort, "name": parsename, "url": parseurl, "lx": parselx };
+                        parselist.push(arr); 
+                        Uparsenum ++;
+                    }
+                }
+            }
+        }
+    }
+    if(dellist.length > 0){
+        SAconfig['dellist'] = dellist;
+        writeFile(cfgfile, JSON.stringify(SAconfig));
+        if(printlog == 1){log("√建议删除解析口:"+dellist);}
+    }
+    if(parselist.length == 0){
+        if(printlog==1){log("√没有可用的解析接口，需重新配置")};
+        hideLoading();
+        return 'toast://√解析口全部无效了，重新配置吧';
+    }else{
+        //解析接口排序，将之前失败的排在后面 
+        parselist.sort(sortData)
+    }
+    if(printlog==1){
+        log("√断插有效解析数："+parselist.length+" (J解析:"+Jparsenum+"，U解析:"+Uparsenum+")");
+    };
+
+    var exclude = /404\.m3u8|xiajia\.mp4|余额不足\.m3u8/;//设置排除地址
+    var contain = /\.mp4|\.m3u8|\.flv|\.avi|\.mpeg|\.wmv|\.mov|\.rmvb|\.dat|qqBFdownload|mime=video%2F|video_mp4|\.ts\?/;//设置符合条件的正确地址
+    var playurl = "";
+    var urls = [];//用于多线路地址
+    var names = [];//用于多线路名称
+    var headers = [];//用于多线路头信息
+    var danmu = "";//多线路弹幕
+    var ismulti = SAconfig.ismulti||0;//是否开启多线程
+    var multiline = SAconfig.multiline||1;//多线程数量
+    var adminuser = SAconfig.adminuser||0;
+
+    if(ismulti==0&&adminuser==0){multiline=2}else{if(multiline>5){multiline=5}}
+    if(testcheck==1){multiline=10}
+
+    //明码解析线程代码
+    var parsetask = function(obj) {
+        let rurl = "";
+        let x5 = 0;
+        if(obj.lx=="J"){
+            rurl = ParseS[obj.name](vipUrl);
+        }else if(obj.lx=="U"){
+            let taskheader = {withStatusCode:true,timeout:3000};
+            let getjson = JSON.parse(request(obj.url+vipUrl,taskheader));
+            if (getjson.body&&getjson.statusCode==200){
+                let gethtml = getjson.body;
+                try {
+                    rurl = JSON.parse(gethtml).url||JSON.parse(gethtml).data.url||JSON.parse(gethtml).data;
+                } catch (e) {
+                    if(contain.test(getjson.url)&&getjson.url.indexOf('=http')==-1){
+                        rurl = getjson.url;
+                    }else if(contain.test(gethtml)){
+                        try {
+                            if(gethtml.indexOf('urls = "') != -1){
+                                rurl = gethtml.match(/urls = "(.*?)"/)[1];
+                            }else if(gethtml.indexOf('"url":"') != -1){
+                                rurl = gethtml.match(/"url":"(.*?)"/)[1];
+                            }else if(gethtml.indexOf('id="video" src="') != -1){
+                                rurl = gethtml.match(/id="video" src="(.*?)"/)[1];
+                            }else if(gethtml.indexOf('url: "') != -1){
+                                rurl = gethtml.match(/url: "(.*?)"/)[1];
+                            }else{
+                                //if(printlog==1){log('将日志提交给作者，帮助完善解析逻辑>>>'+gethtml)};
+                            }
+                        } catch (e) {
+                            //if(printlog==1){log('√明码获取错误：'+e.message)};
+                        }
+                    }
+                }
+                
+                if(rurl == ""){
+                    if(!/404 /.test(gethtml)){
+                        if(obj.url.indexOf('key=')==-1){
+                            if(x5jxlist.length<=5){
+                                x5jxlist.push(obj.url);
+                                x5nmlist.push(obj.name);
+                                if(printlog==1){log(obj.name + '>√加入x5嗅探列表');}
+                            }
+                            x5 = 1;//网页可以正常访问，偿试嗅探
+                        }else{
+                            x5 = 2; //json解析，标记剔除
+                        }
+                    }
+                }
+            }else{
+                x5 = 2;//网页无法访问，标记剔除
+            }
+            obj['x5'] = x5;
+        }
+        if(rurl){   
+            if(/^toast/.test(rurl)){
+                if(printlog==1){log(obj.name+'>√提示：'+rurl.replace('toast://',''))};
+                rurl = "";
+            }else if(/^http/.test(rurl)&&SrcParseS.testvideourl(rurl,obj.name)==0){
+                //检测地址有效性
+                rurl = "";
+            }
+        }
+        obj['rurl'] = rurl;
+        return obj;
+    };
+    //清理sort排序文件线程代码
+    var sorttask = function(obj) {
+        let sortdel =[];
+        for(var j=0;j<sortlist.length;j++){
+            if(!strlist.some(item => item==sortlist[j].name)){ 
+                sortdel.push(sortlist[j].name);
+                sortlist.splice(j,1);
+                j = j - 1;
+            }
+        }
+        if(printlog==1&&sortdel.length>0){log(sortdel.join(',') + '>√从sort文件中删除')}
+        return obj;
+    };
+
+    if(testcheck==1){showLoading('√解析列表，检测中')};
+    var cleansort = 0;
+    for (var i=0;i<parselist.length;i++) {
+        if(playurl){break;}
+        var beresults = [];//用于存储多线程返回对象
+        var beids = [];//用于存储多线程返回id lx+name
+        var beerrors = [];//用于存储多线程是否有错误
+        let p = i+multiline;
+        if(p>parselist.length){p=parselist.length}
+        let JxList = [];
+        for(let s=i;s<p;s++){
+            JxList.push(parselist[s]);
+            i=s;
+        }
+        if(cleansort==0&&!parseStr&&SAconfig.autoselect==1){
+            cleansort = 1;//清理sort文件只调用一轮
+            JxList.push({lx:'cleansort'});
+        }
+
+        let parses = JxList.map((parse)=>{
+            if(parse.lx=="cleansort"){
+                return {
+                    func: sorttask,
+                    param: parse,
+                    id: 'cleansort'
+                }
+            }else{
+                return {
+                    func: parsetask,
+                    param: parse,
+                    id: parse.lx+'|'+parse.name
+                }
+            } 
+        });
+        
+        be(parses, {
+            func: function(obj, id, error, taskResult) {
+                if(id!='cleansort'){
+                    obj.ids.push(id);
+                    obj.results.push(taskResult);
+                    obj.errors.push(error);
+                    if (ismulti!=1&&testcheck!=1&&contain.test(taskResult.rurl) && !exclude.test(taskResult.rurl)) {
+                        //toast("我主动中断了");
+                        if(printlog==1){log("√线程结束");}
+                        return "break";
+                    }
+                }
+            },
+            param: {
+                ids: beids,
+                results: beresults,
+                errors: beerrors
+            }
+        });
+
+        for(let k in beids){
+            parsename = beids[k].split('|')[1];
+            parselx = beids[k].split('|')[0];
+            //if(printlog==1){log("√"+ parsename + ">" + parselx + "解析结果检查")};
+            if(beerrors[k]==null){
+                parseurl = beresults[k].rurl;
+                if(SAconfig.jstoweb==1&&parselx=="J"&&parseurl.search(/x5Rule|webRule/)>-1){
+                        //js中跳转x5或web嗅探
+                        if(printlog==1){log("√JS中跳转x5|web嗅探,解析逻辑被打断,结果自负")};  
+                        return parseurl;
+                }else{
+                    if (contain.test(parseurl) && !exclude.test(parseurl)) {
+                        if(playurl==""){playurl = parseurl;}
+                        if(printlog==1){log(parsename+">√"+parselx+"解析成功>" + parseurl)};  
+                        if(testcheck==1){
+                            playurl = "";
+                        }else{
+                            if(ismulti==1&&multiline>1){
+                                try{
+                                    eval('var urljson = '+ parseurl);
+                                    var urltype = $.type(urljson);
+                                }catch(e){
+                                    var urltype = "string";
+                                }
+                                if(urltype == "object"){
+                                    try {
+                                        let murls = urljson.urls;
+                                        let mnames = urljson.names||[];
+                                        let mheaders = urljson.headers;
+                                        for(var j=0;j<murls.length;j++){
+                                            let MulUrl = SrcParseS.formatMulUrl(murls[j].replace(/;{.*}/g,""), urls.length);
+                                            urls.push(MulUrl.url);
+                                            if(mnames.length>0){
+                                                names.push(mnames[j]);
+                                            }else{
+                                                names.push('线路'+urls.length);
+                                            }
+                                            headers.push(mheaders[j]);
+                                        }
+                                        if(urljson.danmu){danmu = urljson.danmu;}
+                                    } catch (e) {
+                                        log('判断多线路地址对象有错：'+e.message);
+                                    }
+                                }else{
+                                    let MulUrl = SrcParseS.formatMulUrl(parseurl.replace(/;{.*}/g,""), urls.length);
+                                    urls.push(MulUrl.url);
+                                    names.push(parsename);
+                                    headers.push(MulUrl.header);
+                                }
+                            }else{
+                                break;
+                            }
+                        }
+                        for(var j=0;j<sortlist.length;j++){
+                            if(sortlist[j].name == parsename){ 
+                                if(sortlist[j].sort>0){
+                                    sortlist[j].sort = sortlist[j].sort-1;
+                                    issort = 1;
+                                }
+                                break;
+                            }
+                        }
+                    } else {
+                        if(beresults[k].lx=="J" || (beresults[k].lx=="U"&&beresults[k].x5==2)){
+                            //JS解析失败的、非x5嗅探解析，失败排序+1
+                            let failsum =0 ;
+                            for(var j=0;j<sortlist.length;j++){
+                                if(sortlist[j].name == parsename){ 
+                                    sortlist[j].sort = sortlist[j].sort+1;
+                                    issort = 1;
+                                    failsum = sortlist[j].sort;
+                                    if(sortlist[j].stopfrom.indexOf(from)==-1){
+                                        if((SAconfig.autoselect==1&&failsum>=3)||(failsum>=SAconfig.failcount)){
+                                            //自动选择接口时此接口失败大于等于3时、失败次数大于限定，此片源排除此解析接口
+                                            sortlist[j].stopfrom[sortlist[j].stopfrom.length] = from
+                                        };
+                                    }
+                                    break;
+                                }
+                            }
+                            if(testcheck==1){faillist.push(parsename)};
+                            if(printlog==1){log(parsename+">√"+parselx+"解析失败,已失败"+failsum+"次，跳过")};   
+                        }
+                    }
+                }
+            }else{
+                if(testcheck==1){faillist.push(parsename)};
+                if(printlog==1){log(parsename+">√此解析有语法错误，跳过>"+beerrors[k])};
+                for(var j=0;j<sortlist.length;j++){
+                    if(sortlist[j].name == parsename){ 
+                        sortlist[j].sort = sortlist[j].sort+1;
+                        issort = 1;
+                        if(sortlist[j].stopfrom.indexOf(from)==-1){
+                            sortlist[j].stopfrom[sortlist[j].stopfrom.length] = from;
+                        }
+                        break;
+                    }
+                }
+            }
+        }//多线程结果处理
+    }//循环结束
+
+    if(issort==1&&!parseStr&&testcheck!=1){writeFile(sortfile, JSON.stringify(sortlist))};
+
+    //上面js免嗅、json、明码解析、剔除打不开网站做完了
+    try {
+        if (playurl=="") {
+            function uniq(array){
+                var temp = []; //一个新的临时数组
+                for(var i = 0; i < array.length; i++){
+                    if(temp.indexOf(array[i]) == -1){
+                        temp.push(array[i]);
+                    }
+                }
+                return temp;
+            }
+            uniq(faillist);//去除重复
+            if (x5jxlist.length == 0) {
+                hideLoading();
+                if(printlog==1){
+                    if(testcheck==1){
+                        log('√检测结束');
+                        if(faillist.length>0){log('√解析失败的>'+faillist);}
+                        refreshPage(false);
+                    }else{
+                        log('√JS免嗅和URL明码解析失败、无嗅探解析，需重新配置插件')
+                    }
+                };
+                if(testcheck==1){
+                    if (!parseStr) {
+                        if(faillist.length>0){
+                            return $("检测结束,是否处理失败的解析？").confirm((faillist,helper)=>{
+                                return $("#noHistory##noRecordHistory#hiker://empty").rule((faillist,helper)=>{
+                                    requireCache(helper, 48);
+                                    faildeal(faillist)
+                                },faillist,helper);     
+                            },faillist,getMyVar('helper','0'));
+                        }else{
+                            return "toast://检测结束";
+                        }
+                    }else{
+                        initConfig({faillist:faillist});
+                        refreshPage(false);
+                        return "toast://〖"+parseStr+"〗解析失败";
+                    }
+                }else{
+                    return "toast://未找到可用的解析口"
+                }
+            } else {
+                if(printlog==1){if(testcheck==1){log("√JS免嗅和URL明码检测结束，转嗅探检测接口数："+x5jxlist.length)}else{log("√JS免嗅和URL明码失败，转嗅探解析接口数："+x5jxlist.length)}};
+                if(printlog==1){log("√嗅探调用解析口："+x5nmlist[0])};
+                //if(testcheck==1){showLoading('嗅探解析列表，检测中')}else{showLoading('√嗅探解析中，请稍候')};
+                let parmset = {"issort":0,"printlog":printlog,"timeout":SAconfig.x5timeout,"autoselect":SAconfig.autoselect,"failcount":SAconfig.failcount,"from":from,"testcheck":testcheck,"parseStr":parseStr,"helper":getMyVar('helper','0')};
+
+                return x5Player(x5jxlist,x5nmlist,vipUrl,sortlist,parmset,faillist,SrcParseS.formatUrl);
+            }
+        } else {
+            if(urls.length>1){
+                return JSON.stringify({
+                    urls: urls,
+                    names: names,
+                    headers: headers,
+                    danmu: danmu
+                });   
+            }else{
+                return SrcParseS.formatUrl(playurl);
+            }
+        }
+    } catch (e) {
+        if(printlog==1){log("√语法错误")};
+        return 'toast://解析失败，语法错误';
+    }
+};
+
+//x5嗅探通用免嗅函数、自动多层嵌套
+function x5Player(x5jxlist, x5nmlist, vipUrl, sortlist, parmset, faillist, formatUrl) {
+    return 'webRule://' + x5jxlist[0] + vipUrl + '@' + (typeof $$$ == 'undefined' ? $ : $$$).toString((x5jxlist, x5nmlist, vipUrl, sortlist, parmset, faillist, formatUrl, x5Player) => {
+        if(typeof(request)=='undefined'||!request){
+            eval(fba.getInternalJs());
+        };
+
+        if (window.c == null) {
+            fba.hideLoading();
+            window.c = 0;
+            if(parmset.testcheck==1){fba.showLoading('√解析列表，检测中')}else{fba.showLoading('√视频解析中，请稍候')};
+        };
+        window.c++;
+
+        if (window.c * 250 >= parmset.timeout*1000) {
+            if(window.c<1000){faillist.push(x5nmlist[0]);}
+            if (x5jxlist.length == 1) { 
+                //最后一个X5解析失败了，排序+1
+                let failsum = 0;
+                for(var j=0;j<sortlist.length;j++){
+                    if(sortlist[j].name == x5nmlist[0]){ 
+                        sortlist[j].sort = sortlist[j].sort+1;
+                        failsum = sortlist[j].sort;
+                        if(sortlist[j].stopfrom.indexOf(parmset.from)==-1){
+                            if((parmset.autoselect==1&&failsum>2)||(failsum>=parmset.failcount)){
+                                //自动选择接口时此接口失败大于2时、失败次数大于限定，此片源排除此解析接口
+                                sortlist[j].stopfrom[sortlist[j].stopfrom.length] = parmset.from;
+                            };
+                        }
+                        break;
+                    }
+                }
+
+                fba.hideLoading();
+
+                if(parmset.printlog==1){
+                    if(parmset.testcheck==1){
+                        fba.log("√检测结束");
+                        if(faillist.length>0){fba.log('√解析失败的>'+faillist);}
+                    }else{
+                        fba.log("√超过"+window.c * 250+"毫秒还未成功,已失败"+failsum+"次，全部嗅探解析口都失败了");
+                    }
+                };
+                if(parmset.testcheck==1){
+                    if(faillist.length>0){
+                        if (parmset.parseStr) {
+                            return $$$("#noLoading#").lazyRule((faillist)=>{
+                                initConfig({faillist:faillist});
+                                refreshPage(false);
+                                return "toast://〖"+faillist+"〗解析失败";
+                            },faillist);
+                        }else{
+                            return $$$("检测结束,是否处理失败的解析？").confirm((faillist,helper) => {
+                                initConfig({faillist:'0'});
+                                return $("hiker://empty#noHistory##noRecordHistory#").rule((faillist,helper) => {
+                                    requireCache(helper, 48);
+                                    faildeal(faillist);
+                                }, faillist, helper);
+                            }, faillist, parmset.helper);
+                        }
+                        
+                    }else{
+                        return "toast://检测结束";
+                    }
+                }else{
+                    fba.writeFile("hiker://files/rules/Src/Auto/SrcSort.json", JSON.stringify(sortlist));
+                    return "toast://所有解析都失败了，请重新配置断插解析";
+                };
+            } else {
+                //X5解析失败了，排序+1
+                let failsum = 0;
+                for(var j=0;j<sortlist.length;j++){
+                    if(sortlist[j].name == x5nmlist[0]){ 
+                        sortlist[j].sort = sortlist[j].sort+1;
+                        parmset.issort = 1;
+                        failsum = sortlist[j].sort;
+                        if(sortlist[j].stopfrom.indexOf(parmset.from)==-1){
+                            if((parmset.autoselect==1&&failsum>2)||(failsum>=parmset.failcount)){
+                                //自动选择接口时此接口失败大于2时、失败次数大于限定，此片源排除此解析接口
+                                sortlist[j].stopfrom[sortlist[j].stopfrom.length] = parmset.from;
+                            };
+                        }
+                        break;
+                    }
+                }
+                if(parmset.printlog==1){ if(parmset.testcheck==1){fba.log("√检测下一个嗅探解析："+x5nmlist.slice(1)[0]);}else{fba.log(x5nmlist[0]+">√超过"+window.c * 250+"毫秒还未成功,已失败"+failsum+"次，下一个解析："+x5nmlist.slice(1)[0])}};
+                return x5Player(x5jxlist.slice(1), x5nmlist.slice(1), vipUrl, sortlist, parmset, faillist, formatUrl);
+            }
+        }
+
+        //fba.log(fy_bridge_app.getUrls());
+        var urls = _getUrls();
+        var exclude = /\/404\.m3u8|\/xiajia\.mp4|\/余额不足\.m3u8|\.css|\.js|\.gif|\.png|\.jpeg|api\.m3u88\.com|\.php\?v=h|\?url=h/;//设置排除地址
+        var contain = /\.mp4|\.m3u8|\.flv|\.avi|\.mpeg|\.wmv|\.mov|\.rmvb|\.dat|qqBFdownload|mime=video%2F|video_mp4|\.ts\?/;//设置符合条件的正确地址
+        for (var i in urls) {
+            if (!exclude.test(urls[i]) && contain.test(urls[i])) {
+                if(parmset.printlog==1){fy_bridge_app.log(x5nmlist[0]+">√嗅探解析成功>"+urls[i])};
+                if(parmset.testcheck==1){
+                    window.c = 1000;
+                }else{
+                    if(parmset.issort==1){fba.writeFile("hiker://files/rules/Src/Auto/SrcSort.json", JSON.stringify(sortlist))};
+                    return $$$("#noLoading#").lazyRule((url,formatUrl)=>{
+                        return formatUrl(url); 
+                    }, urls[i], formatUrl);
+                }
+            }
+        } 
+    }, x5jxlist, x5nmlist, vipUrl, sortlist, parmset, faillist, formatUrl, x5Player)
+};
+
+var SrcParseS = {
+    formatUrl: function (url, i) {
+        try {
+            if (url.trim() == "") {
+                return "toast://解析失败，建议切换线路或更换解析方式";
+            } else if(/^{/.test(url)){
+                return url;
+            }else {
+                if (url[0] == '/') { url = 'https:' + url }
+                if (i == undefined) {
+                    if (getMyVar('SrcM3U8', '1') == "1"&&url.indexOf('.m3u8')>-1) {
+                        url = cacheM3u8(url, {timeout: 2000});
+                    }
+                    if(url.indexOf('User-Agent')==-1){
+                        if (/wkfile/.test(url)) {
+                            url = url + ';{User-Agent@Mozilla/5.0&&Referer@https://fantuan.tv/}';
+                        } else if (/bilibili|bilivideo/.test(url)) {
+                            url = url + ";{User-Agent@bili2021&&Referer@https://www.bilibili.com/}";
+                        } else if (/mgtv/.test(url)) {
+                            url = url + ";{User-Agent@Mozilla/5.0}";
+                        }
+                    }
+                } else {
+                    if ((getMyVar('SrcM3U8', '1') == "1"||url.indexOf('vkey=')>-1)&&url.indexOf('.m3u8')>-1) {
+                        url = cacheM3u8(url, {timeout: 2000}, 'video' + parseInt(i) + '.m3u8') + '#pre#';
+                    }
+                }
+                if(url.indexOf('#isVideo=true#')==-1){
+                    url = url + '#isVideo=true#';
+                }
+                return url;
+            }
+        } catch (e) {
+            return url;
+        }
+    },
+    mulheader: function (url) {
+        if (/mgtv/.test(url)) {
+            var header = { 'User-Agent': 'Mozilla/5.0', 'Referer': 'www.mgtv.com' };
+        } else if (/bilibili|bilivideo/.test(url)) {
+            var header = { 'User-Agent': 'bili2021', 'Referer': 'https://www.bilibili.com' };
+        } else if (/wkfile/.test(url)) {
+            var header = { 'User-Agent': 'Mozilla/5.0', 'Referer': 'fantuan.tv' };
+        } else {
+            var header = {};
+        }
+        return header;
+    },
+    //处理多线路播放地址
+    formatMulUrl: function (url,i) {
+        try {
+            let header = this.mulheader(url);
+            if ((getMyVar('SrcM3U8', '1') == "1"||url.indexOf('vkey=')>-1)&&url.indexOf('.m3u8')>-1) {
+                var name = 'video'+parseInt(i)+'.m3u8';
+                url = cacheM3u8(url, {headers: header, timeout: 2000}, name)+'#pre#';
+            }
+            return {url:url, header:header};
+        } catch (e) {
+            if(config.printlog==1){log("√错误："+e.message)};
+            return url;
+        }   
+    },
+    //测试视频地址有效性
+    testvideourl: function (url,name,times) {
+        if(!url){return 0}
+        if(!name){name = "解析"}
+        if(!times){times = 120}
+        try {
+            if(/vkey=/.test(url)){
+                return 1;
+            }else if (/\.m3u8/.test(url)) {
+                var urlcode = JSON.parse(fetch(url,{withStatusCode:true,timeout:1500}));
+                //log(name+'url访问状态码：'+urlcode.statusCode)
+                if(urlcode.statusCode==-1){
+                    log(name+'>√m3u8探测超时未拦载，结果未知')
+                    return 1;
+                }else if(urlcode.statusCode!=200){
+                    log(name+'>√m3u8播放地址疑似失效或网络无法访问，不信去验证一下>'+url);
+                    return 0;
+                }else{
+                    try{
+                        var tstime = urlcode.body.match(/#EXT-X-TARGETDURATION:(.*?)\n/)[1];
+                        var urltss = urlcode.body.replace(/#.*?\n/g,'').replace('#EXT-X-ENDLIST','').split('\n');
+                    }catch(e){
+                        log(name+'>√错误：探测异常未拦截>'+e.message)
+                        return 1;
+                    }
+                    if(parseInt(tstime)*parseInt(urltss.length) < times){
+                        log(name+'>√m3u8视频长度小于'+times+'s，疑似跳舞小姐姐或防盗小视频，不信去验证一下>'+url);
+                        return 0;
+                    }else{
+                        var urlts = urltss[0];
+                        if(/^http/.test(urlts)&&!urlts.match(/youku|iqiyi|ixigua|migu|sohu|pptv|le|cctv|1905|mgtv|qq.com/)){
+                            var tscode = JSON.parse(fetch(urlts,{headers:{'Referer':url},onlyHeaders:true,timeout:1500}));
+                            //log(name+'ts访问状态码：'+tscode.statusCode)
+                            if(tscode.statusCode==-1){
+                                log(name+'>√ts段探测超时未拦载，结果未知')
+                                return 1;
+                            }else if(tscode.statusCode!=200 && tscode.statusCode!=403){
+                                log(name+'>√ts段地址疑似失效或网络无法访问，不信去验证一下>'+url);
+                                return 0;
+                            }
+                        }
+                    }
+                }
+            }else if (/\.mp4/.test(url)) {
+                var urlheader = JSON.parse(fetch(url,{onlyHeaders:true,timeout:1500}));
+                if(urlheader.statusCode==-1){
+                    log(name+'>√mp4探测超时未拦载，结果未知')
+                    return 1;
+                }else if(urlheader.statusCode!=200){
+                    log(name+'>√mp4播放地址疑似失效或网络无法访问，不信去验证一下>'+url);
+                    return 0;
+                }else{
+                    var filelength = urlheader.headers['content-length'];
+                    if(parseInt(filelength[0])/1024/1024 < 30){
+                        log(name+'>√mp4播放地址疑似跳舞小姐姐或防盗小视频，不信去验证一下>'+url);
+                        return 0;
+                    }
+                }
+            }
+            return 1;
+        } catch(e) {
+            log(name+'>√错误：探测异常未拦截，可能是失败的>'+e.message)
+            return 1;
+        }
+    }
+}

SrcJiemi.js

@@ -1,53 +0,0 @@
-var jiemi = {
-    获取私钥: function (order) {
-        if(typeof(order)==='string' && order.length>=848){
-            return order
-        }
-        var pkcs8Private;
-        let pkcs8Private1 = `-----BEGIN PRIVATE KEY-----
-        MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAK5WtrOWxP8FHYRu
-        t+qp2kz0JNfv47nj+EH9R/Ft7E7WeCUC/AcXcjrHQV0JqyAUQRec/7tBZZhOcQff
-        QB1flDVAsYvz8GlQfEumWK1zmf9YlljzaJq04jPXKVfr9eAiH1lcR1CsYKMqBK9b
-        W2Xm42QRwSFhijmUlrbNo2Cj1RC9AgMBAAECgYEAiSGQKIcpgWcmpqroY98i5XEN
-        IgWB3RBikJWH53INdJ3id0p3r6RTp8Rft60JO/xyjv5hcYupPDpHUmfa6L/rtQMi
-        AAiak6pWPasi+rMWHkWIyAHz3Lxxn89GeX1vC2FNqp9yLdRhc1qO3CMBz4AFiJPk
-        H2CRqZKNPc3boSW+j4kCQQDZ4j6s98yFErvN1OfJOTAfrfsB4cZdeClt63cxJpWe
-        cAUMBIGCloed663tgesag7a6X8JTBE2+GupxlT4VIuZDAkEAzNZWgta+H0eN6X7T
-        pk1Lyt/lrAW/l36PI6ft1y7fpKoJMQVA7sbIG4vHDIFW9EabAnABQ7HH3NiVDVsk
-        vt48/wJBAM82OnMXKzs3aMJFA7a8G4dVV80fYh6MY6I0+GMXFd3bHQGj22NNM2a9
-        t+iT0PqjXwl6fn2jLyhnwqUI0UUarq8CQFyT8v2neL5CZM1HWPksrji/ANrCrlkW
-        BjOjTkeXE9UkVIsnSLWiegaZIhlwy5AT6TMs1CV4UFBsQtGKhA0P/JkCQC28mkKq
-        uc0mONTWMSenwXHfpAzhOP3l/NxJBkVXPunaOb6kOP7JejGMjMhnRHh4nDiGQRi9
-        Kfo65lNN215J10s=
-        -----END PRIVATE KEY-----`;
-        switch (order){
-            default:
-                pkcs8Private = pkcs8Private1;
-                break;
-        }
-        pkcs8Private = pkcs8Private.split('\n').slice(1,-1).join('');
-        return pkcs8Private
-    },
-    rsaDec: function (data){
-        order = false;
-        if(/data|list|msg|code|{|}/.test(data)){
-            return data
-        }
-        let pkcs8Private = 获取私钥(order);
-        try {
-            let decodedData = rsaDecrypt(data, pkcs8Private, {
-                config: "RSA/ECB/PKCS1Padding",
-                type: 1,
-                long: 2
-            });
-            if(!decodedData){
-                log('通讯解密不正确:',decodedData);
-            }
-            return decodedData||data
-        }
-        catch (e) {
-            log('通讯解密失败:'+e.message);
-            return data
-        }
-    }
-}

SrcJiexi.html

@@ -1,22 +0,0 @@
-<!doctype html>
-<html>
-<head>
-<title>解析</title>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE10" />
-<meta name="renderer" content="webkit|ie-comp|ie-stand">
-<meta name="viewport" content="width=device-width">
-</head>
-<body>
-<script>
-var apiArray=["https://jx.m3u8.tv/jiexi/?url=","https://jx.parwix.com:4433/player/?url=","https://www.1717yun.com/api/?url="];
-var origin=document.location.href.split("url=")[1];
-var iframeHtml="";
-for(var i=0;i<apiArray.length;i++){
-var URL=apiArray[i]+origin;
-iframeHtml=iframeHtml+"<iframe sandbox='allow-scripts allow-same-origin allow-forms' frameborder='0' allowfullscreen='true' webkitallowfullscreen='true' mozallowfullscreen='true' src="+URL+"></iframe>";
-}
-document.write(iframeHtml);
-</script>
-</body>
-</html>

SrcTmplVersion.js

@@ -1,25 +0,0 @@
-var newVersion = {
-    "srcDyTmpl":5.4,
-    "SrcJuying":1.9,
-    "SrcJuyingdesc":{
-        "0.1":"原始搜狗改造",
-        "0.2":"主页界面完成",
-        "0.3":"搜索界面完成",
-        "0.4":"管理界面完成",
-        "0.5":"各界面联动修复bug，功能增加完善",
-        "0.6":"搜索结果显示优化，清除无效显示；管理-扩展中心支持记录订阅历史和切换更新；管理接口和解析增加清空操作",
-        "0.7":"管理接口和解析支持聚影资源码增量导入；支持自定义设置默认搜索线程数；支持自定义设置app解析保留数",
-        "0.8":"管理-接口支持分组保存；搜索界面支持按分组进行搜索",
-        "0.9":"管理-订阅切换删除逻辑加强；依赖自动更新间隔改为3小时；自动订阅更新间隔改为3小时；ua转换改为在搜索界面执行",
-        "1.0":"管理-批量增加接口、解析时分隔符支持中英文逗号；其他资源导入时处理注释部份；增加TVb资源导入",
-        "1.1":"修复版本号和分隔符提示",
-        "1.2":"搜索界面增加快速删除；完善搜索异常错误的处理逻辑；测试记忆",
-        "1.3":"管理界面-操作增加筛选定位功能",
-        "1.4":"管理界面-定位搜索修复；其他资源导入解析未过虑问题修复；其他小问题修复",
-        "1.5":"搜索接口增强兼容很多；主页底稿数据修复异常；其他资源导入提示解析是否导入",
-        "1.6":"搜索接口显示类型和分组；增加优看明码直解支持；增加301跳转解析支持；重构解析逻辑，加强日志显示；cache增加超时；管理-解析增加排除片源手工操作",
-        "1.7":"管理解析测试改用断插常规调用方式；修复优看选集错误；去除dd的的默认ua；增强片源标识取值准确性；管理扩展中的资源码更新和删除逻辑完善",
-        "1.8":"解析逻辑升级，自动探测跳过防盗和跳舞小视频；解析增强日志显示；修复多处小bug",
-        "1.9":"探测失效优化完善；解析增强日志显示；cms改为优先videolist列表；屏蔽优先改为app类的直接全局，私有的只排除单个片源；解析增加优先片源设置"
-    }
-};

SrcVerify.js

@@ -1,17 +0,0 @@
-function verification(imgurl,headers) {
-    const File = java.io.File;
-    let javaImport = new JavaImporter();
-    javaImport.importPackage(
-        Packages.com.example.hikerview.utils
-    );
-    var bsimg = "";
-    with(javaImport) {
-        let png = "hiker://files/cache/SrcVerify.png";
-        downloadFile(imgurl, png, JSON.parse(headers));
-        let path = getPath(png).replace("file://", "");
-        bsimg = _base64.encodeToString(FileUtil.fileToBytes(path), _base64.NO_WRAP);
-        new File(path).delete();
-    }
-    evalPrivateJS("aHTJW8GUqk24nqdf1KutpXLSQxxUqCopcaSjWa/1BqbspogsD9sqzzRKQ0/eY1cbHWXKqK/7SmE36413GhDw1/LB4qZbC87N46M3cbGebQKVsuA+wqokqyn1sWZEySrRyJHtbzpZgnEP0XYECOKzPs0qEDbm2B+3gV+JGJA37bwIqwzm/veCOIIpZgmIiRR++Nd7tnLMDBM+/vxyS+MXfE2IYkez6NE1hioj8TQ9X7UxWHZGX1PS2hc8lotTz+2qqC3Kwy5Jx6cr8zh4grgoykYsrWLjm4wLbAoSHl3Oe6QNNx+Tloen/mKR5K8c2B7xsnPja73djQkKloPGX+pCQHx8DJHZqptu2ObISfk3jBqUk2o06nxPvcT1geVKM4Sz")
-    return ocr(bsimg,config.依赖);
-}

plugins/UrlProcessor.js

@@ -1,122 +0,0 @@
-/**
- * 本地网页插件链接 hiker://files/rules/js/UrlProcessor.js
- * 子页面链接 hiker://page/url-processor
- * 道长仓库链接 http://hiker.nokia.press/hikerule/rulelist.json?id=2849
- * 码云 Gitee 链接 https://gitee.com/reborn0/HikerRules/raw/master/plugins/UrlProcessor.js
- */
-function UrlProcessor() {
-    this.params = {}
-    this.regexMap = [
-        {
-            reg: 'vodtype\\/(\\d+)',
-            exec: () => {
-                return this.params.url
-                    .replace(/vodtype(\/\d+)\.html/, 'vodshow$1-----------.html')
-                    .replace(/\d*(---\d*(\.html|\/))/, this.params.page + '$1')
-            }
-        },
-        {
-            reg: 'type\\/\\w+',
-            exec: () => {
-                return this.params.url
-                    .replace(/type(\/\w+)\//, 'show$1-----------/')
-                    .replace(/\d*(---\d*(\.html|\/))/, this.params.page + '$1')
-            }
-        },
-        {
-            reg: '(vodtype|videot)\\/\\w+',
-            exec: () => {
-                return this.params.url
-                    .replace(/-\d+\.html/, '-' + this.params.page + '.html')
-                    .replace(/((vodtype|videot)\/\w+)\.html/, '$1-' + this.params.page + '.html')
-            }
-        },
-        {
-            reg: '\\/?[\\w\\d]+-.*?-.*?-.*?-.*?-.*?-.*?-.*?-\\d*---\\d*(\\.html|\\/)',
-            exec: () => {
-                return this.params.url
-                    .replace(/\d*(---\d*(\.html|\/))/, this.params.page + '$1') // 拼接页码
-            }
-        },
-        {
-            reg: '((\\/vod\\/show)?(\\/area\\/[\\w\\d%]+)?(\\/by\\/[\\w\\d%]+)?(\\/id\\/\\d+)?(\\/letter\\/[\\w\\d%]+)?)(\\/page\\/\\d+)?(\\/year\\/\\d+)?\\.html',
-            exec: () => {
-                let regExp = /((\/vod\/show)?(\/area\/[\w\d%]+)?(\/by\/[\w\d%]+)?(\/id\/\d+)?(\/letter\/[\w\d%]+)?)(\/page\/\d+)?(\/year\/\d+)?\.html/
-                return this.params.url
-                    .replace(regExp, '$1' + ("/page/" + this.params.page) + '$8' + ".html")
-            }
-        }
-    ]
-}
-
-Object.assign(UrlProcessor.prototype, {
-    constructor: UrlProcessor,
-    checkParams() {
-        if (!this.params.url) {
-            throw new Error("请先调用 .baseUrl(url) 传入链接进行初始化!")
-        }
-        if (!this.params.page) {
-            throw new Error("请先调用 .page(page) 传入页码进行初始化!")
-        }
-    },
-    baseUrl(url){
-        this.params.url = url
-        return this
-    },
-    page(page){
-        this.params.page = page
-        return this
-    },
-    addExtra(regExp) {
-        if (regExp.constructor === Array) {
-            this.regexMap = this.regexMap.concat(regExp)
-        } else {
-            this.regexMap.push(regExp)
-        }
-        return this;
-    },
-    debug() {
-        this.params.debug = true
-        return this;
-    },
-    exec() {
-        this.checkParams()
-        let true_url = ''
-        for (let i = 0; i < this.regexMap.length; i++) {
-            let regObj = this.regexMap[i];
-            let urlExp = regObj.reg;
-            if (typeof urlExp === 'string') {
-                urlExp = new RegExp(urlExp)
-            }
-            if (urlExp.test(this.params.url)) {
-                if (this.params.debug) {
-                    log(urlExp.toString())
-                }
-                true_url = regObj.exec();
-                break;
-            }
-        }
-        if (true_url) {
-            return true_url;
-        } else {
-            return this.params.url
-        }
-    },
-    获取处理结果() {
-        return this.exec()
-    },
-    链接(url) {
-        return this.baseUrl(url)
-    },
-    页码(page) {
-        return this.page(page)
-    },
-    插入新处理规则(regExp) {
-        return this.addExtra(regExp)
-    },
-    调试模式() {
-        return this.debug();
-    }
-})
-$.exports=new UrlProcessor()
-$.exports

plugins/categories-header.js

@@ -1,495 +0,0 @@
-/**
- * 本地网页插件链接 hiker://files/rules/js/categories-header.js
- * 子页面链接 hiker://page/categories-header
- * 道长仓库链接 http://hiker.nokia.press/hikerule/rulelist.json?id=2705
- * 码云 Gitee 链接 https://gitee.com/reborn0/HikerRules/raw/master/plugins/categories-header.js
- */
-/**
- * Object.assign 用法参考链接
- *
- * 1.https://www.daimajiaoliu.com/daima/47139a9e7100407
- * 2.https://segmentfault.com/a/1190000011778875
- * 3.https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
- */
-// 利用 Symbol 实现私有变量和私有方法，外界不可访问（参考链接2）
-const symbolMap = {
-    // checkParams: Symbol('checkParams'),
-    mLayout: Symbol('mLayout'),
-    true_url: Symbol('true_url'),
-    mPage: Symbol('mPage'),
-    src: Symbol('src'),
-    ruleObjList: Symbol('ruleObjList'),
-    mFold: Symbol('mFold'),
-    mFoldInnerEnable: Symbol('mFoldInnerEnable'),
-    mFoldIndex: Symbol('mFoldIndex'),
-    mFoldLayout: Symbol('mFoldLayout'),
-    mColor: Symbol('mColor'),
-    mTag: Symbol('mTag'),
-}
-
-function CategoriesHeader(color) {
-    // 'use strict';
-    // ...
-    // this[symbolMap.listRule] = []
-    // this[symbolMap.subListRule] = []
-    this[symbolMap.mColor] = color || "#FA7298";
-    this[symbolMap.ruleObjList] = []
-    this.VARMAP = {
-        CATEGORY: "header.category",
-        URL: "header.url",
-        FOLD: "header.fold",
-    }
-    this[symbolMap.mFoldLayout] = {
-        injectIndex: 1
-    }
-    this[symbolMap.mFoldIndex] = 1
-}
-
-Object.assign(CategoriesHeader.prototype, {
-    // Override 构造方法，相当于 function.prototype.constructor = (...) => {...}，new function() 的时候会自动执行
-    constructor: CategoriesHeader,
-    // 定义私有方法
-    VERSION: 202112011900,
-    checkParams() {
-        if (!this[symbolMap.mLayout]) {
-            throw new Error("请调用 layout(d) 传入当前界面")
-        }
-        if (!(this[symbolMap.src] || this[symbolMap.true_url])) {
-            throw new Error("请调用 trueUrl(url) 传入当前分类的链接或调用 html(mHtml) 传入当前分类页面的源码")
-        }
-        if (!this[symbolMap.mPage]) {
-            throw new Error("请调用 page(mPage) 传入当前页数")
-        }
-        if (this[symbolMap.ruleObjList].length < 1) {
-            throw new Error("请调用相关方法传入定位规则")
-        }
-        if (!this[symbolMap.mFold]) {
-            this[symbolMap.mFold] = '0'
-        }
-    },
-    layout(mLayout) {
-        this[symbolMap.mLayout] = mLayout
-        return this
-    },
-    trueUrl(url) {
-        this[symbolMap.true_url] = url
-        return this
-    },
-    page(mPage) {
-        if (typeof (mPage) === 'string') {
-            mPage = parseInt(mPage)
-        }
-        this[symbolMap.mPage] = mPage
-        return this
-    },
-    html(mSrc) {
-        this[symbolMap.src] = mSrc
-        return this
-    },
-    list(rule) {
-        if (this[symbolMap.ruleObjList].length > 0) {
-            throw new Error("list(rule) add(ruleObj) 只能二选一！")
-        }
-        this[symbolMap.ruleObjList] = [{}]
-        this[symbolMap.ruleObjList][0].listRule = rule
-        this[symbolMap.ruleObjList][0]['一级分类'] = rule
-        return this
-    },
-    subList(rule) {
-        if (this[symbolMap.ruleObjList].length > 1) {
-            throw new Error("subList(rule) add(ruleObj) 只能二选一！")
-        }
-        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {
-            throw new Error("请先调用 list(rule) 或 一级分类(rule) 定位一级分类")
-        }
-        this[symbolMap.ruleObjList][0].subListRule = rule
-        this[symbolMap.ruleObjList][0]['子分类'] = rule
-        return this
-    },
-    title(rule) {
-        if (this[symbolMap.ruleObjList].length > 1) {
-            throw new Error("title(rule) add(ruleObj) 只能二选一！")
-        }
-        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {
-            throw new Error("请先调用 list(rule) 或 一级分类(rule) 定位一级分类")
-        }
-        this[symbolMap.ruleObjList][0].titleRule = rule
-        this[symbolMap.ruleObjList][0]['分类标题'] = this[symbolMap.ruleObjList][0].titleRule
-        return this
-    },
-    url(rule) {
-        if (this[symbolMap.ruleObjList].length > 1) {
-            throw new Error("url(rule) add(ruleObj) 只能二选一！")
-        }
-        if (!this[symbolMap.ruleObjList][0] || (!this[symbolMap.ruleObjList][0].listRule && !this[symbolMap.ruleObjList][0]['一级分类'])) {
-            throw new Error("请先调用 list(rule) 或 一级分类(rule) 定位一级分类")
-        }
-        this[symbolMap.ruleObjList][0].urlRule = rule
-        this[symbolMap.ruleObjList][0]['分类链接'] = this[symbolMap.ruleObjList][0].urlRule
-        return this
-    },
-    /**
-     * 是否开启折叠功能
-     *
-     * @param enabled true 表示开启，false 表示禁用
-     * @returns {CategoriesHeader}
-     */
-    foldInner(enabled) {
-        if (!(typeof (enabled) === 'boolean')) {
-            throw new Error("请传入 true 或 false 表示开启或关闭折叠功能！")
-        }
-        this[symbolMap.mFoldInnerEnable] = enabled
-        return this
-    },
-    /**
-     * 从第 index 行开始折叠
-     *
-     * @param index 开始折叠的行数
-     * @returns {CategoriesHeader}
-     */
-    foldIndex(index) {
-        if (!(typeof (index) === 'number')) {
-            throw new Error("开始折叠行请传入数字！")
-        }
-        if (index < 1) {
-            throw new Error("开始折叠行请传入大于 0 的整数！")
-        }
-        this[symbolMap.mFoldIndex] = index || 1;
-        return this
-    },
-    /**
-     * 折叠按钮的界面
-     *
-     * @param layout 与 d.push 结构一致，
-     *        例：{ title:"标题1", url:"xxx", col_type:"scroll_button" };
-     *        参数采用可选覆盖模式，不写的参数则使用默认;
-     *        比如传入 { col_type:"text_1" }，那最终结果就是 { title:"标题1", url:"xxx", col_type:"text_1" }
-     * @returns {CategoriesHeader}
-     */
-    foldLayout(layout) {
-        if (typeof layout === 'object') {
-            let keys = Object.keys(layout)
-            let injectIndex = layout.injectIndex || layout['折叠按钮插入行']
-            if (layout.title || layout.url || layout.col_type || injectIndex) {
-                for (let i = 0; i < keys.length; i++) {
-                    const key = keys[i]
-                    this[symbolMap.mFoldLayout][key] = layout[key];
-                }
-            } else {
-                throw new Error("请传入正确的折叠界面元素！")
-            }
-            // injectIndex 折叠按钮插入第 injectIndex 行
-            if (injectIndex) {
-                if (!(typeof (injectIndex) === 'number')) {
-                    throw new Error("折叠按钮插入行请传入数字！")
-                }
-                if (injectIndex < 1) {
-                    throw new Error("折叠按钮插入行请传入大于 0 的整数！")
-                }
-                if (injectIndex > this[symbolMap.mFoldIndex]) {
-                    throw new Error("折叠按钮插入行不得大于显示折叠行数！请调用 .foldIndex(index) 或 .第几行开始折叠(index) 传入正确的显示折叠行数")
-                }
-                this[symbolMap.mFoldLayout].injectIndex = injectIndex || 1;
-            }
-        } else {
-            throw new Error("请传入正确的折叠界面元素！")
-        }
-        return this;
-    },
-    // 当前是否折叠
-    fold(isFold) {
-        if (typeof (isFold) === 'string') {
-            isFold = isFold === '1'
-        }
-        if (isFold) {
-            this[symbolMap.mFold] = '1';
-        } else {
-            this[symbolMap.mFold] = '0';
-        }
-        return this
-    },
-    color(mColor) {
-        this[symbolMap.mColor] = mColor
-        return this
-    },
-    tag(mTag) {
-        this[symbolMap.mTag] = mTag
-        return this
-    },
-    add(ruleObj) {
-        // log($.stringify(ruleObj))
-        if (ruleObj.constructor === Array) {
-            this[symbolMap.ruleObjList] = this[symbolMap.ruleObjList].concat(ruleObj)
-        } else {
-            this[symbolMap.ruleObjList].push(ruleObj)
-        }
-        return this;
-    },
-    evalJSRule(item, jsRule) {
-        let rule = jsRule.replace("@js:", "")
-        rule = rule.trim()
-        // log($.stringify(rule))
-        let input = item
-        if (rule.startsWith("(")) {
-            eval('result = ' + rule)
-        } else {
-            /**
-             * 还原成 $.toString(...) 的最终结果，达到最终处理方式跟上面的 if 一致的目的
-             */
-            eval('result = ' + '(() => {' + rule + '})()')
-        }
-        return (result || '')
-    },
-    getTitle(src, category) {
-        let title = ''
-        let titleRule = category.titleRule || 'a&&Text'
-        if (titleRule.startsWith("@js:")) {
-            title = this.evalJSRule(src, titleRule)
-        } else {
-            title = parseDomForHtml(src, titleRule)
-        }
-        return title.trim() || "";
-    },
-    getUrl(src, category) {
-        let url = ''
-        let urlRule = category.urlRule || 'a&&href'
-        if (typeof urlRule === 'object') {
-            let mUrlRule = urlRule.rule || urlRule['解析规则'] || 'a&&href';
-            if (mUrlRule.startsWith("@js:")) {
-                url = this.evalJSRule(src, mUrlRule);
-            } else {
-                let parse = parseDom;
-                if (urlRule.parseOption) {
-                    switch (urlRule.parseOption) {
-                        case "parseDom":
-                        case "pd":
-                            parse = parseDom;
-                            break;
-                        case "parseDomForHtml":
-                        case "pdfh":
-                            parse = parseDomForHtml;
-                            break;
-                        default:
-                            parse = parseDom;
-                    }
-                } else if (urlRule["解析方法"]) {
-                    switch (urlRule["解析方法"]) {
-                        case "parseDom":
-                        case "pd":
-                            parse = parseDom;
-                            break;
-                        case "parseDomForHtml":
-                        case "pdfh":
-                            parse = parseDomForHtml;
-                            break;
-                        default:
-                            parse = parseDom;
-                    }
-                }
-                url = parse(src, mUrlRule);
-            }
-            if (urlRule.dealUrl) {
-                url = urlRule.dealUrl(url)
-            } else if (urlRule['二次处理']) {
-                url = urlRule['二次处理'](url)
-            }
-        } else {
-            if (urlRule.startsWith("@js:")) {
-                url = this.evalJSRule(src, urlRule);
-            } else {
-                url = parseDom(src, urlRule);
-            }
-        }
-        return url || "";
-    },
-    build() {
-        // 检测是否传入需要的参数
-        this.checkParams()
-        // 每一个分类的唯一标识
-        let mTag = this[symbolMap.mTag] || ""
-        //翻页 需要根据实际替换
-        const html = this[symbolMap.src] || request(this[symbolMap.true_url])
-        const empty = "hiker://empty"
-        //获取列表
-        const categories = []
-        this[symbolMap.ruleObjList].map(ruleObj => {
-            let list = []
-            let listRule = ruleObj.listRule || ruleObj["一级分类"]
-            if (listRule.startsWith("@js:")) {
-                // log($.stringify(listRule))
-                list = this.evalJSRule(html, listRule)
-            } else {
-                list = parseDomForArray(html, listRule)
-            }
-            // log(list)
-            list.map(category => {
-                categories.push({
-                    list: category,
-                    subListRule: ruleObj.subListRule || ruleObj["子分类"],
-                    titleRule: ruleObj.titleRule || ruleObj["分类标题"],
-                    urlRule: ruleObj.urlRule || ruleObj["分类链接"],
-                });
-            })
-        })
-
-        // log($.stringify(categories))
-
-        let init_cate = []
-        for (let i = 0; i < 20; i++) {
-            init_cate.push("0")
-        }
-
-        const cate_temp_json = getMyVar(mTag + this.VARMAP.CATEGORY, JSON.stringify(init_cate))
-        const cate_temp = JSON.parse(cate_temp_json)
-
-        if (this[symbolMap.mPage] === 1) {
-
-            categories.forEach((category, index) => {
-
-                // 折叠 UI
-                if (this[symbolMap.mFoldInnerEnable] && this[symbolMap.mFoldLayout].injectIndex === (index+1)) {
-                    let foldLayout = {
-                        title: this[symbolMap.mFoldLayout].title || (this[symbolMap.mFold] === '1' ? '““””<b><span style="color: #FF0000">∨</span></b>' : '““””<b><span style="color: #1aad19">∧</span></b>'),
-                        url: this[symbolMap.mFoldLayout].url || $("hiker://empty#noHistory#").lazyRule((params) => {
-                            putMyVar(params.mTag + params.VARMAP.FOLD, getMyVar(params.mTag + params.VARMAP.FOLD, params.isFold) === '1' ? '0' : '1')
-                            refreshPage(false);
-                            return "hiker://empty"
-                        }, {
-                            mTag: mTag,
-                            isFold: this[symbolMap.mFold],
-                            VARMAP: this.VARMAP
-                        }),
-                        col_type: this[symbolMap.mFoldLayout].col_type || "scroll_button",
-                    }
-                    this[symbolMap.mLayout].push(foldLayout)
-                }
-
-                //具体列表下的分类
-                let sub_categories = [];
-                if (category.subListRule.startsWith("@js:")) {
-                    sub_categories = this.evalJSRule(category.list, category.subListRule)
-                } else {
-                    sub_categories = parseDomForArray(category.list, category.subListRule);
-                }
-                if (index < (this[symbolMap.mFoldIndex] || 1)) {
-                    sub_categories.forEach((item, key) => {
-                        let title = this.getTitle(item, category)
-                        let url = this.getUrl(item, category)
-
-                        this[symbolMap.mLayout].push({
-                            title: key.toString() === cate_temp[index] ? '““””<b><font color=' + this[symbolMap.mColor] + '>' + title + ' </font></b>' : title,
-                            url: $(url).lazyRule((params) => {
-                                let new_cate = []
-                                if (params.index === 0) {
-                                    params.cate_temp.forEach((cate, index) => {
-                                        new_cate.push(index === 0 ? params.key.toString() : "0")
-                                    });
-                                } else {
-                                    params.cate_temp[params.index] = params.key.toString()
-                                }
-                                putMyVar(params.tag + params.VARMAP.CATEGORY, JSON.stringify(params.index === 0 ? new_cate : params.cate_temp))
-                                putMyVar(params.tag + params.VARMAP.URL, input)
-                                refreshPage(true)
-                                return "hiker://empty"
-                            }, {
-                                cate_temp: cate_temp,
-                                index: index,
-                                VARMAP: this.VARMAP,
-                                tag: mTag,
-                                key: key,
-                                page: this[symbolMap.mPage],
-                            }),
-                            col_type: 'scroll_button',
-                        })
-                    })
-                    this[symbolMap.mLayout].push({
-                        col_type: "blank_block"
-                    });
-                } else if (this[symbolMap.mFold] === '0') {
-                    sub_categories.forEach((item, key) => {
-                        let title = this.getTitle(item, category)
-                        let url = this.getUrl(item, category)
-
-                        this[symbolMap.mLayout].push({
-                            title: key.toString() === cate_temp[index] ? '““””<b><font color=' + this[symbolMap.mColor] + '>' + title + ' </font></b>' : title,
-                            url: $(url).lazyRule((params) => {
-                                params.cate_temp[params.index] = params.key.toString()
-
-                                putMyVar(params.tag + params.VARMAP.CATEGORY, JSON.stringify(params.cate_temp))
-                                putMyVar(params.tag + params.VARMAP.URL, input)
-                                refreshPage(true)
-                                return "hiker://empty"
-                            }, {
-                                cate_temp: cate_temp,
-                                index: index,
-                                VARMAP: this.VARMAP,
-                                tag: mTag,
-                                key: key,
-                                page: this[symbolMap.mPage],
-                            }),
-                            col_type: 'scroll_button',
-                        })
-                    })
-                    this[symbolMap.mLayout].push({
-                        col_type: "blank_block"
-                    });
-                }
-            });
-        }
-    },
-
-    界面(layout) {
-        return this.layout(layout)
-    },
-    分类链接(trueUrl) {
-        return this.trueUrl(trueUrl);
-    },
-    页码(page) {
-        return this.page(page);
-    },
-    源码(html) {
-        return this.html(html);
-    },
-    定位一级分类(list) {
-        return this.list(list);
-    },
-    定位子分类(subList) {
-        return this.subList(subList);
-    },
-    定位分类标题(title) {
-        return this.title(title);
-    },
-    定位分类链接(url) {
-        return this.url(url);
-    },
-    开启内置折叠功能() {
-        return this.foldInner(true);
-    },
-    关闭内置折叠功能() {
-        return this.foldInner(false);
-    },
-    第几行开始折叠(index) {
-        return this.foldIndex(index);
-    },
-    折叠按钮样式(layout) {
-        return this.foldLayout(layout)
-    },
-    折叠(fold) {
-        return this.fold(fold);
-    },
-    选中的分类颜色(color) {
-        return this.color(color);
-    },
-    唯一标识(mTag) {
-        return this.tag(mTag)
-    },
-    添加分类定位(ruleObj) {
-        return this.add(ruleObj);
-    },
-    开始打造分类() {
-        return this.build();
-    },
-
-})
-$.exports = new CategoriesHeader();
-$.exports

srcconfig.js

@@ -1 +0,0 @@
-var configvar = {};