小程序：Alist

海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@Alist@{"last_chapter_rule":"","title":"Alist","author":"Joe&道长魔改","url":"hiker://empty","version":32,"col_type":"pic_1","class_name":"","type":"tool","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\n    var d = [];\nif (getAppVersion() < 3204) {\n    setResult([{\n        title: \"您当前版本不支持本小程序，请更新至最新版本\",\n        url: \"https://haikuo.lanzoui.com/u/GoldRiver\"\n    }])\n} else {\n    const {\n        getFiles,\n        getLink\n    } = $.require('hiker://page/api');\n    const {color,small}=$.require('hiker://page/utils');\n    var path = getMyVar(\"path\", \"\");\n    d.push({\n        title: '⚙️设置',\n        col_type: 'scroll_button',\n        url: 'hiker://page/settings#noHistory##noRecordHistory#',\n        extra: {\n            version: MY_RULE.version\n        }\n    });\n    let sub_urls = $.get_sub_urls();\n    let rstrip = $.rstrip;\n    var base_path = rstrip(getMyVar(\"baseurl\", sub_urls[0].url), '/');\n    let nowSub = sub_urls.find(x=>rstrip(x.url,'/')===base_path);\n    sub_urls.forEach((item) => {\n        var isClicked = base_path === rstrip(item.url, '/');\n        d.push({\n            title: isClicked ? \"‘‘’’<strong><font color='#1E90FF'>\" + item.name + \"</front></strong>\" : item.name,\n            url: isClicked ? base_path + path :  $(rstrip(item.url, '/')+\"#noLoading#\").lazyRule(() => {\n                input = input.split('#')[0];\n                putMyVar(\"baseurl\", input);\n                clearMyVar(\"path\");\n                refreshPage(false);\n                return \"toast://切换成功\"\n            }),\n            col_type: \"scroll_button\"\n        });\n    });\n    d.push({\n        col_type: \"blank_block\"\n    });\n    d.push({\n        title: \"‘‘’’<strong><font color='#1E90FF'>...</front></strong>\",\n        url: $('#noLoading#').lazyRule((path) => {\n            // 返回上级\n            path.pop();\n            putMyVar(\"path\", path.join(\"/\"));\n            if(getItem('clear_change','')){\n                clearMyVar('search','');\n            }\n            refreshPage(false);\n            return \"hiker://empty\"\n        }, path.split(\"/\")),\n        col_type: \"scroll_button\"\n    });\n    d.push({\n        title: \"🏠首页\",\n        col_type: \"scroll_button\",\n        url: $('#noLoading#').lazyRule(() => {\n            putMyVar(\"path\", \"\");\n            if(getItem('clear_refresh','')){\n                clearMyVar('search','');\n            }\n            refreshPage(false);\n            return \"hiker://empty\"\n        }),\n    });\n    let paths = \"\";\n    for (item of path.split(\"/\")) {\n        if (item !== \"\") {\n            paths += \"/\" + item;\n            d.push({\n                title: item,\n                col_type: \"scroll_button\",\n                url: $('#noLoading#').lazyRule((paths) => {\n                    putMyVar(\"path\", paths);\n                    if(getItem('clear_change','')){\n                        clearMyVar('search','');\n                    }\n                    refreshPage(false);\n                    return \"hiker://empty\"\n                }, paths)\n            })\n        }\n    }\n    let sorts = [\"名称\", \"类型\", \"大小\", '时间'];\n    let nsort = getMyVar('sort', '名称');\n    let nsearch = getMyVar('search','');\n    sorts.forEach(item => {\n        let cc = nsort === item + \"-\";\n        let isClicked = nsort === item;\n        d.push({\n            title: cc || isClicked ? \"‘‘’’<strong><font color='#1E90FF'>\" + item + (cc ? \"∧\" : \"∨\") + \"</front></strong>\" : item,\n            col_type: \"flex_button\",\n            url: $('#noLoading#').lazyRule((item, isClicked) => {\n                if (isClicked) {\n                    putMyVar(\"sort\", item + \"-\");\n                } else {\n                    putMyVar(\"sort\", item);\n                    if(getItem('clear_change','')){\n                        clearMyVar('search','');\n                    }\n                }\n                refreshPage(false);\n                return \"hiker://empty\"\n            }, item, isClicked)\n        });\n    });\n    let filterOption = getItem('filterOption','全部');\n    let filter_rules = JSON.parse(readFile('filter_rules.json', 0) || '[]').filter(x=>x.active);\n    let filterSels = ['全部','文件','文件夹'];\n    filterSels = filterSels.concat(filter_rules.map(x=>x.name));\n    let filterSel = filterSels.map(it=>it===filterOption?color(it,'#12b668'):it);\n    filterSel.push(color('自定义过滤','#d96715'));\n    d.push({\n        title:'⏳'+color(filterOption,'#d96715'),\n        col_type:'flex_button',\n        url:$(filterSel,2,'选择要显示的内容').select((filterOption)=>{\n            input = pdfh(input,'body&&Text').replace('““””','');\n            if(input==='自定义过滤'){\n                return 'hiker://page/superSettings#noHistory##noRecordHistory#'\n            }\n            if(filterOption!==input){\n                setItem('filterOption',input);\n                refreshPage(false);\n            }\n            return 'hiker://empty'\n        },filterOption),\n    });\n    d.push({\n        title:nsearch?\"🔍\"+small(color(':'+nsearch,'#12b668')):'🔍',\n        col_type:'flex_button',\n        url:$(nsearch,'输入要搜索的内容。支持正则。如\\\\.js').input((nsearch)=>{\n            if(input!==nsearch){\n                putMyVar('search',input);\n                refreshPage(false);\n            }\n            return 'hiker://empty'\n        },nsearch),\n    });\n    d.push({\n        title: color(\"🕓历史\",\"#d96715\"),\n        url: \"hiker://page/history#noHistory##noRecordHistory#\",\n        col_type: \"flex_button\"\n    });\n    let dirInfo = getFiles(path,filterOption);\n    if(dirInfo.can_upload){\n        d.push({\n            title: color(\"⛅访客\",\"#15ab21\"),\n            url: \"hiker://page/upload#noHistory##noRecordHistory#\",\n            col_type: \"flex_button\"\n        });\n    }\n    // log(nowSub);\n    if(path.split('/').length>1&&nowSub&&nowSub.webdav&&nowSub.webdav.user){\n        let web_dav = nowSub.webdav;\n        // log(webdav);\n        d.push({\n            title: color(\"📂创建\",\"#15ab21\"),\n            url: $('','请输入待创建的文件夹名称').input((user,pwd,base_path,path)=>{\n                if(input){\n                    let url = base_path +'/dav'+path;\n                    log(url);\n                    let webdav = buildWebDav(url, user, pwd);\n                    webdav.makeDir(input);\n                    refreshPage(false);\n                    return \"toast://文件夹\"+input+\"创建完毕\"\n                }\n                return 'hiker://empty'\n            },web_dav.user,web_dav.pwd,base_path,path),\n            col_type: \"flex_button\"\n        });\n        d.push({\n            title: color(\"☁上传\",\"#15ab21\"),\n            url: \"hiker://page/webdavUpload#noHistory##noRecordHistory#\",\n            col_type: \"flex_button\"\n        });\n    }\n    d.push({\n        title:color('🔍全局','#12b668'),\n        col_type:'flex_button',\n        url:'hiker://page/search?page=fypage#noHistory##noRecordHistory#',\n    });\n    d.push({\n        col_type: \"line_blank\"\n    });\n    let clickOption = getItem('clickOption', '打开');\n    let showZimu = getItem('showZimu','开');\n    dirInfo.result.forEach(item => {\n        if (item.url) {\n            d.push({\n                title: item.title,\n                img: item.img,\n                url: item.url,\n                col_type: item.col_type,\n            });\n        } else {\n            // let it_type = item.extra.type;\n            let it_type = item.type;\n            let url = 'hiker://empty';\n            let title = item.extra.name || item.title;\n            let id=item.extra.id;\n            if (it_type === 1) {\n                url = $('#noLoading#').lazyRule((item, title) => {\n                    putMyVar(\"path\", $.rstrip(getMyVar(\"path\", \"\"),'/' )+ \"/\" + title);\n                    if(getItem('clear_change','')){\n                        clearMyVar('search','');\n                    }\n                    refreshPage(false);\n                    return \"hiker://empty\"\n                }, item, title);\n            } else if (it_type === 3 || /\\.m3u8$/.test(title)) { //3是媒体,禁用下载和跳转\n                url = getLink(title, null,'打开', showZimu,'#isVideo=true#');\n            } else if (it_type === 6) {\n                url = getLink(title, null,'打开', showZimu,\"#.jpg\");\n            } else { //跟随系统预览和下载\n                url = getLink(title, null,clickOption,showZimu);\n            }\n            d.push({\n                title: item.title,\n                img: item.img,\n                url: url,\n                col_type: item.col_type,\n                extra: {\n                    id:id,\n                    type: it_type,\n                    title: title,\n                }\n            });\n        }\n    });\n    setResult(d);\n}","search_url":"","group":"①网盘","searchFind":"","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"$.require('hiker://page/libs?rule=道长仓库Pro');\nif (!(getAppVersion() < 3204)) {\n    const {getU}=$.require('hiker://page/api');\n    const {isOffice}=$.require('hiker://page/fileType');\n    const {similar,removeExt,saveHistory,renderText}=$.require('hiker://page/utils');\n    $.extend({\n        get_sub_urls() {\n            let sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\n            if (sub_urls.length < 1) {\n                sub_urls = this.sub_urls;\n            }\n            return sub_urls\n        },\n        getU:getU,\n        isOffice:isOffice,\n        similar:similar,\n        removeExt:removeExt,\n        saveHistory:saveHistory,\n        renderText:renderText,\n        lstrip(string,char){//去除左边指定字符\n            return string.replace(new RegExp('^\\\\'+char+'+', 'g'), '');\n        },\n        rstrip(string,char){//去除右边指定字符\n            return string.replace(new RegExp('\\\\'+char+'+$', 'g'), '');\n        },\n        strip(string,char){//去除两边指定字符\n            return string.replace(new RegExp('^\\\\'+char+'+|\\\\'+char+'+$', 'g'), '');\n        },\n        getTimeOut(){\n            return Number(getItem('timeout',this.timeout+''))\n        },\n        timeout:3500,\n        sub_urls: [{\n            name: '小棉袄仓库',\n            url: 'http://pan.haikuoshijie.cn/',\n        }, {\n            name: '嗨翻',\n            url: 'https://pan.hikerfans.com/',\n        }, {\n            name: '非盘',\n            url: 'http://www.feifwp.top/',\n        }, {\n            name: '姬路白雪',\n            url: 'https://pan.jlbx.xyz/',\n        }, {\n            name: '听闻',\n            url: 'https://wangpan.sangxuesheng.com/',\n        }, {\n            name: 'Joe自用',\n            url: 'http://joegu.tk/',\n        }],\n    });\n}","pages":"[{\"col_type\":\"movie_3\",\"name\":\"代码\",\"path\":\"api\",\"rule\":\"function getFiles(path,filterOption) {\\n    let sort = getMyVar('sort', '名称');\\n    let search = getMyVar('search','');\\n    filterOption = filterOption||'全部';\\n    let result = [];\\n    let can_upload = false;\\n    let sub_urls = $.get_sub_urls();\\n    let baseurl = $.rstrip(getMyVar(\\\"baseurl\\\", sub_urls[0].url), '/');\\n    try {\\n        let password = sub_urls.find(x => x.url.includes(baseurl)).password || {};\\n        var res = JSON.parse(post(baseurl + \\\"/api/public/path\\\", {\\n            headers: {\\n                \\\"Content-Type\\\": \\\"application/json\\\"\\n            },\\n            body: JSON.stringify({\\n                path: path,\\n                password: password[path] || '',\\n            }),\\n            timeout: $.getTimeOut(),\\n        }));\\n    } catch (e) {\\n        log('获取文件列表失败:'+e.message);\\n        return {result:result,can_upload: can_upload}\\n    }\\n    const icon_dict = $.require('hiker://page/fileType').get_icon_dict();\\n    const icons = $.require('hiker://page/fileType').get_icons();\\n    const {\\n        bytesToSize,\\n        small,\\n        color,\\n        sorts,\\n        getTime\\n    } = $.require('hiker://page/utils');\\n    let showDetail = getItem('showDetail', '开') === '开';\\n    try {\\n        let msg = res.message.trim();\\n        if (msg === \\\"success\\\") {\\n            let list = res.data.files;\\n            storage0.putMyVar(\\\"now_files\\\",list);//把当前路径的文件信息储存起来,后面获取匹配字幕要用\\n            can_upload = res.data.meta.upload;\\n            if(filterOption==='文件'){\\n                list = list.filter(x=>x.type!==1)\\n            }else if(filterOption==='文件夹'){\\n                list = list.filter(x=>x.type===1)\\n            }else if(filterOption!=='全部'){\\n                let filter_rules = JSON.parse(readFile('filter_rules.json', 0) || '[]');\\n                let filter_rule = filter_rules.find(x=>x.name===filterOption);\\n                if(filter_rule&&filter_rule.rule){\\n                    if(filter_rule.rule.startsWith('!')){\\n                        list = list.filter(x=>!(new RegExp(filter_rule.rule.slice(1))).test(x.name));\\n                    }else{\\n                        list = list.filter(x=>(new RegExp(filter_rule.rule)).test(x.name));\\n                    }\\n                }\\n            }\\n\\n            if(search){\\n                list = list.filter(x=>(new RegExp(search)).test(x.name))\\n            }\\n            if (['大小', '类型', '名称', '时间'].includes(sort)) {\\n                sorts(list, sort);\\n            } else {\\n                sorts(list, sort.replace('-', '')).reverse();\\n            }\\n            list.forEach(item => {\\n                let ext = item.name.split('.').slice(-1)[0];\\n                let img = item.type === 1 ? icon_dict['1'] : (icons[ext] || icon_dict[item.type + '']);\\n                result.push({\\n                    title: item.name,\\n                    img: img,\\n                    type: item.type,\\n                    col_type: \\\"avatar\\\",\\n                    extra: {\\n                        id:baseurl+path+item.name,\\n                        type: item.type,\\n                        name:item.name,\\n                    }\\n                });\\n                if (showDetail) {\\n                    let date = getTime(item);\\n                    let size = item.size_str;\\n                    if (!size || size === \\\"\\\") {\\n                        size = item.size === 0 ? \\\"/\\\" : bytesToSize(item.size)\\n                    }\\n                    if (size && size !== \\\"\\\" && size !== 0) {\\n                        size = \\\"&nbsp;&nbsp;&nbsp;\\\" + size;\\n                    } else {\\n                        size = \\\"\\\";\\n                    }\\n                    let desc = date + size;\\n                    result.push({\\n                        type: item.type,\\n                        title: small(color(desc, '#aaaaaa')),\\n                        col_type: \\\"text_1\\\",\\n                        extra: {\\n                            id:baseurl+path+item.name,\\n                            type: item.type,\\n                            name: item.name,\\n                        }\\n                    })\\n                }\\n            });\\n        } else if (msg === \\\"Wrong password\\\") {\\n            result.push({\\n                title: \\\"点我输入密码\\\",\\n                col_type: \\\"text_1\\\",\\n                url: $(getMyVar(\\\"password\\\", \\\"\\\")).input((path, baseurl) => {\\n                    let sub_urls = $.get_sub_urls();\\n                    let idex = sub_urls.findIndex(x => x.url.includes(baseurl));\\n                    if (idex > -1) {\\n                        if (!sub_urls[idex].password) {\\n                            sub_urls[idex].password = {}\\n                        }\\n                        sub_urls[idex].password[path] = input;\\n                        saveFile('sub_urls.json', JSON.stringify(sub_urls), 0);\\n                        putMyVar(\\\"password\\\", input);\\n                        refreshPage(false);\\n                        return \\\"hiker://empty\\\"\\n                    } else {\\n                        return 'toast://未获取到链接为:' + baseurl + '的索引'\\n                    }\\n\\n                }, path, baseurl),\\n            })\\n        }\\n    } catch (e) {\\n        log('发生了错误:' + e.message);\\n        throw e\\n    }\\n    return {result:result,can_upload:can_upload}\\n}\\n\\nfunction getLink(input, path,clickOption,showZimu, ext,reload) {\\n    clickOption = clickOption || '打开';\\n    showZimu = showZimu || '开';\\n    ext = ext || false;\\n    reload = reload||false;\\n    path = (path||getMyVar(\\\"path\\\", \\\"\\\")) + \\\"/\\\";\\n    let sub_urls = $.get_sub_urls();\\n    let baseurl = $.rstrip(getMyVar(\\\"baseurl\\\", sub_urls[0].url), '/');\\n    let npath = path + input;\\n    let homeUrl='hiker://empty';\\n    if(/菜单/.test(clickOption)){\\n        homeUrl+='#noLoading#'\\n    }\\n    return $(homeUrl).lazyRule((baseurl, npath, path,clickOption,showZimu,input, ext,reload) => {\\n        const {clickLazy} = $.require('hiker://page/clickFunction');\\n        return clickLazy(baseurl, npath, path,clickOption,showZimu,input, ext,reload)\\n    }, baseurl, npath, path,clickOption,showZimu, input,ext,reload);\\n    // log('当前文件路径:'+npath);\\n}\\n\\nfunction getU(baseurl,npath,ext){\\n    try {\\n        let sub_urls = $.get_sub_urls();\\n        let password = sub_urls.find(x => x.url.includes(baseurl)).password || {};\\n        let res = JSON.parse(post(baseurl + \\\"/api/public/path\\\", {\\n            headers: {\\n                \\\"Content-Type\\\": \\\"application/json\\\"\\n            },\\n            body: JSON.stringify({\\n                path: npath,\\n                password: password[npath] || '',\\n            }),\\n            timeout: $.getTimeOut(),\\n        }));\\n        if (res.data) {\\n            let u = res.data.files[0].url;\\n            u = !/^http/.test(u) ? baseurl.split('//')[0] + u : u;\\n            if (ext) {\\n                u = u + ext;\\n            }\\n            return u\\n        }else{\\n            return \\\"toast://\\\" + res.message\\n        }\\n    }catch (e) {\\n        return 'toast://文件' + npath + '信息获取发生错误:' + e.message;\\n    }\\n}\\n\\n$.exports.getFiles = getFiles;\\n$.exports.getLink = getLink;\\n$.exports.getU = getU;\"},{\"col_type\":\"movie_3\",\"name\":\"设置\",\"path\":\"settings\",\"rule\":\"js:\\nlet d = [];\\nsetPageTitle('Alist|设置');\\nconst {color,small} = $.require('hiker://page/utils');\\nlet timeout=$.getTimeOut();\\naddListener('onClose', $.toString(() => {\\n    refreshPage(false); //刷新\\n}));\\nlet sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\\nd.push({\\n    title: '基础设置 ①初始化',\\n    desc: `默认添加一些远程的alist地址方便订阅\\\\n当前共计${color(sub_urls.length,'#d96715')}条Alist订阅链接`,\\n    col_type: 'text_1',\\n    url: $('确认初始化自带的远程地址吗?将丢失自定义的内容').confirm(() => {\\n        saveFile(\\\"sub_urls.json\\\", JSON.stringify($.sub_urls), 0);\\n        refreshPage(false);\\n        return 'toast://已初始化'\\n    }),\\n});\\n\\nlet newVersion;\\nlet myVersion = MY_PARAMS.version||999;\\ntry {\\n    newVersion = JSON.parse(fetch(\\\"http://hiker.nokia.press/hikerule/dev/getbyid?id=5153\\\",{timeout:timeout})).result.ver\\n} catch (e) {\\n    toast(\\\"道长仓库抽风了，本次未检测到新版信息\\\");\\n    newVersion = myVersion;\\n}\\nlet isUpdate = Number(newVersion) <= Number(myVersion);\\nlet isVer = Number(newVersion) === Number(myVersion);\\nif(!isUpdate||!isVer){\\n    log('有新版本:'+newVersion+',当前:'+myVersion);\\n}\\nd.push({\\n    title: isUpdate ? \\\"已是最新版\\\" : \\\"🆙新版本\\\",\\n    url: \\\"rule://5rW36ZiU6KeG55WM6aaW6aG16aKR6YGT6KeE5YiZ44CQQWxpc3TjgJHvv6Vob21lX3J1bGVfdXJs77+laHR0cDovL2hpa2VyLm5va2lhLnByZXNzL2hpa2VydWxlL3J1bGVsaXN0Lmpzb24/aWQ9NTE1Mw==\\\",\\n    col_type: \\\"text_2\\\"\\n});\\n\\nd.push({\\n    title: \\\"超时毫秒:\\\" + timeout,\\n    url: $(timeout,'请输入全局接口超时毫秒时间').input(() => {\\n        if(!Number(input)){\\n            return 'toast://超时毫秒数必须是整数！'\\n        }\\n        setItem(\\\"timeout\\\",Number(input)+'');\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    }),\\n    col_type: \\\"text_2\\\"\\n});\\nlet clickOption = getItem('clickOption','打开');\\nlet showDetail = getItem('showDetail','开');\\nlet showZimu = getItem('showZimu','开');\\nlet save_mode = getItem(\\\"save_mode\\\", \\\"单个\\\");\\nlet clickSel = ['打开','下载','菜单'].map(it=>it===clickOption?color(it,'#12b668'):it);\\nd.push({\\n    title:'点击操作:'+color(clickOption,'#d96715'),\\n    col_type:'text_2',\\n    url:$(clickSel,2,'请选择点击文件执行操作').select((clickOption)=>{\\n        input = pdfh(input,'body&&Text').replace('““””','');\\n        if(clickOption!==input){\\n            setItem('clickOption',input);\\n            refreshPage(false);\\n        }\\n        return 'hiker://empty'\\n    },clickOption),\\n});\\nd.push({\\n    title: \\\"显示文件详情:\\\" + color(showDetail,'#d96715'),\\n    url: $('#noLoading#').lazyRule((showDetail) => {\\n        setItem(\\\"showDetail\\\", showDetail === \\\"开\\\" ? \\\"关\\\" : \\\"开\\\");\\n        refreshPage(false);\\n        return \\\"toast://切换成功\\\"\\n    },showDetail),\\n    col_type: \\\"text_2\\\"\\n});\\nd.push({\\n    title: \\\"外挂字幕开关:\\\" + color(showZimu,'#d96715'),\\n    url: $('#noLoading#').lazyRule((showZimu) => {\\n        setItem(\\\"showZimu\\\", showZimu === \\\"开\\\" ? \\\"关\\\" : \\\"开\\\");\\n        refreshPage(false);\\n        return \\\"toast://切换成功\\\"\\n    },showZimu),\\n    col_type: \\\"text_2\\\"\\n});\\nd.push({\\n    title: color('更多高级设置','#d96715'),\\n    url: 'hiker://page/superSettings#noHistory##noRecordHistory#',\\n    col_type: \\\"text_2\\\"\\n});\\n\\nif(save_mode!=='批量') {\\n    d.push({\\n        title: '名称',\\n        desc: '备注...',\\n        col_type: 'input',\\n        url: $.toString(() => {\\n        }),\\n        extra: {\\n            defaultValue: getMyVar('alist_name', ''),\\n            onChange: 'putMyVar(\\\"alist_name\\\",input)'\\n        }\\n    });\\n}\\nd.push({\\n    title: '链接',\\n    desc: 'alist服务的首页链接',\\n    col_type: 'input',\\n    url: $.toString(() => {\\n\\n    }),\\n    extra: {\\n        defaultValue: getMyVar('alist_url', ''),\\n        onChange: 'putMyVar(\\\"alist_url\\\",input)',\\n        height: 2,\\n        highlight: save_mode==='批量',\\n        type: \\\"textarea\\\",\\n    }\\n});\\n\\nfunction saveSub(code) {\\n    let a_name = getMyVar('alist_name', '').trim();\\n    let a_url = code||getMyVar('alist_url', '').trim();\\n    let save_mode = code?'批量':getItem(\\\"save_mode\\\", \\\"单个\\\");\\n    if(save_mode === '单个') {\\n        if (!a_name) {\\n            return 'toast://名称必填!'\\n        }\\n        if (!a_url || !/^http/.test(a_url)) {\\n            return 'toast://链接不合法!'\\n        }\\n        let sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\\n        let idex = sub_urls.findIndex(it => $.rstrip(it.url,'/') === $.rstrip(a_name,'/'));\\n        if (idex > -1) {\\n            if (sub_urls[idex].url !== a_url||sub_urls[idex].name !== a_name) {\\n                sub_urls[idex].url = a_url;\\n                sub_urls[idex].name = a_name;\\n                return $('检测到本地有重复的' + a_name + ',是否覆盖?').confirm((sub_urls) => {\\n                    saveFile('sub_urls.json', JSON.stringify(sub_urls), 0);\\n                    refreshPage(false);\\n                    return 'toast://已保存'\\n                }, sub_urls)\\n            } else {\\n                return 'toast://没有操作'\\n            }\\n        } else {\\n            sub_urls.unshift({\\n                name: a_name,\\n                url: a_url,\\n            });\\n            saveFile('sub_urls.json', JSON.stringify(sub_urls), 0);\\n            refreshPage(false);\\n            return 'toast://已保存'\\n        }\\n    }else if(save_mode === '批量'){\\n        let add_data = [];\\n        try {\\n            add_data = eval(a_url);\\n            JSON.stringify(add_data);\\n        }catch (e) {\\n            return 'toast://批量添加格式有误,请参考预处理的json格式。名称重复会直接覆盖保存'\\n        }\\n        let sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\\n        let sub_cnt = sub_urls.length;\\n        let new_add_data = []; // 自动去重\\n        add_data = add_data.filter(x=>x.name&&x.url);\\n        if(!Array.isArray(add_data) || add_data.length < 1){\\n            return 'toast://导入的东西看起来没对呢!'\\n        }\\n        add_data.forEach((it)=>{\\n            let idex = new_add_data.findIndex(x=>$.rstrip(x.url) === $.rstrip(it.url));\\n            idex>-1?new_add_data[idex] = it:new_add_data.unshift(it);\\n        });\\n        // log('准备新增列表:');\\n        // log(new_add_data);\\n        new_add_data.forEach((it)=>{\\n            let idex = sub_urls.findIndex(x=>$.rstrip(x.url) === $.rstrip(it.url));\\n            idex>-1?sub_urls[idex] = Object.assign(sub_urls[idex],it):sub_urls.unshift(it);\\n        });\\n        let new_cnt = sub_urls.length - sub_cnt;\\n        if(new_cnt > 0 ){\\n            saveFile('sub_urls.json', JSON.stringify(sub_urls), 0);\\n            refreshPage(false);\\n            return 'toast://已保存'+new_cnt+'条记录'\\n        }else{\\n            return 'toast://没有待保存的内容'\\n        }\\n    }\\n}\\nlet opCol = 'scroll_button';\\nd.push({\\n    title: save_mode,\\n    col_type: opCol,\\n    url: $('#noLoading#').lazyRule((save_mode) => {\\n        let next_mode = save_mode === '单个'?'批量':'单个';\\n        setItem('save_mode',next_mode);\\n        refreshPage(false);\\n        return 'toast://已切换编辑保存模式为:'+next_mode\\n    },save_mode)\\n});\\nd.push({\\n    title: '保存',\\n    col_type: opCol,\\n    url: $('#noLoading#').lazyRule((saveSub) => {\\n        return saveSub();\\n    }, saveSub)\\n});\\nd.push({\\n    title: '保存并新增',\\n    col_type: opCol,\\n    url: $('#noLoading#').lazyRule((saveSub) => {\\n        let tips = saveSub();\\n        clearMyVar(\\\"alist_name\\\");\\n        clearMyVar(\\\"alist_url\\\");\\n        refreshPage(false);\\n        return tips\\n    }, saveSub)\\n});\\nd.push({\\n    title: '导入',\\n    col_type: opCol,\\n    url: $(\\\"{{clipboard}}\\\", \\\"自动识别剪切板内容或手动输入口令\\\").input((saveSub)=>{\\n        input=input.trim();\\n        let code=input.split('\\\\n')[1];\\n        if(!/Alist订阅编码分享/.test(input)){\\n            return 'toast://导入口令有误'\\n        }\\n        try {\\n            code = base64Decode(code);\\n            log(code);\\n        }catch (e) {\\n            return 'toast://发生错误:\\\\n'+e.message;\\n        }\\n        return saveSub(code);\\n    },saveSub)\\n});\\nd.push({\\n    title: '全编码分享',\\n    col_type: opCol,\\n    url: $('#noLoading#').lazyRule(() => {\\n        let sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\\n        confirm({title:'温馨提示',\\n            content:'将一键分享本地的所有订阅,是否将密码一起分享？',\\n            confirm:$.toString((sub_urls)=>{\\n                let code = 'Alist订阅编码分享 '+sub_urls[0].name+'等'+sub_urls.length+'条'+':\\\\n'+base64Encode(JSON.stringify(sub_urls));\\n                return 'copy://'+code\\n            },sub_urls),\\n            cancel:$.toString((sub_urls)=>{\\n                sub_urls = sub_urls.map((it)=>{return {name:it.name,url:it.url}});\\n                let code = 'Alist订阅编码分享 '+sub_urls[0].name+'等'+sub_urls.length+'条'+':\\\\n'+base64Encode(JSON.stringify(sub_urls));\\n                return 'copy://'+code\\n            },sub_urls)});\\n        return 'hiker://empty'\\n    }),\\n});\\nd.push({\\n    title: '全文件分享',\\n    col_type: opCol,\\n    url: $('#noLoading#').lazyRule(() => {\\n        let sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\\n        let sharePath = 'hiker://files/cache/alist订阅.txt';\\n        confirm({title:'温馨提示',\\n            content:'将一键分享本地的所有订阅,是否将密码一起分享？',\\n            confirm:$.toString((sub_urls,sharePath)=>{\\n                writeFile(sharePath,JSON.stringify(sub_urls));\\n                return 'share://'+sharePath\\n            },sub_urls,sharePath),\\n            cancel:$.toString((sub_urls,sharePath)=>{\\n                sub_urls = sub_urls.map((it)=>{return {name:it.name,url:it.url}});\\n                // log(sub_urls);\\n                writeFile(sharePath,JSON.stringify(sub_urls));\\n                return 'share://'+sharePath\\n            },sub_urls,sharePath)});\\n        return 'hiker://empty'\\n    }),\\n});\\nlet subPath = `hiker://files/rules/files/${MY_RULE.title}/sub_urls.json`;\\nlet cachePath = 'hiker://files/cache/sub_urls.json';\\nd.push({\\n    title: '编辑JSON',\\n    col_type: opCol,\\n    url: $(['接着上次编辑','重新加载编辑'],1,'请选择如何编辑').select((subPath,cachePath) => {\\n        function sub_edit(subPath,cachePath,reload){\\n            reload = reload||false;\\n            if(!fileExist(cachePath)||reload){\\n                writeFile(cachePath,readFile('sub_urls.json', 0) || '[]');\\n            }\\n            let status = fetch('hiker://home@JSON编辑器');\\n            let hasJsonEditor = (status && status !== 'null');\\n            if(!hasJsonEditor){\\n                return 'editFile://'+cachePath;\\n            }else{\\n                return 'hiker://page/interface#noHistory##noRecordHistory#?rule=JSON编辑器&Json='+base64Encode(cachePath);\\n            }\\n        }\\n        if(input==='接着上次编辑'){\\n            return sub_edit(subPath,cachePath);\\n        }else if(input==='重新加载编辑'){\\n            return sub_edit(subPath,cachePath,true);\\n        }else{\\n            return 'hiker://empty'\\n        }\\n    },subPath,cachePath)\\n});\\nd.push({\\n    title:'保存本地',\\n    col_type:opCol,\\n    url:$('将JSON编辑的缓存结果保存为本地订阅?').confirm((cachePath)=>{\\n        let code = JSON.parse(fetch(cachePath));\\n        code = code.filter(x=>x.name && x.url);\\n        saveFile('sub_urls.json', JSON.stringify(code), 0);\\n        refreshPage(false);\\n        return 'toast://保存完毕'\\n    },cachePath)\\n});\\n\\nsub_urls.forEach((it, idex) => {\\n    d.push({\\n        title: it.name,\\n        desc: it.url,\\n        url: $(['置顶','删除', '修改名称','修改地址','快捷输入','密码管理','分享(含密码)','分享(无密码)'], 2, '请选择1个操作').select((it, sub_urls, idex) => {\\n            if (input === '置顶') {\\n                sub_urls.splice(idex, 1);\\n                sub_urls.unshift(it);\\n                if (getMyVar(\\\"baseurl\\\", \\\"\\\") !== it.url) {\\n                    putMyVar(\\\"baseurl\\\", it.url);\\n                    clearMyVar(\\\"path\\\");\\n                }\\n            }\\n            else if (input === '删除') {\\n                sub_urls.splice(idex, 1);\\n                if (getMyVar(\\\"baseurl\\\", \\\"\\\") === it.url) {\\n                    putMyVar(\\\"baseurl\\\", sub_urls[0].url);\\n                    clearMyVar(\\\"path\\\");\\n                }\\n            }else if (input === '修改名称') {\\n                return $(it.name,'给此订阅改个名字吧').input((sub_urls,idex)=>{\\n                    input = input.trim();\\n                    if(input){\\n                        sub_urls[idex].name = input;\\n                        saveFile('sub_urls.json', JSON.stringify(sub_urls), 0);\\n                        refreshPage(false);\\n                        return 'toast://修改成功'\\n                    }else{\\n                        return 'toast://修改失败'\\n                    }\\n                },sub_urls,idex);\\n            }else if (input === '修改地址') {\\n                return $(it.url,'给此订阅改个地址吧').input((sub_urls,idex)=>{\\n                    input = input.trim();\\n                    if(input&&/^http/.test(input)){\\n                        sub_urls[idex].url = input;\\n                        saveFile('sub_urls.json', JSON.stringify(sub_urls), 0);\\n                        refreshPage(false);\\n                        return 'toast://修改成功'\\n                    }else{\\n                        return 'toast://修改失败'\\n                    }\\n                },sub_urls,idex);\\n            } else if (input === '快捷输入') {\\n                putMyVar(\\\"alist_name\\\",it.name);\\n                putMyVar(\\\"alist_url\\\",it.url);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }else if (input === '密码管理') {\\n                return 'hiker://page/passwordManage?idex='+idex\\n            }else if (/分享/.test(input)) {\\n                if(input.includes('无密码')){\\n                    delete it.password;\\n                }\\n                let code = 'Alist订阅编码分享 '+it.name+':\\\\n'+base64Encode(JSON.stringify([it]));\\n                return 'copy://'+code\\n            }\\n            saveFile('sub_urls.json', JSON.stringify(sub_urls), 0);\\n            refreshPage(false);\\n            return 'toast://已' + input\\n        }, it, sub_urls, idex),\\n        col_type: \\\"text_1\\\",\\n        extra:{\\n            idex:idex+''\\n        }\\n    })\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"文件类型\",\"path\":\"fileType\",\"rule\":\"const type_dict = {\\n 0: 'zip|exe|apk|crx',\\n 1: '文件夹',\\n 2: 'pdf|xls|doc',\\n 3: 'mp4|mkv|mp3|flv',\\n 4: '?',\\n 5: 'md|txt|json|js',\\n 6: 'gif|jpg|hiec',\\n}\\n\\nfunction get_icon_dict() {\\n let root = 'https://gitcode.net/qq_32394351/dr/-/raw/master/img/文件类型/';\\n return {\\n  0: root + 'zip.svg',\\n  1: root + '文件夹.svg',\\n  2: root + '文件.svg',\\n  3: root + 'mp4.svg',\\n  4: root + '文件.svg',\\n  5: root + '文件.svg',\\n  6: root + 'gif.svg',\\n }\\n}\\nlet iconStyles = [{\\n name:'默认',\\n url:'https://gitcode.net/qq_32394351/dr/-/raw/master/img/文件类型/'\\n},{\\n name:'蓝莓',\\n url:'https://gitcode.net/qq_32394351/dr/-/raw/master/img/文件类型2/'\\n}];\\nlet iconStyle = getItem('iconStyle','默认');\\nlet nowStyle = iconStyles.find(x=>x.name===iconStyle);\\nlet iconRoot = nowStyle?nowStyle.url:iconStyles[0].url;\\n\\nfunction get_icons() {\\n // let root = 'https://gitcode.net/qq_32394351/dr/-/raw/master/img/文件类型/';\\n let root = iconRoot;\\n let files = 'ai|apk|avi|css|dmg|exe|flv|gif|hiker|html|iso|jpg|js|json|log|mov|mp3|mp4|otf|php|png|ppt|psd|table|txt|wav|xls|zip|文件|文件夹'.split('|');\\n let obj = {};\\n files.forEach((it) => {\\n  obj[it] = root + it + '.svg';\\n });\\n return obj\\n}\\n\\nfunction isOffice(url){\\n let str='doc|docx|docm|dotm|dotx|xlsx|xlsb|xls|xlsm|pptx|ppsx|ppt|pps|pptm|potm|ppam|potx|ppsm'.split('|').map(it=>'\\\\\\\\.'+it+'$').join('|');\\n let mc=new RegExp(str);\\n return mc.test(url);\\n}\\n\\n$.exports.type_dict = type_dict;\\n$.exports.get_icon_dict = get_icon_dict;\\n$.exports.get_icons = get_icons;\\n$.exports.isOffice = isOffice;\\n$.exports.iconStyles = iconStyles;\"},{\"col_type\":\"movie_3\",\"name\":\"工具\",\"path\":\"utils\",\"rule\":\"function bytesToSize(size) {\\n    if (size < 0.1 * 1024) {\\n        //小于0.1KB，则转化成B\\n        size = size.toFixed(2) + \\\"B\\\";\\n    } else if (size < 0.1 * 1024 * 1024) {\\n        // 小于0.1MB，则转化成KB\\n        size = (size / 1024).toFixed(2) + \\\"KB\\\";\\n    } else if (size < 0.1 * 1024 * 1024 * 1024) {\\n        // 小于0.1GB，则转化成MB\\n        size = (size / (1024 * 1024)).toFixed(2) + \\\"MB\\\";\\n    } else {\\n        // 其他转化成GB\\n        size = (size / (1024 * 1024 * 1024)).toFixed(2) + \\\"GB\\\";\\n    }\\n    // 转成字符串\\n    let sizeStr = size + \\\"\\\",\\n        // 获取小数点处的索引\\n        index = sizeStr.indexOf(\\\".\\\"),\\n        // 获取小数点后两位的值\\n        dou = sizeStr.substr(index + 1, 2);\\n    // 判断后两位是否为00，如果是则删除00\\n    if (dou === \\\"00\\\") return sizeStr.substring(0, index) + sizeStr.substr(index + 3, 2);\\n    return size;\\n}\\n$.exports.bytesToSize = bytesToSize;\\n$.exports.color = function(text, color) {\\n    text += \\\"\\\";\\n    if (text.indexOf(\\\"““””\\\") === 0) {\\n        text.replace(\\\"““””\\\", \\\"\\\");\\n    }\\n    return \\\"““””<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n}\\n\\n$.exports.sleep = function(timeout) {\\n    java.lang.Thread.sleep(timeout);\\n}\\n\\nfunction htmlTag(tag, text) {\\n    text += \\\"\\\";\\n    if (text.indexOf(\\\"““””\\\") === 0) {\\n        text.replace(\\\"““””\\\", \\\"\\\");\\n    }\\n    return \\\"““””\\\" + \\\"<\\\" + tag + \\\">\\\" + text + \\\"</\\\" + tag + \\\">\\\";\\n\\n}\\n$.exports.htmlTag = htmlTag;\\n$.exports.small = function(text) {\\n    return htmlTag(\\\"small\\\", text);\\n}\\n\\nfunction getTime(file,isStandard) {\\n    isStandard = isStandard||false;\\n    let tTime = file.updated_at || file.time_str || \\\"\\\";\\n    tTime = tTime.split(\\\"T\\\");\\n    let date = tTime[0];\\n    if(isStandard){\\n        date = date.replace(/-/g,\\\"/\\\");\\n    }\\n    tTime = tTime[1].split(/Z|\\\\./);\\n    date += \\\" \\\" + tTime[0];\\n    return date;\\n}\\nfunction getTimeInt(timeStr){\\n    return (new Date(timeStr)).getTime()\\n}\\n$.exports.getTime = getTime;\\n\\nlet chnNumChar = {\\n    零: 0,\\n    一: 1,\\n    二: 2,\\n    三: 3,\\n    四: 4,\\n    五: 5,\\n    六: 6,\\n    七: 7,\\n    八: 8,\\n    九: 9\\n};\\n\\nlet chnNameValue = {\\n    十: {\\n        value: 10,\\n        secUnit: false\\n    },\\n    百: {\\n        value: 100,\\n        secUnit: false\\n    },\\n    千: {\\n        value: 1000,\\n        secUnit: false\\n    },\\n    万: {\\n        value: 10000,\\n        secUnit: true\\n    },\\n    亿: {\\n        value: 100000000,\\n        secUnit: true\\n    }\\n}\\n\\nfunction ChineseToNumber(chnStr) {\\n    let rtn = 0;\\n    let section = 0;\\n    let number = 0;\\n    let secUnit = false;\\n    let str = chnStr.split('');\\n\\n    for (let i = 0; i < str.length; i++) {\\n        let num = chnNumChar[str[i]];\\n        if (typeof num !== 'undefined') {\\n            number = num;\\n            if (i === str.length - 1) {\\n                section += number;\\n            }\\n        } else {\\n            let unit = chnNameValue[str[i]].value;\\n            secUnit = chnNameValue[str[i]].secUnit;\\n            if (secUnit) {\\n                section = (section + number) * unit;\\n                rtn += section;\\n                section = 0;\\n            } else {\\n                section += (number * unit);\\n            }\\n            number = 0;\\n        }\\n    }\\n    return rtn + section;\\n}\\n\\nfunction nameCompare(a, b) {\\n    if (a == null || b == null)\\n        return a == null ? b == null ? 0 : -1 : 1;\\n\\n    a = a.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return ChineseToNumber(p1);\\n    })\\n    b = b.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return ChineseToNumber(p1);\\n    })\\n\\n    let NUMBERS = java.util.regex.Pattern.compile(\\\"(?<=\\\\\\\\D)(?=\\\\\\\\d)|(?<=\\\\\\\\d)(?=\\\\\\\\D)\\\")\\n    let split1 = NUMBERS.split(new java.lang.String(a));\\n    let split2 = NUMBERS.split(new java.lang.String(b));\\n\\n    for (let i = 0; i < Math.min(split1.length, split2.length); i++) {\\n        let c1 = split1[i].charCodeAt(0);\\n        let c2 = split2[i].charCodeAt(0);\\n        let cmp = 0;\\n        let zeroCharCode = '0'.charCodeAt(0);\\n        let nineCharCode = '9'.charCodeAt(0);\\n\\n        if (c1 >= zeroCharCode && c1 <= nineCharCode && c2 >= zeroCharCode && c2 <= nineCharCode) {\\n            cmp = new java.math.BigInteger(split1[i]).compareTo(new java.math.BigInteger(split2[i]));\\n        }\\n\\n        if (cmp === 0) {\\n            let regex = /[a-zA-Z0-9]/\\n            let s1 = String(split1[i])\\n            let s2 = String(split2[i])\\n            if (regex.test(s1) || regex.test(s2)) {\\n                cmp = new java.lang.String(split1[i]).compareTo(new java.lang.String(split2[i]));\\n                // cmp = s1.localeCompare(s2, 'en')\\n            } else {\\n                cmp = s1.localeCompare(s2, 'zh')\\n            }\\n        }\\n\\n        if (cmp !== 0) {\\n            return cmp;\\n        }\\n    }\\n    let lengthCmp = split1.length - split2.length;\\n    // if (lengthCmp !== 0) lengthCmp = lengthCmp > 0 ? -1 : 1;\\n    return lengthCmp;\\n}\\n\\n$.exports.sorts = function(list, sort) {\\n    if (sort === \\\"类型\\\") {\\n        // log(\\\"类型排序\\\");\\n        list.sort(function(a, b) {\\n            return a.type - b.type\\n        });\\n    } else if (sort === \\\"名称\\\") {\\n        // log(\\\"名称排序\\\");\\n        // list.sort(function(a, b) {\\n        //     return a.name.localeCompare(b.name, \\\"zh\\\")\\n        // });\\n        list.sort(function(a, b) {\\n            return nameCompare(a.name||a.title, b.name||b.title);\\n        });\\n    } else if (sort === \\\"大小\\\") {\\n        // log(\\\"大小排序\\\");\\n        list.sort(function(a, b) {\\n            return (a.size || Number(a.size_str) || 0) - (b.size || Number(b.size_str) || 0);\\n        });\\n    }else if (sort === \\\"时间\\\") {\\n        // log(\\\"时间排序\\\");\\n        list.sort(function(a, b) {\\n            return getTimeInt(getTime(a,true)) - getTimeInt(getTime(b,true))\\n        });\\n    }\\n    return list\\n}\\n\\nfunction similar(s, t, f) {//判断两个字符串之间的相似度\\n    if (!s || !t) {\\n        return 0\\n    }\\n    if(s === t){\\n        return 100;\\n    }\\n    var l = s.length > t.length ? s.length : t.length\\n    var n = s.length\\n    var m = t.length\\n    var d = []\\n    f = f || 2\\n    var min = function (a, b, c) {\\n        return a < b ? (a < c ? a : c) : (b < c ? b : c)\\n    }\\n    var i, j, si, tj, cost\\n    if (n === 0) return m\\n    if (m === 0) return n\\n    for (i = 0; i <= n; i++) {\\n        d[i] = []\\n        d[i][0] = i\\n    }\\n    for (j = 0; j <= m; j++) {\\n        d[0][j] = j\\n    }\\n    for (i = 1; i <= n; i++) {\\n        si = s.charAt(i - 1)\\n        for (j = 1; j <= m; j++) {\\n            tj = t.charAt(j - 1)\\n            if (si === tj) {\\n                cost = 0\\n            } else {\\n                cost = 1\\n            }\\n            d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost)\\n        }\\n    }\\n    let res = (1 - d[n][m] / l) *100\\n    return res.toFixed(f)\\n}\\n\\n$.exports.similar = similar;\\n$.exports.removeExt = function (file){\\n    return file.split('.').slice(0,-1).join('.')\\n};\\n\\n$.exports.saveHistory = function (id,data){\\n    let view_history = JSON.parse(readFile('view_history.json', 0) || '[]');\\n    let idex = view_history.findIndex(x=>x.extra&&x.extra.id===id);\\n    if(idex > -1){\\n        view_history.splice(idex,1);\\n    }\\n    view_history.unshift(data);\\n    saveFile('view_history.json',JSON.stringify(view_history),0);\\n    return true\\n}\\n\\n$.exports.renderText = function (realUrl,type){\\n    type = type || 'code';\\n    return $('hiker://empty#noHistory##noRecordHistory#').rule((realUrl,type) => {\\n        let d = [];\\n        let html;\\n        try {\\n            html = request(realUrl, {\\n                timeout: $.getTimeOut()\\n            }) || '';\\n        } catch (e) {\\n            html = '预览失败:' + e.message\\n        }\\n        if(/md|code/.test(type)){\\n            require('http://hiker.nokia.press/hikerule/rulelist.json?id=3187');\\n            html = type==='md'?marked.parse(html):marked.parse(\\\"```\\\\n\\\" + html + \\\"\\\\n```\\\");\\n        }else if (type==='txt'&& html.length > 6000) {\\n            html = html.slice(0, 6000) + \\\"...\\\\nerror:文件过大不支持预览\\\";\\n        }\\n        let col = /md|code/.test(type) ? 'rich_text' : 'long_text';\\n        d.push({\\n            title: html,\\n            col_type: col,\\n            url: 'hiker://empty'\\n        });\\n        setResult(d);\\n    }, realUrl,type)\\n}\"},{\"name\":\"密码管理\",\"path\":\"passwordManage\",\"rule\":\"js:\\nlet d = [];\\nsetPageTitle('Alist密码管理');\\nconst {color,small} = $.require('hiker://page/utils');\\nlet idex = getParam('idex', MY_PARAMS.idex||\\\"\\\");\\nif(!idex){\\n    d.push({\\n        title:'索引获取失败,无法管理密码',\\n        col_type:'text_1',\\n        url:'hiker://empty'\\n    });\\n}else{\\n    idex = Number(idex);\\n    let sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\\n    let nowSub = sub_urls[idex];\\n    let name = color(nowSub.name,'#d96715');\\n    let password = nowSub.password;\\n    let webdav = nowSub.webdav||{};\\n    if(!password){\\n        d.push({\\n            title:'订阅'+name+'暂无密码',\\n            col_type:'text_1',\\n            url:'hiker://empty'\\n        });\\n    }else{\\n        d.push({\\n            title:'订阅'+name+'密码如下',\\n            col_type:'text_1',\\n            url:'hiker://empty'\\n        });\\n        d.push({\\n            title:JSON.stringify(password),\\n            col_type:'long_text',\\n        });\\n    }\\n    d.push({\\n       title:'<big><strong>webdav配置<big><strong>',\\n       col_type:'rich_text',\\n    });\\n    let webdav_path = $.rstrip(nowSub.url,'/')+'/dav';\\n    d.push({\\n        title:'webdav地址',\\n        desc:webdav_path,\\n        col_type:'text_1',\\n        url:'copy://'+webdav_path\\n    });\\n    d.push({\\n        title: '账号',\\n        url: $.toString((user)=>{\\n            copy(user||getMyVar('webdav_user',''));\\n            return 'hiker://empty'\\n        },webdav.user),\\n        col_type: \\\"input\\\",\\n        desc: \\\"webdav登录账号\\\",\\n        pic_url: \\\"\\\",\\n        extra:{\\n            defaultValue:webdav.user||getMyVar('webdav_user',''),\\n            onChange:\\\"putMyVar('webdav_user',input)\\\",\\n        }\\n    });\\n    d.push({\\n        title: '密码',\\n        url: $.toString((pwd)=>{\\n            copy(pwd||getMyVar('webdav_pwd',''));\\n            return 'hiker://empty'\\n        },webdav.pwd),\\n        col_type: \\\"input\\\",\\n        desc: \\\"webdav登录密码\\\",\\n        pic_url: \\\"\\\",\\n        extra:{\\n            type:'password',\\n            defaultValue:webdav.pwd||getMyVar('webdav_pwd',''),\\n            onChange:\\\"putMyVar('webdav_pwd',input)\\\",\\n        }\\n    });\\n    d.push({\\n        title:'验证并保存',\\n        col_type:'text_center_1',\\n        url:$('#noLoading#').lazyRule((webdav_path,idex)=>{\\n            showLoading('登录验证中,请稍等...');\\n            let url = webdav_path;\\n            let user = getMyVar(\\\"webdav_user\\\");\\n            let pwd = getMyVar(\\\"webdav_pwd\\\");\\n            if (!user|| !pwd) {\\n                return \\\"toast://请输入webdav登录账号和密码\\\";\\n            }\\n            let webdav = buildWebDav(url, user, pwd);\\n            try {\\n                let list = JSON.parse(webdav.list());\\n                if(list.length < 1){\\n                    hideLoading();\\n                    return 'toast://保存失败!登录检测到文件列表为空,请确保账号密码正确且webdav路径下至少有1个文件/文件夹'\\n                }\\n            }catch (e) {\\n                log(e.message);\\n                hideLoading();\\n                return 'toast://保存失败!登录检测到文件列表为空,请确保账号密码正确且webdav路径下至少有1个文件/文件夹'\\n            }\\n            let sub_urls = JSON.parse(readFile('sub_urls.json', 0) || '[]');\\n            let nowSub = sub_urls[idex];\\n            nowSub.webdav = {user:user,pwd:pwd};\\n            saveFile('sub_urls.json', JSON.stringify(sub_urls),0);\\n            // log(list);\\n            hideLoading();\\n            return 'toast://登录验证成功,已保存凭证'\\n        },webdav_path,idex),\\n    });\\n}\\nsetResult(d);\"},{\"name\":\"高级设置\",\"path\":\"superSettings\",\"rule\":\"js:\\nlet d = [];\\nsetPageTitle('Alist|高级设置');\\naddListener('onClose', $.toString(() => {\\n    refreshPage(false); //刷新\\n}));\\nconst {color,small} = $.require('hiker://page/utils');\\nconst {iconStyles} = $.require('hiker://page/fileType');\\nd.push({\\n    title:'搜索记录自动清除',\\n    desc:'设置执行以下动作时是否自动清除搜索内容',\\n    col_type:'text_1',\\n    url:'hiker://empty'\\n});\\nlet clear_change = getItem('clear_change','');\\nlet clear_refresh = getItem('clear_refresh','开');\\nd.push({\\n    title:clear_change?color('切换目录','#12b668'):'切换目录',\\n    col_type:'text_2',\\n    url:$('#noLoading#').lazyRule((clear_change)=>{\\n        setItem(\\\"clear_change\\\", clear_change? \\\"\\\" : \\\"开\\\");\\n        refreshPage(false);\\n        return 'hiker://empty'\\n    },clear_change)\\n});\\nd.push({\\n    title:clear_refresh?color('回首页','#12b668'):'回首页',\\n    col_type:'text_2',\\n    url:$('#noLoading#').lazyRule((clear_refresh)=>{\\n        setItem(\\\"clear_refresh\\\", clear_refresh? \\\"\\\" : \\\"开\\\");\\n        refreshPage(false);\\n        return 'hiker://empty'\\n    },clear_refresh)\\n});\\nlet size = storage0.getItem('search_size',20);\\nd.push({\\n    title:'搜索每页数:'+color(''+size,'#d96715'),\\n    col_type:'text_2',\\n    url:$(size,'请输入全局搜索的每页显示数量\\\\n实测超过200有卡死的风险').input(()=>{\\n        if(!Number(input)){\\n            return 'toast://输入有误'\\n        }\\n        storage0.setItem('search_size',Number(input));\\n        refreshPage(false);\\n        return 'hiker://empty'\\n    }),\\n});\\nlet auth = getItem(\\\"authorization\\\", \\\"\\\");\\nd.push({\\n    title:'站长auth:'+color(auth.substr(0,3),'#d96715'),\\n    col_type:'text_2',\\n    url:$(auth,'你如果是站长可以设置authorization实现免密搜索').input((auth)=>{\\n        input = input.trim();\\n        if(auth!==input){\\n            setItem('authorization',input);\\n            refreshPage(false);\\n        }\\n        return 'hiker://empty'\\n    },auth),\\n});\\n\\nlet iconStyle = getItem('iconStyle','默认');\\nlet iconSel = iconStyles.map(it=>it.name === iconStyles?color(it.name,'#12b668'):it.name);\\nd.push({\\n    title:'图标风格:    '+color(iconStyle,'#d96715'),\\n    desc:'可选全局图标主题样式',\\n    col_type:'text_1',\\n    url:$(iconSel,2,'请选择一套图标样式').select((iconStyle)=>{\\n        input = pdfh(input,'body&&Text').replace('““””','');\\n        if(iconStyle!==input){\\n            setItem('iconStyle',input);\\n            refreshPage(false);\\n        }\\n        return 'hiker://empty'\\n    },iconStyle)\\n});\\nd.push({\\n    title:'自定义过滤条件'+small(color('(点击来个例子)','#aaaaaa')),\\n    desc:'设置一些自定义的筛选内容附加到主页快速筛选栏',\\n    col_type:'text_1',\\n    url:$('来个示例?').confirm(()=>{\\n        putMyVar('filter_name', '视频');\\n        putMyVar('filter_rule', '\\\\\\\\.m3u8|\\\\\\\\.mp4');\\n        refreshPage(false);\\n        return 'toast://例子给你了,自己保存吧!'\\n    })\\n});\\nd.push({\\n    title: '名称',\\n    desc: '如: 视频',\\n    col_type: 'input',\\n    url: $.toString(() => {\\n    }),\\n    extra: {\\n        defaultValue: getMyVar('filter_name', ''),\\n        onChange: 'putMyVar(\\\"filter_name\\\",input)'\\n    }\\n});\\nd.push({\\n    title: '内容',\\n    desc: '如: \\\\\\\\.m3u8|\\\\\\\\.mp4',\\n    col_type: 'input',\\n    url: $.toString(() => {\\n\\n    }),\\n    extra: {\\n        defaultValue: getMyVar('filter_rule', ''),\\n        onChange: 'putMyVar(\\\"filter_rule\\\",input)',\\n        height: 2,\\n        highlight: true,\\n        type: \\\"textarea\\\",\\n    }\\n});\\nfunction saveFilter() {\\n    let filter_name = getMyVar('filter_name', '').trim();\\n    let filter_rule = getMyVar('filter_rule', '').trim();\\n    if (!filter_name) {\\n        return 'toast://名称必填!'\\n    }\\n    if (!filter_rule) {\\n        return 'toast://过滤规则必填!'\\n    }\\n    let filter_rules = JSON.parse(readFile('filter_rules.json', 0) || '[]');\\n    let idex = filter_rules.findIndex(it => it.name === filter_name);\\n    if (idex > -1) {\\n        if (filter_rules[idex].rule !== filter_rule) {\\n            filter_rules[idex].rule = filter_rule;\\n            // filter_rules[idex].active = true;\\n            return $('检测到本地有重复的' + filter_name + ',是否覆盖?').confirm((filter_rules) => {\\n                saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n                refreshPage(false);\\n                return 'toast://已保存'\\n            }, filter_rules)\\n        } else {\\n            return 'toast://没有操作'\\n        }\\n    } else {\\n        filter_rules.unshift({\\n            name: filter_name,\\n            rule: filter_rule,\\n            active:true,\\n        });\\n        saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n        refreshPage(false);\\n        return 'toast://已保存'\\n    }\\n}\\n\\nd.push({\\n    title:'保存规则',\\n    col_type: 'text_3',\\n    url:$('#noLoading#').lazyRule((saveFilter)=>{\\n        return saveFilter();\\n    },saveFilter)\\n});\\nd.push({\\n    title:'导入规则',\\n    col_type: 'text_3',\\n    url:$(\\\"{{clipboard}}\\\", \\\"自动识别剪切板内容或手动输入口令\\\").input(()=>{\\n        input=input.trim();\\n        let url=input.split('\\\\n')[1];\\n        if(!/Alist自定义过滤规则/.test(input)||!/^http/.test(url)){\\n            return 'toast://导入口令有误'\\n        }\\n        try {\\n            let code=parsePaste(url);\\n            let newRules = JSON.parse(base64Decode(code));\\n            let filter_rules = JSON.parse(readFile('filter_rules.json', 0) || '[]');\\n            let filter_cnt = filter_rules.length;\\n            newRules = newRules.filter(x=>x.name&&x.rule);\\n            if(!Array.isArray(newRules) || newRules.length < 1){\\n                return 'toast://导入的东西看起来没对呢!'\\n            }\\n            newRules.forEach((it)=>{\\n                let idex = filter_rules.findIndex(x=>$.rstrip(x.name) === $.rstrip(it.name));\\n                idex>-1?filter_rules[idex] = it:filter_rules.unshift(it);\\n            });\\n            let new_cnt = filter_rules.length - filter_cnt;\\n            if(new_cnt > 0 ){\\n                saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n                refreshPage(false);\\n                return 'toast://已保存'+new_cnt+'条记录'\\n            }else{\\n                return 'toast://没有待保存的内容'\\n            }\\n        }catch (e) {\\n            return 'toast://导入失败!\\\\n'+ e.message;\\n        }\\n    }),\\n});\\nd.push({\\n    title:'分享规则',\\n    col_type: 'text_3',\\n    url:$('#noLoading#').lazyRule(()=>{\\n        let filter_rules = JSON.parse(readFile('filter_rules.json', 0) || '[]');\\n        if(filter_rules.length < 1){\\n            return 'toast://你还没有规则,无法分享!'\\n        }\\n        let shareText = base64Encode(JSON.stringify(filter_rules));\\n        var pastes = getPastes();\\n        var url = sharePaste(shareText,pastes.slice(-1)[0]);\\n        let import_rule= \\\"Alist自定义过滤规则：\\\"+filter_rules[0].name+'等'+filter_rules.length+'条\\\\n'+url;\\n        copy(import_rule);\\n        return 'hiker://empty'\\n    })\\n});\\nlet filter_rules = JSON.parse(readFile('filter_rules.json', 0) || '[]');\\nfilter_rules.forEach((it, idex) => {\\n    d.push({\\n        title: it.active?color(it.name,'#12b668'):color(it.name,'#aaaaaa'),\\n        desc: it.rule,\\n        url: $(['删除', '修改名称','修改规则','快捷输入','启用','禁用'], 2, '请选择1个操作').select((it, filter_rules, idex) => {\\n            if (input === '删除') {\\n                let filterOption = getItem('filterOption','全部');\\n                if(filterOption===it.name){\\n                    clearItem('filterOption')\\n                }\\n                filter_rules.splice(idex, 1);\\n            }else if (input === '修改名称') {\\n                return $(it.name,'给此规则改个名字吧').input((filter_rules,idex)=>{\\n                    input = input.trim();\\n                    if(input){\\n                        filter_rules[idex].name = input;\\n                        saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n                        refreshPage(false);\\n                        return 'toast://修改成功'\\n                    }else{\\n                        return 'toast://修改失败'\\n                    }\\n                },filter_rules,idex);\\n            }else if (input === '修改规则') {\\n                return $(it.rule,'给此规则改个匹配内容吧').input((filter_rules,idex)=>{\\n                    input = input.trim();\\n                    if(input){\\n                        filter_rules[idex].rule = input;\\n                        saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n                        refreshPage(false);\\n                        return 'toast://修改成功'\\n                    }else{\\n                        return 'toast://修改失败'\\n                    }\\n                },filter_rules,idex);\\n            } else if (input === '快捷输入') {\\n                putMyVar(\\\"filter_name\\\",it.name);\\n                putMyVar(\\\"filter_rule\\\",it.rule);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            }else if (input === '启用') {\\n                filter_rules[idex].active = true;\\n                saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n                refreshPage(false);\\n                return 'toast://已启用'\\n            }else if (input === '禁用') {\\n                filter_rules[idex].active = false;\\n                saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n                refreshPage(false);\\n                return 'toast://已禁用'\\n            }\\n            saveFile('filter_rules.json', JSON.stringify(filter_rules), 0);\\n            refreshPage(false);\\n            return 'toast://已' + input\\n        }, it, filter_rules, idex),\\n        col_type: \\\"text_1\\\",\\n        extra:{\\n            idex:idex+''\\n        }\\n    })\\n});\\nsetResult(d);\"},{\"name\":\"观看历史\",\"path\":\"history\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle('Alist|观影历史');\\nconst {color,small} = $.require('hiker://page/utils');\\nd.push({\\n    title: \\\"清空\\\",\\n    url: $('确认清空历史记录?').confirm(() => {\\n        // deleteFile('view_history.json');\\n        saveFile('view_history.json','[]',0);\\n        refreshPage(false);\\n        return \\\"toast://观影历史已清空!\\\"\\n    }),\\n    col_type: \\\"text_3\\\"\\n});\\nlet hisPath = `hiker://files/rules/files/${MY_RULE.title}/view_history.json`;\\nd.push({\\n    title: \\\"编辑\\\",\\n    url: $('#noLoading#').lazyRule((hisPath)=>{\\n        if(!fileExist(hisPath)){\\n            saveFile('view_history.json','[]',0);\\n        }\\n        return 'editFile://'+hisPath\\n    },hisPath),\\n    col_type: \\\"text_3\\\"\\n});\\nlet option = getItem('his_click','播放');\\nd.push({\\n    title: option==='播放'?option:color(option,'#ab2415'),\\n    url: $('#noLoading#').lazyRule((color)=>{\\n        let option = getItem('his_click','播放');\\n        let nextOption = option === '播放'?'删除':'播放';\\n        setItem('his_click',nextOption);\\n        updateItem(\\\"his_click\\\", {\\n            title:nextOption==='播放'?nextOption:color(nextOption,'#ab2415')\\n        });\\n        refreshPage(false);\\n        return 'hiker://empty'\\n    },color),\\n    col_type: \\\"text_3\\\",\\n    extra:{\\n        id:'his_click'\\n    }\\n});\\nlet view_history = JSON.parse(readFile('view_history.json', 0) || '[]');\\nif(view_history.length > 0){\\n    view_history.forEach((it)=>{\\n        it.col_type = 'text_1';\\n        if(option==='删除'){\\n            it.url = $('#noLoading#').lazyRule((id)=>{\\n                let view_history = JSON.parse(readFile('view_history.json', 0) || '[]');\\n                let idex = view_history.findIndex(x=>x.extra.id === id);\\n                view_history.splice(idex,1);\\n                saveFile('view_history.json', JSON.stringify(view_history),0);\\n                refreshPage(false);\\n                return 'hiker://empty'\\n            },it.extra.id);\\n        }\\n        d.push(it);\\n    });\\n}else{\\n  d.push({\\n      title:'暂无观影记录,先去观看一个视频吧!',\\n      col_type:'text_center_1',\\n      url:'hiker://empty'\\n  });\\n}\\nsetResult(d);\"},{\"name\":\"文件上传\",\"path\":\"upload\",\"rule\":\"js:\\nsetPageTitle('Alist|访客上传文件');\\nconst {color,small} = $.require('hiker://page/utils');\\nlet html = `\\n<!doctype html>\\n<html> \\n    <head> \\n    <!--<author>顺承天意&&@LoyDgIk&&道长</author>-->\\n        <meta charset=\\\"UTF-8\\\"> \\n        <meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0\\\"> <!-- <meta name=\\\"color-scheme\\\" content=\\\"light dark\\\"> --> \\n        <title>上传文件</title> \\n        <style>\\n        button {\\n            display: block;\\n            width: 100%;\\n            margin: 6px;\\n            outline: none;\\n            height: 40px;\\n            line-height: 40px;\\n            color: #fff;\\n            background-color: #26a2ff;\\n            text-align: center;\\n            border-radius: 4px;\\n            border: none;\\n            cursor: pointer;\\n        }\\n\\n        #upload-input {\\n            opacity: 0;\\n            filter: alpha(opacity=0);\\n            display: inline-block;\\n            width: 100%;\\n            height: 100%;\\n        }\\n\\n        #upload-text {\\n            position: relative;\\n            bottom: 40px;\\n            user-select: none;\\n        }\\n    </style>\\n    </head>\\n    <body><button onclick=\\\"easyUpload()\\\"> <span id=\\\"upload-input\\\">选择文件</span><span id=\\\"upload-text\\\">选择文件</span> </button>\\n        \\n    </body>\\n</html>\\n`;\\nlet sub_urls = $.get_sub_urls();\\nlet baseurl = $.rstrip(getMyVar(\\\"baseurl\\\", sub_urls[0].url), '/');\\nlet path = getMyVar(\\\"path\\\", \\\"\\\");\\nlet password = sub_urls.find(x => x.url.includes(baseurl)).password || {};\\npassword = password[path] || '';\\nlet obj = {\\n    base_url:baseurl,\\n    path:path,\\n    password:password,\\n    html:html,\\n};\\nfunction x5js(obj) {\\n    document.write(obj.html);\\n    function easyUpload() {\\n        var input = document.createElement(\\\"input\\\");\\n        input.type = \\\"file\\\";\\n        input.click();\\n        input.onchange = function() {\\n            fba.showLoading(\\\"正在上传\\\");\\n            var files = input.files;\\n            const form = new FormData();\\n            for (let i = 0; i < files.length; i++) {\\n                form.append(\\\"files\\\", files[i], files[i].name);\\n            }\\n            form.append(\\\"path\\\", obj.path);\\n            form.append(\\\"password\\\", obj.password);\\n            var xhr = new XMLHttpRequest();\\n            //xhr.setRequestHeader('Content-Type', 'application/json');\\n            var action = obj.base_url + \\\"/api/public/upload\\\"; //上传接口\\n            // fba.log(\\\"正在上传\\\");\\n            xhr.onload = function() {\\n                fba.hideLoading();\\n                if (xhr.readyState === 4 && xhr.status === 200) {\\n                    var resultObj = JSON.parse(xhr.responseText);\\n                    fba.log(xhr.responseText);\\n                    alert(\\\"上传成功\\\\n\\\" + resultObj.message);\\n                    fba.back(true);\\n                }else{\\n                    alert(\\\"上传失败\\\");\\n                }\\n            }\\n            xhr.open(\\\"POST\\\", action);\\n            xhr.send(form); //发送表单数据\\n        }\\n    }\\n    window.easyUpload = function() {\\n        try {\\n            easyUpload();\\n        } catch (e) {\\n            fba.log(e.toString());\\n        }\\n    }\\n}\\nvar d = [];\\nd.push({\\n    title:'当前主页:'+small(color(obj.base_url,'#aaaaaa')),\\n    desc:'当前相对路径:'+small(color(obj.path,'#aaaaaa')),\\n    col_type: 'text_1',\\n    url:obj.base_url + obj.path,\\n    extra: {\\n        password:obj.password\\n    }\\n});\\nd.push({\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"60&&list\\\",\\n    url:\\\"about:blank\\\",\\n    extra: {\\n        js: $.toString(x5js, obj),\\n        //jsLoadingInject: true\\n    }\\n});\\nsetResult(d);\"},{\"name\":\"搜索\",\"path\":\"search\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle('Alist|🔍全局搜索');\\nlet nsearch = getMyVar('searchAll','');\\naddListener('onClose', $.toString(() => {\\n    let clear_refresh = getItem('clear_refresh','开');\\n    if(clear_refresh === '开'){\\n        clearMyVar('searchAll');\\n    }\\n}));\\nif(MY_PAGE===1||!nsearch) {\\n    d.push({\\n        title: '🔍搜索',\\n        desc: '搜点什么吧?',\\n        url: $.toString(() => {\\n            refreshPage(false);\\n        }),\\n        col_type: 'input',\\n        extra: {\\n            defaultValue: nsearch,\\n            onChange: 'putMyVar(\\\"searchAll\\\",input)',\\n        }\\n    });\\n}\\nlet searchResult = [];\\nlet showDetail = getItem('showDetail', '开') === '开';\\nlet filterOption = getItem('filterOption','全部');\\nif(nsearch){\\n    let sub_urls = $.get_sub_urls();\\n    let baseurl = $.rstrip(getMyVar(\\\"baseurl\\\", sub_urls[0].url), '/');\\n    let path = getMyVar(\\\"path\\\", \\\"\\\");\\n    let lastSearch = baseurl + path + '?key='+nsearch+'|'+showDetail;\\n    if(lastSearch === getMyVar('lastSearch','')){\\n        if(MY_PAGE===1) {\\n            showLoading('获取上次搜索结果中...');\\n        }\\n        log(`搜索${nsearch},第${MY_PAGE}页`);\\n        searchResult = JSON.parse(readFile('search_results.json',0));\\n    }else {\\n        showLoading(`搜索${nsearch}中，请稍等...`);\\n        const icon_dict = $.require('hiker://page/fileType').get_icon_dict();\\n        const icons = $.require('hiker://page/fileType').get_icons();\\n        const {getLink} = $.require('hiker://page/api');\\n        let clickOption = getItem('clickOption', '打开');\\n        const {bytesToSize, small, color, getTime,sorts} = $.require('hiker://page/utils');\\n        let showZimu = getItem('showZimu', '开');\\n        d.push({\\n            title: '主页:' + small(color(baseurl, '#aaaaaa')),\\n            desc: '路径:' + small(color(path, '#aaaaaa')),\\n            url: 'hiker://empty',\\n            col_type: 'text_1'\\n        });\\n\\n        try {\\n            let password = sub_urls.find(x => x.url.includes(baseurl)).password || {};\\n            let res = JSON.parse(post(baseurl + \\\"/api/public/search\\\", {\\n                headers: {\\n                    \\\"Content-Type\\\": \\\"application/json\\\",\\n                    \\\"authorization\\\": getItem(\\\"authorization\\\", \\\"\\\")\\n                },\\n                body: JSON.stringify({\\n                    path: path,\\n                    keyword: nsearch,\\n                    password: password[path] || ''\\n                }),\\n                timeout: $.getTimeOut(),\\n            }));\\n\\n            let list = res.data;\\n            if (list.length < 1) {\\n                searchResult.push({\\n                    title: \\\"找不到你想要的ʕ·ᴥ·ʔ\\\",\\n                    url: \\\"hiker://empty\\\"\\n                });\\n            } else {\\n                if(filterOption==='文件'){\\n                    list = list.filter(x=>x.type!==1)\\n                }else if(filterOption==='文件夹'){\\n                    list = list.filter(x=>x.type===1)\\n                }else if(filterOption!=='全部'){\\n                    let filter_rules = JSON.parse(readFile('filter_rules.json', 0) || '[]');\\n                    let filter_rule = filter_rules.find(x=>x.name===filterOption);\\n                    if(filter_rule&&filter_rule.rule){\\n                        if(filter_rule.rule.startsWith('!')){\\n                            list = list.filter(x=>!(new RegExp(filter_rule.rule.slice(1))).test(x.name));\\n                        }else{\\n                            list = list.filter(x=>(new RegExp(filter_rule.rule)).test(x.name));\\n                        }\\n                    }\\n                }\\n                showLoading('搜索到' + list.length + '条结果,加载中');\\n                list.forEach((item) => {\\n                    let it_type = item.type;//资源类型\\n                    let url = 'hiker://empty';\\n                    let title = item.name;//资源名称\\n                    let path = item.path;//资源路径\\n                    let id = baseurl + path + title;//资源唯一标志\\n                    let ext = title.split('.').slice(-1)[0];\\n                    let img = it_type === 1 ? icon_dict['1'] : (icons[ext] || icon_dict[it_type + '']);\\n                    if (it_type === 1) {\\n                        url = $('#noLoading#').lazyRule((item) => {\\n                            putMyVar(\\\"path\\\", item.path + \\\"/\\\" + item.name)\\n                            back();\\n                            return \\\"hiker://empty\\\"\\n                        }, item);\\n                    } else if (it_type === 3 || /\\\\.m3u8$/.test(title)) { //3是媒体,禁用下载和跳转\\n                        url = getLink(title,path, '打开', showZimu, '#isVideo=true#',true);\\n                    } else if (it_type === 6) {\\n                        url = getLink(title,path, '打开', showZimu, \\\"#.jpg\\\",true);\\n                    } else { //跟随系统预览和下载\\n                        url = getLink(title,path, clickOption, showZimu,true);\\n                    }\\n                    searchResult.push({\\n                        name:title,\\n                        title: title,\\n                        img: img,\\n                        url: url,\\n                        col_type: \\\"avatar\\\",\\n                        extra: {\\n                            id: id,\\n                            type: it_type,\\n                            title: title,\\n                        }\\n                    });\\n                    // log(item);\\n                    if (showDetail) {\\n                        let date = (item.updated_at || item.time_str) ? getTime(item) : '\\\\t\\\\t\\\\t\\\\t';\\n                        let size = item.size_str;\\n                        if (!size || size === \\\"\\\") {\\n                            size = item.size === 0 ? \\\"/\\\" : bytesToSize(item.size)\\n                        }\\n                        if (size && size !== \\\"\\\" && size !== 0) {\\n                            size = \\\"&nbsp;&nbsp;&nbsp;\\\" + size;\\n                        } else {\\n                            size = \\\"\\\";\\n                        }\\n                        let desc = date + size;\\n                        searchResult.push({\\n                            name:title,\\n                            title: small(color(desc, '#aaaaaa')),\\n                            col_type: \\\"text_1\\\",\\n                            url: url,\\n                            extra: {\\n                                id: id,\\n                                type: it_type,\\n                                title: title,\\n                            }\\n                        })\\n                    }\\n                });\\n                toast('搜索结束，即将加载完毕...');\\n            }\\n            putMyVar('lastSearch', lastSearch);\\n            if(!showDetail){//非详细模式才自动按名称排序\\n                sorts(searchResult,'名称');\\n            }\\n            saveFile('search_results.json', JSON.stringify(searchResult), 0);\\n\\n        } catch (e) {\\n            searchResult.push({\\n                title: \\\"好像不能搜索,点击返回\\\",\\n                desc: e.message,\\n                url: $('#noLoading#').lazyRule(() => {\\n                    back();\\n                    return \\\"hiker://empty\\\"\\n                })\\n            });\\n            putMyVar('lastSearch', lastSearch);\\n            saveFile('search_results.json', JSON.stringify(searchResult), 0);\\n            // log(e.message);\\n        }\\n    }\\n}\\nlet size = storage0.getItem('search_size',20);\\nif(showDetail){size = size*2} // 显示详细需要x2\\nsearchResult = searchResult.slice((MY_PAGE-1)*size,MY_PAGE*size);\\nd = d.concat(searchResult);\\nhideLoading();\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"点击函数\",\"path\":\"clickFunction\",\"rule\":\"function clickLazy(baseurl, npath, path,clickOption,showZimu,input, ext,reload){\\n    if (clickOption !== '菜单') {\\n        let u=$.getU(baseurl,npath,ext);\\n        if(/toast:/.test(u)){\\n            return u\\n        }\\n        let playUrl = baseurl + \\\"/d\\\" + npath;//文件302直链\\n        u = ext?playUrl+ext:playUrl; // 既然获取u没报错,为了可以让视频投屏,那么u覆写为302直链\\n        //log(u);\\n        if (clickOption === '打开') {\\n            if(ext&&/isVideo/.test(ext)&&showZimu==='开'){//判断打开的是媒体文件才走字幕逻辑\\n                let id = baseurl + npath;//当前文件的唯一标识\\n                let data = {\\n                    title: input,\\n                    desc: id,\\n                    extra:{\\n                        id:id,\\n                    }\\n                };\\n                var now_files = storage0.getMyVar(\\\"now_files\\\",[]);//获取缓存的,避免二次请求\\n                // log('同目录文件数为:'+now_files.length);\\n                if(now_files.length < 1|| reload){//从搜索进去的,只能重新获取了\\n                    const {getFiles} = $.require('hiker://page/api');\\n                    let dirInfo = getFiles(path,'文件');\\n                    now_files = dirInfo.result||[];\\n                    // log('重新获取同目录文件:'+now_files.length);\\n                }\\n                let files;\\n                if(reload){\\n                    files = now_files.filter(x=>x.type!==1&&/\\\\.srt$|\\\\.vtt$|\\\\.ass$|\\\\.ssa$/.test(x.title)).map(x=>x.title); // 筛选文件并且名称含字幕后缀的\\n                }else{\\n                    files = now_files.filter(x=>x.type!==1&&/\\\\.srt$|\\\\.vtt$|\\\\.ass$|\\\\.ssa$/.test(x.name)).map(x=>x.name); // 筛选文件并且名称含字幕后缀的\\n                }\\n                // log(now_files);\\n                if(files.length > 0){//当前目录有字幕文件\\n                    let bestFile = files.find(x=>$.removeExt(input).includes($.removeExt(x)));//视频文件去掉后缀完美包含字幕文件去后缀\\n                    if(bestFile){//找到了最符合的文件名称\\n                        log(`${input}自动匹配最佳外挂字幕文件:${bestFile}`);\\n                        let realUrl = baseurl + '/d' + path + bestFile;\\n                        data.url = JSON.stringify({\\n                            urls: [u],\\n                            subtitle: realUrl\\n                        });\\n                        $.saveHistory(id,data);\\n                        return JSON.stringify({\\n                            urls: [u],\\n                            subtitle: realUrl\\n                        });\\n                    }else{\\n                        files = files.filter(x=>$.similar($.removeExt(input),$.removeExt(x))>=30);//筛选相似度>30的文件\\n                        if (files.length > 0) {\\n                            files.unshift('不需要字幕');\\n                            return $(files, 1, \\\"请选择字幕\\\").select((baseurl, path, u,ext,id,playUrl,data) => {\\n                                if(input==='不需要字幕'){\\n                                    data.url = u;\\n                                    $.saveHistory(id,data);\\n                                    return u\\n                                }\\n                                let realUrl = baseurl + '/d' + path + input;\\n                                data.url = JSON.stringify({\\n                                    urls: [u],\\n                                    subtitle: realUrl\\n                                });\\n                                $.saveHistory(id,data);\\n                                return JSON.stringify({\\n                                    urls: [u],\\n                                    subtitle: realUrl\\n                                });\\n                            }, baseurl, path, u,ext,id,playUrl,data);\\n                        } else {\\n                            data.url = u;\\n                            $.saveHistory(id,data);\\n                            return u\\n                        }\\n                    }\\n                }else{\\n                    data.url = u;\\n                    $.saveHistory(id,data);\\n                    return u\\n                }\\n            }else if(ext&&/isVideo/.test(ext)&&showZimu!=='开'){\\n                let id = baseurl + npath;//当前文件的唯一标识\\n                let data = {\\n                    title: input,\\n                    desc: id,\\n                    url:u,\\n                    extra:{\\n                        id:id,\\n                    }\\n                };\\n                $.saveHistory(id,data);\\n                return u\\n            }else{\\n                return u\\n            }\\n        }\\n        if (clickOption === '打开') {\\n            return u\\n        } else if (clickOption === '下载') {\\n            return 'download://' + u\\n        }\\n    }else{\\n        let sub_urls = $.get_sub_urls();\\n        let rstrip = $.rstrip;\\n        let nowSub = sub_urls.find(x=>rstrip(x.url,'/')===baseurl);\\n        let dav = nowSub?nowSub.webdav||{}:{};\\n        let sel_list = ['打开', '下载', '预览', '复制直链'];\\n        if(path.split('/').length>1&&nowSub&&nowSub.webdav&&nowSub.webdav.user){\\n            sel_list.push('删除');\\n        }\\n        return $(sel_list, 2, '请选择1个文件操作').select((baseurl, path,npath,ext,user,pwd,dav) => {\\n            //log(dav);\\n            let u=$.getU(baseurl,npath,ext);\\n            if(/toast:/.test(u)){\\n                return u\\n            }\\n            let realUrl = baseurl + '/d' + npath;\\n            if (input === '打开') {\\n                return u;\\n            } else if (input === '下载') {\\n                return 'download://' + u\\n            } else if (input === '复制直链') {\\n                return 'copy://' + realUrl\\n            }else if(input === '删除'){\\n                // let url = baseurl +'/dav'+npath;\\n                let fname = npath.split('/').slice(-1)[0];\\n                let url = baseurl +'/dav'+path;\\n                return $('确认删除:'+fname+' ?').confirm((realUrl,url,fname,user,pwd)=>{\\n                    let webdav = buildWebDav(url, user, pwd);\\n                    // log(fname);\\n                    log(url+fname);\\n                    webdav.delete(fname)\\n                    refreshPage(false);\\n                    return \\\"toast://已删除\\\"+realUrl\\n                },realUrl,url,fname,user,pwd);\\n            }else if (input === '预览') {\\n                if (/\\\\.md$/.test(realUrl)) {\\n                    return $.renderText(realUrl,'md');\\n                } else if (/\\\\.html$|\\\\.json$|\\\\.js$|\\\\.css$|\\\\.py$|\\\\.php$|\\\\.go$/.test(realUrl)) {\\n                    return $.renderText(realUrl,'code');\\n                } else if (/\\\\.txt$/.test(realUrl)) {\\n                    return $.renderText(realUrl,'txt');\\n                } else if (/\\\\.pdf$/.test(realUrl)) {\\n                    return \\\"x5://https://alist-org.github.io/pdf.js/web/viewer.html?file=\\\" + realUrl\\n                } else if ($.isOffice(realUrl)) {\\n                    return \\\"x5://https://view.officeapps.live.com/op/view.aspx?src=\\\" + realUrl\\n                } else {\\n                    let sub_urls = $.get_sub_urls();\\n                    let password = sub_urls.find(x => x.url.includes(baseurl)).password || {};\\n                    let res = JSON.parse(post(baseurl + \\\"/api/public/preview\\\", {\\n                        headers: {\\n                            \\\"Content-Type\\\": \\\"application/json\\\"\\n                        },\\n                        body: JSON.stringify({\\n                            path: npath,\\n                            password: password[npath] || \\\"\\\",\\n                        }),\\n                        timeout: $.getTimeOut(),\\n                    }));\\n                    if (res.data) {\\n                        return res.data.preview_url + '&access_token=' + res.data.access_token;\\n                    } else {\\n                        return 'toast://' + res.message;\\n                    }\\n                }\\n            } else {\\n                return 'toast://无效操作'\\n            }\\n        },baseurl, path,npath,ext,dav.user,dav.pwd,dav);\\n\\n    }\\n}\\n\\n$.exports.clickLazy = clickLazy;\"},{\"col_type\":\"movie_3\",\"name\":\"webDav上传文件\",\"path\":\"webdavUpload\",\"rule\":\"js:\\nlet d=[];\\nsetPageTitle('Alist|webdav上传');\\naddListener('onClose', $.toString(() => {\\n    refreshPage(false); //刷新\\n}));\\nd.push({\\n    title: '上传☁️',\\n    url: $.toString(()=>{\\n        let input = getMyVar('webdav_path','');\\n        if(!/^(hiker|file|\\\\/storage\\\\/|\\\\/sdcard\\\\/)/.test(input)){\\n            return 'toast://文件路径有误!'\\n        }\\n        showLoading(\\\"上传中，请稍候\\\");\\n        let sub_urls = $.get_sub_urls();\\n        let rstrip = $.rstrip;\\n        var base_path = rstrip(getMyVar(\\\"baseurl\\\", sub_urls[0].url), '/');\\n        var path = getMyVar(\\\"path\\\", \\\"\\\");\\n        let nowSub = sub_urls.find(x=>rstrip(x.url,'/')===base_path);\\n        let url = base_path +'/dav'+path;\\n        let name = input.split(\\\"/\\\").slice(-1)[0];\\n        log(`开始将${name}上传至${url}`);\\n        let webdav = buildWebDav(url, nowSub.webdav.user, nowSub.webdav.pwd);\\n        webdav.upload(name, input);\\n        hideLoading();\\n        refreshPage(false);\\n        return \\\"toast://上传完毕,可以在此继续选择文件上传或者返回上级查看成功的文件\\\"\\n    }),\\n    col_type: \\\"input\\\",\\n    desc: \\\"待上传的文件路径,支持hiker://,file://,/storage/开头\\\",\\n    pic_url: \\\"\\\",\\n    extra:{\\n        height:3,\\n        type:'textarea',\\n        id:'webdav_path',\\n        defaultValue:getMyVar('webdav_path',''),\\n        onChange:\\\"putMyVar('webdav_path',input)\\\",\\n    }\\n});\\nd.push({\\n    title: \\\"选择文件路径\\\",\\n    url:$('#noLoading#').lazyRule(()=>{\\n        let fp=config.lib.fileSelect;\\n        let f=$.rc(fp);\\n        return f.fileSelectionUri({\\n            callback: $.toString(() => {\\n                let target = findItem(\\\"webdav_path\\\").extra;\\n                updateItem(\\\"webdav_path\\\", {\\n                    extra: Object.assign(target, {\\n                        defaultValue: PATH\\n                    })\\n                });\\n                putMyVar('webdav_path',PATH);\\n                return true;\\n            }),\\n            onClickType:'confirm',\\n            fileType: \\\"\\\",\\n            pattern: 0,\\n            requireUrl:fp,\\n            initialPath:getPath('hiker://files/').slice(7),\\n            memory:'true',\\n        });\\n    }),\\n    col_type: \\\"text_center_1\\\",\\n});\\n\\nsetResult(d)\"}]","icon":"https://cdn.jsdelivr.net/gh/alist-org/logo@main/can_circle.svg","proxy":""}