邀您一起看：《权力的游戏第一季》在线观看/手机迅雷下载-美剧天堂

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥《权力的游戏第一季》在线观看/手机迅雷下载-美剧天堂@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"获取视频目录\",\"path\":\"get_video_catalogue.js\",\"rule\":\"function isMovie(text) {\\n\\n    if (text.length > 8) {\\n        return false;\\n    }\\n    //排除\\n    let reg = /\\\\.|高清直播|写真推荐|影院|影视|蓝光电影|高清电影|第一季|第二季|第三季|第四季|第五季|\\\\n|\\\\r/;\\n    if (reg.test(text)) {\\n        return false;\\n    }\\n    return /(原画|备用|蓝光|超清|高清|正片|韩版|4K|1080P|720P|TC|HD|BD|中字|版)$/i.test(text);\\n}\\n\\nfunction notChapter(text) {\\n    return /[0-9]\\\\.[0-9]分/.test(text);\\n}\\nlet last = null;\\n\\nfunction isChapter0(text, nextText) {\\n    let pri = /^第\\\\d+(集|章|话)$/;\\n    if (pri.test(text)) {\\n        //fba.log(\\\"debug:\\\" + RegExp.$1 + text)\\n        return true;\\n    }\\n\\n    let num1 = Number(text);\\n    if (!text || Number.isNaN(num1)) {\\n        return false;\\n    }\\n    if (num1 === 1) {\\n        //fba.log(\\\"debug:\\\" + num1 + text)\\n        return true;\\n    }\\n    if (nextText === null) {\\n        //fba.log(\\\"debug:\\\" + num1 + nextText)\\n        return true;\\n    }\\n    let num2 = Number(nextText);\\n    if (Number.isNaN(num2)) {\\n        if (last && (last - num1 < 2 && last - num1 > -2)) {\\n            //fba.log(\\\"debug:\\\" + last)\\n            return true;\\n        }\\n        return false;\\n    }\\n    if (num1 - num2 < 2 && num1 - num2 > -2 /*&&num1 - num2!==0*/ ) {\\n        fba.log(\\\"debug:\\\" + num1 + text + num2 + nextText)\\n        last = num1;\\n        return true;\\n    }\\n}\\n\\nfunction isChapter(text, nextText) {\\n    text = text.trim();\\n    nextText = nextText ? nextText.trim() : nextText;\\n    if (!text || notChapter(text)) {\\n        //优先排除\\n        //fba.log(\\\"0排除:\\\"+text)\\n        return false;\\n    }\\n    //判断是不是电影\\n    if (isMovie(text)) {\\n        //fba.log(\\\"1是电影:\\\" + text)\\n        return true;\\n    }\\n\\n    if (isChapter0(text, nextText)) {\\n        //fba.log(\\\"2是剧集:\\\" + text)\\n        return true;\\n    }\\n    //fba.log(text)\\n    return false;\\n}\\n//top浏览器↓\\nvar list_document_link = [];\\nvar list_link = [];\\nvar ymurl = window.location.href;\\nvar choose_channel = 0;\\nlist_document_link = document.querySelectorAll('a');\\nvar top_j = 0;\\n\\nfor (let i = 0; i < list_document_link.length; i++) {\\n    var text = list_document_link[i].innerText;\\n    var href = list_document_link[i].href;\\n    var nextText = i + 1 >= list_document_link.length ? null : list_document_link[i + 1].innerText;\\n    if (text && isChapter(text, nextText) && href && href.indexOf('http') > -1 && href.indexOf(ymurl + \\\"#\\\") == -1) {\\n        if (list_document_link[i].target == '_blank') {\\n            continue;\\n        }\\n        if (list_link[top_j] === undefined) {\\n            list_link[top_j] = [];\\n        }\\n        if (href == location.href) {\\n            choose_channel = top_j;\\n        }\\n        var ss = text.replace(/[^\\\\d+]/g, '');\\n        if (ss.indexOf(0) === 0) {\\n            text = text.replace('0', '');\\n        }\\n        var is_repeat = false;\\n        for (let j = 0; j < list_link[top_j].length; j++) {\\n            if (list_link[top_j][j].href == href) {\\n                is_repeat = true;\\n                break;\\n            }\\n            if (list_link[top_j][j].text == text) {\\n                top_j += 1;\\n                list_link[top_j] = [];\\n            }\\n        }\\n        if (is_repeat) {\\n            continue;\\n        }\\n        var std = {};\\n        std.url = href;\\n        std.text = text;\\n        //排除年代\\n        let reg = /1|2[0-9]+/;\\n        if (text.length == 4 && reg.test(text)) {\\n            continue;\\n        }\\n        list_link[top_j].push(std);\\n    }\\n}\\n//htmlInterface.getVideoCatalogue(JSON.stringify(list_link));\\n//top浏览器↑\\n//fba.log(JSON.stringify(list_link))\\nif (list_link.length == 1 && list_link[0].length <= 0) {\\n    //empty\\n} else {\\n    if (list_link.length > 0) {\\n        window.__fySuccess = true;\\n        fba.open(JSON.stringify({\\n            rule: fy_title,\\n            title: document.title,\\n            url: \\\"hiker://page/video_catalogue_view.js?rule=\\\" + fy_title,\\n            extra: {\\n                list_link: list_link,\\n                href: location.href,\\n                title: document.title\\n            }\\n        }));\\n        window.history.back(-1);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"视频目录\",\"path\":\"video_catalogue_view.js\",\"rule\":\"js:\\nlet d = [];\\nlet i = 1;\\nfor (let playList of MY_PARAMS.list_link) {\\n    d.push({\\n        title: \\\"线路\\\" + i++,\\n        col_type: \\\"text_1\\\",\\n        url: \\\"hiker://empty\\\"\\n    });\\n    for (let li of playList) {\\n        d.push({\\n            title: li.text,\\n            col_type: \\\"text_4\\\",\\n            url: \\\"video://\\\"+li.url,\\n            extra:{\\n                blockRules: [\\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\",'.mp3','.flv', '.3gp', '.mpeg', '.gif', '.jpg', '.jpeg', '.png', '.ico', '.svg'],\\n                videoExcludeRules: ['?url=']\\n            }\\n        });\\n    }\\n}\\nd.push({\\n    title: \\\"““””<small><font color='#aaaaaa'>🔗\\\" + MY_PARAMS.href + \\\"</font></small>\\\",\\n    url: \\\"hiker://page/x5?u=\\\" + base64Encode(MY_PARAMS.href),\\n    col_type: \\\"text_1\\\",\\n    extra: {\\n        pageTitle: MY_PARAMS.title,\\n        lineVisible: false\\n    }\\n});\\n\\nsetResult(d);\\n\"},{\"col_type\":\"movie_3\",\"name\":\"批量导入\",\"path\":\"im\",\"rule\":\"js:\\nvar d = [];\\nlet a = getParam(\\\"a\\\", \\\"\\\");\\nif (a != \\\"\\\") {\\n    a = base64Decode(a);\\n}\\nsetPageTitle(MY_RULE.title + \\\"批量导入\\\")\\nputMyVar(\\\"im\\\", a);\\nd.push({\\n    title: \\\"\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        defaultValue: a,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"im\\\", input);\\n        }),\\n        titleVisible: false,\\n        type: 'textarea',\\n        height: 3,\\n        highlight: true\\n    }\\n});\\n\\nlet save = () => {\\n    let a = getMyVar(\\\"im\\\", \\\"[]\\\");\\n    if (a == \\\"\\\" || !a.startsWith(\\\"[\\\")) {\\n        return \\\"toast://请输入正确的格式\\\"\\n    }\\n    let list = JSON.parse(a);\\n    let {\\n        addAll\\n    } = $.require(\\\"hiker://page/data\\\");\\n    let count = addAll(list);\\n    back(true);\\n    return \\\"toast://已添加\\\" + count + \\\"条地址\\\"\\n};\\nd.push({\\n    title: \\\"导入\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(save),\\n    col_type: \\\"text_center_1\\\",\\n    desc: \\\"\\\",\\n    pic_url: \\\"\\\"\\n});\\n\\nif (getParam(\\\"b\\\", \\\"0\\\") == \\\"1\\\") {\\n    confirm({\\n        title: \\\"温馨提示\\\",\\n        content: \\\"确定立即导入\\\" + MY_RULE.title + \\\"数据？\\\",\\n        confirm: $.toString(save)\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"添加网站\",\"path\":\"add\",\"rule\":\"js:\\nvar d = [];\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\"name\\\");\\n    clearMyVar(\\\"url\\\");\\n}));\\nd.push({\\n    title: \\\"\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入网站名称\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"name\\\", input);\\n        }),\\n        titleVisible: false\\n    }\\n});\\nd.push({\\n    title: \\\"\\\",\\n    url: \\\"\\\",\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入网站地址\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"url\\\", input);\\n        }),\\n        titleVisible: false\\n    }\\n});\\nd.push({\\n    title: \\\"添加保存\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let name = getMyVar(\\\"name\\\", \\\"\\\");\\n        let url = getMyVar(\\\"url\\\", \\\"\\\");\\n        if (name == \\\"\\\" || url == \\\"\\\") {\\n            return \\\"toast://请输入完整信息\\\"\\n        }\\n        let {\\n            add\\n        } = $.require(\\\"hiker://page/data\\\");\\n        add(name, url);\\n        refreshPage();\\n        return \\\"toast://已添加\\\"\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n    desc: \\\"\\\",\\n    pic_url: \\\"\\\"\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"数据管理\",\"path\":\"data\",\"rule\":\"var defaultValue = [\\n    {\\n        name: \\\"豌豆\\\",\\n        url: \\\"https://www.wandou.pro/\\\"\\n    },\\n    {\\n        name: \\\"茶杯狐\\\",\\n        url: \\\"https://cupfox.app/\\\"\\n    },\\n    {\\n        name: \\\"搜片\\\",\\n        url: \\\"http://soupian.de/\\\"\\n    },\\n    {\\n        name: \\\"青麦\\\",\\n        url: \\\"https://www.qimaitv.com/\\\"\\n    },\\n    {\\n        name: \\\"电影狗\\\",\\n        url: \\\"https://www.dianyinggou.com/yingku/\\\"\\n    },\\n    {\\n        name: \\\"茶杯虎\\\",\\n        url: \\\"https://www.725998.com/yingku\\\"\\n    },\\n    {\\n        name: \\\"土拨鼠\\\",\\n        url: \\\"https://www.tbsdy.com/m/index.html\\\"\\n    }\\n];\\n$.exports = {\\n    load: function() {\\n        return storage0.getItem(\\\"data1\\\", defaultValue);\\n    },\\n    add: function(name, url) {\\n        let data = storage0.getItem(\\\"data1\\\", defaultValue);\\n        for (let it of data) {\\n            if (it.name == name) {\\n                return\\n            }\\n        }\\n        data.push({\\n            name: name,\\n            url: url\\n        });\\n        storage0.setItem(\\\"data1\\\", data);\\n    },\\n    addAll: function(list) {\\n        let data = storage0.getItem(\\\"data1\\\", defaultValue);\\n        let names = data.map(it => it.name);\\n        let count = 0;\\n        for (let it of list) {\\n            if (!names.includes(it.name)) {\\n                data.push(it);\\n                count++;\\n            }\\n        }\\n        storage0.setItem(\\\"data1\\\", data);\\n        return count;\\n    },\\n    remove: function(name) {\\n        let data = storage0.getItem(\\\"data1\\\", defaultValue);\\n        data = data.filter(it => it.name != name);\\n        storage0.setItem(\\\"data1\\\", data);\\n    },\\n    top: function(name) {\\n        let data = storage0.getItem(\\\"data1\\\", defaultValue);\\n        let it = data.filter(it => it.name == name)[0];\\n        let d = [];\\n        d.push(it);\\n        for (let ii of data) {\\n            if (ii.name != name) {\\n                d.push(ii);\\n            }\\n        }\\n        storage0.setItem(\\\"data1\\\", d);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"u\",\"path\":\"u\",\"rule\":\"$.exports = function(rule, origin) {\\n    return $.toString((rule, origin) => {\\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.startsWith(\\\"http\\\")) {\\n            log(input);\\n            //能唤起APP的白名单\\n            let white = [\\n                \\\"qklink\\\",\\n                \\\"bdnetdisk\\\",\\n                \\\"xunleiapp\\\",\\n                \\\"smartdrive\\\"\\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\":\"X5\",\"path\":\"x5\",\"rule\":\"js:\\nvar d = [];\\nlet url = base64Decode(getParam(\\\"u\\\"));\\nd.push({\\n    title: \\\"\\\",\\n    url: url,\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"float&&100%\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        floatVideo: true,\\n        canBack: true,\\n        blockRules: [\\\".gif\\\", \\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\"]\\n    }\\n});\\nsetResult(d);\"}],\"params\":\"{\\\"lineVisible\\\":false,\\\"pageTitle\\\":\\\"《权力的游戏第一季》在线观看/手机迅雷下载-美剧天堂\\\"}\",\"saved\":false,\"title\":\"Top测试\",\"version\":0,\"url\":\"hiker://page/x5?u=aHR0cHM6Ly93YXAubWVpanV0dC50di9jb250ZW50L21laWp1MTk0OTMuaHRtbA==\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar d = [];\\nlet url = base64Decode(getParam(\\\"u\\\"));\\nd.push({\\n    title: \\\"\\\",\\n    url: url,\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"float&&100%\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        floatVideo: true,\\n        canBack: true,\\n        blockRules: [\\\".gif\\\", \\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\"]\\n    }\\n});\\nsetResult(d);\",\"group\":\"③AI\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"获取视频目录\\\",\\\"path\\\":\\\"get_video_catalogue.js\\\",\\\"rule\\\":\\\"function isMovie(text) {\\\\n\\\\n    if (text.length > 8) {\\\\n        return false;\\\\n    }\\\\n    //排除\\\\n    let reg = /\\\\\\\\.|高清直播|写真推荐|影院|影视|蓝光电影|高清电影|第一季|第二季|第三季|第四季|第五季|\\\\\\\\n|\\\\\\\\r/;\\\\n    if (reg.test(text)) {\\\\n        return false;\\\\n    }\\\\n    return /(原画|备用|蓝光|超清|高清|正片|韩版|4K|1080P|720P|TC|HD|BD|中字|版)$/i.test(text);\\\\n}\\\\n\\\\nfunction notChapter(text) {\\\\n    return /[0-9]\\\\\\\\.[0-9]分/.test(text);\\\\n}\\\\nlet last = null;\\\\n\\\\nfunction isChapter0(text, nextText) {\\\\n    let pri = /^第\\\\\\\\d+(集|章|话)$/;\\\\n    if (pri.test(text)) {\\\\n        //fba.log(\\\\\\\"debug:\\\\\\\" + RegExp.$1 + text)\\\\n        return true;\\\\n    }\\\\n\\\\n    let num1 = Number(text);\\\\n    if (!text || Number.isNaN(num1)) {\\\\n        return false;\\\\n    }\\\\n    if (num1 === 1) {\\\\n        //fba.log(\\\\\\\"debug:\\\\\\\" + num1 + text)\\\\n        return true;\\\\n    }\\\\n    if (nextText === null) {\\\\n        //fba.log(\\\\\\\"debug:\\\\\\\" + num1 + nextText)\\\\n        return true;\\\\n    }\\\\n    let num2 = Number(nextText);\\\\n    if (Number.isNaN(num2)) {\\\\n        if (last && (last - num1 < 2 && last - num1 > -2)) {\\\\n            //fba.log(\\\\\\\"debug:\\\\\\\" + last)\\\\n            return true;\\\\n        }\\\\n        return false;\\\\n    }\\\\n    if (num1 - num2 < 2 && num1 - num2 > -2 /*&&num1 - num2!==0*/ ) {\\\\n        fba.log(\\\\\\\"debug:\\\\\\\" + num1 + text + num2 + nextText)\\\\n        last = num1;\\\\n        return true;\\\\n    }\\\\n}\\\\n\\\\nfunction isChapter(text, nextText) {\\\\n    text = text.trim();\\\\n    nextText = nextText ? nextText.trim() : nextText;\\\\n    if (!text || notChapter(text)) {\\\\n        //优先排除\\\\n        //fba.log(\\\\\\\"0排除:\\\\\\\"+text)\\\\n        return false;\\\\n    }\\\\n    //判断是不是电影\\\\n    if (isMovie(text)) {\\\\n        //fba.log(\\\\\\\"1是电影:\\\\\\\" + text)\\\\n        return true;\\\\n    }\\\\n\\\\n    if (isChapter0(text, nextText)) {\\\\n        //fba.log(\\\\\\\"2是剧集:\\\\\\\" + text)\\\\n        return true;\\\\n    }\\\\n    //fba.log(text)\\\\n    return false;\\\\n}\\\\n//top浏览器↓\\\\nvar list_document_link = [];\\\\nvar list_link = [];\\\\nvar ymurl = window.location.href;\\\\nvar choose_channel = 0;\\\\nlist_document_link = document.querySelectorAll('a');\\\\nvar top_j = 0;\\\\n\\\\nfor (let i = 0; i < list_document_link.length; i++) {\\\\n    var text = list_document_link[i].innerText;\\\\n    var href = list_document_link[i].href;\\\\n    var nextText = i + 1 >= list_document_link.length ? null : list_document_link[i + 1].innerText;\\\\n    if (text && isChapter(text, nextText) && href && href.indexOf('http') > -1 && href.indexOf(ymurl + \\\\\\\"#\\\\\\\") == -1) {\\\\n        if (list_document_link[i].target == '_blank') {\\\\n            continue;\\\\n        }\\\\n        if (list_link[top_j] === undefined) {\\\\n            list_link[top_j] = [];\\\\n        }\\\\n        if (href == location.href) {\\\\n            choose_channel = top_j;\\\\n        }\\\\n        var ss = text.replace(/[^\\\\\\\\d+]/g, '');\\\\n        if (ss.indexOf(0) === 0) {\\\\n            text = text.replace('0', '');\\\\n        }\\\\n        var is_repeat = false;\\\\n        for (let j = 0; j < list_link[top_j].length; j++) {\\\\n            if (list_link[top_j][j].href == href) {\\\\n                is_repeat = true;\\\\n                break;\\\\n            }\\\\n            if (list_link[top_j][j].text == text) {\\\\n                top_j += 1;\\\\n                list_link[top_j] = [];\\\\n            }\\\\n        }\\\\n        if (is_repeat) {\\\\n            continue;\\\\n        }\\\\n        var std = {};\\\\n        std.url = href;\\\\n        std.text = text;\\\\n        //排除年代\\\\n        let reg = /1|2[0-9]+/;\\\\n        if (text.length == 4 && reg.test(text)) {\\\\n            continue;\\\\n        }\\\\n        list_link[top_j].push(std);\\\\n    }\\\\n}\\\\n//htmlInterface.getVideoCatalogue(JSON.stringify(list_link));\\\\n//top浏览器↑\\\\n//fba.log(JSON.stringify(list_link))\\\\nif (list_link.length == 1 && list_link[0].length <= 0) {\\\\n    //empty\\\\n} else {\\\\n    if (list_link.length > 0) {\\\\n        window.__fySuccess = true;\\\\n        fba.open(JSON.stringify({\\\\n            rule: fy_title,\\\\n            title: document.title,\\\\n            url: \\\\\\\"hiker://page/video_catalogue_view.js?rule=\\\\\\\" + fy_title,\\\\n            extra: {\\\\n                list_link: list_link,\\\\n                href: location.href,\\\\n                title: document.title\\\\n            }\\\\n        }));\\\\n        window.history.back(-1);\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"视频目录\\\",\\\"path\\\":\\\"video_catalogue_view.js\\\",\\\"rule\\\":\\\"js:\\\\nlet d = [];\\\\nlet i = 1;\\\\nfor (let playList of MY_PARAMS.list_link) {\\\\n    d.push({\\\\n        title: \\\\\\\"线路\\\\\\\" + i++,\\\\n        col_type: \\\\\\\"text_1\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\"\\\\n    });\\\\n    for (let li of playList) {\\\\n        d.push({\\\\n            title: li.text,\\\\n            col_type: \\\\\\\"text_4\\\\\\\",\\\\n            url: \\\\\\\"video://\\\\\\\"+li.url,\\\\n            extra:{\\\\n                blockRules: [\\\\\\\"/ad/\\\\\\\", \\\\\\\"google\\\\\\\", \\\\\\\"/sh/to/\\\\\\\", \\\\\\\".GIF\\\\\\\",'.mp3','.flv', '.3gp', '.mpeg', '.gif', '.jpg', '.jpeg', '.png', '.ico', '.svg'],\\\\n                videoExcludeRules: ['?url=']\\\\n            }\\\\n        });\\\\n    }\\\\n}\\\\nd.push({\\\\n    title: \\\\\\\"““””<small><font color='#aaaaaa'>🔗\\\\\\\" + MY_PARAMS.href + \\\\\\\"</font></small>\\\\\\\",\\\\n    url: \\\\\\\"hiker://page/x5?u=\\\\\\\" + base64Encode(MY_PARAMS.href),\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    extra: {\\\\n        pageTitle: MY_PARAMS.title,\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\n\\\\nsetResult(d);\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"批量导入\\\",\\\"path\\\":\\\"im\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet a = getParam(\\\\\\\"a\\\\\\\", \\\\\\\"\\\\\\\");\\\\nif (a != \\\\\\\"\\\\\\\") {\\\\n    a = base64Decode(a);\\\\n}\\\\nsetPageTitle(MY_RULE.title + \\\\\\\"批量导入\\\\\\\")\\\\nputMyVar(\\\\\\\"im\\\\\\\", a);\\\\nd.push({\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    url: \\\\\\\"\\\\\\\",\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        defaultValue: a,\\\\n        onChange: $.toString(() => {\\\\n            putMyVar(\\\\\\\"im\\\\\\\", input);\\\\n        }),\\\\n        titleVisible: false,\\\\n        type: 'textarea',\\\\n        height: 3,\\\\n        highlight: true\\\\n    }\\\\n});\\\\n\\\\nlet save = () => {\\\\n    let a = getMyVar(\\\\\\\"im\\\\\\\", \\\\\\\"[]\\\\\\\");\\\\n    if (a == \\\\\\\"\\\\\\\" || !a.startsWith(\\\\\\\"[\\\\\\\")) {\\\\n        return \\\\\\\"toast://请输入正确的格式\\\\\\\"\\\\n    }\\\\n    let list = JSON.parse(a);\\\\n    let {\\\\n        addAll\\\\n    } = $.require(\\\\\\\"hiker://page/data\\\\\\\");\\\\n    let count = addAll(list);\\\\n    back(true);\\\\n    return \\\\\\\"toast://已添加\\\\\\\" + count + \\\\\\\"条地址\\\\\\\"\\\\n};\\\\nd.push({\\\\n    title: \\\\\\\"导入\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(save),\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    desc: \\\\\\\"\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\"\\\\n});\\\\n\\\\nif (getParam(\\\\\\\"b\\\\\\\", \\\\\\\"0\\\\\\\") == \\\\\\\"1\\\\\\\") {\\\\n    confirm({\\\\n        title: \\\\\\\"温馨提示\\\\\\\",\\\\n        content: \\\\\\\"确定立即导入\\\\\\\" + MY_RULE.title + \\\\\\\"数据？\\\\\\\",\\\\n        confirm: $.toString(save)\\\\n    });\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"添加网站\\\",\\\"path\\\":\\\"add\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\naddListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n    clearMyVar(\\\\\\\"name\\\\\\\");\\\\n    clearMyVar(\\\\\\\"url\\\\\\\");\\\\n}));\\\\nd.push({\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    url: \\\\\\\"\\\\\\\",\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"请输入网站名称\\\\\\\",\\\\n    extra: {\\\\n        onChange: $.toString(() => {\\\\n            putMyVar(\\\\\\\"name\\\\\\\", input);\\\\n        }),\\\\n        titleVisible: false\\\\n    }\\\\n});\\\\nd.push({\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    url: \\\\\\\"\\\\\\\",\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"请输入网站地址\\\\\\\",\\\\n    extra: {\\\\n        onChange: $.toString(() => {\\\\n            putMyVar(\\\\\\\"url\\\\\\\", input);\\\\n        }),\\\\n        titleVisible: false\\\\n    }\\\\n});\\\\nd.push({\\\\n    title: \\\\\\\"添加保存\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n        let name = getMyVar(\\\\\\\"name\\\\\\\", \\\\\\\"\\\\\\\");\\\\n        let url = getMyVar(\\\\\\\"url\\\\\\\", \\\\\\\"\\\\\\\");\\\\n        if (name == \\\\\\\"\\\\\\\" || url == \\\\\\\"\\\\\\\") {\\\\n            return \\\\\\\"toast://请输入完整信息\\\\\\\"\\\\n        }\\\\n        let {\\\\n            add\\\\n        } = $.require(\\\\\\\"hiker://page/data\\\\\\\");\\\\n        add(name, url);\\\\n        refreshPage();\\\\n        return \\\\\\\"toast://已添加\\\\\\\"\\\\n    }),\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    desc: \\\\\\\"\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\"\\\\n});\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据管理\\\",\\\"path\\\":\\\"data\\\",\\\"rule\\\":\\\"var defaultValue = [\\\\n    {\\\\n        name: \\\\\\\"豌豆\\\\\\\",\\\\n        url: \\\\\\\"https://www.wandou.pro/\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"茶杯狐\\\\\\\",\\\\n        url: \\\\\\\"https://cupfox.app/\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"搜片\\\\\\\",\\\\n        url: \\\\\\\"http://soupian.de/\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"青麦\\\\\\\",\\\\n        url: \\\\\\\"https://www.qimaitv.com/\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"电影狗\\\\\\\",\\\\n        url: \\\\\\\"https://www.dianyinggou.com/yingku/\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"茶杯虎\\\\\\\",\\\\n        url: \\\\\\\"https://www.725998.com/yingku\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"土拨鼠\\\\\\\",\\\\n        url: \\\\\\\"https://www.tbsdy.com/m/index.html\\\\\\\"\\\\n    }\\\\n];\\\\n$.exports = {\\\\n    load: function() {\\\\n        return storage0.getItem(\\\\\\\"data1\\\\\\\", defaultValue);\\\\n    },\\\\n    add: function(name, url) {\\\\n        let data = storage0.getItem(\\\\\\\"data1\\\\\\\", defaultValue);\\\\n        for (let it of data) {\\\\n            if (it.name == name) {\\\\n                return\\\\n            }\\\\n        }\\\\n        data.push({\\\\n            name: name,\\\\n            url: url\\\\n        });\\\\n        storage0.setItem(\\\\\\\"data1\\\\\\\", data);\\\\n    },\\\\n    addAll: function(list) {\\\\n        let data = storage0.getItem(\\\\\\\"data1\\\\\\\", defaultValue);\\\\n        let names = data.map(it => it.name);\\\\n        let count = 0;\\\\n        for (let it of list) {\\\\n            if (!names.includes(it.name)) {\\\\n                data.push(it);\\\\n                count++;\\\\n            }\\\\n        }\\\\n        storage0.setItem(\\\\\\\"data1\\\\\\\", data);\\\\n        return count;\\\\n    },\\\\n    remove: function(name) {\\\\n        let data = storage0.getItem(\\\\\\\"data1\\\\\\\", defaultValue);\\\\n        data = data.filter(it => it.name != name);\\\\n        storage0.setItem(\\\\\\\"data1\\\\\\\", data);\\\\n    },\\\\n    top: function(name) {\\\\n        let data = storage0.getItem(\\\\\\\"data1\\\\\\\", defaultValue);\\\\n        let it = data.filter(it => it.name == name)[0];\\\\n        let d = [];\\\\n        d.push(it);\\\\n        for (let ii of data) {\\\\n            if (ii.name != name) {\\\\n                d.push(ii);\\\\n            }\\\\n        }\\\\n        storage0.setItem(\\\\\\\"data1\\\\\\\", d);\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"u\\\",\\\"path\\\":\\\"u\\\",\\\"rule\\\":\\\"$.exports = function(rule, origin) {\\\\n    return $.toString((rule, origin) => {\\\\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.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n            log(input);\\\\n            //能唤起APP的白名单\\\\n            let white = [\\\\n                \\\\\\\"qklink\\\\\\\",\\\\n                \\\\\\\"bdnetdisk\\\\\\\",\\\\n                \\\\\\\"xunleiapp\\\\\\\",\\\\n                \\\\\\\"smartdrive\\\\\\\"\\\\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\\\":\\\"X5\\\",\\\"path\\\":\\\"x5\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet url = base64Decode(getParam(\\\\\\\"u\\\\\\\"));\\\\nd.push({\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    url: url,\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    desc: \\\\\\\"float&&100%\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        floatVideo: true,\\\\n        canBack: true,\\\\n        blockRules: [\\\\\\\".gif\\\\\\\", \\\\\\\"/ad/\\\\\\\", \\\\\\\"google\\\\\\\", \\\\\\\"/sh/to/\\\\\\\", \\\\\\\".GIF\\\\\\\"]\\\\n    }\\\\n});\\\\nsetResult(d);\\\"}]\",\"proxy\":\"\"}","title":"《权力的游戏第一季》在线观看/手机迅雷下载-美剧天堂"}