邀您一起看：奇妙工具箱

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥奇妙工具箱@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"pic\",\"path\":\"pic\",\"rule\":\"js:\\nvar d = [];\\nlet x = getMyVar(\\\"x\\\", \\\"否\\\");\\nlet desc = x == \\\"是\\\" ? \\\"float&&300\\\" : \\\"float&&1\\\";\\nd.push({\\n    col_type: \\\"x5_webview_single\\\",\\n    url: \\\"\\\",\\n    desc: desc,\\n    title: \\\"\\\",\\n    extra: {\\n        js: $.toString(() => {\\n            function getimgs() {\\n                var videoElements = document.getElementsByTagName(\\\"img\\\");\\n                if (videoElements == null) {\\n                    return [];\\n                }\\n                let urls = [];\\n                for (let i = 0; i < videoElements.length; i++) {\\n                    if (videoElements[i].width > 70 && videoElements[i].height > 70) {\\n                        const src = videoElements[i].src;\\n                        if (src == null || src.length < 5 || urls.includes(src) || src.indexOf(\\\"data:\\\") == 0) {\\n                            continue;\\n                        }\\n                        //log(src);\\n                        urls.push(new URL(src).toString());\\n                    }\\n                }\\n                return urls;\\n            }\\n\\n            function check() {\\n                try {\\n                    let urls = getimgs();\\n                    //fba.log(\\\"getimgs：\\\" + urls.length);\\n                    if (window.checkedUrls == null) {\\n                        window.checkedUrls = [];\\n                    }\\n                    let checkedUrls = window.checkedUrls;\\n                    urls = urls.filter(it => {\\n                        return !checkedUrls.includes(it)\\n                    });\\n\\n                    if (urls.length > 0) {\\n                        let pics = urls.filter(it => it != null && it != \\\"\\\")\\n                            .map(it => {\\n                                let u = fba.getHeaderUrl(it);\\n                                let uu = u.split(\\\";\\\");\\n                                let pic = u;\\n                                if (uu.length > 1) {\\n                                    let u1 = uu[0];\\n                                    let u2 = uu[1].slice(1, -1).split(\\\"&&\\\");\\n                                    let referer = null;\\n                                    let ua = null;\\n                                    let cookie0 = null;\\n                                    for (let ii of u2) {\\n                                        let it2 = ii.split(\\\"@\\\");\\n                                        if (it2[0] == \\\"Referer\\\") {\\n                                            referer = it2[1].replace(/；；/g, \\\";\\\");\\n                                        }\\n                                        if (it2[0] == \\\"User-Agent\\\") {\\n                                            ua = it2[1].replace(/；；/g, \\\";\\\");\\n                                        }\\n                                        if (it2[0] == \\\"Cookie\\\") {\\n                                            cookie0 = it2[1].replace(/；；/g, \\\";\\\");\\n                                        }\\n                                    }\\n                                    pic = u1;\\n                                    if (referer) {\\n                                        pic = pic + \\\"@Referer=\\\" + referer;\\n                                    }\\n                                    if (ua) {\\n                                        pic = pic + \\\"@User-Agent=\\\" + ua;\\n                                    }\\n                                    if (cookie0) {\\n                                        pic = pic + \\\"@Cookie=\\\" + cookie0\\n                                    }\\n\\n                                } else {\\n                                    pic = it;\\n                                }\\n                                return {\\n                                    pic: pic,\\n                                    url: u\\n                                }\\n                            });\\n                        fba.log(pics.length + \\\"\\\");\\n                        fba.parseLazyRuleAsync($$$().lazyRule((urls) => {\\n                            //log(urls);\\n\\n                            let arr = urls.map(it => {\\n                                return {\\n                                    title: \\\"\\\",\\n                                    url: it.pic,\\n                                    pic_url: it.pic,\\n                                    col_type: \\\"card_pic_3\\\",\\n                                    extra: {\\n                                        cls: \\\"pics\\\"\\n                                    }\\n                                }\\n                            });\\n                            addItemBefore(\\\"pic_line\\\", arr);\\n                        }, pics), function() {\\n\\n                        });\\n                        for (let it of urls) {\\n                            window.checkedUrls.push(it);\\n                        }\\n                    }\\n\\n                } catch (e) {\\n                    fba.log(e.toString());\\n                }\\n                setTimeout(check, 300);\\n            }\\n            check();\\n        })\\n    }\\n});\\n\\n\\nd.push({\\n    title: \\\"提取\\\",\\n    url: $.toString(() => {\\n        putMyVar(\\\"i\\\", input);\\n        deleteItemByCls(\\\"pics\\\");\\n        refreshX5WebView(input);\\n    }),\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入网页地址\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        defaultValue: getMyVar(\\\"i\\\", \\\"\\\")\\n    }\\n});\\nd.push({\\n    title: \\\"显示网页组件：\\\" + x,\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let x = getMyVar(\\\"x\\\", \\\"否\\\");\\n        let next = x == \\\"否\\\" ? \\\"是\\\" : \\\"否\\\";\\n        putMyVar(\\\"x\\\", next);\\n        let desc = x == \\\"否\\\" ? \\\"float&&300\\\" : \\\"float&&1\\\";\\n        updateItem(\\\"pic_tip\\\", {\\n            title: \\\"显示网页组件：\\\" + next\\n        });\\n        refreshX5Desc(desc);\\n        return \\\"hiker://empty\\\"\\n    }),\\n    col_type: \\\"text_1\\\",\\n    desc: \\\"\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        id: \\\"pic_tip\\\"\\n    }\\n});\\n\\nd.push({\\n    col_type: \\\"line_blank\\\",\\n    extra: {\\n        id: \\\"pic_line\\\"\\n    }\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"text_1\",\"name\":\"epub\",\"path\":\"epub\",\"rule\":\"js:\\nvar d = [];\\nlet path = base64Decode(getParam(\\\"p\\\"));\\nlog(path);\\nlet meta = getEpubMetadata(path);\\n//setPageTitle(meta.firstTitle);\\nlet chapters = getEpubChapters(path);\\n//log(chapters);\\nfor (let it of chapters) {\\n    d.push({\\n        title: it.title,\\n        url: \\\"hiker://page/content#readTheme##autoPage#\\\",\\n        extra: {\\n            href: it.url,\\n            path: path\\n        }\\n    });\\n}\\nsetResult(d);\\n\"},{\"col_type\":\"rich_text\",\"name\":\"正文\",\"path\":\"content\",\"rule\":\"js:\\nvar d = [];\\nlet path = MY_PARAMS.path;\\nlet url = MY_PARAMS.href;\\nlet c = getEpubContent(path, url);\\nd.push({\\n    title: c,\\n    url: \\\"\\\",\\n});\\nsetResult(d);\"}],\"saved\":false,\"title\":\"奇妙工具箱\",\"author\":\"小棉袄🌞\",\"version\":10,\"type\":\"tool\",\"url\":\"hiker://empty##\",\"col_type\":\"movie_3\",\"class_name\":\"\",\"class_url\":\"\",\"area_name\":\"\",\"area_url\":\"\",\"sort_name\":\"\",\"year_name\":\"\",\"sort_url\":\"\",\"year_url\":\"\",\"find_rule\":\"js:\\nvar d = [];\\nd.push({\\n    title: \\\"磁力云播\\\",\\n    url: \\\"hiker://empty\\\",\\n    desc: \\\"““””<small>基于迅雷SDK，支持磁力、电驴、种子、FTP、HTTP、RTMP等多种格式</small>\\\",\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nd.push({\\n    title: \\\"播放\\\",\\n    url: $.toString(() => {\\n        return input;\\n    }),\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入链接\\\",\\n    pic_url: \\\"\\\"\\n});\\n\\nd.push({\\n    title: \\\"视频提取\\\",\\n    desc: \\\"直接输入网页地址即可提取播放、下载视频\\\",\\n    url: \\\"hiker://empty\\\",\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nd.push({\\n    title: \\\"提取\\\",\\n    url: $.toString(() => {\\n        return \\\"video://\\\" + input;\\n    }),\\n    col_type: \\\"input\\\",\\n    desc: \\\"请输入网页链接\\\",\\n    pic_url: \\\"\\\"\\n});\\n\\nd.push({\\n    title: \\\"电子书阅读器(txt)\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let r = fetch(\\\"hiker://home@本地资源管理\\\");\\n        if (r && r.length > 5) {\\n            return \\\"hiker://home@本地资源管理\\\";\\n        } else {\\n            confirm({\\n                title: \\\"温馨提示\\\",\\n                content: \\\"当前未导入扩展插件，点击下方确定按钮导入\\\",\\n                confirm: $.toString(() => {\\n                    return \\\"海阔视界小程序规则【本地资源管理】￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=3559\\\"\\n                })\\n            });\\n            return \\\"hiker://empty\\\"\\n        }\\n    }),\\n    col_type: \\\"card_pic_2\\\",\\n    pic_url: \\\"hiker://images/home_pic4\\\",\\n    extra: {\\n        longClick: [\\n            {\\n                title: \\\"检测更新\\\",\\n                js: \\\"'海阔视界￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=3559'\\\"\\n            }\\n        ]\\n    }\\n});\\nd.push({\\n    title: \\\"epub阅读器\\\",\\n    url: \\\"fileSelect://\\\" + $.toString(() => {\\n        const File = java.io.File;\\n        let javaImport = new JavaImporter();\\n        javaImport.importPackage(\\n            Packages.com.example.hikerview.utils\\n        );\\n        with(javaImport) {\\n            let file = new File(input);\\n            let n = file.getName().replace(\\\"_fileSelect_\\\", \\\"\\\");\\n            let p = getPath(\\\"hiker://files/download/\\\" + n);\\n            p = p.replace(\\\"file://\\\", \\\"\\\");            \\n            FileUtil.copyFile(file, new File(p));\\n            p = base64Encode(p);            \\n            return \\\"hiker://page/epub#autoCache#?p=\\\" + p + \\\"&pageTitle=\\\" + n;\\n        }\\n    }),\\n    col_type: \\\"card_pic_2_2\\\",\\n    pic_url: \\\"hiker://images/home_pic3\\\",\\n    extra: {\\n        inheritTitle: false\\n    }\\n});\\nd.push({\\n    title: \\\"WebDav\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let r = fetch(\\\"hiker://home@Webdav\\\");\\n        log(r);\\n        if (r && r.length > 5) {\\n            return \\\"hiker://home@Webdav\\\";\\n        } else {\\n            confirm({\\n                title: \\\"温馨提示\\\",\\n                content: \\\"当前未导入扩展插件，点击下方确定按钮导入\\\",\\n                confirm: $.toString(() => {\\n                    return \\\"海阔视界小程序规则【Webdav】￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=5210\\\"\\n                })\\n            });\\n            return \\\"hiker://empty\\\"\\n        }\\n    }),\\n    col_type: \\\"card_pic_2_2\\\",\\n    pic_url: \\\"hiker://images/home_pic2\\\"\\n});\\nd.push({\\n    title: \\\"图片提取器\\\",\\n    url: \\\"hiker://page/pic\\\",\\n    col_type: \\\"text_center_1\\\",\\n    desc: \\\"\\\",\\n    pic_url: \\\"\\\"\\n});\\n\\nd.push({\\n    title: \\\"““””<span style=\\\\\\\"color: #aaaaaa\\\\\\\"><small>扩展插件来自小棉袄、LoyDgIk、Joe等</small></span>\\\",\\n    url: \\\"hiker://empty\\\",\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\nd.push({\\n    col_type: \\\"line_blank\\\",\\n    extra: {\\n        id: \\\"qmgjx\\\"\\n    }\\n});\\n\\nsetResult(d);\\ntry {\\n    MY_URL = \\\"https://haikuoshijie.cn/\\\";\\n    let html = request(MY_URL);\\n    let arr = pdfa(html, \\\".post-list&&li\\\");\\n    addItemAfter(\\\"qmgjx\\\", arr.map(it => {\\n        return {\\n            title: pdfh(it, \\\"h3--time&&Text\\\"),\\n            url: \\\"x5://\\\" + pd(it, \\\"a&&href\\\"),\\n            col_type: \\\"text_1\\\",\\n            desc: pdfh(it, \\\".index-time&&Text\\\") + \\\"   \\\" + pdfh(it, \\\".post-meta&&span&&Text\\\")\\n        }\\n    }))\\n} catch (e) {}\",\"searchFind\":\"\",\"search_url\":\"\",\"group\":\"①推荐\",\"detail_col_type\":\"movie_1\",\"detail_find_rule\":\"\",\"sdetail_col_type\":\"movie_1\",\"sdetail_find_rule\":\"\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"pic\\\",\\\"path\\\":\\\"pic\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet x = getMyVar(\\\\\\\"x\\\\\\\", \\\\\\\"否\\\\\\\");\\\\nlet desc = x == \\\\\\\"是\\\\\\\" ? \\\\\\\"float&&300\\\\\\\" : \\\\\\\"float&&1\\\\\\\";\\\\nd.push({\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    url: \\\\\\\"\\\\\\\",\\\\n    desc: desc,\\\\n    title: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        js: $.toString(() => {\\\\n            function getimgs() {\\\\n                var videoElements = document.getElementsByTagName(\\\\\\\"img\\\\\\\");\\\\n                if (videoElements == null) {\\\\n                    return [];\\\\n                }\\\\n                let urls = [];\\\\n                for (let i = 0; i < videoElements.length; i++) {\\\\n                    if (videoElements[i].width > 70 && videoElements[i].height > 70) {\\\\n                        const src = videoElements[i].src;\\\\n                        if (src == null || src.length < 5 || urls.includes(src) || src.indexOf(\\\\\\\"data:\\\\\\\") == 0) {\\\\n                            continue;\\\\n                        }\\\\n                        //log(src);\\\\n                        urls.push(new URL(src).toString());\\\\n                    }\\\\n                }\\\\n                return urls;\\\\n            }\\\\n\\\\n            function check() {\\\\n                try {\\\\n                    let urls = getimgs();\\\\n                    //fba.log(\\\\\\\"getimgs：\\\\\\\" + urls.length);\\\\n                    if (window.checkedUrls == null) {\\\\n                        window.checkedUrls = [];\\\\n                    }\\\\n                    let checkedUrls = window.checkedUrls;\\\\n                    urls = urls.filter(it => {\\\\n                        return !checkedUrls.includes(it)\\\\n                    });\\\\n\\\\n                    if (urls.length > 0) {\\\\n                        let pics = urls.filter(it => it != null && it != \\\\\\\"\\\\\\\")\\\\n                            .map(it => {\\\\n                                let u = fba.getHeaderUrl(it);\\\\n                                let uu = u.split(\\\\\\\";\\\\\\\");\\\\n                                let pic = u;\\\\n                                if (uu.length > 1) {\\\\n                                    let u1 = uu[0];\\\\n                                    let u2 = uu[1].slice(1, -1).split(\\\\\\\"&&\\\\\\\");\\\\n                                    let referer = null;\\\\n                                    let ua = null;\\\\n                                    let cookie0 = null;\\\\n                                    for (let ii of u2) {\\\\n                                        let it2 = ii.split(\\\\\\\"@\\\\\\\");\\\\n                                        if (it2[0] == \\\\\\\"Referer\\\\\\\") {\\\\n                                            referer = it2[1].replace(/；；/g, \\\\\\\";\\\\\\\");\\\\n                                        }\\\\n                                        if (it2[0] == \\\\\\\"User-Agent\\\\\\\") {\\\\n                                            ua = it2[1].replace(/；；/g, \\\\\\\";\\\\\\\");\\\\n                                        }\\\\n                                        if (it2[0] == \\\\\\\"Cookie\\\\\\\") {\\\\n                                            cookie0 = it2[1].replace(/；；/g, \\\\\\\";\\\\\\\");\\\\n                                        }\\\\n                                    }\\\\n                                    pic = u1;\\\\n                                    if (referer) {\\\\n                                        pic = pic + \\\\\\\"@Referer=\\\\\\\" + referer;\\\\n                                    }\\\\n                                    if (ua) {\\\\n                                        pic = pic + \\\\\\\"@User-Agent=\\\\\\\" + ua;\\\\n                                    }\\\\n                                    if (cookie0) {\\\\n                                        pic = pic + \\\\\\\"@Cookie=\\\\\\\" + cookie0\\\\n                                    }\\\\n\\\\n                                } else {\\\\n                                    pic = it;\\\\n                                }\\\\n                                return {\\\\n                                    pic: pic,\\\\n                                    url: u\\\\n                                }\\\\n                            });\\\\n                        fba.log(pics.length + \\\\\\\"\\\\\\\");\\\\n                        fba.parseLazyRuleAsync($$$().lazyRule((urls) => {\\\\n                            //log(urls);\\\\n\\\\n                            let arr = urls.map(it => {\\\\n                                return {\\\\n                                    title: \\\\\\\"\\\\\\\",\\\\n                                    url: it.pic,\\\\n                                    pic_url: it.pic,\\\\n                                    col_type: \\\\\\\"card_pic_3\\\\\\\",\\\\n                                    extra: {\\\\n                                        cls: \\\\\\\"pics\\\\\\\"\\\\n                                    }\\\\n                                }\\\\n                            });\\\\n                            addItemBefore(\\\\\\\"pic_line\\\\\\\", arr);\\\\n                        }, pics), function() {\\\\n\\\\n                        });\\\\n                        for (let it of urls) {\\\\n                            window.checkedUrls.push(it);\\\\n                        }\\\\n                    }\\\\n\\\\n                } catch (e) {\\\\n                    fba.log(e.toString());\\\\n                }\\\\n                setTimeout(check, 300);\\\\n            }\\\\n            check();\\\\n        })\\\\n    }\\\\n});\\\\n\\\\n\\\\nd.push({\\\\n    title: \\\\\\\"提取\\\\\\\",\\\\n    url: $.toString(() => {\\\\n        putMyVar(\\\\\\\"i\\\\\\\", input);\\\\n        deleteItemByCls(\\\\\\\"pics\\\\\\\");\\\\n        refreshX5WebView(input);\\\\n    }),\\\\n    col_type: \\\\\\\"input\\\\\\\",\\\\n    desc: \\\\\\\"请输入网页地址\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        defaultValue: getMyVar(\\\\\\\"i\\\\\\\", \\\\\\\"\\\\\\\")\\\\n    }\\\\n});\\\\nd.push({\\\\n    title: \\\\\\\"显示网页组件：\\\\\\\" + x,\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n        let x = getMyVar(\\\\\\\"x\\\\\\\", \\\\\\\"否\\\\\\\");\\\\n        let next = x == \\\\\\\"否\\\\\\\" ? \\\\\\\"是\\\\\\\" : \\\\\\\"否\\\\\\\";\\\\n        putMyVar(\\\\\\\"x\\\\\\\", next);\\\\n        let desc = x == \\\\\\\"否\\\\\\\" ? \\\\\\\"float&&300\\\\\\\" : \\\\\\\"float&&1\\\\\\\";\\\\n        updateItem(\\\\\\\"pic_tip\\\\\\\", {\\\\n            title: \\\\\\\"显示网页组件：\\\\\\\" + next\\\\n        });\\\\n        refreshX5Desc(desc);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }),\\\\n    col_type: \\\\\\\"text_1\\\\\\\",\\\\n    desc: \\\\\\\"\\\\\\\",\\\\n    pic_url: \\\\\\\"\\\\\\\",\\\\n    extra: {\\\\n        id: \\\\\\\"pic_tip\\\\\\\"\\\\n    }\\\\n});\\\\n\\\\nd.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\",\\\\n    extra: {\\\\n        id: \\\\\\\"pic_line\\\\\\\"\\\\n    }\\\\n});\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"epub\\\",\\\"path\\\":\\\"epub\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet path = base64Decode(getParam(\\\\\\\"p\\\\\\\"));\\\\nlog(path);\\\\nlet meta = getEpubMetadata(path);\\\\n//setPageTitle(meta.firstTitle);\\\\nlet chapters = getEpubChapters(path);\\\\n//log(chapters);\\\\nfor (let it of chapters) {\\\\n    d.push({\\\\n        title: it.title,\\\\n        url: \\\\\\\"hiker://page/content#readTheme##autoPage#\\\\\\\",\\\\n        extra: {\\\\n            href: it.url,\\\\n            path: path\\\\n        }\\\\n    });\\\\n}\\\\nsetResult(d);\\\\n\\\"},{\\\"col_type\\\":\\\"rich_text\\\",\\\"name\\\":\\\"正文\\\",\\\"path\\\":\\\"content\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet path = MY_PARAMS.path;\\\\nlet url = MY_PARAMS.href;\\\\nlet c = getEpubContent(path, url);\\\\nd.push({\\\\n    title: c,\\\\n    url: \\\\\\\"\\\\\\\",\\\\n});\\\\nsetResult(d);\\\"}]\",\"proxy\":\"\",\"icon\":\"\"}","title":"奇妙工具箱"}