Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥装逼生成器,装逼制图神器@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"ysfx\",\"path\":\"ysfx\",\"rule\":\"js:\\nvar d = [];\\nlet rule = getParam(\\\"r\\\").split(\\\"##\\\")[0];\\nlet url = MY_URL.split(\\\"##\\\")[1];\\nlet ite = $.require(\\\"hiker://page/u\\\")(rule, getHome(url));\\nlet js = $.toString(() => {\\n    try {\\n        if (document.title && document.title.length) {\\n            let r = $$$().lazyRule((t) => {\\n                setPageTitle(t);\\n            }, document.title);\\n            fy_bridge_app.parseLazyRule(r);\\n        }\\n    } catch (e) {\\n        fy_bridge_app.log(e.toString());\\n    }\\n});\\nlet js2 = $.require(\\\"hiker://page/x5ai\\\")(rule, url);\\nd.push({\\n    title: \\\"\\\",\\n    url: url,\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"100%&&float\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        urlInterceptor: ite,\\n        js: js + \\\";\\\\n\\\" + js2,\\n        canBack: true,\\n        jsLoadingInject: true,\\n        floatVideo: true\\n    }\\n});\\nd.push({\\n    col_type: \\\"line\\\",\\n    extra: {\\n        id: url\\n    }\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"u\",\"path\":\"u\",\"rule\":\"$.exports = function(rule, origin) {\\n    return $.toString((rule, origin) => {\\n        let host = origin.replace(new RegExp(\\\"http://|https://\\\"), \\\"\\\").split(\\\"/\\\")[0];\\n        let hosts = host.split(\\\".\\\");\\n        if (hosts.length > 2) {\\n            host = hosts[hosts.length - 2] + \\\".\\\" + hosts[hosts.length - 1];\\n        }\\n        if (input.startsWith(\\\"magnet\\\")) {\\n            confirm({\\n                title: \\\"温馨提示\\\",\\n                content: \\\"检测到新的磁链地址，点击确定按钮即可播放，点击取消按钮可以复制链接\\\",\\n                confirm: $.toString((mag) => {\\n                    return mag;\\n                }, input),\\n                cancel: $.toString((mag) => {\\n                    return \\\"copy://\\\" + mag\\n                }, input)\\n            })\\n            return true;\\n        } else if (input.includes(\\\"aliyundrive.com\\\")) {\\n            log(input);\\n            let r1 = fetch(\\\"hiker://home@云盘汇影\\\");\\n            if (!r1 || r1.length <= 5) {\\n                let ru = $.toString(() => {\\n                    return \\\"海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@云盘汇影@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\\\"\\n                });\\n                confirm({\\n                    title: '温馨提示',\\n                    content: '本规则依赖云盘汇影规则，点击下面的确定按钮导入，注意导入后一定要在云盘汇影登录阿里云盘账号，否则不能用',\\n                    confirm: ru,\\n                    cancel: ru\\n                });\\n                return false;\\n            }\\n            log(\\\"input\\\");\\n            return $.toString((url, rule) => {\\n                fy_bridge_app.open(JSON.stringify({\\n                    title: \\\"阿里云盘\\\",\\n                    url: \\\"hiker://page/detail?rule=云盘汇影&url=\\\" + url + '??fypage',\\n                }))\\n            }, input, rule)\\n        } else if (/\\\\.(mp3|flac|m4a)$/.test(input)) {\\n            log(input);\\n            return $.toString((url, rule) => {\\n                fy_bridge_app.playVideo(url);\\n            }, input, rule)\\n        } else if (!input.includes(host) && input.startsWith(\\\"http\\\")) {\\n            log(input);\\n            return $.toString((url, rule) => {\\n                let white = [\\n                    \\\"douyin\\\",\\n                    \\\"douban\\\",\\n                    \\\"ixigua.com\\\",\\n                    \\\"kuaishou\\\",\\n                    \\\"bilibili\\\",\\n                    \\\"weibo\\\",\\n                    \\\"weixin\\\",\\n                    \\\"baidu\\\",\\n                    \\\"zmk.\\\",\\n                    \\\"subhd\\\",\\n                    \\\"thunder\\\",\\n                    \\\"xinjuc\\\",\\n                    \\\"grab4k\\\",\\n                    \\\"/bt\\\",\\n                    \\\"jsr10\\\",\\n                    \\\"assrt\\\",\\n                    \\\"quark\\\"\\n                ];\\n                let inWhite = white.filter(it => url.includes(it)).length > 0;\\n                if (inWhite) {\\n                    //跳网页\\n                    fy_bridge_app.open(JSON.stringify({\\n                        title: \\\"详情\\\",\\n                        url: \\\"hiker://page/ysfx?rule=\\\" + rule + \\\"&r=\\\" + rule + \\\"##\\\" + url,\\n                    }))\\n                } else {\\n                    //AI解析\\n                    fy_bridge_app.open(JSON.stringify({\\n                        title: document.title,\\n                        url: \\\"hiker://page/p?rule=\\\" + rule + \\\"&r=\\\" + rule + \\\"&u=\\\" + fy_bridge_app.base64Encode(url),\\n                    }))\\n                }\\n            }, input, rule);\\n        } else if (!input.startsWith(\\\"http\\\")) {\\n            log(input);\\n            //能唤起APP的白名单\\n            let white = [\\n                \\\"qklink\\\",\\n                \\\"bdnetdisk\\\",\\n                \\\"xunleiapp\\\"\\n            ];\\n            let inWhite = white.filter(it => input.startsWith(it)).length > 0;\\n            if (!inWhite) {\\n                return false;\\n            }\\n            return $.toString((url, rule) => {\\n                fy_bridge_app.openThirdApp && fy_bridge_app.openThirdApp(url);\\n            }, input, rule)\\n        } else {\\n            let white = [\\n                \\\"url=\\\",\\n                \\\"fsou.com\\\",\\n                \\\"bing.\\\",                \\n            ];\\n            let inWhite = white.filter(it => input.includes(it)).length > 0;\\n            if (inWhite) {\\n                return false;\\n            }\\n            let reg = new RegExp(\\\"[\\\\u4e00-\\\\u9fa5]+\\\", \\\"g\\\");\\n            let r = decodeURIComponent(input);\\n            if (reg.test(r) || (input.startsWith(origin) && input.length - origin.length > 2)) {\\n                //有中文，应该是在搜索，跳新页面\\n                return $.toString((url, rule) => {\\n                    fy_bridge_app.open(JSON.stringify({\\n                        title: \\\"详情\\\",\\n                        url: \\\"hiker://page/ysfx?rule=\\\" + rule + \\\"&r=\\\" + rule + \\\"##\\\" + url,\\n                    }));\\n                }, input, rule);\\n            }\\n        }\\n    }, rule, origin);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级解析\",\"path\":\"p\",\"rule\":\"js:\\nvar d = [];\\nlet url = base64Decode(getParam(\\\"u\\\"));\\nlet list = storage0.getItem(\\\"white\\\", []);\\nlet inWhite = list.includes(url);\\nlet d = [];\\nif (!inWhite) {\\n    let html = request(url);\\n    let web = getItem('web', '0') == \\\"1\\\";\\n    let rule = getParam(\\\"r\\\");\\n    let parse = $.require(\\\"hiker://page/parse\\\");\\n    d = parse(rule, web, url, html);\\n}\\nif (d.length == 0) {\\n    //匹配失败\\n    let ite = $.require(\\\"hiker://page/u\\\")(getParam(\\\"r\\\"), getHome(url));\\n    let js = $.toString(() => {\\n        try {\\n            if (document.title && document.title.length) {\\n                let r = $$$().lazyRule((t) => {\\n                    setPageTitle(t);\\n                }, document.title);\\n                fy_bridge_app.parseLazyRule(r);\\n            }\\n        } catch (e) {\\n            fy_bridge_app.log(e.toString());\\n        }\\n    });\\n    let js2 = $.require(\\\"hiker://page/x5ai\\\")(getParam(\\\"r\\\"), url);\\n    d.push({\\n        title: \\\"\\\",\\n        url: url,\\n        col_type: \\\"x5_webview_single\\\",\\n        desc: \\\"float&&100%\\\",\\n        pic_url: \\\"\\\",\\n        extra: {\\n            js: js + \\\";\\\\n\\\" + js2,\\n            urlInterceptor: ite,\\n            canBack: true,\\n            floatVideo: true,\\n            jsLoadingInject: true\\n        }\\n    });\\n    d.push({\\n        col_type: \\\"line\\\",\\n        extra: {\\n            id: url\\n        }\\n    });\\n    if (!inWhite) {\\n        toast(\\\"AI匹配失败，已使用X5加载\\\");\\n    }\\n    setResult(d);\\n} else {\\n    setResult(d);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级parse\",\"path\":\"parse\",\"rule\":\"$.exports = function(rule, web, url, html) {\\n    let d = [];\\n\\n    let alist = pdfa(html, \\\"body&&a\\\");\\n    let arr = alist.map(it => {\\n        return {\\n            //html: it,\\n            text: pdfh(it, \\\"a&&Text\\\"),\\n            title: pdfh(it, \\\"a&&title\\\"),\\n            href: pd(it, \\\"a&&href\\\", url)\\n        }\\n    });\\n    //log(arr);\\n    let debug = false;\\n\\n    function clearText(it) {\\n        return it.replace(/第|集|章/g, \\\"\\\");\\n    }\\n\\n    function isMovie(it) {\\n        if (it == null || it.text == null) {\\n            return false;\\n        }\\n        let tit = it.title || \\\"\\\";\\n        it = it.text || \\\"\\\";\\n        if (it == \\\"\\\" || it.length > 8) {\\n            return false;\\n        }\\n        //排除\\n        let reg = /\\\\.|高清直播|写真推荐|影院|影视|蓝光电影|高清电影|第一季|第二季|第三季|第四季|第五季/;\\n        if (tit != \\\"\\\" && !tit.includes(it) || reg.test(it)) {\\n            return false;\\n        }\\n        return it.match(/原画|备用|蓝光|超清|高清|正片|韩版|4K|4k|1080P|720P|TC|HD|BD/)\\n    }\\n\\n    function notChapter(it) {\\n        if (it == null || it.text == null) {\\n            return true;\\n        }\\n        return it.text.match(/[0-9]\\\\.[0-9]分/);\\n    }\\n\\n    function isChapter(it, pre, next) {\\n        if (notChapter(it)) {\\n            //优先排除\\n            return false;\\n        }\\n        //判断是不是电影\\n        if (isMovie(it)) {\\n            return true;\\n        }\\n        return isChapter0(it, pre) || isChapter0(it, next);\\n    }\\n\\n    function getChapterNum(it) {\\n        if (it == null || it.text == null) {\\n            return -1;\\n        }\\n        it = it.text || \\\"\\\";\\n        if (it == \\\"\\\") {\\n            return -1;\\n        }\\n        it = clearText(it);\\n        let reg = /^[0-9]*$/;\\n        if (!reg.test(it)) {\\n            return -1;\\n        }\\n        it = parseInt(it);\\n        if (isNaN(it)) {\\n            return -1;\\n        }\\n        if (it > 1900 && it < 2100) {\\n            return -1;\\n        }\\n        return it;\\n    }\\n\\n    function isChapter0(it, brother) {\\n        /*if (debug) {\\n            log({\\n                it: it,\\n                brother: brother\\n            });\\n        }*/\\n        it = getChapterNum(it);\\n        //if (debug) log(it);\\n        if (it < 0) {\\n            return false;\\n        }\\n        brother = getChapterNum(brother);\\n        //if (debug) log(brother);\\n        if (brother < 0) {\\n            return false;\\n        }\\n        return it - brother < 2 && it - brother > -2;\\n    }\\n\\n    let _web = $.toString(() => {\\n        let urls = _getUrls();\\n        let reg = /\\\\.html|\\\\.css|\\\\.js/;\\n        for (let k in urls) {\\n            if (!reg.test(urls[k]) && urls[k].match(/\\\\.mp4|\\\\.m3u8/)) {\\n                fy_bridge_app.log(urls[k]);\\n                return fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\"\\\")) + \\\"#ignoreImg=true#\\\";\\n            }\\n        }\\n    });\\n\\n    for (let i = 0; i < arr.length; i++) {\\n        let it = arr[i];\\n        let t = it.text;\\n        if (!it.href || it.href == \\\"\\\") {\\n            continue;\\n        }\\n        let pre = i == 0 ? null : arr[i - 1];\\n        let next = i == (arr.length - 1) ? null : arr[i + 1];\\n        if (isChapter(it, pre, next)) {\\n            if (web) {\\n                var urlx = \\\"webRule://\\\" + it.href + \\\"@\\\" + _web;\\n                var extrax = {\\n                    jsLoadingInject: true,\\n                    id: it.href,\\n                    blockRules: ['.m4a', '.mp3', '.flv', '.avi', '.3gp', '.mpeg', '.wmv', '.mov', '.rmvb', '.gif', '.jpeg', '.png', '.ico', '.svg']\\n                };\\n            } else {\\n                var urlx = \\\"video://\\\" + it.href;\\n                var extrax = {\\n                    id: it.href\\n                };\\n            }\\n            d.push({\\n                title: t,\\n                url: urlx,\\n                col_type: \\\"text_3\\\",\\n                extra: extrax\\n            });\\n        }\\n    }\\n    if (d.length == 0) {\\n        return d;\\n    } else {\\n\\n        d.splice(0, 0, {\\n            title: \\\"🔗\\\" + url,\\n            url: \\\"hiker://page/ysfx?rule=\\\" + rule + \\\"&r=\\\" + rule + \\\"##\\\" + url,\\n            col_type: \\\"text_1\\\",\\n            desc: \\\"\\\",\\n            pic_url: \\\"\\\"\\n        });\\n\\n\\n        //为线路加分割线\\n        let d2 = [];\\n        for (let i = 0; i < d.length; i++) {\\n            d2.push(d[i]);\\n            if (i < d.length - 1) {\\n                let it = d[i];\\n                let t1 = parseInt(clearText(it.title));\\n                let next = d[i + 1];\\n                let t2 = parseInt(clearText(next.title));\\n                if (t2 - t1 > 1 || t1 - t2 > 1) {\\n                    d2.push({\\n                        col_type: \\\"big_blank_block\\\"\\n                    });\\n                    d2.push({\\n                        col_type: \\\"line_blank\\\"\\n                    });\\n                    d2.push({\\n                        col_type: \\\"big_blank_block\\\"\\n                    });\\n                }\\n            }\\n        }\\n        d2.push({\\n            title: \\\"匹配有误？点我不再匹配此页面\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule((url) => {\\n                confirm({\\n                    title: \\\"温馨提示\\\",\\n                    content: \\\"如果只是单次匹配失败，点击下方取消按钮刷新页面重新匹配，如果确认无法匹配，点击下方确定按钮加入白名单\\\",\\n                    cancel: \\\"refreshPage()\\\",\\n                    confirm: $.toString((url) => {\\n                        let list = storage0.getItem(\\\"white\\\", []);\\n                        list.push(url);\\n                        storage0.setItem(\\\"white\\\", list);\\n                        refreshPage();\\n                        return \\\"toast://已加入白名单\\\"\\n                    }, url)\\n                });\\n                return \\\"hiker://empty\\\"\\n            }, url),\\n            col_type: \\\"avatar\\\",\\n            img: \\\"hiker://images/account\\\"\\n        });\\n        return d2;\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"x5AI\",\"path\":\"x5ai\",\"rule\":\"$.exports = function(rule, anchorId) {\\n    return $.toString((rule, anchorId, white) => {\\n        if (window.check0 == null) {\\n            function check0() {\\n                try {\\n                    let html = document.querySelector(\\\"html\\\").innerHTML;\\n                    fba.putVar(\\\"html0\\\", html);\\n                    fba.parseLazyRuleAsync($$$().lazyRule((rule, url, anchorId, white) => {\\n                        try {\\n                            let d = [];\\n                            let html = getVar(\\\"html0\\\", \\\"\\\");\\n                            clearVar(\\\"html0\\\");\\n                            let web = false;\\n                            let white2 = [\\n                                \\\"fsou.com\\\",\\n                                \\\"bing.\\\",\\n                            ];\\n                            let inWhite = white2.filter(it => url.includes(it)).length > 0;                            \\n                            if (!inWhite && !white.includes(url)) {\\n                                let parse = $.require(\\\"hiker://page/parse?rule=\\\" + rule);\\n                                d = parse(rule, web, url, html);\\n                            }\\n                            if (!inWhite && d.length < 1) {\\n                                try {\\n                                    let arr = pdfa(html, \\\"body&&iframe\\\");\\n                                    if (arr.length > 0) {\\n                                        let src = pdfh(arr[0], \\\"iframe&&src\\\");\\n                                        log(\\\"获取到iframe：\\\" + src);\\n                                        if (!white.includes(src)) {\\n                                            if (src && src.startsWith(\\\"http\\\") && !src.match(/\\\\.mp4|\\\\.m3u8|\\\\.mp3|\\\\.flv|\\\\.mkv/)) {\\n                                                html = request(src);\\n                                                d = parse(rule, web, src, html);\\n                                            }\\n                                        }\\n                                    }\\n                                } catch (e) {\\n                                    log(\\\"尝试获取iframe失败\\\");\\n                                }\\n                            }\\n                            if (d.length > 0) {\\n                                d[0].url = $(\\\"#noLoading#\\\").lazyRule((anchorId) => {\\n                                    let desc = getVar(anchorId, \\\"0\\\");\\n                                    if (desc == \\\"0\\\") {\\n                                        refreshX5Desc(\\\"float&&screen-170\\\");\\n                                        putVar(anchorId, \\\"1\\\");\\n                                    } else {\\n                                        refreshX5Desc(\\\"float&&0\\\");\\n                                        putVar(anchorId, \\\"0\\\");\\n                                    }\\n                                    return \\\"hiker://empty\\\";\\n                                }, anchorId + \\\"x5\\\");\\n                                d[0].title = \\\"展开/收起\\\" + d[0].title;\\n                                putVar(anchorId + \\\"x5\\\", \\\"0\\\");\\n                                refreshX5Desc(\\\"float&&0\\\");\\n                                for (let it of d) {\\n                                    let extra = it.extra || {};\\n                                    extra.cls = \\\"x5ai\\\";\\n                                    it.extra = extra;\\n                                }\\n                                deleteItemByCls(\\\"x5ai\\\");\\n                                addItemAfter(anchorId, d);\\n                                toast(\\\"AI匹配成功\\\");\\n                            }\\n                            if (d.length > 0) {\\n                                log(\\\"parseLazyRuleAsync:\\\" + d.length);\\n                            }\\n                            return d.length > 0 ? \\\"1\\\" : \\\"0\\\";\\n                        } catch (e) {\\n                            log(e.toString());\\n                        }\\n                    }, rule, location.href, anchorId, white), $$$.toString(() => {\\n                        if (\\\"0\\\" == input) {\\n                            window.checkc = window.checkc + 1;\\n                            /*if (window.checkc > 120) {\\n                                fba.log(\\\"执行超过30秒，无法解析\\\");\\n                            } else {*/\\n                            setTimeout(window.check0, 250);\\n                            //}\\n                        } else {\\n                            window.checkurl = location.href;\\n\\n                            function checku0() {\\n                                if (window.checkurl != location.href) {\\n                                    //hash发生了变化\\n                                    setTimeout(function() {\\n                                        window.checkc = 0;\\n                                        check0();\\n                                    }, 2000);\\n                                } else {\\n                                    setTimeout(checku0, 250);\\n                                }\\n                            }\\n                            checku0();\\n                        }\\n                    }));\\n                } catch (e) {\\n                    fba.log(e.toString());\\n                    setTimeout(window.check0, 250);\\n                }\\n            }\\n            window.checkc = 0;\\n            window.check0 = check0;\\n            check0();\\n        }\\n    }, rule, anchorId, storage0.getItem(\\\"white\\\", []));\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"home\",\"rule\":\"var d = [];\\nlet url = 网站;\\nlet anchorId = url;\\nlet js = $.require(\\\"hiker://page/x5ai\\\")(MY_RULE.title, anchorId);\\nlet ite = $.require(\\\"hiker://page/u\\\")(MY_RULE.title, getHome(url));\\nd.push({\\n    title: \\\"\\\",\\n    url: url,\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"100%&&float\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        urlInterceptor: ite,\\n        canBack: true,\\n        js: js,\\n        jsLoadingInject: true\\n    }\\n});\\nd.push({\\n    col_type: \\\"line\\\",\\n    extra: {\\n        id: anchorId\\n    }\\n});\\n\\nsetResult(d);\"}],\"saved\":false,\"title\":\"装逼生成\",\"version\":0,\"url\":\"hiker://page/p?rule=装逼生成&r=装逼生成&u=aHR0cDovL2MudGlhbmhlenVsaW4uY29tLw==\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar d = [];\\nlet url = base64Decode(getParam(\\\"u\\\"));\\nlet list = storage0.getItem(\\\"white\\\", []);\\nlet inWhite = list.includes(url);\\nlet d = [];\\nif (!inWhite) {\\n    let html = request(url);\\n    let web = getItem('web', '0') == \\\"1\\\";\\n    let rule = getParam(\\\"r\\\");\\n    let parse = $.require(\\\"hiker://page/parse\\\");\\n    d = parse(rule, web, url, html);\\n}\\nif (d.length == 0) {\\n    //匹配失败\\n    let ite = $.require(\\\"hiker://page/u\\\")(getParam(\\\"r\\\"), getHome(url));\\n    let js = $.toString(() => {\\n        try {\\n            if (document.title && document.title.length) {\\n                let r = $$$().lazyRule((t) => {\\n                    setPageTitle(t);\\n                }, document.title);\\n                fy_bridge_app.parseLazyRule(r);\\n            }\\n        } catch (e) {\\n            fy_bridge_app.log(e.toString());\\n        }\\n    });\\n    let js2 = $.require(\\\"hiker://page/x5ai\\\")(getParam(\\\"r\\\"), url);\\n    d.push({\\n        title: \\\"\\\",\\n        url: url,\\n        col_type: \\\"x5_webview_single\\\",\\n        desc: \\\"float&&100%\\\",\\n        pic_url: \\\"\\\",\\n        extra: {\\n            js: js + \\\";\\\\n\\\" + js2,\\n            urlInterceptor: ite,\\n            canBack: true,\\n            floatVideo: true,\\n            jsLoadingInject: true\\n        }\\n    });\\n    d.push({\\n        col_type: \\\"line\\\",\\n        extra: {\\n            id: url\\n        }\\n    });\\n    if (!inWhite) {\\n        toast(\\\"AI匹配失败，已使用X5加载\\\");\\n    }\\n    setResult(d);\\n} else {\\n    setResult(d);\\n}\",\"group\":\"⑥③🛠️工具\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"ysfx\\\",\\\"path\\\":\\\"ysfx\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet rule = getParam(\\\\\\\"r\\\\\\\").split(\\\\\\\"##\\\\\\\")[0];\\\\nlet url = MY_URL.split(\\\\\\\"##\\\\\\\")[1];\\\\nlet ite = $.require(\\\\\\\"hiker://page/u\\\\\\\")(rule, getHome(url));\\\\nlet js = $.toString(() => {\\\\n    try {\\\\n        if (document.title && document.title.length) {\\\\n            let r = $$$().lazyRule((t) => {\\\\n                setPageTitle(t);\\\\n            }, document.title);\\\\n            fy_bridge_app.parseLazyRule(r);\\\\n        }\\\\n    } catch (e) {\\\\n        fy_bridge_app.log(e.toString());\\\\n    }\\\\n});\\\\nlet js2 = $.require(\\\\\\\"hiker://page/x5ai\\\\\\\")(rule, url);\\\\nd.push({\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    url: url,\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    desc: \\\\\\\"100%&&float\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        urlInterceptor: ite,\\\\n        js: js + \\\\\\\";\\\\\\\\n\\\\\\\" + js2,\\\\n        canBack: true,\\\\n        jsLoadingInject: true,\\\\n        floatVideo: true\\\\n    }\\\\n});\\\\nd.push({\\\\n    col_type: \\\\\\\"line\\\\\\\",\\\\n    extra: {\\\\n        id: url\\\\n    }\\\\n});\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"u\\\",\\\"path\\\":\\\"u\\\",\\\"rule\\\":\\\"$.exports = function(rule, origin) {\\\\n    return $.toString((rule, origin) => {\\\\n        let host = origin.replace(new RegExp(\\\\\\\"http://|https://\\\\\\\"), \\\\\\\"\\\\\\\").split(\\\\\\\"/\\\\\\\")[0];\\\\n        let hosts = host.split(\\\\\\\".\\\\\\\");\\\\n        if (hosts.length > 2) {\\\\n            host = hosts[hosts.length - 2] + \\\\\\\".\\\\\\\" + hosts[hosts.length - 1];\\\\n        }\\\\n        if (input.startsWith(\\\\\\\"magnet\\\\\\\")) {\\\\n            confirm({\\\\n                title: \\\\\\\"温馨提示\\\\\\\",\\\\n                content: \\\\\\\"检测到新的磁链地址，点击确定按钮即可播放，点击取消按钮可以复制链接\\\\\\\",\\\\n                confirm: $.toString((mag) => {\\\\n                    return mag;\\\\n                }, input),\\\\n                cancel: $.toString((mag) => {\\\\n                    return \\\\\\\"copy://\\\\\\\" + mag\\\\n                }, input)\\\\n            })\\\\n            return true;\\\\n        } else if (input.includes(\\\\\\\"aliyundrive.com\\\\\\\")) {\\\\n            log(input);\\\\n            let r1 = fetch(\\\\\\\"hiker://home@云盘汇影\\\\\\\");\\\\n            if (!r1 || r1.length <= 5) {\\\\n                let ru = $.toString(() => {\\\\n                    return \\\\\\\"海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@云盘汇影@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\\\\\\\"\\\\n                });\\\\n                confirm({\\\\n                    title: '温馨提示',\\\\n                    content: '本规则依赖云盘汇影规则，点击下面的确定按钮导入，注意导入后一定要在云盘汇影登录阿里云盘账号，否则不能用',\\\\n                    confirm: ru,\\\\n                    cancel: ru\\\\n                });\\\\n                return false;\\\\n            }\\\\n            log(\\\\\\\"input\\\\\\\");\\\\n            return $.toString((url, rule) => {\\\\n                fy_bridge_app.open(JSON.stringify({\\\\n                    title: \\\\\\\"阿里云盘\\\\\\\",\\\\n                    url: \\\\\\\"hiker://page/detail?rule=云盘汇影&url=\\\\\\\" + url + '??fypage',\\\\n                }))\\\\n            }, input, rule)\\\\n        } else if (/\\\\\\\\.(mp3|flac|m4a)$/.test(input)) {\\\\n            log(input);\\\\n            return $.toString((url, rule) => {\\\\n                fy_bridge_app.playVideo(url);\\\\n            }, input, rule)\\\\n        } else if (!input.includes(host) && input.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n            log(input);\\\\n            return $.toString((url, rule) => {\\\\n                let white = [\\\\n                    \\\\\\\"douyin\\\\\\\",\\\\n                    \\\\\\\"douban\\\\\\\",\\\\n                    \\\\\\\"ixigua.com\\\\\\\",\\\\n                    \\\\\\\"kuaishou\\\\\\\",\\\\n                    \\\\\\\"bilibili\\\\\\\",\\\\n                    \\\\\\\"weibo\\\\\\\",\\\\n                    \\\\\\\"weixin\\\\\\\",\\\\n                    \\\\\\\"baidu\\\\\\\",\\\\n                    \\\\\\\"zmk.\\\\\\\",\\\\n                    \\\\\\\"subhd\\\\\\\",\\\\n                    \\\\\\\"thunder\\\\\\\",\\\\n                    \\\\\\\"xinjuc\\\\\\\",\\\\n                    \\\\\\\"grab4k\\\\\\\",\\\\n                    \\\\\\\"/bt\\\\\\\",\\\\n                    \\\\\\\"jsr10\\\\\\\",\\\\n                    \\\\\\\"assrt\\\\\\\",\\\\n                    \\\\\\\"quark\\\\\\\"\\\\n                ];\\\\n                let inWhite = white.filter(it => url.includes(it)).length > 0;\\\\n                if (inWhite) {\\\\n                    //跳网页\\\\n                    fy_bridge_app.open(JSON.stringify({\\\\n                        title: \\\\\\\"详情\\\\\\\",\\\\n                        url: \\\\\\\"hiker://page/ysfx?rule=\\\\\\\" + rule + \\\\\\\"&r=\\\\\\\" + rule + \\\\\\\"##\\\\\\\" + url,\\\\n                    }))\\\\n                } else {\\\\n                    //AI解析\\\\n                    fy_bridge_app.open(JSON.stringify({\\\\n                        title: document.title,\\\\n                        url: \\\\\\\"hiker://page/p?rule=\\\\\\\" + rule + \\\\\\\"&r=\\\\\\\" + rule + \\\\\\\"&u=\\\\\\\" + fy_bridge_app.base64Encode(url),\\\\n                    }))\\\\n                }\\\\n            }, input, rule);\\\\n        } else if (!input.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n            log(input);\\\\n            //能唤起APP的白名单\\\\n            let white = [\\\\n                \\\\\\\"qklink\\\\\\\",\\\\n                \\\\\\\"bdnetdisk\\\\\\\",\\\\n                \\\\\\\"xunleiapp\\\\\\\"\\\\n            ];\\\\n            let inWhite = white.filter(it => input.startsWith(it)).length > 0;\\\\n            if (!inWhite) {\\\\n                return false;\\\\n            }\\\\n            return $.toString((url, rule) => {\\\\n                fy_bridge_app.openThirdApp && fy_bridge_app.openThirdApp(url);\\\\n            }, input, rule)\\\\n        } else {\\\\n            let white = [\\\\n                \\\\\\\"url=\\\\\\\",\\\\n                \\\\\\\"fsou.com\\\\\\\",\\\\n                \\\\\\\"bing.\\\\\\\",                \\\\n            ];\\\\n            let inWhite = white.filter(it => input.includes(it)).length > 0;\\\\n            if (inWhite) {\\\\n                return false;\\\\n            }\\\\n            let reg = new RegExp(\\\\\\\"[\\\\\\\\u4e00-\\\\\\\\u9fa5]+\\\\\\\", \\\\\\\"g\\\\\\\");\\\\n            let r = decodeURIComponent(input);\\\\n            if (reg.test(r) || (input.startsWith(origin) && input.length - origin.length > 2)) {\\\\n                //有中文，应该是在搜索，跳新页面\\\\n                return $.toString((url, rule) => {\\\\n                    fy_bridge_app.open(JSON.stringify({\\\\n                        title: \\\\\\\"详情\\\\\\\",\\\\n                        url: \\\\\\\"hiker://page/ysfx?rule=\\\\\\\" + rule + \\\\\\\"&r=\\\\\\\" + rule + \\\\\\\"##\\\\\\\" + url,\\\\n                    }));\\\\n                }, input, rule);\\\\n            }\\\\n        }\\\\n    }, rule, origin);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级解析\\\",\\\"path\\\":\\\"p\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet url = base64Decode(getParam(\\\\\\\"u\\\\\\\"));\\\\nlet list = storage0.getItem(\\\\\\\"white\\\\\\\", []);\\\\nlet inWhite = list.includes(url);\\\\nlet d = [];\\\\nif (!inWhite) {\\\\n    let html = request(url);\\\\n    let web = getItem('web', '0') == \\\\\\\"1\\\\\\\";\\\\n    let rule = getParam(\\\\\\\"r\\\\\\\");\\\\n    let parse = $.require(\\\\\\\"hiker://page/parse\\\\\\\");\\\\n    d = parse(rule, web, url, html);\\\\n}\\\\nif (d.length == 0) {\\\\n    //匹配失败\\\\n    let ite = $.require(\\\\\\\"hiker://page/u\\\\\\\")(getParam(\\\\\\\"r\\\\\\\"), getHome(url));\\\\n    let js = $.toString(() => {\\\\n        try {\\\\n            if (document.title && document.title.length) {\\\\n                let r = $$$().lazyRule((t) => {\\\\n                    setPageTitle(t);\\\\n                }, document.title);\\\\n                fy_bridge_app.parseLazyRule(r);\\\\n            }\\\\n        } catch (e) {\\\\n            fy_bridge_app.log(e.toString());\\\\n        }\\\\n    });\\\\n    let js2 = $.require(\\\\\\\"hiker://page/x5ai\\\\\\\")(getParam(\\\\\\\"r\\\\\\\"), url);\\\\n    d.push({\\\\n        title: \\\\\\\"\\\\\\\",\\\\n        url: url,\\\\n        col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n        desc: \\\\\\\"float&&100%\\\\\\\",\\\\n        pic_url: \\\\\\\"\\\\\\\",\\\\n        extra: {\\\\n            js: js + \\\\\\\";\\\\\\\\n\\\\\\\" + js2,\\\\n            urlInterceptor: ite,\\\\n            canBack: true,\\\\n            floatVideo: true,\\\\n            jsLoadingInject: true\\\\n        }\\\\n    });\\\\n    d.push({\\\\n        col_type: \\\\\\\"line\\\\\\\",\\\\n        extra: {\\\\n            id: url\\\\n        }\\\\n    });\\\\n    if (!inWhite) {\\\\n        toast(\\\\\\\"AI匹配失败，已使用X5加载\\\\\\\");\\\\n    }\\\\n    setResult(d);\\\\n} else {\\\\n    setResult(d);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级parse\\\",\\\"path\\\":\\\"parse\\\",\\\"rule\\\":\\\"$.exports = function(rule, web, url, html) {\\\\n    let d = [];\\\\n\\\\n    let alist = pdfa(html, \\\\\\\"body&&a\\\\\\\");\\\\n    let arr = alist.map(it => {\\\\n        return {\\\\n            //html: it,\\\\n            text: pdfh(it, \\\\\\\"a&&Text\\\\\\\"),\\\\n            title: pdfh(it, \\\\\\\"a&&title\\\\\\\"),\\\\n            href: pd(it, \\\\\\\"a&&href\\\\\\\", url)\\\\n        }\\\\n    });\\\\n    //log(arr);\\\\n    let debug = false;\\\\n\\\\n    function clearText(it) {\\\\n        return it.replace(/第|集|章/g, \\\\\\\"\\\\\\\");\\\\n    }\\\\n\\\\n    function isMovie(it) {\\\\n        if (it == null || it.text == null) {\\\\n            return false;\\\\n        }\\\\n        let tit = it.title || \\\\\\\"\\\\\\\";\\\\n        it = it.text || \\\\\\\"\\\\\\\";\\\\n        if (it == \\\\\\\"\\\\\\\" || it.length > 8) {\\\\n            return false;\\\\n        }\\\\n        //排除\\\\n        let reg = /\\\\\\\\.|高清直播|写真推荐|影院|影视|蓝光电影|高清电影|第一季|第二季|第三季|第四季|第五季/;\\\\n        if (tit != \\\\\\\"\\\\\\\" && !tit.includes(it) || reg.test(it)) {\\\\n            return false;\\\\n        }\\\\n        return it.match(/原画|备用|蓝光|超清|高清|正片|韩版|4K|4k|1080P|720P|TC|HD|BD/)\\\\n    }\\\\n\\\\n    function notChapter(it) {\\\\n        if (it == null || it.text == null) {\\\\n            return true;\\\\n        }\\\\n        return it.text.match(/[0-9]\\\\\\\\.[0-9]分/);\\\\n    }\\\\n\\\\n    function isChapter(it, pre, next) {\\\\n        if (notChapter(it)) {\\\\n            //优先排除\\\\n            return false;\\\\n        }\\\\n        //判断是不是电影\\\\n        if (isMovie(it)) {\\\\n            return true;\\\\n        }\\\\n        return isChapter0(it, pre) || isChapter0(it, next);\\\\n    }\\\\n\\\\n    function getChapterNum(it) {\\\\n        if (it == null || it.text == null) {\\\\n            return -1;\\\\n        }\\\\n        it = it.text || \\\\\\\"\\\\\\\";\\\\n        if (it == \\\\\\\"\\\\\\\") {\\\\n            return -1;\\\\n        }\\\\n        it = clearText(it);\\\\n        let reg = /^[0-9]*$/;\\\\n        if (!reg.test(it)) {\\\\n            return -1;\\\\n        }\\\\n        it = parseInt(it);\\\\n        if (isNaN(it)) {\\\\n            return -1;\\\\n        }\\\\n        if (it > 1900 && it < 2100) {\\\\n            return -1;\\\\n        }\\\\n        return it;\\\\n    }\\\\n\\\\n    function isChapter0(it, brother) {\\\\n        /*if (debug) {\\\\n            log({\\\\n                it: it,\\\\n                brother: brother\\\\n            });\\\\n        }*/\\\\n        it = getChapterNum(it);\\\\n        //if (debug) log(it);\\\\n        if (it < 0) {\\\\n            return false;\\\\n        }\\\\n        brother = getChapterNum(brother);\\\\n        //if (debug) log(brother);\\\\n        if (brother < 0) {\\\\n            return false;\\\\n        }\\\\n        return it - brother < 2 && it - brother > -2;\\\\n    }\\\\n\\\\n    let _web = $.toString(() => {\\\\n        let urls = _getUrls();\\\\n        let reg = /\\\\\\\\.html|\\\\\\\\.css|\\\\\\\\.js/;\\\\n        for (let k in urls) {\\\\n            if (!reg.test(urls[k]) && urls[k].match(/\\\\\\\\.mp4|\\\\\\\\.m3u8/)) {\\\\n                fy_bridge_app.log(urls[k]);\\\\n                return fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\\\\\"\\\\\\\")) + \\\\\\\"#ignoreImg=true#\\\\\\\";\\\\n            }\\\\n        }\\\\n    });\\\\n\\\\n    for (let i = 0; i < arr.length; i++) {\\\\n        let it = arr[i];\\\\n        let t = it.text;\\\\n        if (!it.href || it.href == \\\\\\\"\\\\\\\") {\\\\n            continue;\\\\n        }\\\\n        let pre = i == 0 ? null : arr[i - 1];\\\\n        let next = i == (arr.length - 1) ? null : arr[i + 1];\\\\n        if (isChapter(it, pre, next)) {\\\\n            if (web) {\\\\n                var urlx = \\\\\\\"webRule://\\\\\\\" + it.href + \\\\\\\"@\\\\\\\" + _web;\\\\n                var extrax = {\\\\n                    jsLoadingInject: true,\\\\n                    id: it.href,\\\\n                    blockRules: ['.m4a', '.mp3', '.flv', '.avi', '.3gp', '.mpeg', '.wmv', '.mov', '.rmvb', '.gif', '.jpeg', '.png', '.ico', '.svg']\\\\n                };\\\\n            } else {\\\\n                var urlx = \\\\\\\"video://\\\\\\\" + it.href;\\\\n                var extrax = {\\\\n                    id: it.href\\\\n                };\\\\n            }\\\\n            d.push({\\\\n                title: t,\\\\n                url: urlx,\\\\n                col_type: \\\\\\\"text_3\\\\\\\",\\\\n                extra: extrax\\\\n            });\\\\n        }\\\\n    }\\\\n    if (d.length == 0) {\\\\n        return d;\\\\n    } else {\\\\n\\\\n        d.splice(0, 0, {\\\\n            title: \\\\\\\"🔗\\\\\\\" + url,\\\\n            url: \\\\\\\"hiker://page/ysfx?rule=\\\\\\\" + rule + \\\\\\\"&r=\\\\\\\" + rule + \\\\\\\"##\\\\\\\" + url,\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            desc: \\\\\\\"\\\\\\\",\\\\n            pic_url: \\\\\\\"\\\\\\\"\\\\n        });\\\\n\\\\n\\\\n        //为线路加分割线\\\\n        let d2 = [];\\\\n        for (let i = 0; i < d.length; i++) {\\\\n            d2.push(d[i]);\\\\n            if (i < d.length - 1) {\\\\n                let it = d[i];\\\\n                let t1 = parseInt(clearText(it.title));\\\\n                let next = d[i + 1];\\\\n                let t2 = parseInt(clearText(next.title));\\\\n                if (t2 - t1 > 1 || t1 - t2 > 1) {\\\\n                    d2.push({\\\\n                        col_type: \\\\\\\"big_blank_block\\\\\\\"\\\\n                    });\\\\n                    d2.push({\\\\n                        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n                    });\\\\n                    d2.push({\\\\n                        col_type: \\\\\\\"big_blank_block\\\\\\\"\\\\n                    });\\\\n                }\\\\n            }\\\\n        }\\\\n        d2.push({\\\\n            title: \\\\\\\"匹配有误？点我不再匹配此页面\\\\\\\",\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((url) => {\\\\n                confirm({\\\\n                    title: \\\\\\\"温馨提示\\\\\\\",\\\\n                    content: \\\\\\\"如果只是单次匹配失败，点击下方取消按钮刷新页面重新匹配，如果确认无法匹配，点击下方确定按钮加入白名单\\\\\\\",\\\\n                    cancel: \\\\\\\"refreshPage()\\\\\\\",\\\\n                    confirm: $.toString((url) => {\\\\n                        let list = storage0.getItem(\\\\\\\"white\\\\\\\", []);\\\\n                        list.push(url);\\\\n                        storage0.setItem(\\\\\\\"white\\\\\\\", list);\\\\n                        refreshPage();\\\\n                        return \\\\\\\"toast://已加入白名单\\\\\\\"\\\\n                    }, url)\\\\n                });\\\\n                return \\\\\\\"hiker://empty\\\\\\\"\\\\n            }, url),\\\\n            col_type: \\\\\\\"avatar\\\\\\\",\\\\n            img: \\\\\\\"hiker://images/account\\\\\\\"\\\\n        });\\\\n        return d2;\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"x5AI\\\",\\\"path\\\":\\\"x5ai\\\",\\\"rule\\\":\\\"$.exports = function(rule, anchorId) {\\\\n    return $.toString((rule, anchorId, white) => {\\\\n        if (window.check0 == null) {\\\\n            function check0() {\\\\n                try {\\\\n                    let html = document.querySelector(\\\\\\\"html\\\\\\\").innerHTML;\\\\n                    fba.putVar(\\\\\\\"html0\\\\\\\", html);\\\\n                    fba.parseLazyRuleAsync($$$().lazyRule((rule, url, anchorId, white) => {\\\\n                        try {\\\\n                            let d = [];\\\\n                            let html = getVar(\\\\\\\"html0\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                            clearVar(\\\\\\\"html0\\\\\\\");\\\\n                            let web = false;\\\\n                            let white2 = [\\\\n                                \\\\\\\"fsou.com\\\\\\\",\\\\n                                \\\\\\\"bing.\\\\\\\",\\\\n                            ];\\\\n                            let inWhite = white2.filter(it => url.includes(it)).length > 0;                            \\\\n                            if (!inWhite && !white.includes(url)) {\\\\n                                let parse = $.require(\\\\\\\"hiker://page/parse?rule=\\\\\\\" + rule);\\\\n                                d = parse(rule, web, url, html);\\\\n                            }\\\\n                            if (!inWhite && d.length < 1) {\\\\n                                try {\\\\n                                    let arr = pdfa(html, \\\\\\\"body&&iframe\\\\\\\");\\\\n                                    if (arr.length > 0) {\\\\n                                        let src = pdfh(arr[0], \\\\\\\"iframe&&src\\\\\\\");\\\\n                                        log(\\\\\\\"获取到iframe：\\\\\\\" + src);\\\\n                                        if (!white.includes(src)) {\\\\n                                            if (src && src.startsWith(\\\\\\\"http\\\\\\\") && !src.match(/\\\\\\\\.mp4|\\\\\\\\.m3u8|\\\\\\\\.mp3|\\\\\\\\.flv|\\\\\\\\.mkv/)) {\\\\n                                                html = request(src);\\\\n                                                d = parse(rule, web, src, html);\\\\n                                            }\\\\n                                        }\\\\n                                    }\\\\n                                } catch (e) {\\\\n                                    log(\\\\\\\"尝试获取iframe失败\\\\\\\");\\\\n                                }\\\\n                            }\\\\n                            if (d.length > 0) {\\\\n                                d[0].url = $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((anchorId) => {\\\\n                                    let desc = getVar(anchorId, \\\\\\\"0\\\\\\\");\\\\n                                    if (desc == \\\\\\\"0\\\\\\\") {\\\\n                                        refreshX5Desc(\\\\\\\"float&&screen-170\\\\\\\");\\\\n                                        putVar(anchorId, \\\\\\\"1\\\\\\\");\\\\n                                    } else {\\\\n                                        refreshX5Desc(\\\\\\\"float&&0\\\\\\\");\\\\n                                        putVar(anchorId, \\\\\\\"0\\\\\\\");\\\\n                                    }\\\\n                                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n                                }, anchorId + \\\\\\\"x5\\\\\\\");\\\\n                                d[0].title = \\\\\\\"展开/收起\\\\\\\" + d[0].title;\\\\n                                putVar(anchorId + \\\\\\\"x5\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n                                refreshX5Desc(\\\\\\\"float&&0\\\\\\\");\\\\n                                for (let it of d) {\\\\n                                    let extra = it.extra || {};\\\\n                                    extra.cls = \\\\\\\"x5ai\\\\\\\";\\\\n                                    it.extra = extra;\\\\n                                }\\\\n                                deleteItemByCls(\\\\\\\"x5ai\\\\\\\");\\\\n                                addItemAfter(anchorId, d);\\\\n                                toast(\\\\\\\"AI匹配成功\\\\\\\");\\\\n                            }\\\\n                            if (d.length > 0) {\\\\n                                log(\\\\\\\"parseLazyRuleAsync:\\\\\\\" + d.length);\\\\n                            }\\\\n                            return d.length > 0 ? \\\\\\\"1\\\\\\\" : \\\\\\\"0\\\\\\\";\\\\n                        } catch (e) {\\\\n                            log(e.toString());\\\\n                        }\\\\n                    }, rule, location.href, anchorId, white), $$$.toString(() => {\\\\n                        if (\\\\\\\"0\\\\\\\" == input) {\\\\n                            window.checkc = window.checkc + 1;\\\\n                            /*if (window.checkc > 120) {\\\\n                                fba.log(\\\\\\\"执行超过30秒，无法解析\\\\\\\");\\\\n                            } else {*/\\\\n                            setTimeout(window.check0, 250);\\\\n                            //}\\\\n                        } else {\\\\n                            window.checkurl = location.href;\\\\n\\\\n                            function checku0() {\\\\n                                if (window.checkurl != location.href) {\\\\n                                    //hash发生了变化\\\\n                                    setTimeout(function() {\\\\n                                        window.checkc = 0;\\\\n                                        check0();\\\\n                                    }, 2000);\\\\n                                } else {\\\\n                                    setTimeout(checku0, 250);\\\\n                                }\\\\n                            }\\\\n                            checku0();\\\\n                        }\\\\n                    }));\\\\n                } catch (e) {\\\\n                    fba.log(e.toString());\\\\n                    setTimeout(window.check0, 250);\\\\n                }\\\\n            }\\\\n            window.checkc = 0;\\\\n            window.check0 = check0;\\\\n            check0();\\\\n        }\\\\n    }, rule, anchorId, storage0.getItem(\\\\\\\"white\\\\\\\", []));\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"首页\\\",\\\"path\\\":\\\"home\\\",\\\"rule\\\":\\\"var d = [];\\\\nlet url = 网站;\\\\nlet anchorId = url;\\\\nlet js = $.require(\\\\\\\"hiker://page/x5ai\\\\\\\")(MY_RULE.title, anchorId);\\\\nlet ite = $.require(\\\\\\\"hiker://page/u\\\\\\\")(MY_RULE.title, getHome(url));\\\\nd.push({\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    url: url,\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    desc: \\\\\\\"100%&&float\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        urlInterceptor: ite,\\\\n        canBack: true,\\\\n        js: js,\\\\n        jsLoadingInject: true\\\\n    }\\\\n});\\\\nd.push({\\\\n    col_type: \\\\\\\"line\\\\\\\",\\\\n    extra: {\\\\n        id: anchorId\\\\n    }\\\\n});\\\\n\\\\nsetResult(d);\\\"}]\",\"proxy\":\"\"}","title":"装逼生成器,装逼制图神器"}
Add Comment
Please, Sign In to add comment
