API tools faq
paste
xiaomianao666

小程序：小龙盘资源

xiaomianao666
Sep 26th, 2023
109
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 203.97 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@小龙盘资源@{"last_chapter_rule":"","title":"小龙盘资源","author":"Xndy","url":"hiker://empty##","version":12,"col_type":"movie_3","class_name":"","type":"tool","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\n    var d = [];\n\neval(JSON.parse(request('hiker://page/functions')).rule)\n\nstorage0.setItem(\"save\",\"0\")\nstorage0.setItem(\"batch\",\"false\")\n\nputVar(\"token\",token)\n\nid = MY_PARAMS.id\n\nlet indexPage = Number(getMyVar(id+\"indexPage\",\"1\"))\n\nd.push({\n    title:\"登录\",\n    desc: \"\",\n    pic_url:login_image,\n    url:\"hiker://page/login\",\n    col_type: \"icon_4\"\n});\n\nd.push({\n    title:\"放松一下\",\n    desc: \"\",\n    pic_url:rest_image,\n    url:\"hiker://page/rest\",\n    col_type: \"icon_4\"\n});\n\nlet check_login = checkToken()\n\nif(check_login.code === 200){\n\n    d.push({\n        title:\"小龙盘\",\n        desc: \"\",\n        pic_url:png3,\n        url:\"hiker://page/start\",\n        col_type: \"icon_4\"\n    });\n    d.push({\n        title:\"磁力功能\",\n        desc: \"\",\n        pic_url:png4,\n        url:\"hiker://page/addmagent\",\n        col_type: \"icon_4\",\n        extra:{\n            longClick: [\n                {\n                    title:\"磁力解析\",\n                    js: $.toString(()=>{\n                        storage0.setItem(\"CheckMagentType\", \"\");\n                        storage0.setItem(\"CheckMagentMagent\", \"\");\n                        return \"hiker://page/checkMagent\"\n                    })\n                }\n            ]\n        }\n    });\n\n    d.push({\n        title:\"切换查询\",\n        desc: \"\",\n        url:$([\"解析中\",\"上传中\",\"上传完成\"], 2,'查询什么数据？').select(() => {\n\n            if (input === \"解析中\"){\n\n                putVar('dataType', 'running\",\"error')\n                putVar('dataName', '解析中')\n\n            }else if (input === \"上传中\"){\n\n                putVar('dataType', 'outgiving')\n                putVar('dataName', '上传中')\n\n            }else if (input === \"上传完成\"){\n\n                putVar('dataType', 'finished')\n                putVar('dataName', '上传完成')\n\n            }\n            refreshPage();\n            return \"toast://已显示\"+input\n        }),\n        col_type: \"text_2\"\n    });\n\n    fileId = \"123\"\n    fileName = \"name\"\n\n    d.push({\n        title:\"类型：\"+getVar('dataName','解析中'),\n        desc: \"\",\n        //url:\"hiker://page/readBack\",\n        // url: //\"hiker://page/cloud?id=\"+fileId+\"&fileName=\"+fileName+\"&type=\",\n        //     $('').lazyRule(() =>{\n        //         eval(JSON.parse(request('hiker://page/functions')).rule)\n        //         return test()\n        //     }),\n        col_type: \"text_2\"\n        // extra:{\n        //     //type: \"cloud\"\n        //     id:fileId,\n        //     name: fileName,\n        //     type: 'folder',\n        //     newWindow: true,\n        //     windowId: fileId\n        // }\n    });\n\n\n    d.push({\n        col_type: 'big_blank_block'\n    });\n\n    try {\n\n        head={\n            \"Authorization\": \"Bearer \"+getVar(\"token\"),\n            \"User-Agent\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) loongbox-u/1.2.3 Chrome/108.0.5359.179 Electron/22.1.0 Safari/537.36\"\n        }\n\n        body=`{\"type\":\"offline\",\"page\":`+indexPage+`,\"page_size\":100,\"status\":[\"`+getVar('dataType', 'running\",\"error')+`\"]}`\n\n        result=post(check_magent,{headers: head,body:body})\n\n\n        data=JSON.parse(result).data.tasks\n\n        pageSize = JSON.parse(result).data.total\n\n        pageCount = Number(parseInt((pageSize/100)+1)).toFixed(0)\n        minPage = indexPage > 1 ? changePageInt(indexPage,\"-\") : 1\n        maxPage = indexPage >= pageCount ? pageCount : changePageInt(indexPage,\"+\")\n\n\n        if (pageSize > 100){\n            //请求页数\n\n            d.push({\n                title:\"上一页\",\n                url:$('#noLoading#').lazyRule((id,indexPage,minPage) => {\n\n                    if(indexPage>minPage)\n                    {\n                        putMyVar(id+\"indexPage\",minPage)\n                        refreshPage();\n                        return \"toast://上一页\"\n                    }else{return \"toast://已经最前\"}\n\n                },id,indexPage,minPage),\n                //pic_url:last_image,\n                col_type: \"text_3\",\n                extra: {\n                    cls: \"playlist 上一页\"\n                }\n            });\n\n            d.push({\n                title:indexPage+\"/\"+pageCount,\n                url:$('','请输入页码').input((id,pageCount)=>{\n\n                    if(input>0&&Number(input)<=pageCount){\n                        putMyVar(id+'indexPage',input)\n                        refreshPage(false);\n                        return \"toast://已经跳转到\"+input+\"页\"\n                    }else{return \"toast://页数输入错误\"}\n                },id,pageCount),\n                col_type: \"text_3\",\n                extra: {\n                    cls: \"playlist 总页数\"\n                }\n            });\n\n            d.push({\n                title:\"下一页\",\n                url:$('#noLoading#').lazyRule((id,indexPage,maxPage) => {\n\n                    if(indexPage<maxPage) {\n                        putMyVar(id+\"indexPage\",maxPage)\n                        refreshPage();\n                        return \"toast://下一页\"\n                    }else{return \"toast://已经最后\"}\n                },id,indexPage,maxPage),\n                col_type: \"text_3\",\n                //pic_url:next_image,\n                extra: {\n                    cls: \"playlist 下一页\"\n                }\n            });\n        }\n\n        d.push({\n            title:\"总条数\",\n            desc: \"总数： \"+pageSize,\n            url:\"\",\n            col_type: \"text_1\"\n        });\n\n        for (var i in data) {\n\n            fileSize=data[i].file_size/(1024*1024*1024)\n            crTime=data[i].create_time\n            upTime=data[i].update_time\n            magent=data[i].file_name\n\n            if(data[i].progress.equals(\"\")){\n                mgTime='未解析'\n            }else if(data[i].progress.equals(\"0\")){\n                mgTime='未解析'\n            }else{\n                mgTime=data[i].progress+'%'\n            }\n\n\n            fileName=data[i].name.replace(/(『|【|\\[|〖)[^』】\\]〗]+(』|】|\\]|〗)/g,\"\")\n            fileId = data[i].id\n            fileStatus = data[i].status\n\n            if(fileStatus.equals(\"running\")){\n                statuss = \"解析中\"\n            }else if(fileStatus.equals(\"queue\")){\n                statuss = \"排队中\"\n            }else if (fileStatus.equals(\"finished\")){\n                statuss = \"已完成\"\n            }else if(fileStatus.equals(\"outgiving\")){\n                statuss = \"上传中\"\n            }else {\n                statuss = \"错误\"\n            }\n\n            d.push({\n                title:fileName,\n                desc:\"提交时间:\"+crTime+\"  状态:\"+statuss+\"\\n文件大小:\"+Number(fileSize).toFixed(2)+\"G               解析进度:\"+mgTime+\" \\n磁力链接:\"+magent,\n                url:\"copy://magnet:?xt=urn:btih:\"+magent,\n                col_type: \"text_1\",\n                textAlign:\"left\",\n                extra:{\n                    longClick:[\n                        {\n                            title: \"   删除   \",js:$.toString((fileId)=>{\n                                eval(JSON.parse(request('hiker://page/functions')).rule)\n                                return deleteMagent(fileId)\n                            },fileId)\n                        }\n                    ]\n                }\n            });\n\n        }\n\n\n    } catch (e) {\n        toast(\"当前页数过大或者网络不好\")\n        log(e.message)\n    }\n}else {\n    toast(\"密钥有问题或者未登录\")\n}\n\n\nsetResult(d);","search_url":"","group":"A常用","searchFind":"","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"","pages":"[{\"col_type\":\"movie_3\",\"name\":\"剪切板数据\",\"path\":\"剪贴板数据\",\"rule\":\"evalPrivateJS(\\\"87JVE3kANRRcpgod9vE0kr+46PAJr3v2Oo5j3HjU2cSczkcHapXwA2+DuK0Mu8voo3cf15ToQMzeTH0izHs5rUHy+LvxmwBreFtwdN4FfTImeZkWW7ISha5PsNp2dU2qQAqJAuwLXiIbodZzum9JzTvRLtEzbe4cIX1kVkGgMGZVAR+t7dKr3kU90eQMCjErLztLzY0pMyOyizupbFn2JCcF3Kdv3AERf8FBB+t8H6G3w6Qw9TPg0w+LjF2LPMalCc/cE68t8f/Rpad1Z+UAl7rR8Ij1igNt/zs7tl3cB5k=\\\")\"},{\"col_type\":\"movie_3\",\"name\":\"函数\",\"path\":\"functions\",\"rule\":\"\\nfolder_image = \\\"https://img.icons8.com/stickers/100/mail-folder.png\\\"\\n//file_image = \\\"https://img.icons8.com/stickers/100/document.png\\\"\\nfile_image = \\\"https://img.icons8.com/clouds/100/cloud-file.png\\\"\\np_image = \\\"https://img.icons8.com/clouds/100/picture.png\\\"\\nvideo_image = \\\"https://img.icons8.com/clouds/100/video-playlist.png\\\"\\naudio_image = \\\"https://img.icons8.com/clouds/100/music.png\\\"\\nnext_image = \\\"https://img.icons8.com/clouds/50/next.png\\\"\\nlast_image = \\\"https://img.icons8.com/clouds/50/000000/next.png\\\"\\npitch_image = \\\"https://img.icons8.com/clouds/100/checked--v1.png\\\"\\n\\npng1 = \\\"https://img.icons8.com/clouds/100/sent.png\\\"\\npng2 = \\\"https://img.icons8.com/bubbles/100/test-passed.png\\\"\\npng3 = \\\"https://img.icons8.com/stickers/100/cloud-folder.png\\\"\\npng4 = \\\"https://img.icons8.com/cotton/100/magnet.png\\\"\\nrest_image = \\\"https://img.icons8.com/clouds/100/airplane-take-off.png\\\"\\nlogin_image = \\\"https://img.icons8.com/clouds/100/unlock.png\\\"\\nseeds_image = \\\"https://img.icons8.com/clouds/100/power-plant.png\\\"\\nback_folder_image = \\\"https://img.icons8.com/clouds/100/opened-folder.png\\\"\\nback_file_image = \\\"https://img.icons8.com/clouds/100/view-file.png\\\"\\norther_image = \\\"https://img.icons8.com/clouds/100/hdd.png\\\"\\n\\ncheck_user_account = \\\"https://usbapi.stariverpan.com/api/v1/user/account\\\"\\ncheck_magent = \\\"https://usbapi.stariverpan.com/api/v1/task/list\\\"\\nadd_magent = \\\"https://usbapi.stariverpan.com/api/v1/task/add\\\"\\ndelete_magent = \\\"https://usbapi.stariverpan.com/api/v1/task/remove\\\"\\n\\ncheck_url = \\\"https://usbapi.stariverpan.com/api/v1/file/list\\\"\\nadd_folder = \\\"https://usbapi.stariverpan.com/api/v1/file/dir/create\\\"\\nupdate_folder = \\\"https://usbapi.stariverpan.com/api/v1/file/rename\\\"\\ndelete_folder = \\\"https://usbapi.stariverpan.com/api/v1/file/delete\\\"\\nsearch_file = \\\"https://usbapi.stariverpan.com/api/v1/file/search\\\"\\n\\ntrash_file = \\\"https://usbapi.stariverpan.com/api/v1/recycle-bin/file/list\\\"\\ntrash_delete = \\\"https://usbapi.stariverpan.com/api/v1/recycle-bin/file/clear\\\"\\ntrash_clean = \\\"https://usbapi.stariverpan.com/api/v1/recycle-bin/empty\\\"\\nfile_detail = \\\"https://usbapi.stariverpan.com/api/v1/file/detail\\\"\\ntrash_recover = \\\"https://usbapi.stariverpan.com/api/v1/recycle-bin/file/recover\\\"\\n\\ncloud_login = \\\"https://productapi.stariverpan.com/cmsprovider/v1/user/login\\\"\\ncloud_flies = \\\"https://productapi.stariverpan.com/cloudfile/v1/all-files\\\"\\ncloud_vip = \\\"https://productapi.stariverpan.com/cmsprovider/v2.5/user/query\\\"\\ncloud_seeds = \\\"https://productapi.stariverpan.com/cloud-resource/v1/seeds\\\"\\ncloud_seeds_video = \\\"https://productapi.stariverpan.com/cloud-resource/v1/search/recommends\\\"\\n// cloud_seeds_video = \\\"https://productapi.stariverpan.com/cloud-resource/v1/videos\\\"\\n\\ncloud_addFolder = \\\"https://productapi.stariverpan.com/cmsprovider/v1.2/cloud/addFolder\\\"\\ncloud_addFile = \\\"https://productapi.stariverpan.com/cmsprovider/v2.5/cloud/add-file\\\"\\n\\ncloud_checkFolder = \\\"https://productapi.stariverpan.com/cloudfile/v1/folders\\\"\\ncloud_checkFile = \\\"https://productapi.stariverpan.com/cloudfile/v1/files\\\"\\n\\nimage_regular = /(jpg|gif|png|jpeg|webp|image|svg)$/i\\nvideo_regular = /(avi|ts|mp4|mov|m4v|3gp|rm|rmvb|wmv|asf|asxavi|dat|mkv|flv|vob)$/i\\naudio_regular = /(wav|audio|mp3|wma|m4a|flac)$/i\\n\\ntoken = getToken(\\\"start\\\");\\ntoken_name = storage0.getItem(\\\"name\\\",\\\"\\\")\\ncloud_token = getToken(\\\"cloud\\\");\\ncloud_login_token = getCloudLoginToken();\\n\\nlet token_data = JSON.parse(readFile('小龙盘密钥.json', 0) || '[]');\\n\\nlet startPath = \\\"hiker://files/rules/小龙盘资源/备份文件/小龙盘文件夹备份/0.json\\\"\\n\\nlet startIndexPath = \\\"hiker://files/rules/小龙盘资源/备份文件/小龙盘文件夹备份/\\\"\\n\\nlet cloudPath = \\\"hiker://files/rules/IPFS资源/备份文件/小龙云盘文件夹备份/0.json\\\"\\n\\nlet cloudIndexPath = \\\"hiker://files/rules/IPFS资源/备份文件/小龙云盘文件夹备份/\\\"\\n\\nlet line = \\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"\\n\\n//方法\\n\\nfunction test(){\\n\\n}\\n\\nfunction getPostData(url,body){\\n\\n    let head = getHead()\\n\\n    let result = post(url, {headers: head, body: body})\\n\\n    return JSON.parse(result)\\n}\\n\\nfunction getCloudPostData(url,head,body){\\n\\n    try {\\n\\n        let result = post(url, {headers: head, body: body})\\n\\n\\n        let data = JSON.parse(result)\\n\\n        return data\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction getCloudLoginToken(){\\n\\n    let result = checkCloudType(cloud_token)\\n\\n    if (result.code === 200){\\n\\n        return result.data.token\\n\\n    }else {\\n\\n        return \\\"\\\"\\n\\n    }\\n}\\n\\nfunction getLineKey(cloudToken) {\\n\\n    let url = \\\"https://productapi.stariverpan.com/cmsprovider/v1/user/encryption-key\\\"\\n\\n    let body = `{\\\"token\\\":\\\"`+cloudToken+`\\\"}`\\n\\n    let result = post(url,{headers: {},body:body})\\n\\n    let data = JSON.parse(result)\\n\\n    if (data.code === 200){\\n\\n        return data.data\\n\\n    }else {\\n\\n        return \\\"\\\"\\n\\n    }\\n\\n}\\n\\nfunction getToken(type){\\n\\n    if (type === \\\"start\\\"){\\n\\n        return storage0.getItem(\\\"token\\\",\\\"\\\")\\n\\n    }else if (type === \\\"cloud\\\"){\\n\\n        return storage0.getItem(\\\"cloud\\\",\\\"\\\")\\n\\n    }else {\\n\\n        log(\\\"token 错误\\\")\\n\\n        return \\\"\\\"\\n\\n    }\\n}\\n\\nfunction getHead(){\\n\\n    let head={\\n        \\\"Authorization\\\": \\\"Bearer \\\"+getToken(\\\"start\\\"),\\n        \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) loongbox-u/1.2.3 Chrome/108.0.5359.179 Electron/22.1.0 Safari/537.36\\\"\\n    }\\n    return head\\n}\\n\\nfunction getCloudHead(token){\\n    let head={\\n        \\\"Authorization\\\": \\\"Bearer \\\"+token,\\n        \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36 Edg/109.0.1518.70\\\"\\n    }\\n    return head\\n}\\n\\nfunction checkToken() {\\n\\n    let body = `{\\\"type\\\":\\\"offline\\\",\\\"page\\\":1,\\\"page_size\\\":100,\\\"status\\\":[\\\"running\\\",\\\"error\\\"]}`\\n\\n    let data = getPostData(check_magent, body)\\n\\n    return data\\n}\\n\\nfunction checkVip(id){\\n    let body = `{\\\"userId\\\": \\\"`+id+`\\\"}`\\n\\n    try {\\n\\n        let data = getCloudPostData(cloud_vip,getCloudHead(storage0.getItem(\\\"cloud_token\\\")),body).data\\n\\n        return data\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction checkCloudType(token){\\n\\n    if (token.trim().length > 0){\\n\\n        let body=`{\\\"token\\\":\\\"`+token+`\\\"}`\\n\\n        let data = getCloudPostData(cloud_login,getCloudHead(token),body)\\n\\n        if (data.code === 200){\\n\\n            return data\\n\\n        }else{\\n\\n            return \\\"\\\"\\n\\n        }\\n\\n    }else {\\n        return \\\"\\\"\\n    }\\n}\\n\\nfunction checkUserAccount(){\\n\\n    let body=`{}`\\n\\n    try {\\n\\n        let data = getPostData(check_user_account,body)\\n\\n        if (data.code === 200){\\n            let allSize = getFileSize(data.data.stats.storage_sizes)\\n            let count = getFileSize(data.data.limit.storage_limit)\\n            return \\\"‘‘’’<strong><font color='#F44747'>\\\"+allSize+\\\"</font></strong>\\\"+\\\"/\\\"+count\\n        }else {\\n            return \\\"未知\\\"\\n        }\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\n\\n\\n\\nfunction saveToken(a_name,a_user){\\n\\n    if (!a_name || !a_user) {\\n        return 'toast://信息不完整!'\\n    }\\n\\n    let tokenKey = JSON.parse(readFile('小龙盘密钥.json', 0) || '[]');\\n\\n    let idex = tokenKey.findIndex(it => it.name === a_name);\\n\\n    if (idex > -1) {\\n        if (tokenKey[idex].user !== a_user) {\\n\\n            tokenKey[idex].user = a_user;\\n            return $('检测到本地有重复的' + a_name + ',是否覆盖?').confirm((tokenKey) => {\\n                saveFile('小龙盘密钥.json', JSON.stringify(tokenKey), 0);\\n                refreshPage(false);\\n                return 'toast://已保存'\\n            }, tokenKey)\\n        } else {\\n            return 'toast://没有操作'\\n        }\\n    }else {\\n        try {\\n\\n            let user_data = {\\n                name: a_name,\\n                user: a_user,\\n                cloud:'',\\n                addFolder: '',\\n                addFolderName: ''\\n            }\\n\\n            tokenKey.push(user_data);\\n\\n            storage0.setItem(\\\"user_data\\\",user_data)\\n            storage0.setItem(\\\"token\\\",a_user)\\n            storage0.setItem(\\\"name\\\",a_name)\\n            storage0.setItem(\\\"cloud\\\",user_data.cloud)\\n            storage0.setItem(\\\"addFolder\\\",user_data.addFolder)\\n            storage0.setItem(\\\"addFolderName\\\",user_data.addFolderName)\\n            storage0.setItem(\\\"idex\\\",tokenKey.findIndex(it => it.name === a_name))\\n\\n            saveFile('小龙盘密钥.json', JSON.stringify(tokenKey), 0);\\n\\n            refreshPage();\\n\\n            back();\\n\\n            return 'toast://保存成功  \\\\n欢迎你-'+a_name\\n        } catch (e) {\\n\\n            refreshPage(false);\\n            return 'toast://出现错误'\\n        }\\n    }\\n}\\n\\nfunction updateToken(token_data,user,idex){\\n\\n    let newToken = user.trim();\\n\\n    if (newToken) {\\n\\n        token_data[idex].user = newToken;\\n\\n        saveFile('小龙盘密钥.json', JSON.stringify(token_data), 0);\\n\\n        refreshPage(false);\\n\\n        clearItem(\\\"token\\\")\\n\\n        storage0.setItem(\\\"token\\\",newToken)\\n\\n        back();\\n\\n        return 'toast://修改成功'\\n    } else {\\n        return 'toast://修改失败'\\n    }\\n}\\n\\nfunction deleteToken(idex){\\n\\n    token_data.splice(idex, 1);\\n    saveFile('小龙盘密钥.json', JSON.stringify(token_data), 0);\\n\\n    if (token_data[0] === undefined) {\\n\\n        clearItem(\\\"token\\\")\\n        clearItem(\\\"name\\\")\\n        clearItem(\\\"cloud\\\")\\n        clearItem(\\\"idex\\\")\\n        clearItem(\\\"addFolder\\\")\\n        clearItem(\\\"addFolderName\\\")\\n\\n        storage0.setItem(\\\"name\\\",\\\"\\\")\\n        storage0.setItem(\\\"token\\\",\\\"\\\")\\n        storage0.setItem(\\\"cloud\\\",\\\"\\\")\\n        storage0.setItem(\\\"idex\\\",\\\"\\\")\\n        storage0.setItem(\\\"addFolder\\\",\\\"\\\")\\n        storage0.setItem(\\\"addFolderName\\\",\\\"\\\")\\n\\n        back();\\n\\n        return  'toast://请重新登录'\\n    }else {\\n\\n        switched(token_data[0].user,0)\\n        return 'toast://删除成功'\\n\\n    }\\n}\\n\\nfunction switched(user,idex){\\n\\n    let newToken = user.trim();\\n\\n    if (newToken) {\\n\\n        clearItem(\\\"token\\\")\\n        clearItem(\\\"name\\\")\\n        clearItem(\\\"cloud\\\")\\n        clearItem(\\\"idex\\\")\\n        clearItem(\\\"addFolder\\\")\\n        clearItem(\\\"addFolderName\\\")\\n\\n        storage0.setItem(\\\"name\\\",token_data[idex].name)\\n        storage0.setItem(\\\"token\\\",newToken)\\n        storage0.setItem(\\\"cloud\\\",token_data[idex].cloud)\\n        storage0.setItem(\\\"idex\\\",idex)\\n        storage0.setItem(\\\"addFolder\\\",token_data[idex].addFolder)\\n        storage0.setItem(\\\"addFolderName\\\",token_data[idex].addFolderName)\\n\\n        back();\\n\\n        return 'toast://切换成功 欢迎 '+storage0.getItem(\\\"name\\\")\\n    } else {\\n        return 'toast://切换失败'\\n    }\\n}\\n\\nfunction setAddFolder(fileId,folder_name){\\n\\n    if (!fileId.trim()) {\\n        return \\\"toast://文件参数错误\\\"\\n    }else {\\n\\n        token_data[storage0.getItem(\\\"idex\\\")].addFolder = fileId\\n        token_data[storage0.getItem(\\\"idex\\\")].addFolderName = folder_name\\n\\n        saveFile('小龙盘密钥.json', JSON.stringify(token_data), 0);\\n\\n        if (token_data[storage0.getItem(\\\"idex\\\")].addFolder === fileId){\\n\\n            clearItem(\\\"addFolder\\\")\\n            clearItem(\\\"addFolderName\\\")\\n            storage0.setItem(\\\"addFolder\\\",fileId)\\n            storage0.setItem(\\\"addFolderName\\\",folder_name)\\n\\n            refreshPage();\\n\\n            return \\\"toast://设置成功\\\"\\n        }else {\\n            return \\\"toast://设置失败\\\"\\n        }\\n    }\\n\\n}\\n\\nfunction setCloudToken(cloud_token,idex){\\n\\n    if (!cloud_token.trim()) {\\n\\n        return \\\"toast://文件参数错误\\\"\\n\\n    }else {\\n\\n        token_data[idex].cloud = cloud_token\\n\\n        saveFile('小龙盘密钥.json', JSON.stringify(token_data), 0);\\n\\n        if (token_data[idex].cloud === cloud_token){\\n\\n            let data = getLineKey(cloud_token)\\n\\n            clearItem(\\\"cloud\\\")\\n            clearItem(\\\"cloudKey\\\")\\n            storage0.setItem(\\\"cloud\\\",cloud_token)\\n            storage0.setItem(\\\"cloudKey\\\",data.Key)\\n\\n            refreshPage();\\n\\n            return \\\"toast://设置成功\\\"\\n        }else {\\n            return \\\"toast://设置失败\\\"\\n        }\\n    }\\n}\\n\\n\\n\\nfunction changePageInt(num1,num2){\\n    var result\\n    if(num2.equals(\\\"+\\\")){\\n        result = parseInt(num1)+1\\n    }else{\\n        result = parseInt(num1)-1\\n    }\\n    return Number(result).toFixed(0)\\n}\\n\\nfunction getMaxPage(pageCount){\\n\\n    return (pageCount % 100) ? (parseInt(pageCount/100)+1) : (pageCount/100)\\n}\\n\\nfunction getFileSize(file_size){\\n    let size = file_size\\n    if(size < 1024*1024){\\n        size = size / 1024\\n        return size.toFixed(2)+\\\" K\\\"\\n    }else if(size < 1024*1024*1024){\\n        size = size / (1024*1024)\\n        return size.toFixed(2)+\\\" M\\\"\\n    }else if(size < 1024*1024*1024*1024){\\n        size = size / (1024*1024*1024)\\n        return size.toFixed(2)+\\\" G\\\"\\n    }else {\\n        size = size / (1024*1024*1024*1024)\\n        return size.toFixed(2)+\\\" T\\\"\\n    }\\n}\\n\\nfunction timestampToTime(timestamp) {\\n    var date = new Date(timestamp * 1000)\\n    var Y = date.getFullYear() + '-'\\n    var M = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-'\\n    const D = (date.getDate() < 10 ? '0' + date.getDate() : date.getDate()) + ' '\\n    const h = (date.getHours() < 10 ? '0' + date.getHours() : date.getHours()) + ':'\\n    const m = (date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()) + ':'\\n    const s = (date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds())\\n    return Y + M + D + h + m + s\\n}\\n\\nfunction getStartLineSuffix(cid) {\\n\\n    let t=Number(Date.parse( new Date() ).toString().substr(0,10))+86400*6;\\n\\n    if (storage0.getItem(\\\"cloudKey\\\").length > 0 & cloud_token.trim().length > 0){\\n\\n        let data = checkCloudType(cloud_token).data\\n\\n        let u=data.id\\n        let s=md5(storage0.getItem(\\\"cloudKey\\\")+cid+t)\\n        let md5s=md5(s)\\n\\n        return cid+\\\"?filename=0.mp4&v=1&t=\\\"+t+\\\"&u=\\\"+u+\\\"&s=\\\"+md5s+\\\"&c=\\\"+cid\\n    }else {\\n        return cid+\\\"?filename=0.mp4&v=1&t=\\\"+t\\n    }\\n}\\n\\n\\n\\nfunction getImageList(data){\\n\\n    var imageList = []\\n\\n    for(let i = 0;i < data.length;i++){\\n        let is_folder = data[i].is_folder\\n        if (!is_folder){\\n            let file_type = data[i].file_ext\\n            let file_cid = data[i].file_cid\\n\\n\\n            if (image_regular.test(file_type)){\\n\\n                let image = \\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"+file_cid+\\\"@Referer=https://wx.stariverpan.com/\\\"\\n\\n                imageList[i] = image\\n            }\\n        }\\n    }\\n\\n    if(imageList.length<1)return \\\"toast://没识别到图片\\\"\\n\\n    log(imageList.join(\\\"&&\\\"))\\n\\n    return \\\"pics://\\\" +imageList.join(\\\"&&\\\")\\n}\\n\\nfunction immersionInComics(id){\\n\\n    let resultData = [];\\n\\n    showLoading('整合图片中！');\\n\\n    let checkPage = detailForFile(id).data.stats\\n\\n    let pageCount = Number(checkPage.subdir_num + checkPage.subfile_num)\\n\\n    if(pageCount > 100){\\n\\n    }else {\\n\\n        let body =`{\\\"page_num\\\":1,\\\"page_size\\\":100,\\\"parent_id\\\":\\\"`+id+`\\\",\\\"sort_direction\\\":\\\"asc\\\",\\\"sort_field\\\":\\\"name\\\"}`\\n\\n        var result = getPostData(check_url,body)\\n\\n        var data = result.data.files\\n\\n        // data.sort(function (a,b){\\n        //     var numA = parseInt(a.file_name.match(/\\\\d+/)[0]);\\n        //     var numB = parseInt(b.file_name.match(/\\\\d+/)[0]);\\n        //     return numA - numB;\\n        // })\\n\\n        for(var i in data){\\n\\n            let id = data[i].id\\n\\n            let imageList = getImageData(id)\\n\\n            resultData = resultData.concat(imageList);\\n\\n        }\\n\\n    }\\n\\n    hideLoading();\\n\\n    if (resultData.length === pageCount){\\n\\n        return \\\"toast://有非图片文件，不要乱使用\\\"\\n\\n    }else {\\n\\n        return \\\"pics://\\\" +resultData.join(\\\"&&\\\")\\n\\n    }\\n}\\n\\nfunction getImageData(fileId){\\n\\n    let results = [];\\n\\n    let line = \\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"\\n\\n    let suffix = \\\"@Referer=https://wx.stariverpan.com/\\\"\\n\\n    let body =`{\\\"page_num\\\":1,\\\"page_size\\\":100,\\\"parent_id\\\":\\\"`+fileId+`\\\",\\\"sort_direction\\\":\\\"asc\\\",\\\"sort_field\\\":\\\"name\\\"}`\\n\\n    var result = getPostData(check_url,body)\\n\\n    var data = result.data.files\\n\\n    for(var i in data){\\n\\n        let fileCid = data[i].file_cid\\n\\n        let type = data[i].file_ext\\n\\n        let newUrl = line+fileCid+suffix\\n\\n        if(image_regular.test(type)){\\n\\n            results.push(newUrl);\\n\\n        }\\n    }\\n\\n    results.push(line+\\\"bafkreidgame5tiez2yqgavbdbs2hbnqf6oxudpzrsxotq6hntb6bigon3y\\\"+suffix);\\n\\n    return results\\n}\\n\\nfunction backFileImageList(path){\\n\\n    let resultData = [];\\n\\n    showLoading('整合图片中！');\\n\\n    let data = JSON.parse(readFile(path, 0) || '[]').data;\\n\\n    let folderList = data.文件夹\\n\\n    for(let i in folderList){\\n\\n        let folderName = folderList[i]\\n\\n        let newPath = path.slice(0,-5)+\\\"⸝\\\"+folderName+\\\".json\\\"\\n\\n        let imageList = getBackImageData(newPath,folderName);\\n\\n        resultData = resultData.concat(imageList);\\n    }\\n\\n    hideLoading();\\n\\n    if (resultData.length === folderList.length){\\n\\n        return \\\"toast://有非图片文件，不要乱使用\\\"\\n\\n    }else {\\n\\n        return \\\"pics://\\\" +resultData.join(\\\"&&\\\")\\n\\n    }\\n\\n}\\n\\nfunction getBackImageData(path,folderName){\\n\\n    let results = [];\\n\\n    let line = \\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"\\n\\n    let suffix = \\\"@Referer=https://wx.stariverpan.com/\\\"\\n\\n    let data = JSON.parse(readFile(path, 0) || '[]').data;\\n\\n    let fileList = data.文件\\n\\n    results.push(folderName);\\n\\n    for (let i in fileList){\\n\\n        let fileType = fileList[i].文件格式\\n\\n        let cid = fileList[i].文件CID\\n\\n        let newUrl = line + cid + suffix\\n\\n        if(fileType === 2){\\n\\n            results.push(newUrl);\\n\\n        }\\n    }\\n\\n    results.push(line+\\\"bafkreidgame5tiez2yqgavbdbs2hbnqf6oxudpzrsxotq6hntb6bigon3y\\\"+suffix);\\n\\n    return results\\n\\n}\\n\\nfunction backFileImageListForStart(path){\\n\\n    let resultData = [];\\n\\n    showLoading('整合图片中！');\\n\\n    let data = JSON.parse(readFile(path, 0) || '[]').fileData;\\n\\n    let fileList = data.files\\n\\n    for(let i in fileList){\\n\\n        let type = fileList[i].type\\n\\n        let folderName = fileList[i].name\\n\\n        let folderId = fileList[i].id\\n\\n        if (type === 1){\\n\\n            let newPath = startIndexPath+folderId+folderName+\\\".json\\\"\\n\\n            let imageList = getBackImageDataForStart(newPath,folderName);\\n\\n            resultData = resultData.concat(imageList);\\n\\n        }\\n    }\\n\\n    hideLoading();\\n\\n    if (resultData.length === fileList.length){\\n\\n        return \\\"toast://有非图片文件，不要乱使用\\\"\\n\\n    }else {\\n\\n        return \\\"pics://\\\" +resultData.join(\\\"&&\\\")\\n\\n    }\\n}\\n\\nfunction getBackImageDataForStart(path,folderName){\\n\\n    let results = [];\\n\\n    let line = \\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"\\n\\n    let suffix = \\\"@Referer=https://wx.stariverpan.com/\\\"\\n\\n    let data = JSON.parse(readFile(path, 0) || '[]').fileData;\\n\\n    let fileList = data.files\\n\\n    results.push(folderName);\\n\\n    for (let i in fileList){\\n\\n        let type = fileList[i].type\\n\\n        let fileType = fileList[i].suffix\\n\\n        let cid = fileList[i].cid\\n\\n        let newUrl = line + cid + suffix\\n\\n        if (type === 1){\\n\\n            hideLoading();\\n\\n            toast(\\\"有子文件夹，请不要乱使用\\\")\\n\\n            return \\\"\\\"\\n        }\\n\\n        if (image_regular.test(fileType)){\\n\\n            results.push(newUrl);\\n        }\\n    }\\n\\n    results.push(line+\\\"bafkreidgame5tiez2yqgavbdbs2hbnqf6oxudpzrsxotq6hntb6bigon3y\\\"+suffix);\\n\\n    return results\\n\\n}\\n\\n\\n\\n\\nvar getFileUrlLine = $('#noLoading#').lazyRule(() => {\\n\\n    eval(JSON.parse(request('hiker://page/functions')).rule)\\n\\n    let cid=input.split(\\\"&&\\\")[0]\\n    let type=input.split(\\\"&&\\\")[1]\\n\\n    //线路\\n    let line0 = \\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"\\n    let line1 = \\\"https://ipfsgw01.stariverpan.com:9096/ipfs/\\\"\\n    let line2 = \\\"https://ipfsgw02.stariverpan.com:9096/ipfs/\\\"\\n\\n    //line2 = \\\"http://csg.lindensys.cn/poss/v1/myspace/ipfs/\\\"+cid\\n    // line3 = \\\"https://tv4.invbo1.cfd/ipfs/\\\"+cid+\\\"?site=www.invbo.ink\\\",\\n    // line4 = \\\"https://tv2.moecn.ml/ipfs/\\\"+cid+\\\"?site=www.invbo.ink\\\",\\n    // line5 = \\\"https://tv2.invbo2.cfd/ipfs/\\\"+cid+\\\"?site=www.invbo.ink\\\",\\n    let line3 = \\\"https://ipfsgw04.stariverpan.com:9096/ipfs/\\\"\\n    let line4 = \\\"https://ipfsgw05.stariverpan.com:9096/ipfs/\\\"\\n    let line5 = \\\"https://ipfsgw06.stariverpan.com:9096/ipfs/\\\"\\n\\n    let line6 = \\\"https://ipfs.bitark.info/ipfs/\\\"+cid\\n    let line7 = \\\"https://glipfs.com/ipfs/\\\"+cid\\n    let line8 = \\\"https://ipfs-gw.nmedia.space/ipfs/\\\"+cid\\n    let line9 = \\\"https://img.kennelclub.pro/ipfs/\\\"+cid\\n\\n    let line10 = \\\"https://ipfs-gw.nmedia.space/ipfs/\\\"+cid\\n\\n\\n    var ortherLines = [\\n        //line1=\\\"https://ipfsgw01.stariverpan.com:9096/ipfs/\\\"\\n        //line3=\\\"https://ipfsgw03.stariverpan.com:9096/ipfs/\\\"\\n        //line4=\\\"https://ipfsgw04.stariverpan.com:9096/ipfs/\\\"\\n        //line5=\\\"https://ipfsgw05.stariverpan.com:9096/ipfs/\\\"\\n        //line6=\\\"https://ipfs-gw.nmedia.space/ipfs/\\\"+cid\\n        //line7=\\\"https://glipfs.com/ipfs/\\\"+cid\\n\\n        //addr=https://crustwebsites.net\\n        //addr=https://ipfs-gw.decloud.foundation\\n        //addr=https://gw.crustapps.net\\n\\n        //https://ipfsgw04.stariverpan.com:9096/ipfs/\\n    ]\\n\\n    let head = {\\n        \\\"Referer\\\":\\\"https://ushare.stariverpan.com/web/share/?lang=zh&amp;shareId=NjY2ODMzMDA3OTEwMzMwMzY4\\\",\\n        \\\"User-Agent\\\":\\\"Mozilla/5.0 (iPhone; CPU iPhone OS 15_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.1 Mobile/15E148 Safari/604.1\\\"\\n    }\\n    var lines = [line0, line1, line2, line3, line4, line5,line6, line7, line8, line9];\\n    var linesName = [];\\n    var heads = [];\\n    for (var i = 0; i < lines.length; i++) {\\n        if (i < 3){\\n            lines[i] = lines[i] + getStartLineSuffix(cid)+\\\"#isVideo=true#\\\"\\n            heads.push(head)\\n        }\\n        linesName.push(\\\"线路 \\\" + i)\\n        // if (i > 1 && i < 3){\\n        //     heads.push({\\n        //         \\\"User-Agent\\\": \\\"Mozilla/5.0 (iPhone; CPU iPhone OS 15_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.1 Mobile/15E148 Safari/604.1\\\"\\n        //     })\\n        // }\\n        if (i > 2 && i < 6){\\n            // heads.push({\\n            //     \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 12; 2201122C) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.104 Mobile Safari/537.36\\\",\\n            //     \\\"Referer\\\": \\\"www.invbo.ink\\\",\\n            //     \\\"Accept\\\": \\\"*/*\\\",\\n            //     \\\"Accept-Encoding\\\": \\\"identity\\\"\\n            // })\\n            lines[i] = lines[i] + cid+\\\"?v=2&u=686657438220296192&t=\\\"+Number(Date.parse( new Date() ).toString().substr(0,10))+86400*6\\n            heads.push(head)\\n        }\\n        heads.push({\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (iPhone; CPU iPhone OS 15_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.1 Mobile/15E148 Safari/604.1\\\"\\n        })\\n    }\\n\\n    let data = {\\n        \\\"urls\\\":lines,\\n        \\\"headers\\\": heads,\\n        \\\"names\\\":linesName\\n    }\\n\\n    switch (true) {\\n        case image_regular.test(type):\\n\\n            let url_type = '#.jpg@Referer=https://wx.stariverpan.com/'\\n            let url_back = line0+cid+url_type\\n            return url_back;\\n\\n        case video_regular.test(type):\\n\\n            return JSON.stringify(data);\\n\\n        case audio_regular.test(type):\\n            url_type = \\\"#.mp3@Referer@https://wx.stariverpan.com/\\\"\\n            url_back = line0+cid+url_type\\n            return url_back\\n\\n        default:\\n\\n            let down_line = \\\"download://https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"+cid\\n\\n            return down_line;\\n    }\\n})\\n\\n\\n\\n\\n\\nfunction addMagent(id,urls){\\n\\n\\n    let body=`{\\\"params\\\":{\\\"with_thumbnail\\\":true},\\\"parent_id\\\":\\\"`+id+`\\\",\\\"upload_type\\\":\\\"url\\\",\\\"url\\\":\\\"`+urls+`\\\"}`\\n\\n\\n    try {\\n\\n        let data = getPostData(add_magent,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://添加成功'\\n        }else {\\n            let message = data.message === \\\"Task already exist\\\" ? \\\"磁力已在队列中\\\" : data.message\\n            refreshPage();\\n            return 'toast://添加失败'+message\\n        }\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction deleteMagent(id){\\n\\n    let body=`{\\\"task_ids\\\":[\\\"`+id+`\\\"],\\\"type\\\":\\\"offline\\\"}`\\n\\n    try {\\n\\n        let data = getPostData(delete_magent,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://删除成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://删除失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\n\\n\\n\\nfunction createFolder(id,name){\\n\\n    let body = `{\\\"parent_id\\\": \\\"`+id+`\\\", \\\"name\\\": \\\"`+name+`\\\"}`\\n\\n    try {\\n\\n        let data = getPostData(add_folder,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://新建成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://新建失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction updateFileName(id,name){\\n    let body = `{\\\"id\\\": \\\"`+id+`\\\", \\\"name\\\": \\\"`+name+`\\\"}`\\n\\n    try {\\n\\n        let data = getPostData(update_folder,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://修改成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://修改失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction deleteStartFile(id){\\n\\n    let body = `{\\\"ids\\\": [\\\"`+id+`\\\"]}`\\n\\n    try {\\n\\n        let data = getPostData(delete_folder,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://删除成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://删除失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction detailForFile(id){\\n\\n\\n    let body = `{\\\"id\\\": \\\"`+id+`\\\"}`\\n\\n    try {\\n\\n        let data = getPostData(file_detail,body)\\n\\n        if (data.code === 200){\\n\\n            return data\\n        }else {\\n            return 'toast://请求失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\n\\n\\n\\nfunction trashFiles(page,type,asc){\\n\\n    let body = `{\\\"page_num\\\": `+page+`,\\\"page_size\\\": 100,\\\"count\\\": 0,\\\"sort_field\\\": \\\"`+type+`\\\",\\\"sort_direction\\\": \\\"`+asc+`\\\"}`\\n\\n    let data = getPostData(trash_file,body)\\n\\n    if (data.code === 200){\\n        return data\\n    }else {\\n        return 'toast://'+data.message\\n    }\\n\\n}\\n\\nfunction deleteFilesForTrash(id){\\n\\n    let body = `{\\\"ids\\\":[\\\"`+id+`\\\"]}`\\n\\n    try {\\n\\n        let data = getPostData(trash_delete,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://删除成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://删除失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction cleanFilesForTrash(){\\n    let body = `{}`\\n\\n    try {\\n\\n        let data = getPostData(trash_clean,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://清除成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://清除失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction recoverForTrash(id){\\n\\n    let body = `{\\\"ids\\\":[\\\"`+id+`\\\"]}`\\n\\n    try {\\n\\n        let data = getPostData(trash_recover,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://恢复成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://恢复失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction searchAllFiles(name){\\n\\n}\\n\\n\\n\\n\\n\\nfunction saveFileToChange(oldId,oldName,newId,type){\\n\\n    try {\\n\\n        showLoading('操作中转存中！不要乱点击');\\n\\n        if (type === \\\"folder\\\"){\\n\\n            log(\\\"----------文件夹操作中----------\\\")\\n\\n            let checkFolder = checkSaveFolder(newId,oldName)\\n\\n            log(\\\"检查文件是否转存过：\\\"+JSON.stringify(checkFolder))\\n\\n            if (checkFolder){\\n\\n                log(\\\"转存过的文件夹id：\\\"+checkFolder.id)\\n\\n                saveCloudFile(oldId,checkFolder.id)\\n\\n            }else {\\n\\n                let data = createCloudFolder(newId,oldName)\\n\\n                log(\\\"没有转存过 创建文件夹id：\\\"+data.data)\\n\\n                if (data.code === 200){\\n\\n                    saveCloudFile(oldId,data.data)\\n\\n                }else {\\n                    return 'toast://转存失败'\\n                }\\n            }\\n\\n        }else if (type === \\\"file\\\"){\\n\\n            log(\\\"----------文件操作中----------\\\")\\n\\n            let data = detailForFile(oldId).data.file\\n\\n            let fileName = data.file_name\\n            let fileSize = data.file_size\\n            let fileCid = data.file_cid\\n            let fileType = data.file_type\\n            let parentId = newId\\n            let suffix = \\\".\\\"+data.file_ext\\n\\n            let check = checkSaveFile(newId,fileName)\\n\\n            log(\\\"检查文件是否转存过：\\\"+JSON.stringify(check))\\n\\n            if (check){\\n\\n                if (check.fileCid === fileCid) return \\\"toast://已保存过\\\"\\n\\n            }else {\\n\\n                if (saveOneCloudFile(fileName,fileSize,fileCid,fileType,parentId,suffix)){\\n                    return \\\"toast://转存成功\\\"\\n                }else {\\n                    return 'toast://转存失败'\\n                }\\n            }\\n        }\\n\\n        toast(\\\"转存成功！\\\")\\n\\n        hideLoading();\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction saveCloudFile(oldId,newId){\\n\\n    let checkPage = detailForFile(oldId).data.stats\\n\\n    let pageCount = Number(checkPage.subdir_num + checkPage.subfile_num)\\n\\n    let page = pageCount > 100 ? Number((pageCount/100)+1).toFixed(0) : 1\\n\\n    for (let i = 1; i <= page; i++) {\\n\\n        let body =`{\\\"page_num\\\":`+i+`,\\\"page_size\\\":100,\\\"parent_id\\\":\\\"`+oldId+`\\\",\\\"sort_direction\\\":\\\"asc\\\",\\\"sort_field\\\":\\\"name\\\"}`\\n\\n        log(\\\"查询页数：\\\"+page)\\n\\n        try{\\n\\n            let data = getPostData(check_url,body).data.files\\n\\n            for (var x in data){\\n\\n                let fileId = data[x].id\\n                let fileName = data[x].file_name\\n                let isFolder = data[x].is_folder\\n\\n                if (isFolder > 0){\\n\\n                    log(\\\"查询的文件夹：\\\"+fileName)\\n\\n                    let checkFolder = checkSaveFolder(newId,fileName)\\n\\n                    log(\\\"查询文件是否已存在：\\\"+JSON.stringify(checkFolder))\\n\\n                    if (checkFolder) {\\n\\n                        //toast(fileName+\\\"文件已存过正在跳过！\\\")\\n\\n                        log(\\\"文件夹已转存过：\\\"+checkFolder.id)\\n\\n                        saveCloudFile(fileId, checkFolder.id)\\n\\n                    }else {\\n\\n                        let folder = createCloudFolder(newId,fileName)\\n\\n                        log(\\\"文件夹没有转存过：\\\"+JSON.stringify(folder))\\n\\n                        let newsId = folder.data\\n\\n                        log(\\\"新文件夹id：\\\"+newsId)\\n\\n                        saveCloudFile(fileId,newsId)\\n                    }\\n\\n                }else {\\n\\n                    log(\\\"查询的文件\\\"+fileName)\\n\\n                    let fileSize = data[x].file_size\\n                    let fileCid = data[x].file_cid\\n                    let fileType = data[x].file_type\\n                    let parentId = newId\\n                    let suffix = \\\".\\\"+data[x].file_ext\\n\\n                    let check = checkSaveFile(newId,fileName)\\n\\n                    log(\\\"查询文件是否已存在：\\\"+JSON.stringify(check))\\n\\n                    if (check){\\n\\n                        if (check.fileCid === fileCid){\\n\\n                            //toast(fileName+\\\"文件已存过正在跳过！\\\")\\n\\n                        }\\n\\n                    }else {\\n\\n                        if (!saveOneCloudFile(fileName,fileSize,fileCid,fileType,parentId,suffix)){\\n                            return \\\"toast://\\\"+fileName+\\\"转存失败\\\"\\n                        }\\n                    }\\n\\n                }\\n\\n            }\\n\\n        }catch (e) {\\n            log(e.message)\\n        }\\n    }\\n\\n}\\n\\n\\nfunction createCloudFolder(newId,oldName){\\n\\n    try {\\n\\n        let body = `{\\\"parentId\\\": \\\"`+newId+`\\\",\\\"fileName\\\": \\\"`+oldName+`\\\"}`\\n\\n        let data = getCloudPostData(cloud_addFolder,getCloudHead(cloud_login_token),body)\\n\\n        if (data.code === 200){\\n            return data\\n        }else {\\n            return 'toast://新建文件夹失败'\\n        }\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction saveOneCloudFile(fileName,fileSize,fileCid,fileType,parentId,suffix){\\n\\n    let body = `{\\\"filePath\\\":\\\"\\\",\\\"dirPath\\\":[],\\\"fileName\\\":\\\"`+fileName+`\\\",\\\"fileSize\\\":`+fileSize+`,\\\"fileCid\\\":\\\"`+fileCid+`\\\",\\\"fileType\\\":`+fileType+`,\\\"parentId\\\":\\\"`+parentId+`\\\",\\\"id\\\":\\\"\\\",\\\"suffix\\\":\\\"`+suffix+`\\\",\\\"thumbnail\\\":\\\"\\\",\\\"duration\\\":1,\\\"width\\\":\\\"0\\\",\\\"height\\\":\\\"0\\\"}`\\n\\n    let data = getCloudPostData(cloud_addFile,getCloudHead(cloud_login_token),body)\\n\\n    return data.code === 200;\\n}\\n\\n\\n\\nfunction checkSaveFile(parentId,fileName){\\n\\n    let body = `{\\\"fileName\\\": \\\"`+fileName+`\\\",\\\"sortFlag\\\": \\\"name\\\",\\\"sortType\\\": \\\"desc\\\",\\\"parentId\\\": \\\"`+parentId+`\\\"}`\\n\\n    let result = getCloudPostData(cloud_checkFile,getCloudHead(cloud_login_token),body)\\n\\n    if(result.code === 200){\\n\\n        if(result.data.count > 0){\\n\\n            return result.data.data[0]\\n\\n        }else {\\n            return \\\"\\\"\\n        }\\n\\n    }else{\\n        return \\\"toast://查询-文件是否保存过-失败\\\"\\n    }\\n}\\n\\nfunction checkSaveFolder(parentId,fileName){\\n\\n    let body = `{\\\"fileName\\\": \\\"`+fileName+`\\\",\\\"sortFlag\\\": \\\"upload\\\",\\\"sortType\\\": \\\"desc\\\",\\\"parentId\\\": \\\"`+parentId+`\\\"}`\\n\\n    let result = getCloudPostData(cloud_checkFolder,getCloudHead(cloud_login_token),body)\\n\\n    if(result.code === 200){\\n\\n        if(result.data.count > 0){\\n\\n            return result.data.data[0]\\n\\n        }else {\\n            return \\\"\\\"\\n        }\\n\\n    }else{\\n        return \\\"toast://查询-文件夹是否保存过-失败\\\"\\n    }\\n}\\n\\n\\n\\nfunction backSaveOne(name,path,data){\\n\\n    let fileName = \\\"hiker://files/rules/小龙盘资源/备份文件/小龙盘文件夹备份/\\\"+name+\\\".json\\\"\\n\\n    let saveData = `{\\\"createTime\\\":\\\"`+new Date().getTime()+`\\\",\\\"saveType\\\":\\\"文件备份\\\",\\\"fileData\\\": {\\\"path\\\": \\\"`+path+`\\\",\\\"files\\\":[`+data+`]}}`\\n\\n    // log(\\\"保存json文件：\\\"+JSON.stringify(saveData))\\n\\n    saveFile(fileName, saveData, 0);\\n\\n}\\n\\nfunction backSaveByMore(path,data){\\n\\n    let fileBack = JSON.parse(readFile(path, 0) || '[]');\\n\\n    // log(\\\"原来的数据:\\\"+JSON.stringify(fileBack))\\n\\n    fileBack.fileData.files = fileBack.fileData.files.concat(JSON.parse(data))\\n\\n    log(\\\"修改后的：\\\"+JSON.stringify(fileBack).toString())\\n\\n    saveFile(path, JSON.stringify(fileBack).toString(), 0);\\n\\n}\\n\\nfunction deleteBackFile(path){\\n\\n    if (fileExist(path)){\\n\\n        deleteFile(path)\\n\\n    }else {\\n\\n        return \\\"toast://未找到文件\\\"\\n\\n    }\\n}\\n\\n\\n\\nfunction checkBackIsTrue(path,data,pathName){\\n\\n    if (fileExist(startIndexPath+data.id+data.file_name+\\\".json\\\")){\\n\\n        confirm({\\n\\n            title:path.length > 0 ? '文件以备份过，进行更新操作' : '更新首页备份提醒',\\n            content:'确定-将更新原有的数据\\\\n取消-备份取消',\\n\\n            confirm:$.toString((startIndexPath,data)=>{\\n\\n                eval(JSON.parse(request('hiker://page/functions')).rule)\\n\\n                showLoading('更新备份中！不要乱点击');\\n\\n                let file = JSON.parse(readFile(startIndexPath+data.id+data.file_name+\\\".json\\\", 0) || '[]')\\n\\n                checkUpdateBackFile(data.id,data.file_name,file.fileData.path)\\n\\n                hideLoading();\\n\\n                toast(\\\"更新备份成功！\\\")\\n\\n            },startIndexPath,data),\\n\\n            cancel:$.toString(()=>{\\n\\n                showLoading('操作更新备份中！不要乱点击');\\n\\n                hideLoading();\\n\\n                toast(\\\"选择取消！\\\")\\n\\n            })\\n\\n        })\\n\\n    }else {\\n\\n        showLoading('操作备份中！不要乱点击');\\n\\n        if (path.length > 0){\\n\\n            saveBackFileForChange(path,data,pathName)\\n\\n        }else {\\n\\n            saveBackFile(data)\\n\\n        }\\n\\n        hideLoading();\\n\\n        toast(\\\"备份成功！\\\")\\n\\n    }\\n\\n}\\n\\nfunction checkUpdateBackFile(id,name,path){\\n\\n    let checkPage = detailForFile(id).data.stats\\n\\n    let pageCount = Number(checkPage.subdir_num + checkPage.subfile_num)\\n\\n    let page = pageCount > 100 ? Number((pageCount/100)+1).toFixed(0) : 1\\n\\n    for (let i = 1; i <= page; i++) {\\n\\n        let body =`{\\\"page_num\\\":`+i+`,\\\"page_size\\\":100,\\\"parent_id\\\":\\\"`+id+`\\\",\\\"sort_direction\\\":\\\"asc\\\",\\\"sort_field\\\":\\\"name\\\"}`\\n\\n        let data = getPostData(check_url,body).data.files\\n\\n        log(\\\"循环的path数据：\\\"+startIndexPath+id+name+\\\".json\\\")\\n\\n        if (fileExist(startIndexPath+id+name+\\\".json\\\")){\\n\\n            updateBackFile(id,name,getBackSaveData(id))\\n\\n        }else {\\n\\n            backSaveOne(id+name,path+\\\"⸝\\\"+name,getBackSaveData(id))\\n\\n        }\\n\\n        for (var x in data){\\n\\n            let fileId = data[x].id\\n\\n            let fileName = data[x].file_name\\n\\n            let isFolder = data[x].is_folder\\n\\n            if (isFolder > 0){\\n\\n                checkUpdateBackFile(fileId,fileName)\\n\\n            }\\n        }\\n\\n    }\\n}\\n\\nfunction updateBackFile(id,name,newData){\\n\\n    let checkFile = JSON.parse(readFile(startIndexPath+id+name+\\\".json\\\", 0) || '[]')\\n\\n    let oldData = checkFile.fileData.files\\n\\n    if (oldData.length === newData.length){\\n\\n        log(\\\"条数相同，没有新增\\\")\\n\\n        return \\\"\\\"\\n\\n    }else {\\n\\n        let fileBack = JSON.parse(readFile(startIndexPath+id+name+\\\".json\\\", 0) || '[]');\\n\\n        let saveData = '['+(newData.toString())+']'\\n\\n        fileBack.fileData.files = JSON.parse(saveData)\\n\\n        saveFile(startIndexPath+id+name+\\\".json\\\", JSON.stringify(fileBack), 0);\\n\\n\\n    }\\n\\n}\\n\\n\\nfunction saveBackFileForChange(path,data,pathName){\\n\\n    showLoading('操作备份中！不要乱点击');\\n\\n    let check = detailForFile(data.id)\\n\\n    if (data.is_folder === 0){\\n\\n        if (data.file_cid.length < 1){\\n\\n            hideLoading();\\n\\n            toast(\\\"文件cid丢失！\\\")\\n\\n            return \\\"\\\"\\n        }\\n\\n    }else {\\n\\n        let checkPage = check.data.stats\\n\\n        if (check.code === undefined){\\n\\n            hideLoading();\\n\\n            toast(\\\"文件错误或不存在！\\\")\\n\\n            return \\\"\\\"\\n        }\\n\\n        if (Number(checkPage.subdir_num + checkPage.subfile_num) < 1){\\n\\n            hideLoading();\\n\\n            toast(\\\"没文件你备份什么？小心我锤死你！\\\")\\n\\n            return \\\"\\\"\\n        }\\n\\n    }\\n\\n    let indexPath = \\\"hiker://files/rules/小龙盘资源/备份文件/小龙盘文件夹备份/\\\"\\n\\n    let indexFile = [];\\n\\n    if (data.is_folder === 1){\\n\\n        indexFile.push(getBackSaveFolder(data.id,data.file_name));\\n\\n    }else {\\n\\n        let fileName = data.file_name\\n        let fileSize = data.file_size\\n        let fileCid = data.file_cid\\n        let fileType = data.file_type\\n        let suffix = \\\".\\\"+data.file_ext\\n\\n        indexFile.push(getBackSaveFile(fileName,fileSize,fileCid,fileType,suffix));\\n\\n    }\\n\\n    let index = indexPath+path+\\\".json\\\"\\n\\n    backSaveByMore(index,indexFile)\\n\\n    let id = data.id\\n\\n    if (data.is_folder === 1){\\n\\n        saveForFolder(id,data.file_name,pathName)\\n\\n    }\\n\\n    hideLoading();\\n\\n    toast(\\\"备份成功！\\\")\\n\\n    storage0.setItem(\\\"backChange\\\",\\\"false\\\")\\n\\n}\\n\\nfunction saveBackFile(data){\\n\\n    showLoading('操作备份中！不要乱点击');\\n\\n    let check = detailForFile(data.id)\\n\\n    if (data.is_folder === 0){\\n\\n        if (data.file_cid.length < 1){\\n\\n            hideLoading();\\n\\n            toast(\\\"文件cid丢失！\\\")\\n\\n            return \\\"\\\"\\n        }\\n\\n    }else {\\n\\n        let checkPage = check.data.stats\\n\\n        if (check.code === undefined){\\n\\n            hideLoading();\\n\\n            toast(\\\"文件错误或不存在！\\\")\\n\\n            return \\\"\\\"\\n        }\\n\\n        if (Number(checkPage.subdir_num + checkPage.subfile_num) < 1){\\n\\n            hideLoading();\\n\\n            toast(\\\"没文件你备份什么？小心我锤死你！\\\")\\n\\n            return \\\"\\\"\\n        }\\n\\n    }\\n\\n    let path = \\\"hiker://files/rules/小龙盘资源/备份文件/小龙盘文件夹备份/\\\"\\n\\n    let indexFile = [];\\n\\n    if (data.is_folder === 1){\\n\\n        indexFile.push(getBackSaveFolder(data.id,data.file_name));\\n\\n    }else {\\n\\n        let fileName = data.file_name\\n        let fileSize = data.file_size\\n        let fileCid = data.file_cid\\n        let fileType = data.file_type\\n        let suffix = \\\".\\\"+data.file_ext\\n\\n        indexFile.push(getBackSaveFile(fileName,fileSize,fileCid,fileType,suffix));\\n\\n    }\\n\\n    if(fileExist(path+\\\"0.json\\\")){\\n\\n        let index = path+\\\"0.json\\\"\\n\\n        backSaveByMore(index,indexFile)\\n\\n    }else {\\n\\n        backSaveOne(\\\"0\\\",\\\"0\\\",indexFile)\\n\\n    }\\n\\n    let id = data.id\\n\\n    let newName = data.file_name\\n\\n    if (data.is_folder === 1){\\n\\n        saveForFolder(id,newName,\\\"\\\")\\n\\n    }\\n\\n    hideLoading();\\n\\n    toast(\\\"备份成功！\\\")\\n\\n}\\n\\nfunction moveBackFile(data,oldPath,newPath){\\n\\n    if (oldPath === newPath){\\n\\n        toast(\\\"移动到原来的位置你在想什么？\\\")\\n\\n        clearItem(\\\"moveType\\\")\\n\\n        clearItem(\\\"moveData\\\")\\n\\n        storage0.setItem(\\\"moveType\\\", \\\"false\\\");\\n\\n        refreshPage()\\n\\n        return \\\"\\\"\\n    }\\n\\n    if (newPath.includes(data.name)){\\n\\n        toast(\\\"把文件夹保存到文件夹本身下，你真会玩！\\\")\\n\\n        clearItem(\\\"moveType\\\")\\n\\n        clearItem(\\\"moveData\\\")\\n\\n        storage0.setItem(\\\"moveType\\\", \\\"false\\\");\\n\\n        refreshPage()\\n\\n        return \\\"\\\"\\n    }\\n\\n    let oldData = JSON.parse(readFile(oldPath, 0) || '[]')\\n\\n    let oldFile = oldData.fileData.files\\n\\n    let dataIndex = oldFile.findIndex(item => item.name === data.name);\\n\\n    if (dataIndex !== -1) {\\n\\n        oldData.fileData.files.splice(dataIndex, 1);\\n\\n    }\\n\\n    saveFile(oldPath, JSON.stringify(oldData), 0);\\n\\n    let newData = JSON.parse(readFile(newPath, 0) || '[]')\\n\\n    if (data.type === 1){\\n\\n        let checkData = JSON.parse(readFile(startIndexPath+data.id+data.name+\\\".json\\\", 0) || '[]')\\n\\n        checkData.fileData.path = newData.fileData.path+\\\"⸝\\\"+data.name\\n\\n        saveFile(startIndexPath+data.id+data.name+\\\".json\\\", JSON.stringify(checkData), 0);\\n    }\\n\\n    let newFile = newData.fileData.files\\n\\n    newFile.push(data)\\n\\n    saveFile(newPath, JSON.stringify(newData), 0);\\n\\n    toast(\\\"移动成功\\\")\\n\\n    clearItem(\\\"moveType\\\")\\n\\n    clearItem(\\\"moveData\\\")\\n\\n    storage0.setItem(\\\"moveType\\\", \\\"false\\\");\\n\\n    refreshPage()\\n\\n    return \\\"\\\"\\n\\n}\\n\\n\\nfunction saveForFolder(id,name,path){\\n\\n    let checkPage = detailForFile(id).data.stats\\n\\n    let pageCount = Number(checkPage.subdir_num + checkPage.subfile_num)\\n\\n    let page = pageCount > 100 ? Number((pageCount/100)+1).toFixed(0) : 1\\n\\n    for (let i = 1; i <= page; i++) {\\n\\n        let body =`{\\\"page_num\\\":`+i+`,\\\"page_size\\\":100,\\\"parent_id\\\":\\\"`+id+`\\\",\\\"sort_direction\\\":\\\"asc\\\",\\\"sort_field\\\":\\\"name\\\"}`\\n\\n        let data = getPostData(check_url,body).data.files\\n\\n        let saveData = getBackSaveData(id)\\n\\n        if (path === \\\"\\\"){\\n\\n            path = \\\"0⸝\\\"+name\\n\\n        }else {\\n\\n            path = path+\\\"⸝\\\"+name\\n        }\\n\\n        backSaveOne(id+name,path,saveData)\\n\\n        for (var x in data){\\n\\n            let fileId = data[x].id\\n\\n            let fileName = data[x].file_name\\n\\n            let isFolder = data[x].is_folder\\n\\n            if (isFolder > 0){\\n\\n                saveForFolder(fileId,fileName,path)\\n\\n            }\\n        }\\n\\n    }\\n\\n}\\n\\nfunction getBackSaveData(id){\\n\\n    let fileData = [];\\n\\n    let checkPage = detailForFile(id).data.stats\\n\\n    let pageCount = Number(checkPage.subdir_num + checkPage.subfile_num)\\n\\n    let page = pageCount > 100 ? Number((pageCount/100)+1).toFixed(0) : 1\\n\\n    for (let i = 1; i <= page; i++) {\\n\\n        let body =`{\\\"page_num\\\":`+i+`,\\\"page_size\\\":100,\\\"parent_id\\\":\\\"`+id+`\\\",\\\"sort_direction\\\":\\\"asc\\\",\\\"sort_field\\\":\\\"name\\\"}`\\n\\n        let data = getPostData(check_url,body).data.files\\n\\n        for (var x in data){\\n\\n            let fileId = data[x].id\\n\\n            let fileName = data[x].file_name\\n\\n            let isFolder = data[x].is_folder\\n\\n            if (isFolder > 0){\\n\\n                fileData.push(getBackSaveFolder(fileId,fileName));\\n\\n            }else {\\n\\n                let fileSize = data[x].file_size\\n                let fileCid = data[x].file_cid\\n                let fileType = data[x].file_type\\n                let suffix = \\\".\\\"+data[x].file_ext\\n\\n                fileData.push(getBackSaveFile(fileName,fileSize,fileCid,fileType,suffix));\\n\\n            }\\n        }\\n\\n    }\\n\\n    return fileData\\n\\n}\\n\\nfunction getBackDeleteForFile(id,name,fileData){\\n\\n    let files = JSON.parse(readFile(startIndexPath+id+name+\\\".json\\\", 0) || '[]').fileData.files\\n\\n    for (let i in files) {\\n\\n        let id = files[i].id\\n\\n        let name = files[i].name\\n\\n        let type = files[i].type\\n\\n        if (type === 1){\\n\\n            fileData.push(startIndexPath+id+name+\\\".json\\\")\\n\\n            getBackDeleteForFile(id,name,fileData)\\n        }\\n    }\\n\\n    return fileData\\n}\\n\\nfunction backFolderDelete(data,path){\\n\\n    if (fileExist(startIndexPath+data.id+data.name+\\\".json\\\")){\\n\\n        showLoading('删除备份中！不要乱点击');\\n\\n        let fileData = [];\\n\\n        let indexData = JSON.parse(readFile(path, 0) || '[]')\\n\\n        let indexFile = indexData.fileData.files\\n\\n        let dataIndex = indexFile.findIndex(item => item.id === data.id);\\n\\n        if (dataIndex !== -1) {\\n\\n            indexData.fileData.files.splice(dataIndex, 1);\\n\\n        }\\n\\n        saveFile(path, JSON.stringify(indexData), 0);\\n\\n        if (indexData.fileData.files.length < 1){\\n\\n            fileData.push(path)\\n\\n        }\\n\\n        fileData.push(startIndexPath+data.id+data.name+\\\".json\\\")\\n\\n        let files = getBackDeleteForFile(data.id,data.name,fileData)\\n\\n        for (let i in files) {\\n\\n            deleteBackFile(files[i])\\n\\n        }\\n\\n        hideLoading();\\n\\n        toast(\\\"删除备份成功！\\\")\\n\\n        refreshPage();\\n\\n    }else {\\n\\n        return 'toast://备份文件不存在或程序错误，请联系开发'\\n    }\\n\\n}\\n\\nfunction backFileDelete(data,path){\\n\\n    if (fileExist(path)){\\n\\n        showLoading('删除备份中！不要乱点击');\\n\\n        let indexData = JSON.parse(readFile(path, 0) || '[]')\\n\\n        let indexFile = indexData.fileData.files\\n\\n        let dataIndex = indexFile.findIndex(item => item.cid === data.cid);\\n\\n        if (dataIndex !== -1) {\\n\\n            indexData.fileData.files.splice(dataIndex, 1);\\n\\n        }\\n\\n        saveFile(path, JSON.stringify(indexData), 0);\\n\\n        hideLoading();\\n\\n        toast(\\\"删除备份成功！\\\")\\n\\n        refreshPage();\\n\\n    }else {\\n\\n        return 'toast://备份文件不存在或程序错误，请联系开发'\\n    }\\n\\n}\\n\\n\\nfunction getBackSaveFolder(fileId,fileName){\\n\\n    return `{\\\"id\\\":\\\"`+fileId+`\\\",\\\"name\\\": \\\"`+fileName+`\\\",\\\"type\\\": 1}`\\n}\\n\\nfunction getBackSaveFile(fileName,fileSize,fileCid,fileType,suffix){\\n\\n    return `{\\\"name\\\": \\\"`+fileName+`\\\",\\\"type\\\": 0,\\\"size\\\": \\\"`+fileSize+`\\\",\\\"cid\\\": \\\"`+fileCid+`\\\",\\\"fileType\\\": \\\"`+fileType+`\\\",\\\"suffix\\\": \\\"`+suffix+`\\\"}`\\n}\\n\\n\\n\\nfunction batchForFile(data){\\n\\n    log(JSON.stringify(data))\\n\\n    clearItem(\\\"batch\\\")\\n\\n    clearMyVar(\\\"batchData\\\")\\n\\n}\\n\\nfunction batchForFileDelete(data){\\n\\n    let deleteData = [];\\n\\n    for(let i in data){\\n\\n        let fileId = data[i].id\\n\\n        //let fileName = data[i].file_name\\n\\n        deleteData.push(fileId)\\n\\n    }\\n\\n    let body = `{\\\"ids\\\": `+JSON.stringify(deleteData)+`}`\\n\\n    try {\\n\\n        let data = getPostData(delete_folder,body)\\n\\n        if (data.code === 200){\\n            refreshPage();\\n            return 'toast://批量删除成功'\\n        }else {\\n            refreshPage();\\n            return 'toast://批量删除失败'+data.message\\n        }\\n\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\n\\n\\n\\nfunction getCloudFileData(id,page){\\n\\n    let body = `{\\\"fileType\\\":   [], \\\"fileName\\\": \\\"\\\", \\\"pageNum\\\": `+parseInt(page)+`, \\\"pageSize\\\": 100, \\\"parentId\\\": \\\"`+id+`\\\", \\\"sortType\\\": \\\"desc\\\", \\\"sortFlag\\\": \\\"name\\\", \\\"count\\\": 0}`\\n\\n    try {\\n\\n        let data = getCloudPostData(cloud_flies,getCloudHead(cloud_login_token),body)\\n\\n        return data\\n    }catch (e){\\n        log(e.message)\\n    }\\n\\n}\\n\\nfunction getSeedsData(page){\\n\\n    let body = `{\\\"page_seq\\\": `+parseInt(page)+`,\\\"page_size\\\": 100}`\\n\\n    try {\\n\\n        let data = getCloudPostData(cloud_seeds,getCloudHead(cloud_login_token),body)\\n\\n        if (data.code === 200){\\n            return data\\n        }else {\\n            return 'toast://查询失败'+data.message\\n        }\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\nfunction getSeedsForVideoData(){\\n\\n    toast(\\\"数据第一次获取较慢，请耐心等候！\\\")\\n\\n    let body = `{}`\\n\\n    try {\\n\\n        let data = getCloudPostData(cloud_seeds_video,getCloudHead(cloud_login_token),body)\\n\\n        //log(JSON.stringify(data))\\n\\n        if (data.code === 200){\\n            putMyVar(\\\"seedsVideos\\\",data.data.videos)\\n            putMyVar(\\\"seedsVideosLength\\\",data.data.videos.length)\\n            return data.data.videos\\n        }else {\\n            return 'toast://查询失败'+data.message\\n        }\\n    }catch (e){\\n        log(e.message)\\n    }\\n}\\n\\n\\n\\n\\nfunction checkMagentData(magent,type) {\\n\\n    if (type === 'data') {\\n\\n        let url = \\\"https://api.magnet-vip.com/api2/magnetinfo\\\"\\n\\n        let head={}\\n\\n        let body = `{\\\"url\\\":\\\"` + magent + `\\\"}`\\n\\n        let data = post(url, {headers:head,body: body})\\n\\n        if (data === \\\"Too many requests, please try again later.\\\") {\\n\\n            return \\\"error\\\"\\n        } else if(data === \\\"\\\"){\\n            return \\\"\\\"\\n        }else {\\n\\n            return data\\n        }\\n\\n    } else {\\n\\n        let url = \\\"https://whatslink.info/api/v1/link?url=\\\" + magent\\n\\n        let data = request(url)\\n\\n        if (data === \\\"Too many requests, please try again later.\\\") {\\n\\n            return `{\\\"status\\\": \\\"error\\\"}`\\n        } else {\\n\\n            return data\\n        }\\n\\n    }\\n\\n}\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"小龙盘文件\",\"path\":\"start\",\"rule\":\"js:\\n    var d = [];\\n\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\n//值传递\\n\\nid = MY_PARAMS.id\\nparent_id = MY_PARAMS.parent_id\\n\\nlet startPage = Number(getMyVar(id+\\\"startPage\\\",\\\"1\\\"))\\n\\n\\nif(!id){\\n    id = \\\"\\\"\\n    parent_id = \\\"\\\"\\n}\\n\\nlet check_login = checkToken()\\n\\nif(check_login.code === 200){\\n    //线路列表\\n\\n    line=\\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"\\n\\n//固定值以及图标\\n\\n    token = getVar(\\\"token\\\")\\n\\n    try{\\n\\n\\n        head = {\\n            \\\"Authorization\\\": \\\"Bearer \\\"+token,\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) loongbox-u/1.2.3 Chrome/108.0.5359.179 Electron/22.1.0 Safari/537.36\\\"\\n        }\\n\\n        // if (storage0.getItem(\\\"search\\\",\\\"0\\\") === \\\"1\\\"){\\n        //     url = search_file\\n        //     body = `{\\\"keywords\\\": \\\"`+storage0.getItem(\\\"searchName\\\", \\\"\\\")+`\\\", \\\"sort_direction\\\": \\\"`+storage0.getItem(\\\"排序方式\\\", \\\"asc\\\")+`\\\", \\\"sort_field\\\": \\\"`+storage0.getItem(\\\"排序类型\\\", \\\"name\\\")+`\\\", \\\"count\\\": 0, \\\"page_num\\\": `+page+`, \\\"page_size\\\": 100, \\\"suffixes\\\": [], \\\"root_id\\\": \\\"\\\"}`\\n        // }else {\\n        url = check_url\\n        body =`{\\\"page_num\\\":`+startPage+`,\\\"page_size\\\":100,\\\"parent_id\\\":\\\"`+id+`\\\",\\\"sort_direction\\\":\\\"`+storage0.getItem(\\\"排序方式\\\", \\\"asc\\\")+`\\\",\\\"sort_field\\\":\\\"`+storage0.getItem(\\\"排序类型\\\", \\\"name\\\")+`\\\"}`\\n        // }\\n\\n\\n        result = post(url,{headers: head,body:body})\\n\\n        data = JSON.parse(result).data.files\\n        pages = Number(JSON.parse(result).data.total_num)\\n        pageCount = parseInt((pages + 100 -1)/100)\\n        minPage = startPage > 1 ? changePageInt(startPage,\\\"-\\\") : 1\\n        maxPage = startPage >= pageCount ? pageCount : changePageInt(startPage,\\\"+\\\")\\n\\n\\n        //排序功能\\n        d.push({\\n            title:storage0.getItem(\\\"排序变量\\\", \\\"名称正序\\\"),\\n            col_type: \\\"text_3\\\",\\n            url:$([\\\"名称正序\\\",\\\"名称倒序\\\",\\\"时间正序\\\",\\\"时间倒序\\\",\\\"大小正序\\\",\\\"大小倒序\\\"], 2,'需要什么类型排序？').select(() => {\\n\\n                storage0.setItem(\\\"排序变量\\\", input);\\n                if(input.includes(\\\"名称\\\"))\\n                    storage0.setItem(\\\"排序类型\\\", \\\"name\\\");\\n                else if(input.includes(\\\"时间\\\"))\\n                    storage0.setItem(\\\"排序类型\\\", \\\"upload\\\");\\n                else\\n                    storage0.setItem(\\\"排序类型\\\", \\\"size\\\");\\n\\n                if(input.includes(\\\"正序\\\"))\\n                    storage0.setItem(\\\"排序方式\\\", \\\"asc\\\");\\n                else\\n                    storage0.setItem(\\\"排序方式\\\", \\\"desc\\\");\\n\\n                refreshPage(false);\\n                return \\\"toast://切换成功\\\"\\n\\n            }),\\n            extra:{\\n                textSize:6\\n            }\\n        });\\n        //显示类型\\n        d.push({\\n            title:storage0.getItem(\\\"文件样式\\\", \\\"列表模式\\\"),\\n            col_type: \\\"text_3\\\",\\n            url:$([\\\"列表模式\\\",\\\"图文模式\\\",\\\"全名模式\\\",\\\"漫画模式\\\"], 2,'需要什么样式显示？').select((data) => {\\n\\n                storage0.setItem(\\\"文件样式\\\", input);\\n                if(input==\\\"列表模式\\\")\\n                    storage0.setItem(\\\"文件样式变量\\\", \\\"avatar\\\");\\n                if(input==\\\"图文模式\\\")\\n                    storage0.setItem(\\\"文件样式变量\\\", \\\"movie_2\\\");\\n                if(input==\\\"全名模式\\\")\\n                    storage0.setItem(\\\"文件样式变量\\\", \\\"text_1\\\");\\n                if (input==\\\"漫画模式\\\")\\n                    return $('').lazyRule((data) => {\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return getImageList(data)\\n                    },data)\\n                refreshPage(false);\\n                return \\\"toast://切换成功\\\"\\n\\n            },data)\\n        });\\n        //更多功能\\n        d.push({\\n            title:\\\"更多功能\\\",\\n            col_type: \\\"text_3\\\",\\n            url:$([\\\"新建文件夹\\\",\\\"搜索\\\",\\\"批量操作\\\",\\\"漫画模式\\\",\\\"转存模式\\\",\\\"批量模式\\\",\\\"普通模式\\\"], 2,'功能操作').select((data,id) => {\\n\\n                if (input == \\\"新建文件夹\\\"){\\n                    return $(\\\"\\\",\\\"文件名称\\\").input((id) => {\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return createFolder(id,input)\\n                    },id)\\n                }else if(input==\\\"搜索\\\"){\\n                    // return $(\\\"\\\",\\\"文件名称\\\").input(() => {\\n                    //     clearItem(\\\"search\\\")\\n                    //     clearItem(\\\"searchName\\\")\\n                    //     storage0.setItem(\\\"search\\\", \\\"1\\\");\\n                    //     storage0.setItem(\\\"searchName\\\", input)\\n                    //     refreshPage();\\n                    //     toast(\\\"搜索成功\\\")\\n                    // })\\n                    return \\\"toast://待实现\\\"\\n                }else if(input==\\\"批量操作\\\"){\\n\\n                    return $([\\\"批量备份\\\",\\\"批量删除\\\"], 2,'功能操作').select((id) => {\\n\\n                        let batchFileJson = JSON.parse(getMyVar(\\\"batchData\\\",\\\"[]\\\"))\\n\\n                        if (batchFileJson.length < 1){\\n\\n                            return \\\"toast://没有选择数据,请进入批量模式选择！\\\"\\n                        }\\n\\n                        if (input === \\\"批量备份\\\"){\\n\\n                            clearItem(\\\"backType\\\")\\n                            clearItem(\\\"backChange\\\")\\n                            clearItem(\\\"backChangeData\\\")\\n                            clearItem(\\\"backChangeType\\\")\\n                            storage0.setItem(\\\"backType\\\", \\\"start\\\");\\n                            storage0.setItem(\\\"backChange\\\",\\\"true\\\");\\n                            storage0.setItem(\\\"backChangeType\\\",\\\"true\\\");\\n\\n                            return \\\"hiker://page/readBack\\\"\\n\\n                        }else if (input === \\\"批量删除\\\"){\\n\\n                            eval(JSON.parse(request('hiker://page/functions')).rule)\\n                            return batchForFileDelete(batchFileJson)\\n\\n                        }\\n\\n                    },id)\\n                }else if (input==\\\"漫画模式\\\"){\\n                    return $('').lazyRule((data) => {\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return getImageList(data)\\n                    },data)\\n                }else if (input==\\\"转存模式\\\"){\\n                    return confirm({\\n                        title:'转存确认',\\n                        content:'请注意：转存模式开启后无法查询小龙盘文件！',\\n\\n                        confirm:$.toString(() => {\\n                            clearItem(\\\"save\\\")\\n                            storage0.setItem(\\\"save\\\", \\\"1\\\");\\n                            refreshPage();\\n                            return \\\"toast://转存模式已开启\\\"\\n                        }),\\n\\n                        cancel:$.toString(() => {\\n                            clearItem(\\\"save\\\")\\n                            storage0.setItem(\\\"save\\\", \\\"0\\\");\\n                            refreshPage();\\n                            return \\\"toast://取消转存\\\"\\n\\n                        })\\n                    })\\n                } else if (input==\\\"普通模式\\\"){\\n                    clearItem(\\\"save\\\")\\n                    clearItem(\\\"search\\\")\\n                    clearItem(\\\"searchName\\\")\\n                    clearItem(\\\"batch\\\")\\n                    storage0.setItem(\\\"search\\\", \\\"0\\\");\\n                    storage0.setItem(\\\"save\\\", \\\"0\\\");\\n                    storage0.setItem(\\\"batch\\\", \\\"false\\\");\\n                    refreshPage();\\n                    return \\\"toast://普通模式已开启\\\"\\n                }else if (input==\\\"批量模式\\\"){\\n                    clearItem(\\\"save\\\")\\n                    storage0.setItem(\\\"batch\\\", \\\"true\\\");\\n                    refreshPage();\\n                    return \\\"toast://批量模式已开启\\\"\\n                }\\n\\n            },data,id)\\n        });\\n\\n\\n        // d.push({\\n        //     title: \\\"\\\",\\n        //     desc:getPostData(check_url,body).data.files,\\n        //     col_type: \\\"text_3\\\"\\n        // });\\n\\n\\n        //顶部页数操作\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,startPage,minPage) => {\\n\\n                    if(startPage>minPage)\\n                    {\\n                        putMyVar(id+\\\"startPage\\\",minPage)\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,startPage,minPage),\\n                //pic_url:last_image,\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:startPage+\\\"/\\\"+pageCount,\\n                url:$('','请输入页码').input((id,pageCount)=>{\\n\\n                    if(input>0&&Number(input)<=pageCount){\\n                        putMyVar(id+'startPage',input)\\n                        refreshPage(false);\\n                        return \\\"toast://已经跳转到第\\\"+input+\\\"页\\\"\\n                    }else{return \\\"toast://输入错误\\\"}\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 总页数\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,startPage,maxPage) => {\\n\\n                    if(startPage<maxPage) {\\n                        putMyVar(id+\\\"startPage\\\",maxPage)\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,startPage,maxPage),\\n                col_type: \\\"text_3\\\",\\n                //pic_url:next_image,\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n\\n        //数据循环\\n\\n        for (var i in data) {\\n\\n            //固定值判断\\n\\n            picType = folder_image\\n            url_type = \\\"\\\"\\n            url_back = \\\"\\\"\\n            colType = storage0.getItem(\\\"文件样式变量\\\", \\\"avatar\\\")\\n\\n            //循环固定值\\n\\n            fileName = data[i].file_name\\n            time = timestampToTime(data[i].create_time)\\n            isFolder = data[i].is_folder\\n            fileId = data[i].id\\n            file_size = getFileSize(data[i].file_size)\\n            parentId = data[i].parent_id\\n            fileType = data[i].file_type\\n\\n            let backData = data[i]\\n\\n\\n//判断文件夹和文件\\n\\n            if(isFolder > 0){\\n\\n                picType = folder_image\\n\\n\\n                if (storage0.getItem(\\\"save\\\",\\\"0\\\").equals(\\\"1\\\")){\\n                    d.push({\\n                        title: \\\"转存此文件夹：\\\"+fileName,\\n                        desc: \\\"\\\",\\n                        url:\\\"hiker://page/cloud?id=\\\"+fileId+\\\"&fileName=\\\"+fileName+\\\"&type=\\\",\\n                        pic_url: picType,\\n                        col_type: colType,\\n                        extra:{\\n                            id:fileId,\\n                            name: fileName,\\n                            type: 'folder',\\n                            newWindow: true,\\n                            windowId: fileId\\n                        }\\n                    });\\n                }\\n                else if (storage0.getItem(\\\"batch\\\",\\\"false\\\").equals(\\\"true\\\")){\\n\\n                    let batchData = data[i]\\n\\n                    d.push({\\n                        title:\\\"批量- \\\"+fileName,\\n                        desc:\\\"\\\",\\n                        pic_url:getMyVar(fileId+batchData,folder_image),\\n                        col_type:colType,\\n                        url:$(\\\"#noLoading#\\\").lazyRule((fileId,batchData)=>{\\n\\n                            let batchForData = JSON.parse(getMyVar(\\\"batchData\\\",\\\"[]\\\"))\\n\\n                            log(\\\"数据：\\\"+JSON.stringify(batchForData))\\n\\n                            if (getMyVar(fileId+batchData)){\\n\\n                                batchForData.splice(batchForData.indexOf(batchData),1)\\n\\n                                putMyVar(\\\"batchData\\\",batchForData)\\n\\n                                log(\\\"删除：\\\"+getMyVar(\\\"batchData\\\"))\\n\\n                                clearMyVar(fileId+batchData)\\n\\n                                refreshPage(false)\\n\\n                                toast(\\\"取消选择:\\\"+batchData.file_name)\\n\\n                                return \\\"hiker://empty\\\"\\n\\n                            }else {\\n\\n                                log(\\\"进入\\\")\\n\\n                                let data = [];\\n\\n                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n\\n                                data.push(batchData);\\n\\n                                batchForData = batchForData.concat(data)\\n\\n                                putMyVar(\\\"batchData\\\",batchForData)\\n\\n                                putMyVar(fileId+batchData,pitch_image)\\n\\n                                log(\\\"添加：\\\"+getMyVar(\\\"batchData\\\"))\\n\\n                                refreshPage(false)\\n\\n                                toast(\\\"选择:\\\"+batchData.file_name)\\n\\n                                return \\\"hiker://empty\\\"\\n                            }\\n                        },fileId,batchData),\\n                        extra:{\\n                            id:fileId\\n                        }\\n                    });\\n\\n                }\\n                else {\\n                    d.push({\\n                        title: fileName,\\n                        desc: time,\\n                        pic_url: picType,\\n                        url: colType==\\\"漫画模式\\\"?$('').lazyRule((data) => {\\n                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                return getImageList(data)\\n                            },data):\\n                            \\\"hiker://page/start#noRecordHistory##cacheOnly#?id=\\\"+fileId+\\\"&startPage=\\\"+startPage+\\\"&parent_id=\\\"+parentId,\\n                        col_type: colType,\\n                        extra:{\\n                            id:fileId,\\n                            startPage:1,\\n                            parent_id:parentId,\\n                            longClick:[\\n                                {title: \\\"文件操作\\\", js: $.toString((fileId)=>{\\n                                            return $([\\\"修改名称\\\",\\\"删除文件\\\",\\\"文件详情\\\"], 2,'功能操作').select((fileId) =>{\\n                                                if (input === \\\"修改名称\\\"){\\n                                                    return $(\\\"\\\",\\\"文件名称\\\").input((fileId) => {\\n                                                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                        return updateFileName(fileId,input)\\n                                                    },fileId)\\n                                                } else if (input === \\\"删除文件\\\"){\\n                                                    eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                    return deleteStartFile(fileId)\\n                                                } else if(input === \\\"文件详情\\\"){\\n\\n                                                    eval(JSON.parse(request('hiker://page/functions')).rule)\\n\\n                                                    let data = detailForFile(fileId).data\\n\\n                                                    log(JSON.stringify(data))\\n\\n                                                    let folder = data.stats.subdir_num\\n\\n                                                    let file = data.stats.subfile_num\\n\\n                                                    let size = getFileSize(data.stats.subfile_size)\\n\\n                                                    return `confirm://文件📑:`+file+`\\\\n文件夹🗂:`+folder+`\\\\n大小💥:`+size+`.js:'toast://🌚🌚🌚'`\\n\\n                                                }\\n                                        },fileId)\\n                                    },fileId)\\n                                },\\n                                {title: \\\"磁力操作\\\",js: $.toString((fileId,fileName)=>{\\n                                        return $([\\\"设置默认磁力\\\",\\\"添加磁力\\\"], 2,'功能操作').select((fileId,fileName) =>{\\n                                            if (input === \\\"设置默认磁力\\\"){\\n                                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                log(fileId)\\n                                                return setAddFolder(fileId,fileName)\\n                                            }else if(input === \\\"添加磁力\\\"){\\n                                                return $(\\\"\\\",\\\"磁力链接\\\").input((fileId) => {\\n                                                    eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                    return addMagent(fileId,input)\\n                                                },fileId)\\n                                            }\\n                                        },fileId,fileName)\\n                                    },fileId,fileName)\\n                                },{title: \\\"更多操作\\\", js: $.toString((fileId,backData)=>{\\n                                        return $([\\\"沉浸漫画\\\",\\\"备份文件\\\",\\\"自主备份\\\"], 2,'功能操作').select((fileId,backData) =>{\\n                                            if(input === \\\"沉浸漫画\\\"){\\n                                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                return immersionInComics(fileId)\\n                                            }else if(input === \\\"备份文件\\\"){\\n                                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                return checkBackIsTrue(\\\"\\\",backData,\\\"\\\")\\n                                            }else if(input === \\\"自主备份\\\"){\\n                                                clearItem(\\\"backType\\\")\\n                                                clearItem(\\\"backChange\\\")\\n                                                clearItem(\\\"backChangeData\\\")\\n                                                clearItem(\\\"backChangeType\\\")\\n                                                storage0.setItem(\\\"backType\\\", \\\"start\\\");\\n                                                storage0.setItem(\\\"backChange\\\",\\\"true\\\");\\n                                                storage0.setItem(\\\"backChangeType\\\",\\\"false\\\");\\n                                                storage0.setItem(\\\"backChangeData\\\",backData);\\n                                                return \\\"hiker://page/readBack\\\"\\n                                            }\\n                                        },fileId,backData)\\n                                    },fileId,backData)\\n                                }\\n                            ],\\n                            textSize:24,\\n                        }\\n                    });\\n                }\\n\\n\\n\\n            }else{\\n\\n                //文件固定值\\n\\n                cid = data[i].file_cid\\n                type = data[i].file_ext\\n                picType = file_image\\n\\n\\n                //判断文件类型\\n\\n                switch (true) {\\n                    case image_regular.test(type):\\n                        picType = line+cid+'@Referer=https://wx.stariverpan.com/'\\n                        break;\\n\\n                    case video_regular.test(type):\\n                        picType = video_image\\n                        break;\\n\\n                    case audio_regular.test(type):\\n                        picType = audio_image\\n                        break;\\n\\n                    default:\\n                        picType = file_image\\n                        break;\\n                }\\n\\n                if (storage0.getItem(\\\"save\\\",\\\"0\\\").equals(\\\"1\\\")){\\n\\n                    d.push({\\n                        title: \\\"转存此文件：\\\"+fileName,\\n                        desc: file_size,\\n                        pic_url: picType,\\n                        url: \\\"hiker://page/cloud?id=\\\"+fileId+\\\"&fileName=\\\"+fileName+\\\"&type=\\\",\\n                        col_type: colType,\\n                        extra:{\\n                            id:fileId,\\n                            name: fileName,\\n                            type:'file',\\n                            newWindow: true,\\n                            windowId: fileId\\n                        }\\n\\n                    });\\n\\n                }else{\\n\\n                    d.push({\\n                        title: fileName,\\n                        desc: file_size,\\n                        pic_url: picType,\\n                        url: cid+\\\"&&\\\"+type+getFileUrlLine,\\n                        col_type: colType,\\n                        extra:{\\n                            longClick: [\\n                                {title: \\\"更多操作\\\", js: $.toString((fileId,backData)=>{\\n                                        return $([\\\"备份文件\\\",\\\"自主备份\\\"], 2,'功能操作').select((fileId,backData) =>{\\n                                            if(input === \\\"备份文件\\\"){\\n                                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                return saveBackFile(backData)\\n                                            }else if(input === \\\"自主备份\\\"){\\n                                                clearItem(\\\"backType\\\")\\n                                                clearItem(\\\"backChange\\\")\\n                                                clearItem(\\\"backChangeData\\\")\\n                                                storage0.setItem(\\\"backType\\\", \\\"start\\\");\\n                                                storage0.setItem(\\\"backChange\\\",\\\"true\\\");\\n                                                storage0.setItem(\\\"backChangeData\\\",backData);\\n                                                return \\\"hiker://page/readBack\\\"\\n                                            }\\n                                        },fileId,backData)\\n                                    },fileId,backData)}\\n                            ]\\n                        }\\n                    });\\n\\n                }\\n\\n\\n            }\\n        }\\n\\n        //尾部页数操作\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,startPage,minPage) => {\\n\\n                    if(startPage>minPage)\\n                    {\\n                        putMyVar(id+\\\"startPage\\\",minPage)\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,startPage,minPage),\\n                //pic_url:last_image,\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"更多操作\\\",\\n                url:$([\\\"返回首页\\\",\\\"跳转尾页\\\"], 2,'请选择更多页数功能').select((id,pageCount) => {\\n                    if(input==\\\"返回首页\\\"){\\n                        return $('#noLoading#').lazyRule((id) => {\\n                            putMyVar(id+'startPage',1)\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到首页\\\"\\n                        },id)\\n                    }else if (input==\\\"跳转尾页\\\"){\\n                        return $('#noLoading#').lazyRule((id,pageCount) => {\\n                            putMyVar(id+'startPage',pageCount)\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到尾页\\\"\\n                        },id,pageCount)\\n                    }\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 更多操作\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,startPage,maxPage) => {\\n\\n                    if(startPage<maxPage) {\\n                        putMyVar(id+\\\"startPage\\\",maxPage)\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,startPage,maxPage),\\n                col_type: \\\"text_3\\\",\\n                //pic_url:next_image,\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n    }catch(e){\\n        log(e.message)\\n    }\\n}else {\\n    toast(\\\"密钥有问题或者未登录\\\")\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"添加磁力\",\"path\":\"addmagent\",\"rule\":\"js:\\n    var d = [];\\n\\ntry{\\n\\n    if (!storage0.getItem(\\\"addFolderName\\\")){\\n        name = \\\"首页\\\"\\n    }else{\\n        name = storage0.getItem(\\\"addFolderName\\\")\\n    }\\n\\n\\n    d.push({\\n        title:\\\"操作\\\",\\n        desc:\\\"请输入磁力链接\\\\n默认添加到\\\"+name,\\n        col_type: \\\"input\\\",\\n        url:$.toString(() => {\\n            eval(JSON.parse(request('hiker://page/functions')).rule)\\n            head = {\\n                \\\"Authorization\\\": \\\"Bearer \\\"+getVar(\\\"token\\\"),\\n                \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) loongbox-u/1.2.3 Chrome/108.0.5359.179 Electron/22.1.0 Safari/537.36\\\"\\n            }\\n\\n\\n            body=`{\\\"params\\\":{\\\"with_thumbnail\\\":true},\\\"parent_id\\\":\\\"`+storage0.getItem(\\\"addFolder\\\")+`\\\",\\\"upload_type\\\":\\\"url\\\",\\\"url\\\":\\\"`+input+`\\\"}`\\n\\n\\n            result=JSON.parse(post(add_magent,{headers: head,body:body}))\\n\\n            if(result.code === \\\"200\\\"){\\n                refreshPage()\\n                return 'toast://提交成功!'\\n            }else {\\n                let message = result.message === \\\"Task already exist\\\" ? \\\"磁力已在队列中\\\" : result.message\\n                refreshPage()\\n                return 'toast://'+message\\n            }\\n        }),\\n        extra: {type: 'textarea',height: 2}\\n    });\\n\\n}catch(e){\\n    log(e.message)\\n}\\n\\nsetResult(d);\\n\"},{\"col_type\":\"movie_1\",\"name\":\"休息\",\"path\":\"rest\",\"rule\":\"js:\\n    setResult(\\n        [{\\n            col_type: \\\"x5_webview_single\\\",\\n            url: \\\"https://tucdn.wpon.cn/api-girl/index.php?wpon=302\\\",    //\\\"http:/\\\"+\\\"/hhdglm.com/dy.html\\\",\\n            desc:\\\"float&&100%\\\",\\n            extra:{\\n                autoPlay:true,\\n                canBack:true,\\n                showProgress:false,\\n                js:'refreshPage();'\\n            }\\n        }]\\n\\n    )\"},{\"col_type\":\"movie_3\",\"name\":\"登录\",\"path\":\"login\",\"rule\":\"js:\\n    var d = [];\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\nlet type = getMyVar(\\\"type\\\",\\\"\\\")\\n\\nd.push({\\n    title: '名称',\\n    desc: '备注随便填',\\n    col_type: 'input',\\n    url: $.toString(() => {}),\\n    extra: {\\n        defaultValue: getMyVar('name', ''),\\n        onChange: 'putMyVar(\\\"name\\\",input)'\\n    }\\n});\\n\\nd.push({\\n    title: '账号(密钥)',\\n    desc: '必须填小龙盘密钥',\\n    col_type: 'input',\\n    url: $.toString(() => {}),\\n    extra: {\\n        defaultValue: getMyVar('userkey', ''),\\n        onChange: 'putMyVar(\\\"userkey\\\",input)'\\n    }\\n});\\n\\n\\nfunction saveSub() {\\n    let a_name = getMyVar('name', '').trim();\\n    let a_user = getMyVar('userkey', '').trim();\\n    return $('').lazyRule((a_name,a_user) => {\\n        eval(JSON.parse(request('hiker://page/functions')).rule)\\n        return saveToken(a_name,a_user)\\n    },a_name,a_user)\\n}\\n\\nd.push({\\n    title: '新增账号',\\n    col_type: \\\"text_2\\\",\\n    url: $('#noLoading#').lazyRule((saveSub) => {\\n        let tips = saveSub();\\n        clearMyVar(\\\"name\\\");\\n        clearMyVar(\\\"userkey\\\");\\n\\n\\n        return tips\\n    }, saveSub)\\n});\\n\\nd.push({\\n    title: '更多功能',\\n    col_type: \\\"text_2\\\",\\n    url:$([\\\"资源库\\\",\\\"回收站\\\",\\\"小龙盘备份\\\",\\\"云盘备份\\\"], 2,'请选择更多功能').select(() => {\\n        if(input==\\\"资源库\\\"){\\n            storage0.setItem(\\\"seedsType\\\",\\\"sends\\\")\\n            return \\\"hiker://page/seeds\\\"\\n        }else if (input==\\\"回收站\\\"){\\n            return \\\"hiker://page/trash\\\"\\n        }else if (input==\\\"小龙盘备份\\\"){\\n            clearItem(\\\"backType\\\")\\n            clearItem(\\\"moveType\\\")\\n            clearItem(\\\"moveData\\\")\\n            storage0.setItem(\\\"backType\\\", \\\"start\\\");\\n            return \\\"hiker://page/readBack\\\"\\n        }else if (input==\\\"云盘备份\\\"){\\n            clearItem(\\\"backType\\\")\\n            clearItem(\\\"moveType\\\")\\n            clearItem(\\\"moveData\\\")\\n            storage0.setItem(\\\"backType\\\", \\\"cloud\\\");\\n            return \\\"hiker://page/readBack\\\"\\n        }\\n    }),\\n    extra:{\\n        type: storage0.getItem(\\\"backType\\\")\\n    }\\n});\\n\\ntoken_data.forEach((it, idex) => {\\n    d.push({\\n        title: it.name+\\\"\\\\n\\\\n使用容量：\\\"+checkUserAccount(),\\n        desc: it.user,\\n        url: \\\"\\\",\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            idex: idex + '',\\n            longClick: [\\n                {\\n                    title:\\\"修改信息\\\",js:$.toString((it,token_data, idex)=> {\\n                        return $(it.user, '修改密钥').input((token_data, idex) => {\\n                            eval(JSON.parse(request('hiker://page/functions')).rule)\\n                            return updateToken(token_data, input, idex)\\n                        }, token_data, idex)\\n                    },it,token_data, idex)\\n                },\\n                {\\n                    title:\\\"切换账号\\\",js:$.toString((it, idex)=> {\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return switched(it.user, idex)\\n                    },it, idex)\\n                },\\n                {\\n                    title:\\\"删除账号\\\",js:$.toString((idex)=> {\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return deleteToken(idex)\\n                    },idex)\\n                },\\n                {\\n                    title:\\\"修改云盘密钥\\\",js:$.toString((it,idex)=> {\\n                        return $(it.cloud, '修改云盘密钥').input((idex) => {\\n                            eval(JSON.parse(request('hiker://page/functions')).rule)\\n                            return setCloudToken(input,idex)\\n                        }, idex)\\n                    },it,idex)\\n                }\\n            ]\\n        }\\n    });\\n})\\n\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"测试\",\"path\":\"test\",\"rule\":\"js:\\nvar d = [];\\n\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\ntoast(token)\\n\\nd.push({\\n    title:\\\"test\\\",\\n    desc: \\\"\\\",\\n    pic_url:png1,\\n    url:\\\"\\\",\\n    col_type: \\\"icon_4\\\"\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"小龙云盘\",\"path\":\"cloud\",\"rule\":\"js:\\n    var d = []\\n\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\nid = MY_PARAMS.id\\noldFileName = MY_PARAMS.name\\ntype = MY_PARAMS.type\\ncheckId = MY_PARAMS.checkId\\n\\n\\nstorage0.setItem(\\\"save\\\",\\\"0\\\")\\n\\nlet cloudPage = getMyVar(id+\\\"cloudPage\\\",\\\"1\\\")\\n\\nif (!id) {\\n    id = 0\\n    fileName = \\\"\\\"\\n}\\n\\nif (!checkId) {\\n    checkId = 0\\n}\\n\\nif (!type) {\\n    type = \\\"\\\"\\n}\\n\\ndata = checkCloudType(cloud_token).data\\n\\nif (data === undefined) {\\n\\n    toast(\\\"请检查云盘密钥！\\\")\\n\\n    java.lang.Thread.sleep(1500)\\n\\n    back();\\n\\n}else{\\n\\n    vip = checkVip(data.id).isVip\\n\\n    if (vip === 2) {\\n\\n        fileData = getCloudFileData(checkId,cloudPage)\\n\\n        if (cloudPage > fileData.data.totalPage) {\\n\\n            putMyVar(id+\\\"cloudPage\\\",\\\"1\\\")\\n\\n            refreshPage();\\n        }\\n\\n        pages = Number(fileData.data.count)\\n        pageCount = Number(fileData.data.totalPage)\\n        minPage = cloudPage > 1 ? changePageInt(cloudPage,\\\"-\\\") : 1\\n        maxPage = cloudPage >= pageCount ? pageCount : changePageInt(cloudPage,\\\"+\\\")\\n\\n\\n\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,cloudPage,minPage) => {\\n\\n                    if(Number(cloudPage)>Number(minPage)) {\\n                        putMyVar(id+\\\"cloudPage\\\",minPage)\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,cloudPage,minPage),\\n                //pic_url:last_image,\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:cloudPage+\\\"/\\\"+pageCount,\\n                url:$('','请输入页码').input((id,pageCount)=>{\\n\\n                    if(input>0&&Number(input)<=pageCount){\\n                        putMyVar(id+'cloudPage',input)\\n                        refreshPage(false);\\n                        return \\\"toast://已经跳转到第\\\"+input+\\\"页\\\"\\n                    }else{return \\\"toast://输入错误\\\"}\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 总页数\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,cloudPage,maxPage) => {\\n\\n                    if(Number(cloudPage)<Number(maxPage)) {\\n                        putMyVar(id+\\\"cloudPage\\\",maxPage)\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,cloudPage,maxPage),\\n                col_type: \\\"text_3\\\",\\n                //pic_url:next_image,\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n        /*d.push({\\n            title: vip,\\n            desc: \\\"\\\",\\n            pic_url: \\\"\\\",\\n            url: \\\"\\\",\\n            col_type: \\\"text_1\\\"\\n        });*/\\n\\n\\n        if (fileData.code === 200){\\n\\n            result = fileData.data.data\\n\\n            for (var i in result){\\n\\n                picType = \\\"\\\"\\n                url_type = \\\"\\\"\\n                url_back = \\\"\\\"\\n                colType = storage0.getItem(\\\"文件样式变量\\\", \\\"avatar\\\")\\n\\n                fileName = result[i].fileName\\n                time = result[i].createTime\\n                isFolder = result[i].isFolder\\n                fileId = result[i].id\\n                file_size = getFileSize(result[i].fileSize)\\n\\n\\n                if(isFolder > 0){\\n\\n                    picType = folder_image\\n\\n                    d.push({\\n                        title: fileName,\\n                        desc: time,\\n                        pic_url: picType,\\n                        url: \\\"hiker://page/cloud#noRecordHistory##cacheOnly#?id=\\\"+id+\\\"&checkId=\\\"+checkId+\\\"&type=\\\"+type,\\n                        col_type: colType,\\n                        extra: {\\n                            id:id,\\n                            checkId: fileId,\\n                            type: type,\\n                            longClick:[\\n                                {\\n                                    \\\"title\\\":\\\"转存到此\\\",js: $.toString((id,oldFileName,fileId,type)=>{\\n                                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                        return saveFileToChange(id,oldFileName,fileId,type)\\n                                    },id,oldFileName,fileId,type)\\n                                }\\n                            ]\\n                        }\\n                    });\\n\\n                }else{\\n                    d.push({\\n                        title: fileName,\\n                        desc: file_size,\\n                        pic_url: p_image,\\n                        col_type: colType,\\n                        url: \\\"toast://你在想什么？\\\"\\n                        // extra: {\\n                        //     longClick:[\\n                        //         {\\n                        //             \\\"title\\\":\\\"转存到此\\\",js: $.toString((id,fileName,checkId)=>{\\n                        //                 eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        //                 return saveFileToChange(id,fileName,checkId,\\\"file\\\")\\n                        //             },id,fileName,checkId)\\n                        //         }\\n                        //     ]\\n                        // }\\n                    });\\n                }\\n            }\\n\\n            if (pages > 100){\\n                //请求页数\\n\\n                d.push({\\n                    title:\\\"上一页\\\",\\n                    url:$('#noLoading#').lazyRule((id,cloudPage,minPage) => {\\n\\n                        if(Number(cloudPage)>Number(minPage))\\n                        {\\n                            putMyVar(id+\\\"cloudPage\\\",minPage)\\n                            refreshPage();\\n                            return \\\"toast://上一页\\\"\\n                        }else{return \\\"toast://已经最前\\\"}\\n\\n                    },id,cloudPage,minPage),\\n                    //pic_url:last_image,\\n                    col_type: \\\"text_3\\\",\\n                    extra: {\\n                        cls: \\\"playlist 上一页\\\"\\n                    }\\n                });\\n\\n                d.push({\\n                    title:\\\"更多操作\\\",\\n                    url:$([\\\"返回首页\\\",\\\"跳转尾页\\\"], 2,'请选择更多页数功能').select((id,pageCount) => {\\n                        if(input==\\\"返回首页\\\"){\\n                            return $('#noLoading#').lazyRule((id) => {\\n                                putMyVar(id+'cloudPage',1)\\n                                refreshPage();\\n                                return \\\"toast://已经跳转到首页\\\"\\n                            },id)\\n                        }else if (input==\\\"跳转尾页\\\"){\\n                            return $('#noLoading#').lazyRule((id,pageCount) => {\\n                                putMyVar(id+'cloudPage',pageCount)\\n                                refreshPage();\\n                                return \\\"toast://已经跳转到尾页\\\"\\n                            },id,pageCount)\\n                        }\\n                    },id,pageCount),\\n                    col_type: \\\"text_3\\\",\\n                    extra: {\\n                        cls: \\\"playlist 更多操作\\\"\\n                    }\\n                });\\n\\n                d.push({\\n                    title:\\\"下一页\\\",\\n                    url:$('#noLoading#').lazyRule((id,cloudPage,maxPage) => {\\n\\n                        if(Number(cloudPage)<Number(maxPage)) {\\n                            putMyVar(id+\\\"cloudPage\\\",maxPage)\\n                            refreshPage();\\n                            return \\\"toast://下一页\\\"\\n                        }else{return \\\"toast://已经最后\\\"}\\n                    },id,cloudPage,maxPage),\\n                    col_type: \\\"text_3\\\",\\n                    //pic_url:next_image,\\n                    extra: {\\n                        cls: \\\"playlist 下一页\\\"\\n                    }\\n                });\\n            }\\n\\n        }else {\\n            toast(fileData.message)\\n        }\\n    }else {\\n        toast(\\\"你目前还不是vip\\\")\\n\\n        java.lang.Thread.sleep(1500)\\n\\n        back();\\n    }\\n\\n\\n}\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\" 资源库\",\"path\":\"seeds\",\"rule\":\"js:\\n\\n    var d = [];\\n\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\nid = MY_PARAMS.id\\n\\nif(!id){\\n    id = \\\"\\\"\\n}\\n\\nlet page = Number(getMyVar(id+\\\"page\\\",\\\"1\\\"))\\n\\nlet num = Number(getMyVar(id+\\\"num\\\",\\\"1\\\"))\\n\\nlet count = Number(getMyVar(id+\\\"count\\\",\\\"100\\\"))\\n\\nlet colType = storage0.getItem(\\\"文件样式变量\\\", \\\"avatar\\\")\\n\\nif (checkCloudType(cloud_token).code === 200){\\n\\n    d.push({\\n        title:\\\"-切换数据,类型显示-\\\" ,\\n        desc: \\\"\\\",\\n        pic_url: orther_image,\\n        col_type:\\\"avatar\\\",\\n        url: $([\\\"磁力列表\\\",\\\"资源列表\\\",\\\"列表模式\\\",\\\"图文模式\\\",\\\"全名模式\\\"], 2,'功能操作').select(() => {\\n            if(input === \\\"磁力列表\\\"){\\n\\n                clearItem(\\\"seedsType\\\")\\n                storage0.setItem(\\\"seedsType\\\", \\\"sends\\\");\\n                refreshPage();\\n\\n            }else if(input === \\\"资源列表\\\"){\\n\\n                clearItem(\\\"seedsType\\\")\\n                storage0.setItem(\\\"seedsType\\\", \\\"video\\\");\\n                refreshPage();\\n\\n            }else if(input === \\\"列表模式\\\"){\\n                storage0.setItem(\\\"文件样式变量\\\", \\\"avatar\\\");\\n                refreshPage();\\n            }else if(input === \\\"图文模式\\\"){\\n                storage0.setItem(\\\"文件样式变量\\\", \\\"movie_2\\\");\\n                refreshPage();\\n            }else if(input === \\\"全名模式\\\"){\\n                storage0.setItem(\\\"文件样式变量\\\", \\\"text_1\\\");\\n                refreshPage();\\n            }\\n        }),\\n        extra:{\\n            textAlign:'center'\\n        }\\n    });\\n\\n    if (storage0.getItem(\\\"seedsType\\\",\\\"sends\\\") === \\\"sends\\\"){\\n\\n        data = getSeedsData(page).data\\n\\n        pages = Number(data.count)\\n        pageCount = Number((pages/100)+1).toFixed(0)\\n        minPage = page > 1 ? changePageInt(page,\\\"-\\\") : 1\\n        maxPage = page >= pageCount ? pageCount : changePageInt(page,\\\"+\\\")\\n\\n// d.push({\\n//     title:minPage+\\\"/\\\"+maxPage+\\\"/\\\"+page,\\n//     url: \\\"\\\",\\n//     col_type: \\\"text_1\\\"\\n// });\\n\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,minPage) => {\\n\\n                    if(page>minPage)\\n                    {\\n                        putMyVar(id+\\\"page\\\",minPage)\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,page,minPage),\\n                //pic_url:last_image,\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:page+\\\"/\\\"+pageCount,\\n                url:$('','请输入页码').input((id,pageCount)=>{\\n\\n                    if(input>0&&Number(input)<=pageCount){\\n                        putMyVar(id+'page',input)\\n                        refreshPage(false);\\n                        return \\\"toast://已经跳转到第\\\"+input+\\\"页\\\"\\n                    }else{return \\\"toast://输入错误\\\"}\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 总页数\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,maxPage) => {\\n\\n                    if(page<maxPage) {\\n                        putMyVar(id+\\\"page\\\",maxPage)\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,page,maxPage),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n\\n        result = data.rows\\n\\n        for (var i in result) {\\n\\n            file_name = result[i].name\\n            magnet_name = result[i].magnet\\n\\n\\n            d.push({\\n                title:file_name,\\n                url: \\\"copy://\\\"+magnet_name,\\n                desc:\\\"\\\",\\n                col_type: colType,\\n                pic_url:seeds_image\\n            });\\n        }\\n\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,minPage) => {\\n\\n                    if(page>minPage)\\n                    {\\n                        putMyVar(id+\\\"page\\\",minPage)\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,page,minPage),\\n                //pic_url:last_image,\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"更多操作\\\",\\n                url:$([\\\"返回首页\\\",\\\"跳转尾页\\\"], 2,'请选择更多页数功能').select((id,pageCount) => {\\n                    if(input==\\\"返回首页\\\"){\\n                        return $('#noLoading#').lazyRule((id) => {\\n                            putMyVar(id+'page',1)\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到首页\\\"\\n                        },id)\\n                    }else if (input==\\\"跳转尾页\\\"){\\n                        return $('#noLoading#').lazyRule((id,pageCount) => {\\n                            putMyVar(id+'page',pageCount)\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到尾页\\\"\\n                        },id,pageCount)\\n                    }\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 更多操作\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,maxPage) => {\\n\\n                    if(page<maxPage) {\\n                        putMyVar(id+\\\"page\\\",maxPage)\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,page,maxPage),\\n                col_type: \\\"text_3\\\",\\n                //pic_url:next_image,\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n    }\\n    else if (storage0.getItem(\\\"seedsType\\\") === \\\"video\\\"){\\n\\n        let data = getMyVar(\\\"seedsVideos\\\") ? JSON.parse(getMyVar(\\\"seedsVideos\\\")) : getSeedsForVideoData()\\n\\n        let pages = getMyVar(\\\"seedsVideosLength\\\") ? Number(getMyVar(\\\"seedsVideosLength\\\")) : 1\\n\\n        let pageCount = parseInt((pages + 100 -1)/100 -1)\\n\\n        let minPage = page > 1 ? changePageInt(page,\\\"-\\\") : 1\\n\\n        let maxPage = page >= pageCount ? pageCount : changePageInt(page,\\\"+\\\")\\n\\n\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,minPage,num,count) => {\\n\\n                    if(page>minPage)\\n                    {\\n                        putMyVar(id+\\\"page\\\",minPage)\\n                        putMyVar(id+\\\"num\\\",Number(num-100))\\n                        putMyVar(id+\\\"count\\\",Number(count-100))\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,page,minPage,num,count),\\n                //pic_url:last_image,\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:page+\\\"/\\\"+pageCount,\\n                url:$('','请输入页码').input((id,pageCount)=>{\\n\\n                    let pageChange = Number(input * 100)\\n\\n                    if(input>0&&Number(input)<=pageCount){\\n                        putMyVar(id+'page',input)\\n                        putMyVar(id+\\\"num\\\",Number(pageChange+1))\\n                        putMyVar(id+\\\"count\\\",Number(pageChange+100))\\n                        refreshPage(false);\\n                        return \\\"toast://已经跳转到第\\\"+input+\\\"页\\\"\\n                    }else{return \\\"toast://输入错误\\\"}\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 总页数\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,maxPage,num,count) => {\\n\\n                    if(page<maxPage) {\\n                        putMyVar(id+\\\"page\\\",maxPage)\\n                        putMyVar(id+\\\"num\\\",Number(num+100))\\n                        putMyVar(id+\\\"count\\\",Number(count+100))\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,page,maxPage,num,count),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n        for (let i = num;i < pages && i <= count; i++) {\\n\\n            let picType = orther_image\\n\\n            let fileName = data[i].fileName\\n\\n            let cid = data[i].fileCid\\n\\n            let size = getFileSize(data[i].fileSize)\\n\\n            //let fileType = data[i].fileType\\n\\n            switch (true) {\\n                case image_regular.test(fileName):\\n                    picType = line+cid+'@Referer=https://wx.stariverpan.com/'\\n                    break;\\n\\n                case video_regular.test(fileName):\\n                    picType = video_image\\n                    break;\\n\\n                case audio_regular.test(fileName):\\n                    picType = audio_image\\n                    break;\\n\\n                default:\\n                    picType = file_image\\n                    break;\\n            }\\n\\n            d.push({\\n                title: fileName,\\n                desc: size,\\n                pic_url: picType,\\n                col_type: colType,\\n                url:cid+\\\"&&\\\"+fileName+getFileUrlLine\\n            });\\n        }\\n\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,minPage,num,count) => {\\n\\n                    if(page>minPage)\\n                    {\\n                        putMyVar(id+\\\"page\\\",minPage)\\n                        putMyVar(id+\\\"num\\\",Number(num-100))\\n                        putMyVar(id+\\\"count\\\",Number(count-100))\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,page,minPage,num,count),\\n                //pic_url:last_image,\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"更多操作\\\",\\n                url:$([\\\"返回首页\\\",\\\"跳转尾页\\\"], 2,'请选择更多页数功能').select((id,pageCount) => {\\n                    if(input==\\\"返回首页\\\"){\\n                        return $('#noLoading#').lazyRule((id) => {\\n                            putMyVar(id+'page',1)\\n                            putMyVar(id+\\\"num\\\",1)\\n                            putMyVar(id+\\\"count\\\",100)\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到首页\\\"\\n                        },id)\\n                    }else if (input==\\\"跳转尾页\\\"){\\n                        return $('#noLoading#').lazyRule((id,pageCount) => {\\n\\n                            let maxCount = Number(pageCount * 100)\\n\\n                            putMyVar(id+'page',pageCount)\\n                            putMyVar(id+\\\"num\\\",Number(maxCount+1))\\n                            putMyVar(id+\\\"count\\\",Number(maxCount+100))\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到尾页\\\"\\n                        },id,pageCount)\\n                    }\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 更多操作\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,maxPage,num,count) => {\\n\\n                    if(page<maxPage) {\\n                        putMyVar(id+\\\"page\\\",maxPage)\\n                        putMyVar(id+\\\"num\\\",Number(num+100))\\n                        putMyVar(id+\\\"count\\\",Number(count+100))\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,page,maxPage,num,count),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n    }\\n\\n}else{\\n    toast(\\\"请确认云盘密钥\\\")\\n\\n    java.lang.Thread.sleep(1500)\\n\\n    back();\\n}\\n\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"回收站\",\"path\":\"trash\",\"rule\":\"js:\\n    var d = [];\\n\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\nid = MY_PARAMS.id\\n\\nif(!id){\\n    id = \\\"\\\"\\n}\\n\\nlet page = Number(getMyVar(id+\\\"page\\\",\\\"1\\\"))\\n\\ntry {\\n\\n    let check_login = checkToken()\\n\\n    if(check_login.code === 200){\\n\\n\\n        result = trashFiles(page,storage0.getItem(\\\"排序类型\\\", \\\"name\\\"),storage0.getItem(\\\"排序方式\\\", \\\"asc\\\"))\\n\\n        /*d.push({\\n            title:result,\\n            url: \\\"\\\",\\n            col_type: \\\"text_1\\\"\\n        });*/\\n\\n        pages = Number(result.data.total_num)\\n        pageCount = Number((pages/100)+1).toFixed(0)\\n        minPage = page > 1 ? changePageInt(page,\\\"-\\\") : 1\\n        maxPage = page >= pageCount ? pageCount : changePageInt(page,\\\"+\\\")\\n\\n\\n        data = result.data.files\\n\\n        //排序功能\\n        d.push({\\n            title:storage0.getItem(\\\"排序变量\\\", \\\"名称正序\\\"),\\n            col_type: \\\"text_3\\\",\\n            url:$([\\\"名称正序\\\",\\\"名称倒序\\\",\\\"时间正序\\\",\\\"时间倒序\\\",\\\"大小正序\\\",\\\"大小倒序\\\"], 2,'需要什么类型排序？').select(() => {\\n\\n                storage0.setItem(\\\"排序变量\\\", input);\\n                if(input.includes(\\\"名称\\\"))\\n                    storage0.setItem(\\\"排序类型\\\", \\\"name\\\");\\n                else if(input.includes(\\\"时间\\\"))\\n                    storage0.setItem(\\\"排序类型\\\", \\\"upload\\\");\\n                else\\n                    storage0.setItem(\\\"排序类型\\\", \\\"size\\\");\\n\\n                if(input.includes(\\\"正序\\\"))\\n                    storage0.setItem(\\\"排序方式\\\", \\\"asc\\\");\\n                else\\n                    storage0.setItem(\\\"排序方式\\\", \\\"desc\\\");\\n\\n                refreshPage(false);\\n                return \\\"toast://切换成功\\\"\\n\\n            }),\\n            extra:{\\n                textSize:6\\n            }\\n        });\\n        //显示类型\\n        d.push({\\n            title:storage0.getItem(\\\"文件样式\\\", \\\"列表模式\\\"),\\n            col_type: \\\"text_3\\\",\\n            url:$([\\\"列表模式\\\",\\\"图文模式\\\",\\\"全名模式\\\",\\\"漫画模式\\\"], 2,'需要什么样式显示？').select((data) => {\\n\\n                storage0.setItem(\\\"文件样式\\\", input);\\n                if(input==\\\"列表模式\\\")\\n                    storage0.setItem(\\\"文件样式变量\\\", \\\"avatar\\\");\\n                if(input==\\\"图文模式\\\")\\n                    storage0.setItem(\\\"文件样式变量\\\", \\\"movie_2\\\");\\n                if(input==\\\"全名模式\\\")\\n                    storage0.setItem(\\\"文件样式变量\\\", \\\"text_1\\\");\\n                if (input==\\\"漫画模式\\\")\\n                    return $('').lazyRule((data) => {\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return getImageList(data)\\n                    },data)\\n                refreshPage(false);\\n                return \\\"toast://切换成功\\\"\\n\\n            },data)\\n        });\\n        //更多功能\\n        d.push({\\n            title:\\\"更多功能\\\",\\n            col_type: \\\"text_3\\\",\\n            url:$([\\\"清空回收站\\\"], 2,'功能操作').select(() => {\\n                if(input === \\\"清空回收站\\\"){\\n                    return $('#noLoading#').lazyRule(() =>{\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return cleanFilesForTrash()\\n                    })\\n                }\\n            })\\n        });\\n\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,minPage) => {\\n\\n                    if(page>minPage)\\n                    {\\n                        putMyVar(id+\\\"page\\\",minPage)\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,page,minPage),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:page+\\\"/\\\"+pageCount,\\n                url:$('','请输入页码').input((id,pageCount)=>{\\n\\n                    if(input>0&&Number(input)<=pageCount){\\n                        putMyVar(id+'page',input)\\n                        refreshPage(false);\\n                        return \\\"toast://已经跳转到第\\\"+input+\\\"页\\\"\\n                    }else{return \\\"toast://输入错误\\\"}\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 总页数\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,maxPage) => {\\n\\n                    if(page<maxPage) {\\n                        putMyVar(id+\\\"page\\\",maxPage)\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{return \\\"toast://已经最后\\\"}\\n                },id,page,maxPage),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n\\n        for (var i in data) {\\n\\n            //固定值判断\\n\\n            picType = \\\"\\\"\\n            url_type = \\\"\\\"\\n            url_back = \\\"\\\"\\n            colType = storage0.getItem(\\\"文件样式变量\\\", \\\"avatar\\\")\\n\\n            //循环固定值\\n\\n            fileName = data[i].file_name\\n            time = timestampToTime(data[i].create_time)\\n            isFolder = data[i].is_folder\\n            fileId = data[i].id\\n            file_size = getFileSize(data[i].file_size)\\n            parentId = data[i].parent_id\\n\\n\\n            //判断文件夹和文件\\n\\n            if(isFolder > 0){\\n\\n                picType = folder_image\\n\\n                d.push({\\n                    title: fileName,\\n                    desc: time,\\n                    pic_url: picType,\\n                    url: colType==\\\"漫画模式\\\"?$('').lazyRule((data) => {\\n                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                        return getImageList(data)\\n                    },data):\\\"\\\",\\n                    col_type: colType,\\n                    extra:{\\n                        longClick:[\\n                            {title: \\\"删除文件\\\", js: $.toString((fileId)=>{\\n                                    eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                    return deleteFilesForTrash(fileId)\\n                                },fileId)\\n                            },{title: \\\"恢复文件\\\", js: $.toString((fileId)=>{\\n                                    eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                    return recoverForTrash(fileId)\\n                                },fileId)\\n                            }\\n                        ],\\n                        textSize:24\\n                    }\\n                });\\n\\n            }else{\\n\\n                //文件固定值\\n\\n                cid = data[i].file_cid\\n                type = data[i].file_ext\\n                picType = file_image\\n\\n\\n                //判断文件类型\\n\\n                switch (true) {\\n                    case image_regular.test(type):\\n                        picType = line+cid+'@Referer=https://wx.stariverpan.com/'\\n                        break;\\n\\n                    case video_regular.test(type):\\n                        picType = video_image\\n                        break;\\n\\n                    case audio_regular.test(type):\\n                        picType = audio_image\\n                        break;\\n\\n                    default:\\n                        picType = file_image\\n                        break;\\n                }\\n\\n\\n                d.push({\\n                    title: fileName,\\n                    desc: file_size,\\n                    pic_url: picType,\\n                    url: cid+\\\"&&\\\"+type+getFileUrlLine,\\n                    col_type: colType,\\n                    extra:{\\n                        longClick:[\\n                            {title: \\\"删除文件\\\", js: $.toString((fileId)=>{\\n                                    eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                    return deleteFilesForTrash(fileId)\\n                                },fileId)\\n                            },{title: \\\"恢复文件\\\", js: $.toString((fileId)=>{\\n                                    eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                    return recoverForTrash(fileId)\\n                                },fileId)\\n                            }\\n                        ]\\n                    }\\n                });\\n\\n\\n            }\\n        }\\n\\n        if (pages > 100){\\n            //请求页数\\n\\n            d.push({\\n                title:\\\"上一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,minPage) => {\\n\\n                    if(page>minPage)\\n                    {\\n                        putMyVar(id+\\\"page\\\",minPage)\\n                        refreshPage();\\n                        return \\\"toast://上一页\\\"\\n                    }else{return \\\"toast://已经最前\\\"}\\n\\n                },id,page,minPage),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 上一页\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"更多操作\\\",\\n                url:$([\\\"返回首页\\\",\\\"跳转尾页\\\"], 2,'请选择更多页数功能').select((id,pageCount) => {\\n                    if(input==\\\"返回首页\\\"){\\n                        return $('#noLoading#').lazyRule((id) => {\\n                            putMyVar(id+'page',1)\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到首页\\\"\\n                        },id)\\n                    }else if (input==\\\"跳转尾页\\\"){\\n                        return $('#noLoading#').lazyRule((id,pageCount) => {\\n                            putMyVar(id+'page',pageCount)\\n                            refreshPage();\\n                            return \\\"toast://已经跳转到尾页\\\"\\n                        },id,pageCount)\\n                    }\\n                },id,pageCount),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 更多操作\\\"\\n                }\\n            });\\n\\n            d.push({\\n                title:\\\"下一页\\\",\\n                url:$('#noLoading#').lazyRule((id,page,maxPage) => {\\n\\n                    if(page<maxPage) {\\n                        putMyVar(id+\\\"page\\\",maxPage)\\n                        refreshPage();\\n                        return \\\"toast://下一页\\\"\\n                    }else{\\n                        return \\\"toast://已经最后\\\"\\n                    }\\n                },id,page,maxPage),\\n                col_type: \\\"text_3\\\",\\n                extra: {\\n                    cls: \\\"playlist 下一页\\\"\\n                }\\n            });\\n        }\\n\\n    }else {\\n        toast(\\\"密钥有问题或者未登录\\\")\\n\\n        java.lang.Thread.sleep(1500)\\n\\n        back();\\n    }\\n\\n}catch (e){\\n    log(e.message)\\n}\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"磁力数据解析\",\"path\":\"checkMagent\",\"rule\":\"js:\\n    var d = []\\n\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\ntype = storage0.getItem(\\\"CheckMagentType\\\", \\\"\\\");\\nmagent = storage0.getItem(\\\"CheckMagentMagent\\\", \\\"\\\");\\n\\n\\nd.push({\\n    title:\\\"查询\\\\n具体内容\\\",\\n    desc:\\\"请输入磁力链接\\\",\\n    col_type: \\\"input\\\",\\n    url:$.toString(() => {\\n        storage0.setItem(\\\"CheckMagentType\\\", \\\"data\\\");\\n        storage0.setItem(\\\"CheckMagentMagent\\\", input);\\n        refreshPage();\\n    }),\\n    extra: {type: 'textarea',height: 2}\\n});\\n\\nd.push({\\n    title:\\\"查询\\\\n带图片\\\",\\n    desc:\\\"请输入磁力链接\\\",\\n    col_type: \\\"input\\\",\\n    url:$.toString(() => {\\n        storage0.setItem(\\\"CheckMagentType\\\", \\\"image\\\");\\n        storage0.setItem(\\\"CheckMagentMagent\\\", input);\\n        refreshPage();\\n    }),\\n    extra: {type: 'textarea',height: 2}\\n});\\n\\nif (type === \\\"data\\\"){\\n\\n    result = checkMagentData(magent,type)\\n\\n    if (result === \\\"error\\\"){\\n\\n        toast(\\\"查询次数更多，请稍后再试!\\\")\\n\\n    }else if(result === \\\"\\\"){\\n        toast(\\\"查询超时，请更换模式!\\\")\\n    }else {\\n\\n        data = JSON.parse(result).info\\n\\n        fileName = data.name\\n        hash = data.magnet\\n        countSize = getFileSize(data.length)\\n        files = data.files\\n\\n        d.push({\\n            title: fileName,\\n            desc: \\\"大小：\\\"+countSize+\\\"\\\\n链接：\\\"+hash,\\n            url:\\\"copy://\\\"+hash,\\n            pic_url: \\\"\\\",\\n            col_type: \\\"text_1\\\"\\n        });\\n\\n        d.push({\\n            col_type: 'line_blank'\\n        });\\n\\n        for (var i in files){\\n\\n            path = files[i].path\\n            fileName = files[i].name\\n            size = getFileSize(files[i].length)\\n\\n            d.push({\\n                title: fileName,\\n                desc: \\\"大小：\\\"+size+\\\"\\\\n路径：\\\"+path,\\n                url:\\\"\\\",\\n                pic_url: \\\"\\\",\\n                col_type: \\\"text_1\\\"\\n            });\\n\\n        }\\n\\n    }\\n\\n\\n}else if (type === \\\"image\\\"){\\n\\n    result = checkMagentData(magent,type)\\n\\n    data = JSON.parse(result)\\n\\n    fileName = data.name\\n    hash = magent\\n    countSize = getFileSize(data.size)\\n    count = data.count\\n    type = data.file_type\\n    files = data.screenshots\\n\\n    d.push({\\n        title: fileName,\\n        desc: \\\"类型：\\\"+type+\\\"\\\\n大小：\\\"+countSize+\\\"\\\\n总数：\\\"+count,\\n        url:\\\"copy://\\\"+hash,\\n        pic_url: \\\"\\\",\\n        col_type: \\\"text_1\\\"\\n    });\\n\\n    d.push({\\n        col_type: 'line_blank'\\n    });\\n\\n    for (var i in files){\\n\\n        file_images = files[i].screenshot\\n\\n        d.push({\\n            title: \\\"展示图-\\\"+i,\\n            desc: \\\"\\\",\\n            url:file_images+\\\"#.jpg@Referer=https://whatslink.info/\\\",\\n            pic_url: file_images,\\n            col_type: \\\"movie_2\\\"\\n        });\\n\\n    }\\n\\n}else {\\n    toast(\\\"温馨提示!具体数据不可重复刷新,会有使用次数限制\\\")\\n}\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"读取备份\",\"path\":\"readBack\",\"rule\":\"js:\\n    var d = []\\n\\neval(JSON.parse(request('hiker://page/functions')).rule)\\n\\nlet path = MY_PARAMS.path\\n\\nlet type = storage0.getItem(\\\"backType\\\",\\\"\\\")\\n\\nlet moveType = storage0.getItem(\\\"moveType\\\",\\\"false\\\")\\n\\nlet moveData = storage0.getItem(\\\"moveData\\\",'[]')\\n\\nlet moveFileDataPath = storage0.getItem(\\\"moveFileDataPath\\\",\\\"\\\")\\n\\naddListener('onClose',$.toString(()=>{refreshPage()}))\\n\\nif (!path){\\n\\n    if (type === 'start'){\\n\\n        path = startPath\\n\\n    }else if (type === 'cloud'){\\n\\n        path = cloudPath\\n\\n    }\\n\\n}\\n\\nif (fileExist(path)){\\n\\n    let line = \\\"https://ipfsgw00.stariverpan.com:9095/ipfs/\\\"\\n\\n    if (type === 'start'){\\n\\n        try {\\n\\n            let fileBack = JSON.parse(readFile(path, 0) || '[]');\\n\\n            let data = fileBack.fileData\\n\\n            let files = data.files\\n\\n            for (let i in files){\\n\\n                let data = files[i]\\n\\n                let isFolder = files[i].type\\n\\n                let fileName = files[i].name\\n\\n                let fileId = files[i].id\\n\\n                let newPath = startIndexPath+fileId+fileName+\\\".json\\\"\\n\\n                let pathName = fileId+fileName\\n\\n                if (isFolder > 0){\\n\\n                    let backPath = JSON.parse(readFile(newPath, 0) || '[]').fileData.path\\n\\n                    d.push({\\n                        title: fileName,\\n                        pic_url: back_folder_image,\\n                        url:\\\"hiker://page/readBack\\\",\\n                        col_type:\\\"avatar\\\",\\n                        extra:{\\n                            path: newPath,\\n                            longClick: moveType === \\\"false\\\" ? [\\n                                {\\n                                    title: \\\"更多操作\\\", js: $.toString((newPath)=>{\\n                                        return $([\\\"沉浸漫画\\\"], 2,'功能操作').select((newPath) =>{\\n                                            if(input === \\\"沉浸漫画\\\"){\\n                                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                return backFileImageListForStart(newPath)\\n                                            }\\n                                        },newPath)\\n                                    },newPath)},\\n                                {\\n                                    title: \\\"自主备份到此\\\",js:$.toString((pathName,backPath)=>{\\n\\n                                        confirm({\\n\\n                                            title:'选择备份',\\n                                            content:'确定-将存入当前自主备份目录\\\\n取消-重新选择自主备份的目录',\\n\\n                                            confirm:$.toString((pathName,backPath)=>{\\n\\n                                                if (storage0.getItem(\\\"backChange\\\",\\\"false\\\") === \\\"true\\\"){\\n\\n                                                    if (storage0.getItem(\\\"backChangeType\\\",\\\"false\\\") === \\\"true\\\"){\\n\\n                                                        log(JSON.stringify(getMyVar(\\\"batchData\\\")))\\n\\n                                                    }else {\\n\\n                                                        let data = storage0.getItem(\\\"backChangeData\\\");\\n\\n                                                        if (data.length < 1){\\n\\n                                                            return \\\"toast://备份数据异常，请联系开发\\\"\\n\\n                                                        }else {\\n\\n                                                            eval(JSON.parse(request('hiker://page/functions')).rule)\\n\\n                                                            checkBackIsTrue(pathName,data,backPath)\\n\\n                                                        }\\n\\n                                                    }\\n\\n                                                }else {\\n\\n                                                    return \\\"toast://请从自主备份那跳转过来\\\"\\n                                                }\\n\\n                                            },pathName,backPath),\\n\\n                                            cancel:$.toString(()=>{\\n\\n                                            })\\n\\n                                        })\\n                                    },pathName,backPath)\\n                                },\\n                                {title: \\\"文件操作\\\", js: $.toString((data,path)=>{\\n                                        return $([\\\"移动备份\\\",\\\"删除备份\\\"], 2,'功能操作').select((data,path) =>{\\n                                            if (input === \\\"移动备份\\\"){\\n                                                clearItem(\\\"backType\\\")\\n                                                clearItem(\\\"moveType\\\")\\n                                                clearItem(\\\"moveData\\\")\\n                                                clearItem(\\\"moveFileDataPath\\\")\\n                                                storage0.setItem(\\\"moveType\\\",\\\"true\\\")\\n                                                storage0.setItem(\\\"moveData\\\",data)\\n                                                storage0.setItem(\\\"moveFileDataPath\\\",path)\\n                                                storage0.setItem(\\\"backType\\\", \\\"start\\\");\\n                                                refreshPage()\\n                                            } else if (input === \\\"删除备份\\\"){\\n\\n                                                confirm({\\n\\n                                                    title: '删除播放',\\n                                                    content: '确定-删除备份文件或文件夹\\\\n取消-取消删除播放操作',\\n\\n                                                    confirm: $.toString((data,path) => {\\n\\n                                                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                        return backFolderDelete(data,path)\\n                                                        \\n                                                    },data,path),\\n\\n                                                    cancel: $.toString(() => {\\n\\n                                                    })\\n                                                    \\n                                                })\\n                                            }\\n                                        },data,path)\\n                                    },data,path)\\n                                }\\n                            ] : [\\n                                {\\n                                    title: \\\"移动到同级目录\\\", js: $.toString((moveData,moveFileDataPath,path)=>{\\n\\n                                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                        return moveBackFile(moveData,moveFileDataPath,path)\\n\\n                                    },moveData,moveFileDataPath,path)\\n                                },\\n                                {\\n                                    title: \\\"移动到子级目录\\\", js: $.toString((moveData,moveFileDataPath,fileId,fileName)=>{\\n\\n                                        eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                        return moveBackFile(moveData,moveFileDataPath,startIndexPath+fileId+fileName+\\\".json\\\")\\n\\n                                    },moveData,moveFileDataPath,fileId,fileName)\\n                                }\\n                            ]\\n                        }\\n                    });\\n\\n                }else {\\n\\n                    let picType = back_file_image\\n\\n                    let colType = storage0.getItem(\\\"文件样式变量\\\", \\\"avatar\\\")\\n\\n                    let cid = files[i].cid\\n\\n                    let file_size = getFileSize(files[i].size)\\n\\n                    switch (true) {\\n\\n                        case image_regular.test(fileName):\\n                            picType = line+cid+'@Referer=https://wx.stariverpan.com/'\\n                            break;\\n\\n                        case video_regular.test(fileName):\\n                            picType = video_image\\n                            break;\\n\\n                        case audio_regular.test(fileName):\\n                            picType = audio_image\\n                            break;\\n\\n                        default:\\n                            picType = back_file_image\\n                            break;\\n                    }\\n\\n                    d.push({\\n                        title: fileName,\\n                        desc: file_size,\\n                        pic_url: picType,\\n                        url: cid+\\\"&&\\\"+fileName+getFileUrlLine,\\n                        col_type: colType,\\n                        extra:{\\n                            path: newPath,\\n                            longClick: moveType === \\\"false\\\" ? [\\n                                {title: \\\"文件操作\\\", js: $.toString((data,path)=>{\\n                                        return $([\\\"移动备份\\\",\\\"删除备份\\\"], 2,'功能操作').select((data,path) =>{\\n                                            if (input === \\\"移动备份\\\"){\\n                                                clearItem(\\\"backType\\\")\\n                                                clearItem(\\\"moveType\\\")\\n                                                clearItem(\\\"moveData\\\")\\n                                                clearItem(\\\"moveFileDataPath\\\")\\n                                                storage0.setItem(\\\"moveType\\\",\\\"true\\\")\\n                                                storage0.setItem(\\\"moveData\\\",data)\\n                                                storage0.setItem(\\\"moveFileDataPath\\\",path)\\n                                                storage0.setItem(\\\"backType\\\", \\\"start\\\");\\n                                                refreshPage()\\n                                            } else if (input === \\\"删除备份\\\"){\\n                                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                return backFileDelete(data,path)\\n                                            }\\n                                        },data,path)\\n                                    },data,path)\\n                                }\\n                            ] : [\\n                        {\\n                            title: \\\"移动到同级目录\\\", js: $.toString((moveData,moveFileDataPath,path)=>{\\n\\n                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                return moveBackFile(moveData,moveFileDataPath,path)\\n\\n                            },moveData,moveFileDataPath,path)\\n                        }\\n                    ]\\n                        }\\n                    });\\n\\n\\n                }\\n            }\\n\\n\\n        }catch (e) {e.message}\\n\\n    } else if (type === 'cloud'){\\n\\n        try {\\n\\n            let dataAll;\\n\\n            let fileBack = JSON.parse(readFile(path, 0) || '[]');\\n\\n            let data = fileBack.data\\n\\n            let dataA = data.文件夹\\n\\n            let dataB = data.文件\\n\\n            dataAll = dataA.concat(dataB)\\n\\n            if (dataA.length > 0) {\\n\\n                for (let i in dataA) {\\n\\n                    let folderName = dataA[i]\\n\\n                    let newPath = path.slice(0,-5)+\\\"⸝\\\"+folderName+\\\".json\\\"\\n\\n                    d.push({\\n                        title: folderName,\\n                        pic_url: back_folder_image,\\n                        url: \\\"hiker://page/readBack#noRecordHistory#\\\",\\n                        col_type:\\\"avatar\\\",\\n                        extra:{\\n                            path: newPath,\\n                            longClick:[\\n                                {title: \\\"更多操作\\\", js: $.toString((newPath)=>{\\n                                        return $([\\\"沉浸漫画\\\"], 2,'功能操作').select((newPath) =>{\\n                                            if(input === \\\"沉浸漫画\\\"){\\n                                                eval(JSON.parse(request('hiker://page/functions')).rule)\\n                                                return backFileImageList(newPath)\\n                                            }\\n                                        },newPath)\\n                                    },newPath)\\n                                }\\n                            ]\\n                        }\\n                    });\\n\\n                }\\n\\n            }\\n\\n            if (dataB.length > 0) {\\n\\n                for (let x in dataB){\\n\\n                    let fileName = dataB[x].文件名\\n\\n                    let picType = back_file_image\\n\\n                    let colType = storage0.getItem(\\\"文件样式变量\\\", \\\"avatar\\\")\\n\\n                    let cid = dataB[x].文件CID\\n\\n                    let file_size = getFileSize(dataB[x].文件大小)\\n\\n                    switch (true) {\\n\\n                        case image_regular.test(fileName):\\n                            picType = line+cid+'@Referer=https://wx.stariverpan.com/'\\n                            break;\\n\\n                        case video_regular.test(fileName):\\n                            picType = video_image\\n                            break;\\n\\n                        case audio_regular.test(fileName):\\n                            picType = audio_image\\n                            break;\\n\\n                        default:\\n                            picType = back_file_image\\n                            break;\\n                    }\\n\\n                    d.push({\\n                        title: fileName,\\n                        desc: file_size,\\n                        pic_url: picType,\\n                        url: cid+\\\"&&\\\"+fileName+getFileUrlLine,\\n                        col_type: colType\\n                    });\\n\\n                }\\n\\n            }\\n\\n\\n        }catch (e) {e.message}\\n\\n    }\\n\\n}else {\\n\\n    toast(\\\"暂未发现备份文件\\\")\\n}\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"搜索磁力\",\"path\":\"searchMagent\",\"rule\":\"js:\\nvar d = [];\\n\\nlet searchUrl = \\\"https://skrbtiu.top/search?keyword=\\\"\\n\\nlet data = [];\\n\\nd.push({\\n    title: \\\"搜索磁力\\\",\\n    desc: \\\"\\\",\\n    col_type: 'input',\\n    url: $.toString((searchUrl) => {\\n\\n      log(searchUrl+input)\\n\\n      let html = request(searchUrl+input)\\n\\n      data = parseDomForArray(html,'body&&url&&.list-unstyled')\\n\\n      log(data)\\n\\n    },searchUrl)\\n});\\n\\nsetResult(d);\"}]","icon":"https://ipfsgw00.stariverpan.com:9095/ipfs/bafkreib54mchy3i3sts6pu47h6ixd4jezcw23psdlrj4v5a2v7tgzdpftm#.jpg@Referer=https://wx.stariverpan.com/","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
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!