小程序：图书馆Pro

海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@图书馆Pro@{"last_chapter_rule":"","title":"图书馆Pro","author":"Joe","url":"hiker://empty","version":13,"col_type":"movie_3","class_name":"","type":"read","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nlet layout = [];\nlayout.push({\n    col_type: \"big_blank_block\"\n});\nlayout.push({\n    col_type: \"big_blank_block\"\n});\nlayout.push({\n    col_type: \"big_blank_block\"\n});\nlayout.push({\n    col_type: \"big_blank_block\"\n});\n\nlayout.push({\n    title: '<h1 style=\"text-align: center;\"><big><font color=\"#FEBD6F\">图书馆Pro</font></big><br><small><font color=\"#FB6C73\">你的私人图书馆</font></small></h1>',\n    col_type: \"rich_text\"\n});\nlayout.push({\n    col_type: \"input\",\n    url: \"'hiker://search?s=' + input\",\n    extra: {\n        rules: $.toString(() => {\n            let data = [];\n            $.require(\"api\").engines.forEach((Map, i) => {\n                data.push({\n                    \"title\": Map,\n                    \"search_url\": buildUrl(\"hiker://empty\", {\n                        kw: \"**\",\n                        page: \"fypage\",\n                        engine: Map\n                    }),\n                    \"searchFind\": \"js:$.require('hiker://page/搜索?rule=图书馆Pro')\"\n                });\n            })\n            return JSON.stringify(data);\n        })\n    },\n    title: \"搜索\"\n})\nlayout.push({\n    col_type: \"big_blank_block\"\n});\nlayout.push({\n    col_type: \"big_blank_block\"\n});\nlayout.push({\n    col_type: \"big_blank_block\"\n});\nlayout.push({\n    title: \"🔰 历史记录\",\n    col_type: \"text_1\",\n    url: $(\"确认清除？\").confirm(() => {\n        clearItem(\"history\")\n        refreshPage()\n        toast(\"清理成功\")\n    })\n});\nvar history = storage0.getItem(\"history\", [])\nhistory.forEach(item => {\n    layout.push({\n        title: item,\n        url: 'hiker://search?s=' + item,\n        extra: {\n            rules: $.toString(() => {\n                let data = [];\n                $.require(\"api\").engines.forEach((Map, i) => {\n                    data.push({\n                        \"title\": Map,\n                        \"search_url\": buildUrl(\"hiker://empty\", {\n                            kw: \"**\",\n                            page: \"fypage\",\n                            engine: Map\n                        }),\n                        \"searchFind\": \"js:$.require('hiker://page/搜索?rule=图书馆Pro')\"\n                    });\n                })\n                return JSON.stringify(data);\n            })\n        },\n        col_type: \"flex_button\"\n    })\n})\nsetResult(layout);","search_url":"hiker://empty?kw=**","group":"①②阅读资讯🥰","searchFind":"js:\nsetResult([{\n    url: 'hiker://search?s=' + getParam(\"kw\"),\n    extra: {\n        rules: $.toString(() => {\n            let data = [];\n            $.require(\"api\").engines.forEach((Map, i) => {\n                data.push({\n                    \"title\": Map,\n                    \"search_url\": buildUrl(\"hiker://empty\", {\n                        kw: \"**\",\n                        page: \"fypage\",\n                        engine: Map\n                    }),\n                    \"searchFind\": \"js:$.require('hiker://page/搜索?rule=图书馆Pro')\"\n                });\n            })\n            return JSON.stringify(data);\n        })\n    },\n    title: \"搜索：\" + getParam(\"kw\")\n}])","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"","pages":"[{\"col_type\":\"text_1\",\"name\":\"搜索\",\"path\":\"搜索\",\"rule\":\"js:\\nvar d = [];\\nvar history = storage0.getItem(\\\"history\\\", [])\\nif (!history.includes(getParam(\\\"kw\\\"))) {\\n    history.unshift(getParam(\\\"kw\\\"))\\n    storage0.setItem(\\\"history\\\", history)\\n}\\n$.require(\\\"hiker://page/api?rule=图书馆Pro\\\")[getParam(\\\"engine\\\")](getParam(\\\"kw\\\"), MY_PAGE)\\nsetResult(d);\"},{\"col_type\":\"text_1\",\"name\":\"api\",\"path\":\"api\",\"rule\":\"$.exports = {\\n    engines: [\\\"豆瓣\\\", \\\"Ylibrary\\\", \\\"Zlibrary\\\", \\\"Libgen\\\", \\\"鸠摩\\\", \\\"无名图书\\\"],\\n    豆瓣: function(kw, page) {\\n        var d = [];\\n        var computeRating = $.require(\\\"api?rule=图书馆Pro\\\").computeRating\\n        var url = buildUrl(\\\"https://frodo.douban.com/api/v2/search/subjects\\\", {\\n            type: \\\"book\\\",\\n            q: kw,\\n            start: page == 1 ? 0 : ((page - 1) * 20),\\n            count: 20,\\n            apikey: \\\"0dad551ec0f84ed02907ff5c42e8ec70\\\"\\n        })\\n        var res = JSON.parse(post(url, {\\n            body: {\\n                host: \\\"frodo.douban.com\\\"\\n            },\\n            headers: {\\n                \\\"User-Agent\\\": \\\"Rexxar-Core/0.1.3 api-client/1 com.douban.frodo/7.9.0.beta2(215) Android/25 product/TAS-AL00 vendor/HUAWEI model/TAS-AL00  rom/android  network/wifi  platform/mobile com.douban.frodo/7.9.0.beta2(215) Rexxar/1.2.151  platform/mobile 1.2.151\\\"\\n            }\\n        })).items\\n        res.forEach(item => {\\n            item = item.target\\n            star = (item.rating ? \\\"\\\\n\\\" + computeRating(item.rating.max, item.rating.value) + \\\" 评分：\\\" + item.rating.value : \\\"\\\")\\n            desc = item.card_subtitle + star\\n            d.push({\\n                title: item.title,\\n                content: desc,\\n                img: item.cover_url,\\n                col_type: \\\"movie_1_vertical_pic\\\",\\n                url: $(\\\"hiker://empty#immersiveTheme#\\\").rule((id, star) => {\\n                    var d = []\\n                    var u = buildUrl(\\\"https://frodo.douban.com/api/v2/book/\\\" + id, {\\n                        apikey: \\\"0dad551ec0f84ed02907ff5c42e8ec70\\\"\\n                    })\\n                    var res = JSON.parse(post(u, {\\n                        body: {\\n                            host: \\\"frodo.douban.com\\\"\\n                        },\\n                        headers: {\\n                            \\\"User-Agent\\\": \\\"Rexxar-Core/0.1.3 api-client/1 com.douban.frodo/7.9.0.beta2(215) Android/25 product/TAS-AL00 vendor/HUAWEI model/TAS-AL00  rom/android  network/wifi  platform/mobile com.douban.frodo/7.9.0.beta2(215) Rexxar/1.2.151  platform/mobile 1.2.151\\\"\\n                        }\\n                    }))\\n                    d.unshift({\\n                        title: res.title,\\n                        img: res.pic.normal,\\n                        url: \\\"x5://\\\" + res.info_url,\\n                        desc: res.card_subtitle + \\\"\\\\n\\\" + star,\\n                        col_type: \\\"movie_1_vertical_pic_blur\\\"\\n                    }, {\\n                        col_type: \\\"line_blank\\\"\\n                    })\\n                    var intro = `作者：${res.author.join(\\\",\\\")}\\\\n\\\\n翻译：${res.translator.join(\\\",\\\")}\\\\n\\\\n简介：${res.intro}\\\\n\\\\n作者简介：${res.author_intro}\\\\n\\\\n摘录：${res.catalog}`\\n                    d.push({\\n                        title: intro,\\n                        col_type: \\\"long_text\\\"\\n                    })\\n                    setResult(d)\\n                }, item.id, star)\\n            })\\n        })\\n        setResult(d);\\n    },\\n    Ylibrary: function(kw, page) {\\n        var d = []\\n        var res = JSON.parse(post(\\\"https://api.ylibrary.org/api/search/\\\", {\\n            body: JSON.stringify({\\n                \\\"keyword\\\": kw,\\n                \\\"page\\\": page,\\n                \\\"sensitive\\\": false\\n            })\\n        })).data\\n        res.forEach(item => {\\n            d.push({\\n                title: item.title,\\n                content: `作者:${item.author} 出版社:${item.publisher?item.publisher:\\\"暂无\\\"} ISBN:${item.isbn?item.isbn:\\\"暂无\\\"} 出版时间:${item.year?item.year:\\\"暂无\\\"} 文件格式:${item.extension} 文件大小:${$.require(\\\"api?rule=图书馆Pro\\\").getFileSize(item.filesize)}`,\\n                url: $().lazyRule((id) => {\\n                    try {\\n                        var res = JSON.parse(post(\\\"https://api.ylibrary.org/api/detail/\\\", {\\n                            body: JSON.stringify({\\n                                \\\"id\\\": id,\\n                                \\\"source\\\": \\\"zlibrary\\\"\\n                            })\\n                        }))\\n                        var servers = $.require(\\\"hiker://page/api?rule=图书馆Pro\\\").servers\\n                        servers.unshift(\\\"百度云盘转存\\\")\\n                        if (res.in_libgen) {\\n                            servers.unshift(\\\"Libgen(推荐)\\\")\\n                        }\\n                        return $(servers, 1, \\\"选择线路\\\").select((res) => {\\n                            if (input == \\\"Libgen(推荐)\\\") {\\n                                return pdfh(request(\\\"http://library.lol/main/\\\" + res.md5), \\\"#download&&a&&href\\\")\\n                            } else if (input == \\\"百度云盘转存\\\") {\\n                                return $.require(\\\"api?rule=图书馆Pro\\\").baidu(res)\\n                            } else if (input == \\\"ipfs下载\\\") {\\n                                return `https://ipfs-checker.1kbtool.com/${res.ipfs_cid}`\\n                            } else {\\n                                return input + res.ipfs_cid\\n                            }\\n                        }, res)\\n                    } catch (e) {\\n                        log(e.message)\\n                        return \\\"toast://解析失败\\\"\\n                    }\\n                }, item.id)\\n            })\\n        })\\n        setResult(d);\\n    },\\n    Zlibrary: function(kw, page) {\\n        var d = [];\\n        var res = JSON.parse(post(\\\"https://worker.zlib.app/api/search/\\\", {\\n            body: JSON.stringify({\\n                \\\"keyword\\\": kw,\\n                \\\"page\\\": page,\\n                \\\"sensitive\\\": false\\n            })\\n        })).data\\n        res.forEach(item => {\\n            d.push({\\n                title: item.title,\\n                content: `<small>作者:${item.author} 出版社:${item.publisher?item.publisher:\\\"暂无\\\"} ISBN:${item.isbn?item.isbn:\\\"暂无\\\"} 出版时间:${item.year?item.year:\\\"暂无\\\"} 文件格式:${item.extension} 文件大小:${$.require(\\\"api?rule=图书馆Pro\\\").getFileSize(item.filesize)}`,\\n                img: item.cover,\\n                url: \\\"https://worker.zlib.app/download/\\\" + item.id\\n            })\\n        })\\n        setResult(d)\\n    },\\n    鸠摩: function(kw) {\\n        var d = []\\n        var id = JSON.parse(post(\\\"https://www5.jiumodiary.com/init_hubs.php\\\", {\\n            body: {\\n                q: kw,\\n                remote_ip: \\\"\\\",\\n                time_int: Date.parse(new Date()) + \\\"\\\"\\n            }\\n        })).id\\n        var res = JSON.parse(post(\\\"https://www5.jiumodiary.com/ajax_fetch_hubs.php\\\", {\\n            body: {\\n                id: id,\\n                set: 0\\n            }\\n        })).sources\\n        res.forEach(item => {\\n            item.details.data.forEach(item2 => {\\n                d.push({\\n                    title: item2.title,\\n                    content: item2.des + \\\"\\\\n\\\" + item2.v_des,\\n                    img: \\\"http:\\\" + item2.img_link,\\n                    col_type: item2.img_link ? \\\"movie_1_vertical_pic\\\" : \\\"text_1\\\",\\n                    url: item2.link\\n                })\\n            })\\n        })\\n        setResult(d);\\n    },\\n    checkLibgen: function() {\\n        var domains = [\\\"http://libgen.rs\\\", \\\"http://libgen.is\\\", \\\"http://libgen.st\\\"]\\n        try {\\n            for (item of domains) {\\n                var code = JSON.parse(request(item, {\\n                    withStatusCode: true\\n                })).statusCode\\n                if (code == 200) {\\n                    setItem(\\\"libgen\\\", item)\\n                    toast(\\\"检测到可用镜像，请刷新后重新搜索\\\")\\n                    refreshPage()\\n                    break\\n                }\\n            }\\n            toast(\\\"所有镜像都无法使用，请打开TZ使用\\\")\\n        } catch (e) {\\n            log(e.message)\\n        }\\n    },\\n    Libgen: function(kw, page) {\\n        var d = []\\n        if (getItem(\\\"libgen\\\", \\\"\\\") == \\\"\\\") {\\n            toast(\\\"无可用镜像，正在检测中...\\\")\\n            $.require(\\\"api?rule=图书馆Pro\\\").checkLibgen()\\n        } else {\\n            var url = getItem(\\\"libgen\\\") + \\\"/search.php?req=\\\" + kw + \\\"&page=\\\" + page\\n            var r = JSON.parse(request(url, {\\n                withHeaders: true\\n            }))\\n            if (r.statusCode == 200) {\\n                var res = r.body\\n                var list = pdfa(res, \\\"body&&tr\\\").filter(item => {\\n                    if (item.includes(\\\"nowrap\\\")) {\\n                        return item\\n                    }\\n                })\\n                list.forEach(item => {\\n                    var li = item.match(new RegExp(\\\"<td(.*?)</td>\\\", \\\"g\\\"))\\n                    var desc = pdfh(li[1], \\\"a&&Text\\\")\\n                    for (let i = 3; i < li.length - 3; i++) {\\n                        desc += \\\"；\\\" + pdfh(li[i], \\\"Text\\\")\\n                    }\\n                    d.push({\\n                        title: pdfh(li[2], \\\"Text\\\"),\\n                        content: desc,\\n                        url: $().lazyRule((li) => {\\n                            return pdfh(request(pdfh(li[9], \\\"a&&href\\\")), \\\"#download&&a&&href\\\")\\n                        }, li)\\n                    })\\n                })\\n            } else {\\n                toast(\\\"镜像失效，重新检测中...\\\")\\n                $.require(\\\"api?rule=图书馆Pro\\\").checkLibgen()\\n            }\\n        }\\n        setResult(d);\\n    },\\n    网盘: function(kw, page) {\\n        var d = []\\n        var res = JSON.parse(post(\\\"https://api.bookpan.net/api/search/\\\", {\\n            body: JSON.stringify({\\n                \\\"keyword\\\": kw,\\n                \\\"page\\\": page,\\n                \\\"sensitive\\\": false\\n            })\\n        })).data\\n        res.forEach(item => {\\n            d.push({\\n                title: item.info,\\n                content: item.source,\\n                url: $().lazyRule((id, source) => {\\n                    try {\\n                        var res = JSON.parse(post(\\\"https://api.bookpan.net/api/detail/\\\", {\\n                            body: JSON.stringify({\\n                                \\\"id\\\": id,\\n                                \\\"source\\\": source\\n                            })\\n                        }))\\n                        if (res.download_link) {\\n                            var dict = {}\\n                            res.download_link.unshift({\\n                                name: \\\"原网页\\\",\\n                                url: res.url\\n                            })\\n                            return $(res.download_link.map(function(item) {\\n                                return item.name\\n                            }), 1, \\\"请选择下载线路\\\").select((links) => {\\n                                return links[links.map(function(item) {\\n                                    return item.name\\n                                }).indexOf(input)].url\\n                            }, res.download_link)\\n                        } else {\\n                            return res.url\\n                        }\\n                    } catch (e) {\\n                        log(e.message)\\n                        return \\\"toast://解析失败\\\"\\n                    }\\n                }, item.id, item.source)\\n            })\\n        })\\n        setResult(d);\\n    },\\n    无名图书: function(kw, page) {\\n        var d = []\\n        var url = \\\"https://www.book123.info/list?key=\\\" + kw + \\\"&page=\\\" + page\\n        var res = request(url)\\n        var list = pdfa(res, \\\".list_pageContent__z_yzv&&li\\\")\\n        list.forEach(item => {\\n            d.push({\\n                title: pdfh(item, \\\".list_title__06nt2&&Text\\\"),\\n                content: pdfh(item, \\\".list_author__lPwpl&&Text\\\") + \\\"\\\\n\\\" + pdfh(item, \\\".list_rate__J7Ox1&&Text\\\") + \\\"\\\\n\\\" + pdfh(item, \\\".list_desc__kJj1Y&&Text\\\"),\\n                url: $().lazyRule((url) => {\\n                    return pdfh(request(url), \\\".detail_download_btn__v7b7k&&href\\\")\\n                }, \\\"https://www.book123.info\\\" + pdfh(item, \\\"a&&href\\\"))\\n            })\\n        })\\n        setResult(d);\\n    },\\n    baidu: function(res) {\\n        try {\\n            if (!fileExist(\\\"hiker://files/rules/Joe/baidu.txt\\\")) {\\n                toast(\\\"还未登陆\\\")\\n                return \\\"hiker://page/baiduLogin?rule=图书馆Pro\\\"\\n            } else {\\n                var bdstoken = JSON.parse(request(\\\"https://pan.baidu.com/api/gettemplatevariable?fields=[%22bdstoken%22]\\\", {\\n                    headers: {\\n                        Cookie: request(\\\"hiker://files/rules/Joe/baidu.txt\\\")\\n                    }\\n                })).result.bdstoken\\n                return $(\\\"/电子书/\\\" + res.title + \\\".\\\" + res.extension, \\\"请输入保存路径\\\").input((bdstoken, res) => {\\n                    var res = JSON.parse(post(\\\"https://pan.baidu.com/rest/2.0/xpan/file?method=create&bdstoken=\\\" + bdstoken, {\\n                        headers: {\\n                            Cookie: request(\\\"hiker://files/rules/Joe/baidu.txt\\\")\\n                        },\\n                        body: {\\n                            size: res.filesize + \\\"\\\",\\n                            path: input,\\n                            block_list: [res.md5],\\n                            rtype: 0\\n                        }\\n                    }))\\n                    if (res.errno == 0) {\\n                        return \\\"toast://转存成功\\\"\\n                    } else if (res.errno == -8) {\\n                        return \\\"toast://转存失败，已经保存过这个文件了\\\"\\n                    } else if (res.errno == 2) {\\n                        return \\\"toast://转存失败，错误的路径\\\"\\n                    } else {\\n                        log(res.errno)\\n                        return \\\"toast://转存失败\\\"\\n                    }\\n                }, bdstoken, res)\\n            }\\n        } catch (e) {\\n            log(e.message)\\n            return \\\"toast://转存失败\\\"\\n        }\\n    },\\n    computeRating: function(e, t) {\\n        let i = \\\"\\\";\\n        for (let r = 0; r < 5; r++) r < Math.round(t / (e / 5)) ? i += \\\"★\\\" : i += \\\"☆\\\";\\n        return i;\\n    },\\n    servers: [\\\"ipfs下载\\\", \\\"https://dweb.link/ipfs/\\\", \\\"https://ipfs.jpu.jp/ipfs/\\\", \\\"https://cf-ipfs.com/ipfs/\\\", \\\"https://gateway.pinata.cloud/ipfs/\\\", \\\"https://ipfs-gateway.cloud/ipfs/\\\"],\\n    getFileSize: function(size) {\\n        if (size <= 0) {\\n            return \\\"\\\";\\n        }\\n        let unitForm = [\\\"Byte\\\", \\\"KB\\\", \\\"MB\\\", \\\"GB\\\", \\\"TB\\\"];\\n        for (let i = 0, len = unitForm.length; i < len; i++) {\\n            if (size > 1024) {\\n                size /= 1024;\\n                continue;\\n            } else {\\n                return size.toFixed(2).replace(/(\\\\.00)$/, \\\"\\\") + unitForm[i];\\n            }\\n        }\\n        return \\\"ERROR:数值过大\\\";\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"百度云盘登陆\",\"path\":\"baiduLogin\",\"rule\":\"js:\\nsetResult([{\\n    url: \\\"https://pan.baidu.com/\\\",\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"100%&&float\\\",\\n    extra: {\\n        js: $.toString(() => {\\n            var url = location.href\\n            if (url.includes(\\\"https://pan.baidu.com/wap\\\")) {\\n                fba.writeFile(\\\"hiker://files/rules/Joe/baidu.txt\\\", fba.getCookie(\\\"\\\"))\\n                alert(\\\"已获取到cookie，返回即可\\\")\\n                fba.back()\\n            }\\n        }),\\n        ua: MOBILE_UA,\\n        canBack: true\\n    }\\n}])\"}]","icon":"https://lanmeiguojiang.com/tubiao/ke/38.png","proxy":""}