邀您一起看：免费视频分享大全-大师兄电影网

海阔视界规则分享，当前分享的是：二级页面详情￥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 ite = $.require(\\\"hiker://page/u\\\")(getParam(\\\"r\\\").split(\\\"##\\\")[0], getHome(MY_URL.split(\\\"##\\\")[1]));\\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});\\nd.push({\\n    title: \\\"\\\",\\n    url: MY_URL.split(\\\"##\\\")[1],\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"100%&&float\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        urlInterceptor: ite,\\n        js: js,\\n        canBack: true,\\n        blockRules: [\\\".gif\\\", \\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\"]\\n    }\\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        }\\n    }, rule, origin);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级解析\",\"path\":\"p\",\"rule\":\"js:\\nvar d = [];\\nlet url = base64Decode(getParam(\\\"u\\\"));\\nlet html = request(url);\\nlet alist = pdfa(html, \\\"body&&a\\\");\\nlet 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);\\nlet debug = false;\\n\\nfunction clearText(it) {\\n    return it.replace(/第|集|章/g, \\\"\\\");\\n}\\n\\nfunction 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\\nfunction notChapter(it) {\\n    if (it == null || it.text == null) {\\n        return true;\\n    }\\n    return it.text.match(/[0-9]\\\\.[0-9]分/);\\n}\\n\\nfunction 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\\nfunction 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    return it;\\n}\\n\\nfunction 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\\nlet _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\\nlet web = getItem('web', '0') == \\\"1\\\";\\n\\nfor (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}\\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    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            urlInterceptor: ite,\\n            canBack: true,\\n            floatVideo: true,\\n            blockRules: [\\\".gif\\\", \\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\"]\\n        }\\n    });\\n    toast(\\\"AI匹配失败，已使用X5加载\\\");\\n    setResult(d);\\n} else {\\n    let rule = getParam(\\\"r\\\");\\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    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\\n    setResult(d2);\\n}\"}],\"saved\":false,\"title\":\"土拨鼠\",\"version\":0,\"url\":\"hiker://page/p?rule=土拨鼠&r=土拨鼠&u=aHR0cHM6Ly9oYjFyc2YuNTFjaGlqaTQuY29tLw==\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar d = [];\\nlet url = base64Decode(getParam(\\\"u\\\"));\\nlet html = request(url);\\nlet alist = pdfa(html, \\\"body&&a\\\");\\nlet 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);\\nlet debug = false;\\n\\nfunction clearText(it) {\\n    return it.replace(/第|集|章/g, \\\"\\\");\\n}\\n\\nfunction 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\\nfunction notChapter(it) {\\n    if (it == null || it.text == null) {\\n        return true;\\n    }\\n    return it.text.match(/[0-9]\\\\.[0-9]分/);\\n}\\n\\nfunction 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\\nfunction 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    return it;\\n}\\n\\nfunction 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\\nlet _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\\nlet web = getItem('web', '0') == \\\"1\\\";\\n\\nfor (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}\\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    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            urlInterceptor: ite,\\n            canBack: true,\\n            floatVideo: true,\\n            blockRules: [\\\".gif\\\", \\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\"]\\n        }\\n    });\\n    toast(\\\"AI匹配失败，已使用X5加载\\\");\\n    setResult(d);\\n} else {\\n    let rule = getParam(\\\"r\\\");\\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    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\\n    setResult(d2);\\n}\",\"group\":\"③AI\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"ysfx\\\",\\\"path\\\":\\\"ysfx\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet ite = $.require(\\\\\\\"hiker://page/u\\\\\\\")(getParam(\\\\\\\"r\\\\\\\").split(\\\\\\\"##\\\\\\\")[0], getHome(MY_URL.split(\\\\\\\"##\\\\\\\")[1]));\\\\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});\\\\nd.push({\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    url: MY_URL.split(\\\\\\\"##\\\\\\\")[1],\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    desc: \\\\\\\"100%&&float\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        urlInterceptor: ite,\\\\n        js: js,\\\\n        canBack: true,\\\\n        blockRules: [\\\\\\\".gif\\\\\\\", \\\\\\\"/ad/\\\\\\\", \\\\\\\"google\\\\\\\", \\\\\\\"/sh/to/\\\\\\\", \\\\\\\".GIF\\\\\\\"]\\\\n    }\\\\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        }\\\\n    }, rule, origin);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级解析\\\",\\\"path\\\":\\\"p\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet url = base64Decode(getParam(\\\\\\\"u\\\\\\\"));\\\\nlet html = request(url);\\\\nlet alist = pdfa(html, \\\\\\\"body&&a\\\\\\\");\\\\nlet 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);\\\\nlet debug = false;\\\\n\\\\nfunction clearText(it) {\\\\n    return it.replace(/第|集|章/g, \\\\\\\"\\\\\\\");\\\\n}\\\\n\\\\nfunction 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\\\\nfunction notChapter(it) {\\\\n    if (it == null || it.text == null) {\\\\n        return true;\\\\n    }\\\\n    return it.text.match(/[0-9]\\\\\\\\.[0-9]分/);\\\\n}\\\\n\\\\nfunction 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\\\\nfunction 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    return it;\\\\n}\\\\n\\\\nfunction 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\\\\nlet _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\\\\nlet web = getItem('web', '0') == \\\\\\\"1\\\\\\\";\\\\n\\\\nfor (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}\\\\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    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            urlInterceptor: ite,\\\\n            canBack: true,\\\\n            floatVideo: true,\\\\n            blockRules: [\\\\\\\".gif\\\\\\\", \\\\\\\"/ad/\\\\\\\", \\\\\\\"google\\\\\\\", \\\\\\\"/sh/to/\\\\\\\", \\\\\\\".GIF\\\\\\\"]\\\\n        }\\\\n    });\\\\n    toast(\\\\\\\"AI匹配失败，已使用X5加载\\\\\\\");\\\\n    setResult(d);\\\\n} else {\\\\n    let rule = getParam(\\\\\\\"r\\\\\\\");\\\\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    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\\\\n    setResult(d2);\\\\n}\\\"}]\",\"proxy\":\"\"}","title":"免费视频分享大全-大师兄电影网"}