邀您一起看：夸克网盘分享

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥夸克网盘分享@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"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    }\\n});\\n\\nsetResult(d);\"},{\"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.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.startsWith(origin) && input.startsWith(\\\"http\\\")) {\\n            log(input);\\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        } 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\":\"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: \\\"KK小站\\\",\\n        url: \\\"https://kkxz.vip/\\\"\\n    },\\n    {\\n        name: \\\"橘子盘搜\\\",\\n        url: \\\"https://www.nmme.cc\\\"\\n    },\\n    {\\n        name: \\\"新剧场\\\",\\n        url: \\\"https://www.xinjuc.com/\\\"\\n    },\\n    {\\n        name: \\\"SN\\\",\\n        url: \\\"http://sxjjj.com/apps/index.html?id=2060sn\\\"\\n    },\\n    {\\n        name: \\\"易搜\\\",\\n        url: \\\"web://https://yiso.fun/\\\"\\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\":\"批量导入\",\"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);\"}],\"saved\":false,\"title\":\"聚云盘Plus\",\"version\":0,\"url\":\"hiker://page/ysfx?rule=聚云盘Plus&r=聚云盘Plus##https://pan.quark.cn/s/97e0c80e9624\",\"col_type\":\"movie_3\",\"find_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    }\\n});\\n\\nsetResult(d);\",\"group\":\"①网盘\",\"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    }\\\\n});\\\\n\\\\nsetResult(d);\\\"},{\\\"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.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.startsWith(origin) && input.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n            log(input);\\\\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        } 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\\\":\\\"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: \\\\\\\"KK小站\\\\\\\",\\\\n        url: \\\\\\\"https://kkxz.vip/\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"橘子盘搜\\\\\\\",\\\\n        url: \\\\\\\"https://www.nmme.cc\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"新剧场\\\\\\\",\\\\n        url: \\\\\\\"https://www.xinjuc.com/\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"SN\\\\\\\",\\\\n        url: \\\\\\\"http://sxjjj.com/apps/index.html?id=2060sn\\\\\\\"\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"易搜\\\\\\\",\\\\n        url: \\\\\\\"web://https://yiso.fun/\\\\\\\"\\\\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\\\":\\\"批量导入\\\",\\\"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);\\\"}]\",\"proxy\":\"\"}","title":"夸克网盘分享"}