API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：⚙️设置

xiaomianao666
Jan 17th, 2024
113
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 116.04 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥⚙️设置@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"主页\",\"path\":\"home\",\"rule\":\"js:\\nvar d = [];\\nif (fileExist(\\\"hiker://files/cache/alist_cache.json\\\")) {\\n    let alist = storage0.getItem(\\\"list\\\", [])\\n    var l = JSON.parse(fetch(\\\"hiker://files/cache/alist_cache.json\\\"))\\n    var testlist = alist.map(function(item) {\\n        return item.url\\n    })\\n    l.forEach(item => {\\n        if (!testlist.includes(item.url)) {\\n            alist.push(item)\\n        } else {\\n            toast(\\\"重复的链接，导入失败\\\")\\n        }\\n    })\\n    storage0.setItem(\\\"list\\\", alist)\\n    deleteFile(\\\"hiker://files/cache/alist_cache.json\\\")\\n}\\nvar alist = storage0.getItem(\\\"list\\\", [])\\nvar {\\n    getIcon,\\n    formatDate,\\n    getFileSize,\\n    sorts,\\n    getHzm\\n} = $.require(\\\"api\\\")\\nif (alist.length == 0) {\\n    setResult([{\\n        title: \\\"当前无Alist配置\\\",\\n        url: \\\"hiker://page/config\\\",\\n        col_type: \\\"text_center_1\\\"\\n    }])\\n} else {\\n    // 设置headers\\n    var headers = {}\\n\\n    var path = MY_PARAMS.path ? MY_PARAMS.path : \\\"/\\\"\\n\\n    var selected = parseInt(getItem(\\\"selected\\\", \\\"0\\\"))\\n    var now = alist[selected]\\n\\n    if (alist[selected][\\\"browser-password\\\"][path]) {\\n        headers[\\\"Cookie\\\"] = \\\"browser-password=\\\" + alist[selected][\\\"browser-password\\\"][path]\\n    } else {\\n        headers[\\\"Cookie\\\"] = \\\"browser-password=\\\"\\n    }\\n\\n    let sorr = [\\\"默认\\\", \\\"名称\\\", \\\"时间\\\", \\\"大小\\\"]\\n    var nsort = getItem(\\\"sort\\\", \\\"默认\\\")\\n\\n    // 有密码的先获取token\\n    if (now.user && now.password) {\\n        let res = JSON.parse(post(now.url + \\\"api/auth/login\\\", {\\n            body: JSON.stringify({\\n                \\\"username\\\": now.user,\\n                \\\"password\\\": now.password,\\n                \\\"otp_code\\\": \\\"\\\"\\n            })\\n        }))\\n        if (res.code == 200) {\\n            headers[\\\"Authorization\\\"] = res.data.token\\n        } else {\\n            toast(\\\"登陆失败\\\")\\n            log(res)\\n            d.push({\\n                title: \\\"账号密码错误\\\",\\n                url: \\\"hiker://page/config\\\",\\n                col_type: \\\"text_center_1\\\"\\n            })\\n            setResult(d)\\n        }\\n    }\\n    if (MY_PAGE == 1) {\\n        if (path == \\\"/\\\") {\\n            d.push({\\n                title: \\\"⚙️设置\\\",\\n                url: \\\"hiker://page/config\\\",\\n                col_type: \\\"scroll_button\\\"\\n            })\\n            alist.forEach((item, i) => {\\n                d.push({\\n                    title: i == selected ? $.require(\\\"api\\\").color(item.name, \\\"red\\\") : item.name,\\n                    col_type: \\\"scroll_button\\\",\\n                    url: i == selected ? \\\"x5://\\\" + now.url : $().lazyRule((i) => {\\n                        setItem(\\\"selected\\\", i + \\\"\\\")\\n                        refreshPage()\\n                        return \\\"hiker://empty\\\"\\n                    }, i)\\n                })\\n            })\\n        }\\n        d.push({\\n            col_type: \\\"blank_block\\\"\\n        })\\n        if (now.search) {\\n            d.push({\\n                title: \\\"🔎 搜索\\\",\\n                col_type: \\\"scroll_button\\\",\\n                url: \\\"hiker://page/search?page=fypage&u=\\\" + now.url + \\\"&path=\\\" + path,\\n                extra: {\\n                    headers: headers,\\n                    now: now\\n                }\\n            })\\n        }\\n        if (now.user && now.password) {\\n            d.push({\\n                title: \\\"新建文件夹\\\",\\n                col_type: \\\"scroll_button\\\",\\n                url: $(\\\"\\\").input((path, now, headers) => {\\n                    var res = JSON.parse(post(now.url + \\\"api/fs/mkdir\\\", {\\n                        body: JSON.stringify({\\n                            path: path + \\\"/\\\" + input\\n                        }),\\n                        headers: headers\\n                    })).code\\n                    if (res == 200) {\\n                        refreshPage()\\n                        return \\\"toast://创建成功\\\"\\n                    } else {\\n                        return \\\"toast://创建失败\\\"\\n                    }\\n                }, path, now, headers)\\n            }, {\\n                title: \\\"新建文件\\\",\\n                col_type: \\\"scroll_button\\\",\\n                url: $(\\\"\\\").input((path, now, headers) => {\\n                    headers[\\\"File-Path\\\"] = encodeURI(path + \\\"/\\\" + input)\\n                    var res = JSON.parse(request(now.url + \\\"api/fs/put\\\", {\\n                        body: \\\"\\\",\\n                        headers: headers,\\n                        method: \\\"PUT\\\"\\n                    })).code\\n                    if (res == 200) {\\n                        refreshPage()\\n                        return \\\"toast://创建成功\\\"\\n                    } else {\\n                        return \\\"toast://创建失败\\\"\\n                    }\\n                }, path, now, headers)\\n            }, {\\n                title: \\\"添加aria2任务\\\",\\n                col_type: \\\"scroll_button\\\",\\n                url: $(\\\"\\\", \\\"多条用回车隔开\\\").input((path, now, headers) => {\\n                    var res = JSON.parse(post(now.url + \\\"api/fs/add_aria2\\\", {\\n                        body: JSON.stringify({\\n                            path: path,\\n                            urls: input.split(\\\"\\\\n\\\")\\n                        }),\\n                        headers: headers\\n                    })).code\\n                    if (res == 200) {\\n                        refreshPage()\\n                        return \\\"toast://创建成功\\\"\\n                    } else {\\n                        return \\\"toast://创建失败\\\"\\n                    }\\n                }, path, now, headers)\\n            })\\n        }\\n\\n        d.push({\\n            col_type: \\\"line_blank\\\"\\n        })\\n        d.push({\\n            col_type: \\\"big_blank_block\\\"\\n        })\\n        d.push({\\n            col_type: \\\"big_blank_block\\\"\\n        })\\n\\n        // 排序\\n        sorr.forEach(item => {\\n            if (nsort == item) {\\n                var title = item + \\\"↓\\\"\\n            } else if (nsort.includes(\\\"反\\\") && nsort.includes(item)) {\\n                var title = item + \\\"↑\\\"\\n            } else {\\n                var title = item + \\\"↕\\\"\\n            }\\n            d.push({\\n                title: title,\\n                col_type: \\\"scroll_button\\\",\\n                url: $().lazyRule((item) => {\\n                    if (getItem(\\\"sort\\\", \\\"默认\\\") == item) {\\n                        setItem(\\\"sort\\\", item + \\\"反\\\")\\n                    } else {\\n                        setItem(\\\"sort\\\", item)\\n                    }\\n                    refreshPage()\\n                    return \\\"hiker://empty\\\"\\n                }, item)\\n            })\\n        })\\n    }\\n\\n    let bid = path + \\\"-loading-\\\" + MY_PAGE;\\n    let d2 = [];\\n    d.push({\\n        title: \\\"努力加载中，请稍候...\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: bid,\\n            lineVisible: false\\n        }\\n    })\\n    setResult(d);\\n\\n    try {\\n        // 获取文件列表\\n        var list = JSON.parse(post(now.url + \\\"api/fs/list\\\", {\\n            body: JSON.stringify({\\n                \\\"path\\\": path,\\n                \\\"password\\\": alist[selected][\\\"browser-password\\\"][path] ? alist[selected][\\\"browser-password\\\"][path] : \\\"\\\",\\n                \\\"page\\\": MY_PAGE,\\n                \\\"per_page\\\": 30,\\n                \\\"refresh\\\": false\\n            }),\\n            headers: headers\\n        }))\\n        if (list.code == 200 && list.data.content) {\\n            sorts(list.data.content, nsort)\\n            list.data.content.forEach((item, index) => {\\n                var desc = formatDate(item.modified) + \\\" \\\" + getFileSize(item.size)\\n                var down_url = encodeURI(now.url + \\\"d\\\" + (path == \\\"/\\\" ? \\\"\\\" : path) + \\\"/\\\" + item.name + \\\"?sign=\\\" + item.sign)\\n                var url = $().lazyRule((item, url, path, list, u) => {\\n                    const type_dict = {\\n                        0: $.toString((url) => {\\n                            return \\\"download://\\\" + url\\n                        }, url),\\n                        2: $.toString((url, list, u, path) => {\\n                            var subtitles = $.require(\\\"api\\\").getSubtitles(list, u, path)\\n                            if (subtitles.length > 1) {\\n                                var namelist = subtitles.map(function(item) {\\n                                    return item.name\\n                                })\\n                                return $(namelist, 1, \\\"请选择字幕\\\").select((subtitles, namelist, url) => {\\n                                    return JSON.stringify({\\n                                        urls: [url],\\n                                        subtitle: subtitles[namelist.indexOf(input)].url\\n                                    })\\n                                }, subtitles, namelist, url)\\n                            } else {\\n                                return url + \\\"#isVideo=true#\\\"\\n                            }\\n                        }, url, list, u, path),\\n                        3: $.toString((url) => {\\n                            return url + \\\"#isMusic=true#\\\"\\n                        }, url),\\n                        4: $.toString((url) => {\\n                            return \\\"download://\\\" + url\\n                        }, url),\\n                        5: $.toString((url) => {\\n                            return url + \\\"#.jpg\\\"\\n                        }, url)\\n                    }\\n                    if (item.is_dir) {\\n                        return \\\"hiker://page/home?page=fypage\\\"\\n                    } else if ($.require(\\\"api\\\").getHzm(item.name) == \\\"pdf\\\") {\\n                        return \\\"https://alist-org.github.io/pdf.js/web/viewer.html?file=\\\" + url\\n                    } else if ($.office.includes($.require(\\\"api\\\").getHzm(item.name))) {\\n                        return $([\\\"微软\\\", \\\"谷歌\\\"]).select((url) => {\\n                            if (input == \\\"微软\\\") {\\n                                return \\\"https://view.officeapps.live.com/op/view.aspx?src=\\\" + url\\n                            } else {\\n                                return \\\"https://docs.google.com/gview?&embedded=true&url=\\\" + url\\n                            }\\n                        }, url)\\n                    } else {\\n                        return eval(type_dict[item.type])\\n                    }\\n                }, item, down_url, path, list.data.content, now.url)\\n                var longClick = []\\n                if (!item.is_dir) {\\n                    longClick.push({\\n                        title: \\\"下载\\\",\\n                        js: $.toString((item, u, path) => {\\n                            return \\\"download://\\\" + u\\n                        }, item, down_url, path)\\n                    }, {\\n                        title: \\\"用其他软件打开\\\",\\n                        js: $.toString((item, u, path) => {\\n                            downloadFile(u, \\\"hiker://files/cache/\\\" + item.name)\\n                            return \\\"openFile://\\\" + \\\"hiker://files/cache/\\\" + item.name\\n                        }, item, down_url, path)\\n                    })\\n                }\\n                if (now.user && now.password) {\\n                    longClick.push({\\n                        title: \\\"删除\\\",\\n                        js: $.toString((item, headers, path, now) => {\\n                            return $(\\\"确认删除？\\\").confirm((item, headers, path, now) => {\\n                                var res = JSON.parse(post(now.url + \\\"api/fs/remove\\\", {\\n                                    headers: headers,\\n                                    body: JSON.stringify({\\n                                        dir: path,\\n                                        names: [item.name]\\n                                    })\\n                                })).code\\n                                if (res == 200) {\\n                                    refreshPage()\\n                                    return \\\"toast://删除成功\\\"\\n                                } else {\\n                                    return \\\"toast://删除失败\\\"\\n                                }\\n                            }, item, headers, path, now)\\n                        }, item, headers, path, now)\\n                    }, {\\n                        title: \\\"重命名\\\",\\n                        js: $.toString((item, headers, path, now) => {\\n                            return $(item.name).input((item, headers, path, now) => {\\n                                var res = JSON.parse(post(now.url + \\\"api/fs/rename\\\", {\\n                                    headers: headers,\\n                                    body: JSON.stringify({\\n                                        path: path + \\\"/\\\" + item.name,\\n                                        name: input\\n                                    })\\n                                })).code\\n                                if (res == 200) {\\n                                    refreshPage()\\n                                    return \\\"toast://重命名成功\\\"\\n                                } else {\\n                                    return \\\"toast://重命名失败\\\"\\n                                }\\n                            }, item, headers, path, now)\\n                        }, item, headers, path, now)\\n                    })\\n                }\\n                d2.push({\\n                    title: item.name,\\n                    col_type: getItem(\\\"style\\\", \\\"avatar\\\"),\\n                    img: getIcon(item),\\n                    desc: desc,\\n                    url: url,\\n                    extra: {\\n                        longClick: longClick,\\n                        pageTitle: item.name,\\n                        path: (path == \\\"/\\\" ? \\\"/\\\" : path + \\\"/\\\") + item.name,\\n                        id: item.name,\\n                        cls: \\\"playlist main\\\"\\n                    }\\n                })\\n                if (getItem(\\\"style\\\", \\\"avatar\\\") == \\\"avatar\\\") {\\n                    d2.push({\\n                        title: `‘‘’’<small><font color='#aaaaaa'>${desc}</font></small>`,\\n                        col_type: \\\"text_1\\\",\\n                        url: url,\\n                        extra: {\\n                            longClick: longClick,\\n                            pageTitle: item.name,\\n                            path: (path == \\\"/\\\" ? \\\"/\\\" : path + \\\"/\\\") + item.name,\\n                            cls: \\\"playlist desc\\\"\\n                        }\\n                    })\\n                }\\n            })\\n        } else if (list.message == \\\"password is incorrect or you have no permission\\\") {\\n            d2.push({\\n                title: \\\"浏览密码错误\\\",\\n                col_type: \\\"text_center_1\\\",\\n                url: $(\\\"\\\", \\\"输入密码\\\").input((alist, selected, path) => {\\n                    alist[selected][\\\"browser-password\\\"][path] = input\\n                    storage0.setItem(\\\"list\\\", alist)\\n                    refreshPage()\\n                }, alist, selected, path)\\n            })\\n        } else if (list.code != 200) {\\n            toast(\\\"出错了\\\")\\n            log(list.message)\\n        }\\n    } catch (e) {\\n        d2.push({\\n            title: \\\"出现错误\\\",\\n            url: \\\"hiker://page/config\\\",\\n            col_type: \\\"text_center_1\\\"\\n        })\\n        log(e.message)\\n    }\\n    addItemBefore(bid, d2);\\n    deleteItem(bid);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"设置\",\"path\":\"config\",\"rule\":\"js:\\nvar d = [];\\nd.push({\\n    title: \\\"显示网站详情:\\\" + getItem(\\\"detail\\\", \\\"开\\\"),\\n    url: $().lazyRule(() => {\\n        setItem(\\\"detail\\\", getItem(\\\"detail\\\", \\\"开\\\") == \\\"开\\\" ? \\\"关\\\" : \\\"开\\\")\\n        refreshPage()\\n        return \\\"hiker://empty\\\"\\n    }),\\n    col_type: \\\"text_2\\\"\\n}, {\\n    title: \\\"切换样式:\\\" + getItem(\\\"style\\\", \\\"avatar\\\"),\\n    url: $([\\\"movie_3\\\", \\\"movie_1_left_pic\\\", \\\"movie_1_vertical_pic\\\", \\\"card_pic_3\\\", \\\"avatar\\\", \\\"text_1\\\"]).select(() => {\\n        setItem(\\\"style\\\", input)\\n        refreshPage()\\n        return \\\"toast://已切换\\\"\\n    }),\\n    col_type: \\\"text_2\\\"\\n})\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n})\\nd.push({\\n    title: \\\"➕ 新增Alist\\\",\\n    url: $(\\\"\\\", \\\"名称\\\").input(() => {\\n        if (input == \\\"\\\") {\\n            return \\\"toast://名称不能为空\\\"\\n        } else if (storage0.getItem(\\\"list\\\", []).map(function(i) {\\n                return i.name\\n            }).includes(input)) {\\n            return \\\"toast://已经有相同的网站了\\\"\\n        } else {\\n            return $(\\\"\\\", \\\"链接 示例:http://127.0.0.1/\\\").input((name) => {\\n                if (!input.includes(\\\"http\\\")) {\\n                    return \\\"toast://链接格式错误\\\"\\n                } else {\\n                    if (input[input.length - 1] != \\\"/\\\") {\\n                        input += \\\"/\\\"\\n                    }\\n                    var config = JSON.parse(request(input + \\\"api/public/settings\\\")).data\\n                    var list = storage0.getItem(\\\"list\\\", [])\\n                    list.push({\\n                        name: name,\\n                        url: input,\\n                        \\\"browser-password\\\": {},\\n                        \\\"search\\\": config.search_index && config.search_index != \\\"none\\\"\\n                    })\\n                    storage0.setItem(\\\"list\\\", list)\\n                    refreshPage()\\n                }\\n            }, input)\\n        }\\n    }),\\n    col_type: \\\"text_2\\\"\\n}, {\\n    title: \\\"分享\\\",\\n    col_type: \\\"text_2\\\",\\n    url: $([\\\"仅分享网站\\\", \\\"分享网站加密码\\\"]).select(() => {\\n        var list = storage0.getItem(\\\"list\\\", [])\\n        if (input == \\\"仅分享网站\\\") {\\n            var alist = list.map(function(item) {\\n                return {\\n                    name: item.name,\\n                    url: item.url,\\n                    \\\"browser-password\\\": {}\\n                }\\n            })\\n            var url = sharePaste(JSON.stringify(alist))\\n            return \\\"copy://Alist V3网盘导入口令 共\\\" + alist.length + \\\"个@\\\" + url + \\\"@import=js:\\\" + $.toString(() => {\\n                $.require(\\\"hiker://page/cloudimport?rule=Alist V3\\\").input(input)\\n            })\\n        } else {\\n            var url = sharePaste(JSON.stringify(list))\\n            return \\\"copy://Alist V3网盘导入口令 共\\\" + alist.length + \\\"个@\\\" + url + \\\"@import=js:\\\" + $.toString(() => {\\n                $.require(\\\"hiker://page/cloudimport?rule=Alist V3\\\").input(input)\\n            })\\n        }\\n    })\\n})\\nvar list = storage0.getItem(\\\"list\\\", [])\\nlist.forEach((item, i) => {\\n    d.push({\\n        title: item.name,\\n        desc: item.url,\\n        url: $([\\\"删除\\\", \\\"排序\\\", \\\"修改名称\\\", \\\"修改链接\\\", \\\"修改账户密码\\\"]).select((a, i) => {\\n            var list = storage0.getItem(\\\"list\\\", [])\\n            switch (input) {\\n                case \\\"删除\\\":\\n                    return $(\\\"确认删除？\\\").confirm((list, i) => {\\n                        list.splice(i, 1)\\n                        storage0.setItem(\\\"list\\\", list)\\n                        clearItem(\\\"selected\\\")\\n                        refreshPage()\\n                    }, list, i)\\n                    break;\\n                case \\\"修改名称\\\":\\n                    return $(list[i].name).input((list, i) => {\\n                        if (input == \\\"\\\") {\\n                            return \\\"toast://名称不能为空\\\"\\n                        } else if (storage0.getItem(\\\"list\\\", []).map(function(i) {\\n                                return i.name\\n                            }).includes(input)) {\\n                            return \\\"toast://已经有相同的网站了\\\"\\n                        } else {\\n                            list[i].name = input\\n                            storage0.setItem(\\\"list\\\", list)\\n                            refreshPage()\\n                        }\\n                    }, list, i)\\n                    break\\n                case \\\"修改链接\\\":\\n                    return $(list[i].url).input((list, i) => {\\n                        if (!input.includes(\\\"http\\\")) {\\n                            return \\\"toast://链接格式错误\\\"\\n                        } else if (input[input.length - 1] != \\\"/\\\") {\\n                            return \\\"toast://链接格式错误\\\"\\n                        } else {\\n                            list[i].url = input\\n                            storage0.setItem(\\\"list\\\", list)\\n                            refreshPage()\\n                        }\\n                    }, list, i)\\n                    break\\n                case \\\"修改账户密码\\\":\\n                    return $(list[i][\\\"user\\\"] ? list[i][\\\"user\\\"] : \\\"\\\", \\\"账号\\\").input((list, i) => {\\n                        return $(list[i][\\\"password\\\"] ? list[i][\\\"password\\\"] : \\\"\\\", \\\"密码\\\").input((user, list, i) => {\\n                            list[i][\\\"user\\\"] = user\\n                            list[i][\\\"password\\\"] = input\\n                            storage0.setItem(\\\"list\\\", list)\\n                            refreshPage()\\n                        }, input, list, i)\\n                    }, list, i)\\n                case \\\"排序\\\":\\n                    return $(i + 1 + \\\"\\\", \\\"拍到第几个\\\").input((list, i) => {\\n                        function checkRate(input) {　　\\n                            var re = /^[0-9]+.?[0-9]*/; //判断字符串是否为数字//判断正整数/[1−9]+[0−9]∗]∗/\\n                            　　\\n                            return re.test(input)　　\\n                        }\\n                        if (checkRate(input)) {\\n                            var a = parseInt(input) - 1 // 目标\\n                            if (a > list.length && a == 0) {\\n                                toast(\\\"不能大于列表数量！\\\")\\n                            } else {\\n                                var temp = list[a]\\n                                list[a] = list[i]\\n                                list[i] = temp\\n                                storage0.setItem(\\\"list\\\", list)\\n                                refreshPage()\\n                            }\\n                        } else {\\n                            toast(\\\"请输入正整数\\\")\\n                        }\\n                    }, list, i)\\n            }\\n        }, item, i),\\n        col_type: \\\"text_1\\\"\\n    })\\n})\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"代码\",\"path\":\"api\",\"rule\":\"$.exports = {\\n    color: function(text, color) {\\n        return `‘‘’’<strong><font color=\\\"${color}\\\">${text}</front></strong>`\\n    },\\n    getIcon: function(content) {\\n        if (content.is_dir) {\\n            img = \\\"https://hikerfans.com/tubiao/more/274.png\\\"\\n        } else {\\n            let fileName = content.name.toLowerCase()\\n            let hzm = $.require(\\\"api\\\").getHzm(fileName)\\n            if (content.thumb && content.type != 0) {\\n                img = content.thumb\\n            } else if ($.movie.includes(hzm)) {\\n                img = \\\"https://hikerfans.com/tubiao/more/30.png\\\"\\n            } else if ($.audio.includes(hzm)) {\\n                img = \\\"https://hikerfans.com/tubiao/more/40.png\\\"\\n            } else if ($.text.includes(hzm)) {\\n                img = \\\"https://hikerfans.com/tubiao/more/78.png\\\"\\n            } else if ($.img.includes(hzm)) {\\n                img = \\\"https://hikerfans.com/tubiao/more/38.png\\\"\\n            } else if ($.yasuo.includes(hzm)) {\\n                img = \\\"https://hikerfans.com/tubiao/more/201.png\\\"\\n            } else if ($.office.includes(hzm)) {\\n                img = \\\"https://hikerfans.com/tubiao/more/185.png\\\"\\n            } else {\\n                img = \\\"https://hikerfans.com/tubiao/more/239.png\\\"\\n            }\\n        }\\n        return img\\n    },\\n    formatDate: function(time) {\\n        return time.split(\\\"T\\\")[0] + \\\" \\\" + time.split(\\\"T\\\")[1].split(\\\".\\\")[0].split(\\\"Z\\\")[0].split(\\\"+\\\")[0]\\n    },\\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    getHzm: function(fileName) {\\n        return fileName.substr(fileName.lastIndexOf(\\\".\\\") + 1)\\n    },\\n    sorts: function(list, method) {\\n        if (method.includes(\\\"名称\\\")) {\\n            list.sort(function(a, b) {\\n                return a.name.localeCompare(b.name)\\n            })\\n        } else if (method.includes(\\\"时间\\\")) {\\n            list.sort(function(a, b) {\\n                return a.modified - b.modified\\n            })\\n        } else if (method.includes(\\\"大小\\\")) {\\n            list.sort(function(a, b) {\\n                return a.size - b.size\\n            })\\n        }\\n        if (method.includes(\\\"反\\\")) {\\n            list.reverse();\\n        }\\n        return list\\n    },\\n    getSubtitles: function(list, url, path) {\\n        const {\\n            getHzm\\n        } = $.require(\\\"api\\\")\\n        let s = []\\n        list.forEach(item => {\\n            if ($.subtitle.includes(getHzm(item.name))) {\\n                s.push({\\n                    name: item.name,\\n                    url: encodeURI(url + \\\"d\\\" + (path == \\\"/\\\" ? \\\"\\\" : path) + \\\"/\\\" + item.name + \\\"?sign=\\\" + item.sign)\\n                })\\n            }\\n        })\\n        s.unshift({\\n            name: \\\"不需要字幕\\\"\\n        })\\n        return s\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"search\",\"rule\":\"js:\\ntry {\\n    var d = [];\\n    var {\\n        getIcon,\\n        getFileSize\\n    } = $.require(\\\"api\\\")\\n    var url = getParam(\\\"u\\\")\\n    var now = MY_PARAMS.now\\n    var headers = MY_PARAMS.headers\\n    if (MY_PAGE == 1) {\\n        d.unshift({\\n            title: \\\"搜索\\\",\\n            url: $.toString(() => {\\n                putMyVar(\\\"kw\\\", input)\\n                refreshPage()\\n            }),\\n            col_type: \\\"input\\\",\\n            extra: {\\n                defaultValue: getMyVar(\\\"kw\\\", \\\"\\\")\\n            }\\n        })\\n    }\\n    var path = getParam(\\\"path\\\")\\n    if (getMyVar(\\\"kw\\\", \\\"\\\") != \\\"\\\") {\\n        var list = JSON.parse(post(url + \\\"api/fs/search\\\", {\\n            headers: headers,\\n            body: JSON.stringify({\\n                \\\"parent\\\": getParam(\\\"path\\\"),\\n                \\\"keywords\\\": getMyVar(\\\"kw\\\", \\\"\\\"),\\n                \\\"page\\\": MY_PAGE,\\n                \\\"per_page\\\": 100\\n            })\\n        }))\\n        if (list.code == 200 && list.data.content) {\\n            list.data.content.forEach(item => {\\n                var desc = getFileSize(item.size)\\n                var url = $().lazyRule((item, u, path, headers) => {\\n                    var sign = JSON.parse(post(u + \\\"api/fs/get\\\", {\\n                        headers: headers,\\n                        body: JSON.stringify({\\n                            \\\"path\\\": item.parent + \\\"/\\\" + item.name\\n                        })\\n                    })).data.sign\\n                    var url = encodeURI(u + \\\"d\\\" + item.parent + \\\"/\\\" + item.name + \\\"?sign=\\\" + sign)\\n                    const type_dict = {\\n                        0: $.toString((url) => {\\n                            return \\\"download://\\\" + url\\n                        }, url),\\n                        2: $.toString((url) => {\\n                            return url + \\\"#isVideo=true#\\\"\\n                        }, url),\\n                        3: $.toString((url) => {\\n                            return url + \\\"#isMusic=true#\\\"\\n                        }, url),\\n                        4: $.toString((url) => {\\n                            return \\\"download://\\\" + url\\n                        }, url),\\n                        5: $.toString((url) => {\\n                            return url + \\\"#.jpg\\\"\\n                        }, url)\\n                    }\\n                    if (item.is_dir) {\\n                        return \\\"hiker://page/home?page=fypage\\\"\\n                    } else if ($.require(\\\"api\\\").getHzm(item.name) == \\\"pdf\\\") {\\n                        return \\\"https://alist-org.github.io/pdf.js/web/viewer.html?file=\\\" + url\\n                    } else if ($.office.includes($.require(\\\"api\\\").getHzm(item.name))) {\\n                        return $([\\\"微软\\\", \\\"谷歌\\\"]).select((url) => {\\n                            if (input == \\\"微软\\\") {\\n                                return \\\"https://view.officeapps.live.com/op/view.aspx?src=\\\" + url\\n                            } else {\\n                                return \\\"https://docs.google.com/gview?&embedded=true&url=\\\" + url\\n                            }\\n                        }, url)\\n                    } else {\\n                        return eval(type_dict[item.type])\\n                    }\\n                }, item, now.url, path, headers)\\n                var longClick = []\\n                if (!item.is_dir) {\\n                    longClick.push({\\n                        title: \\\"下载\\\",\\n                        js: $.toString((item, u, path, headers) => {\\n                            return \\\"download://\\\" + encodeURI(u + \\\"d\\\" + item.parent + \\\"/\\\" + item.name + \\\"?sign=\\\" + JSON.parse(post(u + \\\"api/fs/get\\\", {\\n                                headers: headers,\\n                                body: JSON.stringify({\\n                                    \\\"path\\\": item.parent + \\\"/\\\" + item.name\\n                                })\\n                            })).data.sign)\\n                        }, item, now.url, path, headers)\\n                    }, {\\n                        title: \\\"用其他软件打开\\\",\\n                        js: $.toString((item, u, path, headers) => {\\n                            var sign = JSON.parse(post(u + \\\"api/fs/get\\\", {\\n                                headers: headers,\\n                                body: JSON.stringify({\\n                                    \\\"path\\\": item.parent + \\\"/\\\" + item.name\\n                                })\\n                            })).data.sign\\n                            downloadFile(encodeURI(u + \\\"d\\\" + item.parent + \\\"/\\\" + item.name + \\\"?sign=\\\" + sign), \\\"hiker://files/cache/\\\" + item.name)\\n                            return \\\"openFile://\\\" + \\\"hiker://files/cache/\\\" + item.name\\n                        }, item, now.url, path, headers)\\n                    })\\n                }\\n                if (now.user && now.password) {\\n                    longClick.push({\\n                        title: \\\"删除\\\",\\n                        js: $.toString((item, headers, path, now) => {\\n                            return $(\\\"确认删除？\\\").confirm((item, headers, path, now) => {\\n                                var res = JSON.parse(post(now.url + \\\"api/fs/remove\\\", {\\n                                    headers: headers,\\n                                    body: JSON.stringify({\\n                                        dir: item.parent,\\n                                        names: [item.name]\\n                                    })\\n                                })).code\\n                                if (res == 200) {\\n                                    refreshPage()\\n                                    return \\\"toast://删除成功\\\"\\n                                } else {\\n                                    return \\\"toast://删除失败\\\"\\n                                }\\n                            }, item, headers, path, now)\\n                        }, item, headers, path, now)\\n                    }, {\\n                        title: \\\"重命名\\\",\\n                        js: $.toString((item, headers, path, now) => {\\n                            return $(item.name).input((item, headers, path, now) => {\\n                                var res = JSON.parse(post(now.url + \\\"api/fs/rename\\\", {\\n                                    headers: headers,\\n                                    body: JSON.stringify({\\n                                        path: item.parent + \\\"/\\\" + item.name,\\n                                        name: input\\n                                    })\\n                                })).code\\n                                if (res == 200) {\\n                                    refreshPage()\\n                                    return \\\"toast://操作成功\\\"\\n                                } else {\\n                                    return \\\"toast://操作失败\\\"\\n                                }\\n                            }, item, headers, path, now)\\n                        }, item, headers, path, now)\\n                    })\\n                }\\n                d.push({\\n                    title: item.name,\\n                    col_type: getItem(\\\"style\\\", \\\"avatar\\\"),\\n                    img: getIcon(item),\\n                    desc: desc,\\n                    url: url,\\n                    extra: {\\n                        longClick: longClick,\\n                        path: item.parent + \\\"/\\\" + item.name,\\n                        pageTitle: item.name\\n                    }\\n                })\\n                if (getItem(\\\"style\\\", \\\"avatar\\\") == \\\"avatar\\\") {\\n                    d.push({\\n                        title: `‘‘’’<small><font color='#aaaaaa'>${desc}</font></small>`,\\n                        col_type: \\\"text_1\\\",\\n                        url: url,\\n                        extra: {\\n                            longClick: longClick,\\n                            path: item.parent + \\\"/\\\" + item.name,\\n                            pageTitle: item.name\\n                        }\\n                    })\\n                }\\n            })\\n        } else if (list.code != 200) {\\n            toast(\\\"出错了\\\")\\n            log(list.message)\\n        }\\n    }\\n} catch (e) {\\n    setResult([{\\n        title: \\\"设置\\\",\\n        url: \\\"hiker://page/config\\\",\\n        col_type: \\\"text_center_1\\\"\\n    }])\\n    log(e.message)\\n    toast(\\\"程序出现错误，请重试\\\")\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"云口令\",\"path\":\"cloudimport\",\"rule\":\"$.exports.input = function(url) {\\n    var url = url.split(\\\"@\\\")[1]\\n    var content = parsePaste(url)\\n    writeFile(\\\"hiker://files/cache/alist_cache.json\\\", content)\\n}\"}],\"saved\":false,\"title\":\"Alist V3\",\"version\":0,\"url\":\"hiker://page/config\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar d = [];\\nd.push({\\n    title: \\\"显示网站详情:\\\" + getItem(\\\"detail\\\", \\\"开\\\"),\\n    url: $().lazyRule(() => {\\n        setItem(\\\"detail\\\", getItem(\\\"detail\\\", \\\"开\\\") == \\\"开\\\" ? \\\"关\\\" : \\\"开\\\")\\n        refreshPage()\\n        return \\\"hiker://empty\\\"\\n    }),\\n    col_type: \\\"text_2\\\"\\n}, {\\n    title: \\\"切换样式:\\\" + getItem(\\\"style\\\", \\\"avatar\\\"),\\n    url: $([\\\"movie_3\\\", \\\"movie_1_left_pic\\\", \\\"movie_1_vertical_pic\\\", \\\"card_pic_3\\\", \\\"avatar\\\", \\\"text_1\\\"]).select(() => {\\n        setItem(\\\"style\\\", input)\\n        refreshPage()\\n        return \\\"toast://已切换\\\"\\n    }),\\n    col_type: \\\"text_2\\\"\\n})\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n})\\nd.push({\\n    title: \\\"➕ 新增Alist\\\",\\n    url: $(\\\"\\\", \\\"名称\\\").input(() => {\\n        if (input == \\\"\\\") {\\n            return \\\"toast://名称不能为空\\\"\\n        } else if (storage0.getItem(\\\"list\\\", []).map(function(i) {\\n                return i.name\\n            }).includes(input)) {\\n            return \\\"toast://已经有相同的网站了\\\"\\n        } else {\\n            return $(\\\"\\\", \\\"链接 示例:http://127.0.0.1/\\\").input((name) => {\\n                if (!input.includes(\\\"http\\\")) {\\n                    return \\\"toast://链接格式错误\\\"\\n                } else {\\n                    if (input[input.length - 1] != \\\"/\\\") {\\n                        input += \\\"/\\\"\\n                    }\\n                    var config = JSON.parse(request(input + \\\"api/public/settings\\\")).data\\n                    var list = storage0.getItem(\\\"list\\\", [])\\n                    list.push({\\n                        name: name,\\n                        url: input,\\n                        \\\"browser-password\\\": {},\\n                        \\\"search\\\": config.search_index && config.search_index != \\\"none\\\"\\n                    })\\n                    storage0.setItem(\\\"list\\\", list)\\n                    refreshPage()\\n                }\\n            }, input)\\n        }\\n    }),\\n    col_type: \\\"text_2\\\"\\n}, {\\n    title: \\\"分享\\\",\\n    col_type: \\\"text_2\\\",\\n    url: $([\\\"仅分享网站\\\", \\\"分享网站加密码\\\"]).select(() => {\\n        var list = storage0.getItem(\\\"list\\\", [])\\n        if (input == \\\"仅分享网站\\\") {\\n            var alist = list.map(function(item) {\\n                return {\\n                    name: item.name,\\n                    url: item.url,\\n                    \\\"browser-password\\\": {}\\n                }\\n            })\\n            var url = sharePaste(JSON.stringify(alist))\\n            return \\\"copy://Alist V3网盘导入口令 共\\\" + alist.length + \\\"个@\\\" + url + \\\"@import=js:\\\" + $.toString(() => {\\n                $.require(\\\"hiker://page/cloudimport?rule=Alist V3\\\").input(input)\\n            })\\n        } else {\\n            var url = sharePaste(JSON.stringify(list))\\n            return \\\"copy://Alist V3网盘导入口令 共\\\" + alist.length + \\\"个@\\\" + url + \\\"@import=js:\\\" + $.toString(() => {\\n                $.require(\\\"hiker://page/cloudimport?rule=Alist V3\\\").input(input)\\n            })\\n        }\\n    })\\n})\\nvar list = storage0.getItem(\\\"list\\\", [])\\nlist.forEach((item, i) => {\\n    d.push({\\n        title: item.name,\\n        desc: item.url,\\n        url: $([\\\"删除\\\", \\\"排序\\\", \\\"修改名称\\\", \\\"修改链接\\\", \\\"修改账户密码\\\"]).select((a, i) => {\\n            var list = storage0.getItem(\\\"list\\\", [])\\n            switch (input) {\\n                case \\\"删除\\\":\\n                    return $(\\\"确认删除？\\\").confirm((list, i) => {\\n                        list.splice(i, 1)\\n                        storage0.setItem(\\\"list\\\", list)\\n                        clearItem(\\\"selected\\\")\\n                        refreshPage()\\n                    }, list, i)\\n                    break;\\n                case \\\"修改名称\\\":\\n                    return $(list[i].name).input((list, i) => {\\n                        if (input == \\\"\\\") {\\n                            return \\\"toast://名称不能为空\\\"\\n                        } else if (storage0.getItem(\\\"list\\\", []).map(function(i) {\\n                                return i.name\\n                            }).includes(input)) {\\n                            return \\\"toast://已经有相同的网站了\\\"\\n                        } else {\\n                            list[i].name = input\\n                            storage0.setItem(\\\"list\\\", list)\\n                            refreshPage()\\n                        }\\n                    }, list, i)\\n                    break\\n                case \\\"修改链接\\\":\\n                    return $(list[i].url).input((list, i) => {\\n                        if (!input.includes(\\\"http\\\")) {\\n                            return \\\"toast://链接格式错误\\\"\\n                        } else if (input[input.length - 1] != \\\"/\\\") {\\n                            return \\\"toast://链接格式错误\\\"\\n                        } else {\\n                            list[i].url = input\\n                            storage0.setItem(\\\"list\\\", list)\\n                            refreshPage()\\n                        }\\n                    }, list, i)\\n                    break\\n                case \\\"修改账户密码\\\":\\n                    return $(list[i][\\\"user\\\"] ? list[i][\\\"user\\\"] : \\\"\\\", \\\"账号\\\").input((list, i) => {\\n                        return $(list[i][\\\"password\\\"] ? list[i][\\\"password\\\"] : \\\"\\\", \\\"密码\\\").input((user, list, i) => {\\n                            list[i][\\\"user\\\"] = user\\n                            list[i][\\\"password\\\"] = input\\n                            storage0.setItem(\\\"list\\\", list)\\n                            refreshPage()\\n                        }, input, list, i)\\n                    }, list, i)\\n                case \\\"排序\\\":\\n                    return $(i + 1 + \\\"\\\", \\\"拍到第几个\\\").input((list, i) => {\\n                        function checkRate(input) {　　\\n                            var re = /^[0-9]+.?[0-9]*/; //判断字符串是否为数字//判断正整数/[1−9]+[0−9]∗]∗/\\n                            　　\\n                            return re.test(input)　　\\n                        }\\n                        if (checkRate(input)) {\\n                            var a = parseInt(input) - 1 // 目标\\n                            if (a > list.length && a == 0) {\\n                                toast(\\\"不能大于列表数量！\\\")\\n                            } else {\\n                                var temp = list[a]\\n                                list[a] = list[i]\\n                                list[i] = temp\\n                                storage0.setItem(\\\"list\\\", list)\\n                                refreshPage()\\n                            }\\n                        } else {\\n                            toast(\\\"请输入正整数\\\")\\n                        }\\n                    }, list, i)\\n            }\\n        }, item, i),\\n        col_type: \\\"text_1\\\"\\n    })\\n})\\nsetResult(d);\",\"group\":\"①网盘\",\"ua\":\"mobile\",\"preRule\":\"$.extend({\\n    text: [\\\"htm\\\", \\\"html\\\", \\\"xml\\\", \\\"java\\\", \\\"properties\\\", \\\"sql\\\", \\\"js\\\", \\\"md\\\", \\\"json\\\", \\\"conf\\\", \\\"ini\\\", \\\"vue\\\", \\\"php\\\", \\\"py\\\", \\\"bat\\\", \\\"gitignore\\\", \\\"yml\\\", \\\"go\\\", \\\"sh\\\", \\\"c\\\", \\\"cpp\\\", \\\"h\\\", \\\"hpp\\\", \\\"tsx\\\", \\\"txt\\\", \\\"epub\\\", \\\"azw3\\\", \\\"mobi\\\", \\\"pdf\\\", \\\"chm\\\"],\\n    audio: [\\\"mp3\\\", \\\"flac\\\", \\\"ogg\\\", \\\"m4a\\\", \\\"wav\\\", \\\"opus\\\"],\\n    movie: [\\\"mp4\\\", \\\"mkv\\\", \\\"avi\\\", \\\"mov\\\", \\\"rmvb\\\", \\\"webm\\\", \\\"flv\\\", \\\"m4v\\\", \\\"m3u8\\\", \\\"ts\\\"],\\n    img: [\\\"jpg\\\", \\\"png\\\", \\\"jpeg\\\", \\\"gif\\\", \\\"svg\\\", \\\"raw\\\"],\\n    subtitle: [\\\"vtt\\\", \\\"srt\\\", \\\"ass\\\"],\\n    yasuo: [\\\"zip\\\", \\\"rar\\\", \\\"jar\\\"],\\n    office: [\\\"doc\\\", \\\"docx\\\", \\\"xls\\\", \\\"xlsx\\\", \\\"ppt\\\", \\\"pptx\\\"]\\n})\\n// 调试用，请勿擅自开启\\n//clearItem(\\\"list\\\")\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"主页\\\",\\\"path\\\":\\\"home\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nif (fileExist(\\\\\\\"hiker://files/cache/alist_cache.json\\\\\\\")) {\\\\n    let alist = storage0.getItem(\\\\\\\"list\\\\\\\", [])\\\\n    var l = JSON.parse(fetch(\\\\\\\"hiker://files/cache/alist_cache.json\\\\\\\"))\\\\n    var testlist = alist.map(function(item) {\\\\n        return item.url\\\\n    })\\\\n    l.forEach(item => {\\\\n        if (!testlist.includes(item.url)) {\\\\n            alist.push(item)\\\\n        } else {\\\\n            toast(\\\\\\\"重复的链接，导入失败\\\\\\\")\\\\n        }\\\\n    })\\\\n    storage0.setItem(\\\\\\\"list\\\\\\\", alist)\\\\n    deleteFile(\\\\\\\"hiker://files/cache/alist_cache.json\\\\\\\")\\\\n}\\\\nvar alist = storage0.getItem(\\\\\\\"list\\\\\\\", [])\\\\nvar {\\\\n    getIcon,\\\\n    formatDate,\\\\n    getFileSize,\\\\n    sorts,\\\\n    getHzm\\\\n} = $.require(\\\\\\\"api\\\\\\\")\\\\nif (alist.length == 0) {\\\\n    setResult([{\\\\n        title: \\\\\\\"当前无Alist配置\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/config\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n    }])\\\\n} else {\\\\n    // 设置headers\\\\n    var headers = {}\\\\n\\\\n    var path = MY_PARAMS.path ? MY_PARAMS.path : \\\\\\\"/\\\\\\\"\\\\n\\\\n    var selected = parseInt(getItem(\\\\\\\"selected\\\\\\\", \\\\\\\"0\\\\\\\"))\\\\n    var now = alist[selected]\\\\n\\\\n    if (alist[selected][\\\\\\\"browser-password\\\\\\\"][path]) {\\\\n        headers[\\\\\\\"Cookie\\\\\\\"] = \\\\\\\"browser-password=\\\\\\\" + alist[selected][\\\\\\\"browser-password\\\\\\\"][path]\\\\n    } else {\\\\n        headers[\\\\\\\"Cookie\\\\\\\"] = \\\\\\\"browser-password=\\\\\\\"\\\\n    }\\\\n\\\\n    let sorr = [\\\\\\\"默认\\\\\\\", \\\\\\\"名称\\\\\\\", \\\\\\\"时间\\\\\\\", \\\\\\\"大小\\\\\\\"]\\\\n    var nsort = getItem(\\\\\\\"sort\\\\\\\", \\\\\\\"默认\\\\\\\")\\\\n\\\\n    // 有密码的先获取token\\\\n    if (now.user && now.password) {\\\\n        let res = JSON.parse(post(now.url + \\\\\\\"api/auth/login\\\\\\\", {\\\\n            body: JSON.stringify({\\\\n                \\\\\\\"username\\\\\\\": now.user,\\\\n                \\\\\\\"password\\\\\\\": now.password,\\\\n                \\\\\\\"otp_code\\\\\\\": \\\\\\\"\\\\\\\"\\\\n            })\\\\n        }))\\\\n        if (res.code == 200) {\\\\n            headers[\\\\\\\"Authorization\\\\\\\"] = res.data.token\\\\n        } else {\\\\n            toast(\\\\\\\"登陆失败\\\\\\\")\\\\n            log(res)\\\\n            d.push({\\\\n                title: \\\\\\\"账号密码错误\\\\\\\",\\\\n                url: \\\\\\\"hiker://page/config\\\\\\\",\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n            })\\\\n            setResult(d)\\\\n        }\\\\n    }\\\\n    if (MY_PAGE == 1) {\\\\n        if (path == \\\\\\\"/\\\\\\\") {\\\\n            d.push({\\\\n                title: \\\\\\\"⚙️设置\\\\\\\",\\\\n                url: \\\\\\\"hiker://page/config\\\\\\\",\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n            })\\\\n            alist.forEach((item, i) => {\\\\n                d.push({\\\\n                    title: i == selected ? $.require(\\\\\\\"api\\\\\\\").color(item.name, \\\\\\\"red\\\\\\\") : item.name,\\\\n                    col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                    url: i == selected ? \\\\\\\"x5://\\\\\\\" + now.url : $().lazyRule((i) => {\\\\n                        setItem(\\\\\\\"selected\\\\\\\", i + \\\\\\\"\\\\\\\")\\\\n                        refreshPage()\\\\n                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                    }, i)\\\\n                })\\\\n            })\\\\n        }\\\\n        d.push({\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\n        })\\\\n        if (now.search) {\\\\n            d.push({\\\\n                title: \\\\\\\"🔎 搜索\\\\\\\",\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: \\\\\\\"hiker://page/search?page=fypage&u=\\\\\\\" + now.url + \\\\\\\"&path=\\\\\\\" + path,\\\\n                extra: {\\\\n                    headers: headers,\\\\n                    now: now\\\\n                }\\\\n            })\\\\n        }\\\\n        if (now.user && now.password) {\\\\n            d.push({\\\\n                title: \\\\\\\"新建文件夹\\\\\\\",\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $(\\\\\\\"\\\\\\\").input((path, now, headers) => {\\\\n                    var res = JSON.parse(post(now.url + \\\\\\\"api/fs/mkdir\\\\\\\", {\\\\n                        body: JSON.stringify({\\\\n                            path: path + \\\\\\\"/\\\\\\\" + input\\\\n                        }),\\\\n                        headers: headers\\\\n                    })).code\\\\n                    if (res == 200) {\\\\n                        refreshPage()\\\\n                        return \\\\\\\"toast://创建成功\\\\\\\"\\\\n                    } else {\\\\n                        return \\\\\\\"toast://创建失败\\\\\\\"\\\\n                    }\\\\n                }, path, now, headers)\\\\n            }, {\\\\n                title: \\\\\\\"新建文件\\\\\\\",\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $(\\\\\\\"\\\\\\\").input((path, now, headers) => {\\\\n                    headers[\\\\\\\"File-Path\\\\\\\"] = encodeURI(path + \\\\\\\"/\\\\\\\" + input)\\\\n                    var res = JSON.parse(request(now.url + \\\\\\\"api/fs/put\\\\\\\", {\\\\n                        body: \\\\\\\"\\\\\\\",\\\\n                        headers: headers,\\\\n                        method: \\\\\\\"PUT\\\\\\\"\\\\n                    })).code\\\\n                    if (res == 200) {\\\\n                        refreshPage()\\\\n                        return \\\\\\\"toast://创建成功\\\\\\\"\\\\n                    } else {\\\\n                        return \\\\\\\"toast://创建失败\\\\\\\"\\\\n                    }\\\\n                }, path, now, headers)\\\\n            }, {\\\\n                title: \\\\\\\"添加aria2任务\\\\\\\",\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $(\\\\\\\"\\\\\\\", \\\\\\\"多条用回车隔开\\\\\\\").input((path, now, headers) => {\\\\n                    var res = JSON.parse(post(now.url + \\\\\\\"api/fs/add_aria2\\\\\\\", {\\\\n                        body: JSON.stringify({\\\\n                            path: path,\\\\n                            urls: input.split(\\\\\\\"\\\\\\\\n\\\\\\\")\\\\n                        }),\\\\n                        headers: headers\\\\n                    })).code\\\\n                    if (res == 200) {\\\\n                        refreshPage()\\\\n                        return \\\\\\\"toast://创建成功\\\\\\\"\\\\n                    } else {\\\\n                        return \\\\\\\"toast://创建失败\\\\\\\"\\\\n                    }\\\\n                }, path, now, headers)\\\\n            })\\\\n        }\\\\n\\\\n        d.push({\\\\n            col_type: \\\\\\\"line_blank\\\\\\\"\\\\n        })\\\\n        d.push({\\\\n            col_type: \\\\\\\"big_blank_block\\\\\\\"\\\\n        })\\\\n        d.push({\\\\n            col_type: \\\\\\\"big_blank_block\\\\\\\"\\\\n        })\\\\n\\\\n        // 排序\\\\n        sorr.forEach(item => {\\\\n            if (nsort == item) {\\\\n                var title = item + \\\\\\\"↓\\\\\\\"\\\\n            } else if (nsort.includes(\\\\\\\"反\\\\\\\") && nsort.includes(item)) {\\\\n                var title = item + \\\\\\\"↑\\\\\\\"\\\\n            } else {\\\\n                var title = item + \\\\\\\"↕\\\\\\\"\\\\n            }\\\\n            d.push({\\\\n                title: title,\\\\n                col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                url: $().lazyRule((item) => {\\\\n                    if (getItem(\\\\\\\"sort\\\\\\\", \\\\\\\"默认\\\\\\\") == item) {\\\\n                        setItem(\\\\\\\"sort\\\\\\\", item + \\\\\\\"反\\\\\\\")\\\\n                    } else {\\\\n                        setItem(\\\\\\\"sort\\\\\\\", item)\\\\n                    }\\\\n                    refreshPage()\\\\n                    return \\\\\\\"hiker://empty\\\\\\\"\\\\n                }, item)\\\\n            })\\\\n        })\\\\n    }\\\\n\\\\n    let bid = path + \\\\\\\"-loading-\\\\\\\" + MY_PAGE;\\\\n    let d2 = [];\\\\n    d.push({\\\\n        title: \\\\\\\"努力加载中，请稍候...\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        extra: {\\\\n            id: bid,\\\\n            lineVisible: false\\\\n        }\\\\n    })\\\\n    setResult(d);\\\\n\\\\n    try {\\\\n        // 获取文件列表\\\\n        var list = JSON.parse(post(now.url + \\\\\\\"api/fs/list\\\\\\\", {\\\\n            body: JSON.stringify({\\\\n                \\\\\\\"path\\\\\\\": path,\\\\n                \\\\\\\"password\\\\\\\": alist[selected][\\\\\\\"browser-password\\\\\\\"][path] ? alist[selected][\\\\\\\"browser-password\\\\\\\"][path] : \\\\\\\"\\\\\\\",\\\\n                \\\\\\\"page\\\\\\\": MY_PAGE,\\\\n                \\\\\\\"per_page\\\\\\\": 30,\\\\n                \\\\\\\"refresh\\\\\\\": false\\\\n            }),\\\\n            headers: headers\\\\n        }))\\\\n        if (list.code == 200 && list.data.content) {\\\\n            sorts(list.data.content, nsort)\\\\n            list.data.content.forEach((item, index) => {\\\\n                var desc = formatDate(item.modified) + \\\\\\\" \\\\\\\" + getFileSize(item.size)\\\\n                var down_url = encodeURI(now.url + \\\\\\\"d\\\\\\\" + (path == \\\\\\\"/\\\\\\\" ? \\\\\\\"\\\\\\\" : path) + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\"?sign=\\\\\\\" + item.sign)\\\\n                var url = $().lazyRule((item, url, path, list, u) => {\\\\n                    const type_dict = {\\\\n                        0: $.toString((url) => {\\\\n                            return \\\\\\\"download://\\\\\\\" + url\\\\n                        }, url),\\\\n                        2: $.toString((url, list, u, path) => {\\\\n                            var subtitles = $.require(\\\\\\\"api\\\\\\\").getSubtitles(list, u, path)\\\\n                            if (subtitles.length > 1) {\\\\n                                var namelist = subtitles.map(function(item) {\\\\n                                    return item.name\\\\n                                })\\\\n                                return $(namelist, 1, \\\\\\\"请选择字幕\\\\\\\").select((subtitles, namelist, url) => {\\\\n                                    return JSON.stringify({\\\\n                                        urls: [url],\\\\n                                        subtitle: subtitles[namelist.indexOf(input)].url\\\\n                                    })\\\\n                                }, subtitles, namelist, url)\\\\n                            } else {\\\\n                                return url + \\\\\\\"#isVideo=true#\\\\\\\"\\\\n                            }\\\\n                        }, url, list, u, path),\\\\n                        3: $.toString((url) => {\\\\n                            return url + \\\\\\\"#isMusic=true#\\\\\\\"\\\\n                        }, url),\\\\n                        4: $.toString((url) => {\\\\n                            return \\\\\\\"download://\\\\\\\" + url\\\\n                        }, url),\\\\n                        5: $.toString((url) => {\\\\n                            return url + \\\\\\\"#.jpg\\\\\\\"\\\\n                        }, url)\\\\n                    }\\\\n                    if (item.is_dir) {\\\\n                        return \\\\\\\"hiker://page/home?page=fypage\\\\\\\"\\\\n                    } else if ($.require(\\\\\\\"api\\\\\\\").getHzm(item.name) == \\\\\\\"pdf\\\\\\\") {\\\\n                        return \\\\\\\"https://alist-org.github.io/pdf.js/web/viewer.html?file=\\\\\\\" + url\\\\n                    } else if ($.office.includes($.require(\\\\\\\"api\\\\\\\").getHzm(item.name))) {\\\\n                        return $([\\\\\\\"微软\\\\\\\", \\\\\\\"谷歌\\\\\\\"]).select((url) => {\\\\n                            if (input == \\\\\\\"微软\\\\\\\") {\\\\n                                return \\\\\\\"https://view.officeapps.live.com/op/view.aspx?src=\\\\\\\" + url\\\\n                            } else {\\\\n                                return \\\\\\\"https://docs.google.com/gview?&embedded=true&url=\\\\\\\" + url\\\\n                            }\\\\n                        }, url)\\\\n                    } else {\\\\n                        return eval(type_dict[item.type])\\\\n                    }\\\\n                }, item, down_url, path, list.data.content, now.url)\\\\n                var longClick = []\\\\n                if (!item.is_dir) {\\\\n                    longClick.push({\\\\n                        title: \\\\\\\"下载\\\\\\\",\\\\n                        js: $.toString((item, u, path) => {\\\\n                            return \\\\\\\"download://\\\\\\\" + u\\\\n                        }, item, down_url, path)\\\\n                    }, {\\\\n                        title: \\\\\\\"用其他软件打开\\\\\\\",\\\\n                        js: $.toString((item, u, path) => {\\\\n                            downloadFile(u, \\\\\\\"hiker://files/cache/\\\\\\\" + item.name)\\\\n                            return \\\\\\\"openFile://\\\\\\\" + \\\\\\\"hiker://files/cache/\\\\\\\" + item.name\\\\n                        }, item, down_url, path)\\\\n                    })\\\\n                }\\\\n                if (now.user && now.password) {\\\\n                    longClick.push({\\\\n                        title: \\\\\\\"删除\\\\\\\",\\\\n                        js: $.toString((item, headers, path, now) => {\\\\n                            return $(\\\\\\\"确认删除？\\\\\\\").confirm((item, headers, path, now) => {\\\\n                                var res = JSON.parse(post(now.url + \\\\\\\"api/fs/remove\\\\\\\", {\\\\n                                    headers: headers,\\\\n                                    body: JSON.stringify({\\\\n                                        dir: path,\\\\n                                        names: [item.name]\\\\n                                    })\\\\n                                })).code\\\\n                                if (res == 200) {\\\\n                                    refreshPage()\\\\n                                    return \\\\\\\"toast://删除成功\\\\\\\"\\\\n                                } else {\\\\n                                    return \\\\\\\"toast://删除失败\\\\\\\"\\\\n                                }\\\\n                            }, item, headers, path, now)\\\\n                        }, item, headers, path, now)\\\\n                    }, {\\\\n                        title: \\\\\\\"重命名\\\\\\\",\\\\n                        js: $.toString((item, headers, path, now) => {\\\\n                            return $(item.name).input((item, headers, path, now) => {\\\\n                                var res = JSON.parse(post(now.url + \\\\\\\"api/fs/rename\\\\\\\", {\\\\n                                    headers: headers,\\\\n                                    body: JSON.stringify({\\\\n                                        path: path + \\\\\\\"/\\\\\\\" + item.name,\\\\n                                        name: input\\\\n                                    })\\\\n                                })).code\\\\n                                if (res == 200) {\\\\n                                    refreshPage()\\\\n                                    return \\\\\\\"toast://重命名成功\\\\\\\"\\\\n                                } else {\\\\n                                    return \\\\\\\"toast://重命名失败\\\\\\\"\\\\n                                }\\\\n                            }, item, headers, path, now)\\\\n                        }, item, headers, path, now)\\\\n                    })\\\\n                }\\\\n                d2.push({\\\\n                    title: item.name,\\\\n                    col_type: getItem(\\\\\\\"style\\\\\\\", \\\\\\\"avatar\\\\\\\"),\\\\n                    img: getIcon(item),\\\\n                    desc: desc,\\\\n                    url: url,\\\\n                    extra: {\\\\n                        longClick: longClick,\\\\n                        pageTitle: item.name,\\\\n                        path: (path == \\\\\\\"/\\\\\\\" ? \\\\\\\"/\\\\\\\" : path + \\\\\\\"/\\\\\\\") + item.name,\\\\n                        id: item.name,\\\\n                        cls: \\\\\\\"playlist main\\\\\\\"\\\\n                    }\\\\n                })\\\\n                if (getItem(\\\\\\\"style\\\\\\\", \\\\\\\"avatar\\\\\\\") == \\\\\\\"avatar\\\\\\\") {\\\\n                    d2.push({\\\\n                        title: `‘‘’’<small><font color='#aaaaaa'>${desc}</font></small>`,\\\\n                        col_type: \\\\\\\"text_1\\\\\\\",\\\\n                        url: url,\\\\n                        extra: {\\\\n                            longClick: longClick,\\\\n                            pageTitle: item.name,\\\\n                            path: (path == \\\\\\\"/\\\\\\\" ? \\\\\\\"/\\\\\\\" : path + \\\\\\\"/\\\\\\\") + item.name,\\\\n                            cls: \\\\\\\"playlist desc\\\\\\\"\\\\n                        }\\\\n                    })\\\\n                }\\\\n            })\\\\n        } else if (list.message == \\\\\\\"password is incorrect or you have no permission\\\\\\\") {\\\\n            d2.push({\\\\n                title: \\\\\\\"浏览密码错误\\\\\\\",\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n                url: $(\\\\\\\"\\\\\\\", \\\\\\\"输入密码\\\\\\\").input((alist, selected, path) => {\\\\n                    alist[selected][\\\\\\\"browser-password\\\\\\\"][path] = input\\\\n                    storage0.setItem(\\\\\\\"list\\\\\\\", alist)\\\\n                    refreshPage()\\\\n                }, alist, selected, path)\\\\n            })\\\\n        } else if (list.code != 200) {\\\\n            toast(\\\\\\\"出错了\\\\\\\")\\\\n            log(list.message)\\\\n        }\\\\n    } catch (e) {\\\\n        d2.push({\\\\n            title: \\\\\\\"出现错误\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/config\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n        })\\\\n        log(e.message)\\\\n    }\\\\n    addItemBefore(bid, d2);\\\\n    deleteItem(bid);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"设置\\\",\\\"path\\\":\\\"config\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nd.push({\\\\n    title: \\\\\\\"显示网站详情:\\\\\\\" + getItem(\\\\\\\"detail\\\\\\\", \\\\\\\"开\\\\\\\"),\\\\n    url: $().lazyRule(() => {\\\\n        setItem(\\\\\\\"detail\\\\\\\", getItem(\\\\\\\"detail\\\\\\\", \\\\\\\"开\\\\\\\") == \\\\\\\"开\\\\\\\" ? \\\\\\\"关\\\\\\\" : \\\\\\\"开\\\\\\\")\\\\n        refreshPage()\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n}, {\\\\n    title: \\\\\\\"切换样式:\\\\\\\" + getItem(\\\\\\\"style\\\\\\\", \\\\\\\"avatar\\\\\\\"),\\\\n    url: $([\\\\\\\"movie_3\\\\\\\", \\\\\\\"movie_1_left_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic\\\\\\\", \\\\\\\"card_pic_3\\\\\\\", \\\\\\\"avatar\\\\\\\", \\\\\\\"text_1\\\\\\\"]).select(() => {\\\\n        setItem(\\\\\\\"style\\\\\\\", input)\\\\n        refreshPage()\\\\n        return \\\\\\\"toast://已切换\\\\\\\"\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n})\\\\nd.push({\\\\n    col_type: \\\\\\\"line_blank\\\\\\\"\\\\n})\\\\nd.push({\\\\n    title: \\\\\\\"➕ 新增Alist\\\\\\\",\\\\n    url: $(\\\\\\\"\\\\\\\", \\\\\\\"名称\\\\\\\").input(() => {\\\\n        if (input == \\\\\\\"\\\\\\\") {\\\\n            return \\\\\\\"toast://名称不能为空\\\\\\\"\\\\n        } else if (storage0.getItem(\\\\\\\"list\\\\\\\", []).map(function(i) {\\\\n                return i.name\\\\n            }).includes(input)) {\\\\n            return \\\\\\\"toast://已经有相同的网站了\\\\\\\"\\\\n        } else {\\\\n            return $(\\\\\\\"\\\\\\\", \\\\\\\"链接 示例:http://127.0.0.1/\\\\\\\").input((name) => {\\\\n                if (!input.includes(\\\\\\\"http\\\\\\\")) {\\\\n                    return \\\\\\\"toast://链接格式错误\\\\\\\"\\\\n                } else {\\\\n                    if (input[input.length - 1] != \\\\\\\"/\\\\\\\") {\\\\n                        input += \\\\\\\"/\\\\\\\"\\\\n                    }\\\\n                    var config = JSON.parse(request(input + \\\\\\\"api/public/settings\\\\\\\")).data\\\\n                    var list = storage0.getItem(\\\\\\\"list\\\\\\\", [])\\\\n                    list.push({\\\\n                        name: name,\\\\n                        url: input,\\\\n                        \\\\\\\"browser-password\\\\\\\": {},\\\\n                        \\\\\\\"search\\\\\\\": config.search_index && config.search_index != \\\\\\\"none\\\\\\\"\\\\n                    })\\\\n                    storage0.setItem(\\\\\\\"list\\\\\\\", list)\\\\n                    refreshPage()\\\\n                }\\\\n            }, input)\\\\n        }\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n}, {\\\\n    title: \\\\\\\"分享\\\\\\\",\\\\n    col_type: \\\\\\\"text_2\\\\\\\",\\\\n    url: $([\\\\\\\"仅分享网站\\\\\\\", \\\\\\\"分享网站加密码\\\\\\\"]).select(() => {\\\\n        var list = storage0.getItem(\\\\\\\"list\\\\\\\", [])\\\\n        if (input == \\\\\\\"仅分享网站\\\\\\\") {\\\\n            var alist = list.map(function(item) {\\\\n                return {\\\\n                    name: item.name,\\\\n                    url: item.url,\\\\n                    \\\\\\\"browser-password\\\\\\\": {}\\\\n                }\\\\n            })\\\\n            var url = sharePaste(JSON.stringify(alist))\\\\n            return \\\\\\\"copy://Alist V3网盘导入口令 共\\\\\\\" + alist.length + \\\\\\\"个@\\\\\\\" + url + \\\\\\\"@import=js:\\\\\\\" + $.toString(() => {\\\\n                $.require(\\\\\\\"hiker://page/cloudimport?rule=Alist V3\\\\\\\").input(input)\\\\n            })\\\\n        } else {\\\\n            var url = sharePaste(JSON.stringify(list))\\\\n            return \\\\\\\"copy://Alist V3网盘导入口令 共\\\\\\\" + alist.length + \\\\\\\"个@\\\\\\\" + url + \\\\\\\"@import=js:\\\\\\\" + $.toString(() => {\\\\n                $.require(\\\\\\\"hiker://page/cloudimport?rule=Alist V3\\\\\\\").input(input)\\\\n            })\\\\n        }\\\\n    })\\\\n})\\\\nvar list = storage0.getItem(\\\\\\\"list\\\\\\\", [])\\\\nlist.forEach((item, i) => {\\\\n    d.push({\\\\n        title: item.name,\\\\n        desc: item.url,\\\\n        url: $([\\\\\\\"删除\\\\\\\", \\\\\\\"排序\\\\\\\", \\\\\\\"修改名称\\\\\\\", \\\\\\\"修改链接\\\\\\\", \\\\\\\"修改账户密码\\\\\\\"]).select((a, i) => {\\\\n            var list = storage0.getItem(\\\\\\\"list\\\\\\\", [])\\\\n            switch (input) {\\\\n                case \\\\\\\"删除\\\\\\\":\\\\n                    return $(\\\\\\\"确认删除？\\\\\\\").confirm((list, i) => {\\\\n                        list.splice(i, 1)\\\\n                        storage0.setItem(\\\\\\\"list\\\\\\\", list)\\\\n                        clearItem(\\\\\\\"selected\\\\\\\")\\\\n                        refreshPage()\\\\n                    }, list, i)\\\\n                    break;\\\\n                case \\\\\\\"修改名称\\\\\\\":\\\\n                    return $(list[i].name).input((list, i) => {\\\\n                        if (input == \\\\\\\"\\\\\\\") {\\\\n                            return \\\\\\\"toast://名称不能为空\\\\\\\"\\\\n                        } else if (storage0.getItem(\\\\\\\"list\\\\\\\", []).map(function(i) {\\\\n                                return i.name\\\\n                            }).includes(input)) {\\\\n                            return \\\\\\\"toast://已经有相同的网站了\\\\\\\"\\\\n                        } else {\\\\n                            list[i].name = input\\\\n                            storage0.setItem(\\\\\\\"list\\\\\\\", list)\\\\n                            refreshPage()\\\\n                        }\\\\n                    }, list, i)\\\\n                    break\\\\n                case \\\\\\\"修改链接\\\\\\\":\\\\n                    return $(list[i].url).input((list, i) => {\\\\n                        if (!input.includes(\\\\\\\"http\\\\\\\")) {\\\\n                            return \\\\\\\"toast://链接格式错误\\\\\\\"\\\\n                        } else if (input[input.length - 1] != \\\\\\\"/\\\\\\\") {\\\\n                            return \\\\\\\"toast://链接格式错误\\\\\\\"\\\\n                        } else {\\\\n                            list[i].url = input\\\\n                            storage0.setItem(\\\\\\\"list\\\\\\\", list)\\\\n                            refreshPage()\\\\n                        }\\\\n                    }, list, i)\\\\n                    break\\\\n                case \\\\\\\"修改账户密码\\\\\\\":\\\\n                    return $(list[i][\\\\\\\"user\\\\\\\"] ? list[i][\\\\\\\"user\\\\\\\"] : \\\\\\\"\\\\\\\", \\\\\\\"账号\\\\\\\").input((list, i) => {\\\\n                        return $(list[i][\\\\\\\"password\\\\\\\"] ? list[i][\\\\\\\"password\\\\\\\"] : \\\\\\\"\\\\\\\", \\\\\\\"密码\\\\\\\").input((user, list, i) => {\\\\n                            list[i][\\\\\\\"user\\\\\\\"] = user\\\\n                            list[i][\\\\\\\"password\\\\\\\"] = input\\\\n                            storage0.setItem(\\\\\\\"list\\\\\\\", list)\\\\n                            refreshPage()\\\\n                        }, input, list, i)\\\\n                    }, list, i)\\\\n                case \\\\\\\"排序\\\\\\\":\\\\n                    return $(i + 1 + \\\\\\\"\\\\\\\", \\\\\\\"拍到第几个\\\\\\\").input((list, i) => {\\\\n                        function checkRate(input) {　　\\\\n                            var re = /^[0-9]+.?[0-9]*/; //判断字符串是否为数字//判断正整数/[1−9]+[0−9]∗]∗/\\\\n                            　　\\\\n                            return re.test(input)　　\\\\n                        }\\\\n                        if (checkRate(input)) {\\\\n                            var a = parseInt(input) - 1 // 目标\\\\n                            if (a > list.length && a == 0) {\\\\n                                toast(\\\\\\\"不能大于列表数量！\\\\\\\")\\\\n                            } else {\\\\n                                var temp = list[a]\\\\n                                list[a] = list[i]\\\\n                                list[i] = temp\\\\n                                storage0.setItem(\\\\\\\"list\\\\\\\", list)\\\\n                                refreshPage()\\\\n                            }\\\\n                        } else {\\\\n                            toast(\\\\\\\"请输入正整数\\\\\\\")\\\\n                        }\\\\n                    }, list, i)\\\\n            }\\\\n        }, item, i),\\\\n        col_type: \\\\\\\"text_1\\\\\\\"\\\\n    })\\\\n})\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码\\\",\\\"path\\\":\\\"api\\\",\\\"rule\\\":\\\"$.exports = {\\\\n    color: function(text, color) {\\\\n        return `‘‘’’<strong><font color=\\\\\\\"${color}\\\\\\\">${text}</front></strong>`\\\\n    },\\\\n    getIcon: function(content) {\\\\n        if (content.is_dir) {\\\\n            img = \\\\\\\"https://hikerfans.com/tubiao/more/274.png\\\\\\\"\\\\n        } else {\\\\n            let fileName = content.name.toLowerCase()\\\\n            let hzm = $.require(\\\\\\\"api\\\\\\\").getHzm(fileName)\\\\n            if (content.thumb && content.type != 0) {\\\\n                img = content.thumb\\\\n            } else if ($.movie.includes(hzm)) {\\\\n                img = \\\\\\\"https://hikerfans.com/tubiao/more/30.png\\\\\\\"\\\\n            } else if ($.audio.includes(hzm)) {\\\\n                img = \\\\\\\"https://hikerfans.com/tubiao/more/40.png\\\\\\\"\\\\n            } else if ($.text.includes(hzm)) {\\\\n                img = \\\\\\\"https://hikerfans.com/tubiao/more/78.png\\\\\\\"\\\\n            } else if ($.img.includes(hzm)) {\\\\n                img = \\\\\\\"https://hikerfans.com/tubiao/more/38.png\\\\\\\"\\\\n            } else if ($.yasuo.includes(hzm)) {\\\\n                img = \\\\\\\"https://hikerfans.com/tubiao/more/201.png\\\\\\\"\\\\n            } else if ($.office.includes(hzm)) {\\\\n                img = \\\\\\\"https://hikerfans.com/tubiao/more/185.png\\\\\\\"\\\\n            } else {\\\\n                img = \\\\\\\"https://hikerfans.com/tubiao/more/239.png\\\\\\\"\\\\n            }\\\\n        }\\\\n        return img\\\\n    },\\\\n    formatDate: function(time) {\\\\n        return time.split(\\\\\\\"T\\\\\\\")[0] + \\\\\\\" \\\\\\\" + time.split(\\\\\\\"T\\\\\\\")[1].split(\\\\\\\".\\\\\\\")[0].split(\\\\\\\"Z\\\\\\\")[0].split(\\\\\\\"+\\\\\\\")[0]\\\\n    },\\\\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    getHzm: function(fileName) {\\\\n        return fileName.substr(fileName.lastIndexOf(\\\\\\\".\\\\\\\") + 1)\\\\n    },\\\\n    sorts: function(list, method) {\\\\n        if (method.includes(\\\\\\\"名称\\\\\\\")) {\\\\n            list.sort(function(a, b) {\\\\n                return a.name.localeCompare(b.name)\\\\n            })\\\\n        } else if (method.includes(\\\\\\\"时间\\\\\\\")) {\\\\n            list.sort(function(a, b) {\\\\n                return a.modified - b.modified\\\\n            })\\\\n        } else if (method.includes(\\\\\\\"大小\\\\\\\")) {\\\\n            list.sort(function(a, b) {\\\\n                return a.size - b.size\\\\n            })\\\\n        }\\\\n        if (method.includes(\\\\\\\"反\\\\\\\")) {\\\\n            list.reverse();\\\\n        }\\\\n        return list\\\\n    },\\\\n    getSubtitles: function(list, url, path) {\\\\n        const {\\\\n            getHzm\\\\n        } = $.require(\\\\\\\"api\\\\\\\")\\\\n        let s = []\\\\n        list.forEach(item => {\\\\n            if ($.subtitle.includes(getHzm(item.name))) {\\\\n                s.push({\\\\n                    name: item.name,\\\\n                    url: encodeURI(url + \\\\\\\"d\\\\\\\" + (path == \\\\\\\"/\\\\\\\" ? \\\\\\\"\\\\\\\" : path) + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\"?sign=\\\\\\\" + item.sign)\\\\n                })\\\\n            }\\\\n        })\\\\n        s.unshift({\\\\n            name: \\\\\\\"不需要字幕\\\\\\\"\\\\n        })\\\\n        return s\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索\\\",\\\"path\\\":\\\"search\\\",\\\"rule\\\":\\\"js:\\\\ntry {\\\\n    var d = [];\\\\n    var {\\\\n        getIcon,\\\\n        getFileSize\\\\n    } = $.require(\\\\\\\"api\\\\\\\")\\\\n    var url = getParam(\\\\\\\"u\\\\\\\")\\\\n    var now = MY_PARAMS.now\\\\n    var headers = MY_PARAMS.headers\\\\n    if (MY_PAGE == 1) {\\\\n        d.unshift({\\\\n            title: \\\\\\\"搜索\\\\\\\",\\\\n            url: $.toString(() => {\\\\n                putMyVar(\\\\\\\"kw\\\\\\\", input)\\\\n                refreshPage()\\\\n            }),\\\\n            col_type: \\\\\\\"input\\\\\\\",\\\\n            extra: {\\\\n                defaultValue: getMyVar(\\\\\\\"kw\\\\\\\", \\\\\\\"\\\\\\\")\\\\n            }\\\\n        })\\\\n    }\\\\n    var path = getParam(\\\\\\\"path\\\\\\\")\\\\n    if (getMyVar(\\\\\\\"kw\\\\\\\", \\\\\\\"\\\\\\\") != \\\\\\\"\\\\\\\") {\\\\n        var list = JSON.parse(post(url + \\\\\\\"api/fs/search\\\\\\\", {\\\\n            headers: headers,\\\\n            body: JSON.stringify({\\\\n                \\\\\\\"parent\\\\\\\": getParam(\\\\\\\"path\\\\\\\"),\\\\n                \\\\\\\"keywords\\\\\\\": getMyVar(\\\\\\\"kw\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n                \\\\\\\"page\\\\\\\": MY_PAGE,\\\\n                \\\\\\\"per_page\\\\\\\": 100\\\\n            })\\\\n        }))\\\\n        if (list.code == 200 && list.data.content) {\\\\n            list.data.content.forEach(item => {\\\\n                var desc = getFileSize(item.size)\\\\n                var url = $().lazyRule((item, u, path, headers) => {\\\\n                    var sign = JSON.parse(post(u + \\\\\\\"api/fs/get\\\\\\\", {\\\\n                        headers: headers,\\\\n                        body: JSON.stringify({\\\\n                            \\\\\\\"path\\\\\\\": item.parent + \\\\\\\"/\\\\\\\" + item.name\\\\n                        })\\\\n                    })).data.sign\\\\n                    var url = encodeURI(u + \\\\\\\"d\\\\\\\" + item.parent + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\"?sign=\\\\\\\" + sign)\\\\n                    const type_dict = {\\\\n                        0: $.toString((url) => {\\\\n                            return \\\\\\\"download://\\\\\\\" + url\\\\n                        }, url),\\\\n                        2: $.toString((url) => {\\\\n                            return url + \\\\\\\"#isVideo=true#\\\\\\\"\\\\n                        }, url),\\\\n                        3: $.toString((url) => {\\\\n                            return url + \\\\\\\"#isMusic=true#\\\\\\\"\\\\n                        }, url),\\\\n                        4: $.toString((url) => {\\\\n                            return \\\\\\\"download://\\\\\\\" + url\\\\n                        }, url),\\\\n                        5: $.toString((url) => {\\\\n                            return url + \\\\\\\"#.jpg\\\\\\\"\\\\n                        }, url)\\\\n                    }\\\\n                    if (item.is_dir) {\\\\n                        return \\\\\\\"hiker://page/home?page=fypage\\\\\\\"\\\\n                    } else if ($.require(\\\\\\\"api\\\\\\\").getHzm(item.name) == \\\\\\\"pdf\\\\\\\") {\\\\n                        return \\\\\\\"https://alist-org.github.io/pdf.js/web/viewer.html?file=\\\\\\\" + url\\\\n                    } else if ($.office.includes($.require(\\\\\\\"api\\\\\\\").getHzm(item.name))) {\\\\n                        return $([\\\\\\\"微软\\\\\\\", \\\\\\\"谷歌\\\\\\\"]).select((url) => {\\\\n                            if (input == \\\\\\\"微软\\\\\\\") {\\\\n                                return \\\\\\\"https://view.officeapps.live.com/op/view.aspx?src=\\\\\\\" + url\\\\n                            } else {\\\\n                                return \\\\\\\"https://docs.google.com/gview?&embedded=true&url=\\\\\\\" + url\\\\n                            }\\\\n                        }, url)\\\\n                    } else {\\\\n                        return eval(type_dict[item.type])\\\\n                    }\\\\n                }, item, now.url, path, headers)\\\\n                var longClick = []\\\\n                if (!item.is_dir) {\\\\n                    longClick.push({\\\\n                        title: \\\\\\\"下载\\\\\\\",\\\\n                        js: $.toString((item, u, path, headers) => {\\\\n                            return \\\\\\\"download://\\\\\\\" + encodeURI(u + \\\\\\\"d\\\\\\\" + item.parent + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\"?sign=\\\\\\\" + JSON.parse(post(u + \\\\\\\"api/fs/get\\\\\\\", {\\\\n                                headers: headers,\\\\n                                body: JSON.stringify({\\\\n                                    \\\\\\\"path\\\\\\\": item.parent + \\\\\\\"/\\\\\\\" + item.name\\\\n                                })\\\\n                            })).data.sign)\\\\n                        }, item, now.url, path, headers)\\\\n                    }, {\\\\n                        title: \\\\\\\"用其他软件打开\\\\\\\",\\\\n                        js: $.toString((item, u, path, headers) => {\\\\n                            var sign = JSON.parse(post(u + \\\\\\\"api/fs/get\\\\\\\", {\\\\n                                headers: headers,\\\\n                                body: JSON.stringify({\\\\n                                    \\\\\\\"path\\\\\\\": item.parent + \\\\\\\"/\\\\\\\" + item.name\\\\n                                })\\\\n                            })).data.sign\\\\n                            downloadFile(encodeURI(u + \\\\\\\"d\\\\\\\" + item.parent + \\\\\\\"/\\\\\\\" + item.name + \\\\\\\"?sign=\\\\\\\" + sign), \\\\\\\"hiker://files/cache/\\\\\\\" + item.name)\\\\n                            return \\\\\\\"openFile://\\\\\\\" + \\\\\\\"hiker://files/cache/\\\\\\\" + item.name\\\\n                        }, item, now.url, path, headers)\\\\n                    })\\\\n                }\\\\n                if (now.user && now.password) {\\\\n                    longClick.push({\\\\n                        title: \\\\\\\"删除\\\\\\\",\\\\n                        js: $.toString((item, headers, path, now) => {\\\\n                            return $(\\\\\\\"确认删除？\\\\\\\").confirm((item, headers, path, now) => {\\\\n                                var res = JSON.parse(post(now.url + \\\\\\\"api/fs/remove\\\\\\\", {\\\\n                                    headers: headers,\\\\n                                    body: JSON.stringify({\\\\n                                        dir: item.parent,\\\\n                                        names: [item.name]\\\\n                                    })\\\\n                                })).code\\\\n                                if (res == 200) {\\\\n                                    refreshPage()\\\\n                                    return \\\\\\\"toast://删除成功\\\\\\\"\\\\n                                } else {\\\\n                                    return \\\\\\\"toast://删除失败\\\\\\\"\\\\n                                }\\\\n                            }, item, headers, path, now)\\\\n                        }, item, headers, path, now)\\\\n                    }, {\\\\n                        title: \\\\\\\"重命名\\\\\\\",\\\\n                        js: $.toString((item, headers, path, now) => {\\\\n                            return $(item.name).input((item, headers, path, now) => {\\\\n                                var res = JSON.parse(post(now.url + \\\\\\\"api/fs/rename\\\\\\\", {\\\\n                                    headers: headers,\\\\n                                    body: JSON.stringify({\\\\n                                        path: item.parent + \\\\\\\"/\\\\\\\" + item.name,\\\\n                                        name: input\\\\n                                    })\\\\n                                })).code\\\\n                                if (res == 200) {\\\\n                                    refreshPage()\\\\n                                    return \\\\\\\"toast://操作成功\\\\\\\"\\\\n                                } else {\\\\n                                    return \\\\\\\"toast://操作失败\\\\\\\"\\\\n                                }\\\\n                            }, item, headers, path, now)\\\\n                        }, item, headers, path, now)\\\\n                    })\\\\n                }\\\\n                d.push({\\\\n                    title: item.name,\\\\n                    col_type: getItem(\\\\\\\"style\\\\\\\", \\\\\\\"avatar\\\\\\\"),\\\\n                    img: getIcon(item),\\\\n                    desc: desc,\\\\n                    url: url,\\\\n                    extra: {\\\\n                        longClick: longClick,\\\\n                        path: item.parent + \\\\\\\"/\\\\\\\" + item.name,\\\\n                        pageTitle: item.name\\\\n                    }\\\\n                })\\\\n                if (getItem(\\\\\\\"style\\\\\\\", \\\\\\\"avatar\\\\\\\") == \\\\\\\"avatar\\\\\\\") {\\\\n                    d.push({\\\\n                        title: `‘‘’’<small><font color='#aaaaaa'>${desc}</font></small>`,\\\\n                        col_type: \\\\\\\"text_1\\\\\\\",\\\\n                        url: url,\\\\n                        extra: {\\\\n                            longClick: longClick,\\\\n                            path: item.parent + \\\\\\\"/\\\\\\\" + item.name,\\\\n                            pageTitle: item.name\\\\n                        }\\\\n                    })\\\\n                }\\\\n            })\\\\n        } else if (list.code != 200) {\\\\n            toast(\\\\\\\"出错了\\\\\\\")\\\\n            log(list.message)\\\\n        }\\\\n    }\\\\n} catch (e) {\\\\n    setResult([{\\\\n        title: \\\\\\\"设置\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/config\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n    }])\\\\n    log(e.message)\\\\n    toast(\\\\\\\"程序出现错误，请重试\\\\\\\")\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"云口令\\\",\\\"path\\\":\\\"cloudimport\\\",\\\"rule\\\":\\\"$.exports.input = function(url) {\\\\n    var url = url.split(\\\\\\\"@\\\\\\\")[1]\\\\n    var content = parsePaste(url)\\\\n    writeFile(\\\\\\\"hiker://files/cache/alist_cache.json\\\\\\\", content)\\\\n}\\\"}]\",\"proxy\":\"\"}","title":"⚙️设置"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!