Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@百度网盘@{"last_chapter_rule":"","title":"百度网盘","author":"dy2020","url":"hiker://empty##fypage","version":2025051015,"col_type":"movie_3","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\n//clearItem('history');\nvar d = [];\n//原版作者Joe佬,整合ZHAO大佬版本\naddListener('onClose', $.toString(() => {\n    clearMyVar('paths');\n}));\n\nlet lastTime = getItem('getTime');\nlet currentTime = Date.now();\nsetItem('getTime', currentTime + '');\nif (lastTime == 'undefined' || currentTime - lastTime >= 86400000) {\n    let pathGitee = 'https://gitee.com/mistywater/hiker_info/raw/master/%E7%99%BE%E5%BA%A6%E7%BD%91%E7%9B%98.json';\n    let htmlGitee = fetchPC(pathGitee);\n    let version = htmlGitee.match(/version\":(\\d+)/)[1];\n    if (MY_RULE.version < version) {\n        confirm({\n            title: \"有新版本\",\n            content: '导入新版本吗?',\n            confirm() {\n                return \"rule://5rW36ZiU6KeG55WM6aaW6aG16aKR6YGT6KeE5YiZ44CQ55m+5bqm572R55uY44CR77+laG9tZV9ydWxlX3VybO+/pWh0dHBzOi8vZ2l0ZWUuY29tL21pc3R5d2F0ZXIvaGlrZXJfaW5mby9yYXcvbWFzdGVyL+eZvuW6pue9keebmC5qc29u\";\n            },\n            cancel() {}\n        });\n    }\n}\n\nif (getItem(\"first\") != MY_RULE.version) {\n    $.require(\"说明\");\n} else {\n    rc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\n\n    if (MY_PAGE == 1) {\n        d.push({\n            title: '🔍',\n            url: $.toString((r) => {\n                if (input == '') {\n                    clearVar('paths');\n                } else if (input == ' ') {\n                    clearVar('paths');\n                    clearVar('keyword');\n                } else {\n                    putVar('keyword', input);\n                    $.require(\"hiker://page/lists\").storeHistorySearch(input);\n                    return $.require(\"hiker://page/lists\").codeParseSearchUrl(input);\n                }\n                refreshPage();\n                return 'hiker://empty';\n            }, MY_RULE.title),\n            desc: '关键词|@关键词|分享链接|空格:清除',\n            col_type: 'input',\n            extra: {\n                defaultValue: getVar('keyword', ''),\n            }\n        });\n        d.push({\n            title: '设置',\n            url: 'hiker://page/login',\n            col_type: 'scroll_button',\n            extra: {\n                id: '设置'\n            }\n        });\n    }\n    if (getItem(\"access_token\") == 'undefined') {\n        d.push({\n            title: 'token不存在,需要token登录',\n            url: 'hiker://page/login',\n            col_type: 'text_center_1',\n        });\n    }\n    if (getItem(\"BDUSS\") == 'undefined') {\n        d.push({\n            title: 'cookie不存在,需要网页登录',\n            url: 'hiker://page/login',\n            col_type: 'text_center_1',\n        });\n    }\n    if (getItem(\"access_token\") != 'undefined' && getItem(\"BDUSS\") != 'undefined') {\n        $.require(\"hiker://page/lists\").codeList();\n    }\n}\nsetResult(d);","search_url":"hiker://empty##fypage##**","group":"①==自用","searchFind":"js:\nrc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\n\nvar d = [];\nvar key = \"4OToScUFOaeVTrHE\";\nvar iv = \"9CLGao1vHKqm17Oz\";\nvar urlSearch = 'https://miaosou.fun/api/secendsearch?name=' + MY_URL.split('##').at(-1) + '&pageNo=' + MY_PAGE + '&type=&from=baidu';\nlog(urlSearch);\nvar html = fetchPC(urlSearch);\nvar json = JSON.parse(html);\nvar list = json.data.list;\nlist.forEach((list) => {\n    var url = de(key, iv, list.url, 'AES/CBC/PKCS7Padding');\n    d.push({\n        title: list.name.replace(/<.*?>/g, ''),\n        desc: list.gmtCreate + \" \" + list.from.replace(/ali.*/, '阿里云盘').replace(/baidu.*/, '百度网盘').replace(/quark.*/, '夸克网盘').replace(/uc.*/, 'UC网盘'),\n        url: $(url).lazyRule(() => {\n            putVar('urlBaidu', input);\n            return \"hiker://page/list?rule=百度网盘&realurl=\" + input;\n        }),\n    });\n});\nsetResult(d);","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"/*<$>\n@include start\nhttps://gitee.com/mistywater/hiker_info/raw/master/globalVar.json\n@include end\n<$>*/","pages":"[{\"col_type\":\"text_2\",\"name\":\"设置\",\"path\":\"login\",\"rule\":\"js:\\nrc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\nvar d = [];\\nd.push({\\n    title: sb(\\\"token登录和网页登录都需要登录\\\", 'FF0000'),\\n    url: \\\"hiker://empty\\\",\\n    col_type: \\\"text_center_1\\\",\\n});\\nd.push({\\n    title: !getItem(\\\"access_token\\\",'')?strong(\\\"先获取token\\\",'FF0000'):color('已token登录','00FF00'),\\n    url: \\\"https://openapi.baidu.com/oauth/2.0/authorize?response_type=code&client_id=iYCeC9g08h5vuP9UqvPHKKSVrKFXGa1v&redirect_uri=https://alist.nn.ci/tool/baidu/callback&scope=basic,netdisk&qrcode=1\\\",\\n    col_type: \\\"text_2\\\",\\n});\\n\\nd.push({\\n    title: !getItem(\\\"BDUSS\\\",'')?color(\\\"未网页登录\\\",'FF0000'):color('已网页登录','00FF00'),\\n    url: $(\\\"hiker://empty\\\").rule(() => {\\n        let d = [];\\n        setPageTitle(\\\"登录账号\\\");\\n        addListener(\\\"onClose\\\", () => clearMyVar(\\\"cookie\\\"));\\n        d.push({\\n            title: \\\"““确认登录””\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n                var bdwp_cookie = request(\\\"hiker://files/cache/bdwp_cookie.txt\\\") || \\\"\\\"; //log(bdwp_cookie)\\n                var header = {\\n                    \\\"User-Agent\\\": \\\"Android\\\",\\n                    \\\"Referer\\\": \\\"https://pan.baidu.com/\\\",\\n                    \\\"Cookie\\\": bdwp_cookie,\\n                }\\n                var html = request(\\\"https://wappass.baidu.com/v3/login/api/auth?notjump=1&return_type=5&tpl=netdisk&u=https://pan.baidu.com/buy/ad/home?useCanvas=1&pathname=/share_wap\\\", {\\n                    headers: header,\\n                    method: \\\"GET\\\",\\n                    redirect: false,\\n                    onlyHeaders: true\\n                });\\n                var url = JSON.parse(html).headers.location[0]; //log(url)\\n                var html = request(url, {\\n                    headers: header,\\n                    method: \\\"GET\\\",\\n                    redirect: false,\\n                    onlyHeaders: true\\n                });\\n                var setcookie = JSON.parse(html).headers[\\\"set-cookie\\\"].toString(); //log(setcookie)\\n                setItem(\\\"cookieTmp\\\", setcookie);\\n                if (bdwp_cookie.includes(\\\"BDUSS=\\\")) {\\n                    if (bdwp_cookie.includes(\\\"BDUSS=\\\")) {\\n                        var BDUSS = bdwp_cookie.match(/(BDUSS=.*?);/)[1];\\n                        log(BDUSS)\\n                        setItem(\\\"BDUSS\\\", BDUSS)\\n                        //log(\\\"BDUSS设置成功\\\")\\n                    }\\n                    if (setcookie.includes(\\\"STOKEN=\\\")) {\\n                        var STOKEN = setcookie.match(/STOKEN=\\\\w*/)[0];\\n                        log(STOKEN)\\n                        setItem(\\\"STOKEN\\\", STOKEN)\\n                        //log(\\\"STOKEN设置成功\\\")\\n                    }\\n                }\\n                back();\\n                toast(\\\"登录成功\\\")\\n                return \\\"hiker://empty\\\";\\n            }),\\n            desc: \\\"““””<small>点击头像可以退出账号重新登录</small>\\\",\\n            col_type: \\\"text_2\\\",\\n        });\\n        d.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n        let url = 'https://wappass.baidu.com/passport?login&authsite=1&tpl=netdisk&overseas=1&regdomestic=1&smsLoginLink=1&display=mobile&u=https://pan.baidu.com/wap/home?loginform=pass&realName=1&wapBehaviorLog=wap_click_welcome_login&branchType=SMSlogin#/one_key_h5_new'\\n        d.push({\\n            col_type: 'x5_webview_single',\\n            url: url,\\n            desc: 'list&&screen-150',\\n            extra: {\\n                ua: 'Android',\\n                js: $.toString((url) => {\\n                    function check() {\\n                        var co = fba.getCookie(url);\\n                        //console.log(co)\\n                        if (co.includes('STOKEN=')) {\\n                            fba.parseLazyRule($$$().lazyRule((co) => {\\n                                writeFile('hiker://files/cache/bdwp_cookie.txt', co);\\n                                toast('Cookie获取成功，请确认登录')\\n                            }, co));\\n                        } else {\\n                            setTimeout(check, 500);\\n                        }\\n                    }\\n                    check();\\n                }, url)\\n            },\\n        });\\n        setResult(d)\\n    }),\\n    col_type: 'text_2',\\n});\\n//clearItem(\\\"access_token\\\")\\n//clearItem(\\\"refresh_token\\\")\\nd.push({\\n    title: !getItem(\\\"access_token\\\",'')?color(\\\"未token登录\\\",'FF0000'):color('已token登录','00FF00'),\\n    url: $(getItem('refresh_token'), \\\"填写获取到的token\\\").input(() => {\\n        setItem('refresh_token', input);\\n        let res = JSON.parse(request(buildUrl(\\\"https://openapi.baidu.com/oauth/2.0/token\\\", {\\n            \\\"grant_type\\\": \\\"refresh_token\\\",\\n            \\\"refresh_token\\\": input,\\n            \\\"client_id\\\": \\\"iYCeC9g08h5vuP9UqvPHKKSVrKFXGa1v\\\",\\n            \\\"client_secret\\\": \\\"jXiFMOPVPCWlO2M5CwWQzffpNPaGTRBG\\\"\\n        })));\\n        if (!res.access_token) {\\n            return \\\"toast://错误！！！\\\"\\n        } else {\\n            setItem(\\\"access_token\\\", res.access_token)\\n            setItem(\\\"refresh_token\\\", res.refresh_token)\\n            //back();\\n        }\\n    }),\\n    col_type: \\\"text_2\\\",\\n});\\nd.push({\\n    title: \\\"Cookie登录\\\",\\n    url: $(getItem(\\\"cookieTmp\\\"), \\\"填写Cookie\\\").input(() => {\\n            if (!input.includes(\\\"AAAA\\\")) {\\n                return \\\"toast://Cookie错误\\\"\\n            } else {\\n                if (input.includes(\\\"BDUSS=\\\")) {\\n                    var BDUSS = input.match(/(BDUSS=.*?);/)[1];\\n                    setItem(\\\"BDUSS\\\", BDUSS)\\n                    toast(\\\"BDUSS设置成功\\\")\\n                }\\n                if (input.includes(\\\"STOKEN=\\\")) {\\n                    var STOKEN = input.match(/STOKEN=\\\\w*/)[0];\\n                    setItem(\\\"STOKEN\\\", STOKEN)\\n                    toast(\\\"STOKEN设置成功\\\")\\n                }\\n                back();\\n            }\\n    }),\\n    col_type: \\\"text_2\\\",\\n});\\nd.push({\\n    title: \\\"清除token\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        return $('确认清除吗?').confirm(() => {\\n            clearItem(\\\"access_token\\\");\\n            toast(\\\"已清除token\\\");\\n            return 'hiker://empty';\\n        });\\n           }),\\n    col_type: \\\"text_2\\\",\\n});\\nd.push({\\n    title: \\\"清除cookie\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        return $('确认清除吗?').confirm(() => {\\n            setItem(\\\"cookieTmp\\\",getItem(\\\"BDUSS\\\") + ';' + getItem(\\\"STOKEN\\\"));\\n            clearItem(\\\"BDUSS\\\");\\n            clearItem(\\\"STOKEN\\\");\\n            clearItem(\\\"PTOKEN\\\");\\n            toast(\\\"已清除cookie\\\");\\n            return 'hiker://empty';\\n        });\\n         }),\\n    col_type: \\\"text_2\\\",\\n});\\n\\nd.push({\\n    title: \\\"选择接口：\\\" + (getItem(\\\"jk\\\", \\\"0\\\") == \\\"0\\\" ? \\\"官方接口：不是vip会限速，稳定\\\" : \\\"百度网盘TV接口\\\"),\\n    url: $().lazyRule(() => {\\n        setItem(\\\"jk\\\", getItem(\\\"jk\\\", \\\"0\\\") == \\\"0\\\" ? \\\"1\\\" : \\\"0\\\")\\n        refreshPage()\\n        return \\\"hiker://empty\\\"\\n    }),\\n    col_type: \\\"text_center_1\\\"\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"代码\",\"path\":\"code\",\"rule\":\"$.exports.getIcon = function(content) {\\n    let {\\n        getHzm\\n    } = $.require('hiker://page/code')\\n    let root = 'https://gitee.com/mistywater/hiker_info/raw/master/iconSystem/';\\n    if (content.isdir == 1) {\\n        img = 'https://staticsns.cdn.bcebos.com/amis/2024-8/1722592402960/%E6%96%87%E4%BB%B6%E5%A4%B9%20(2).png';\\n    } else {\\n        let files = '3gp|ai|ape|apk|avi|avif|bat|chm|css|dmg|doc|epub|exc|exe|f4v|flac|flv|gif|hiker|htm|html|ico|iff|ilbm|iso|jfif|jpe|jpeg|jpg|js|json|jxr|kux|log|m3u8|m4a|m4v|mkv|mng|mov|mp3|mp4|mpeg|mpg|ogg|opus|otf|pcx|pdf|php|pjp|pjpeg|pmp|png|ppm|ppt|psd|psp|qsv|ram|rar|reg|rm|rmvb|sai|svg|svgz|swf|table|tif|tiff|ts|ttf|txt|ufo|wav|webm|webp|wmv|xbm|xcf|xls|xlsx|xpm|zip'.split('|');\\n        let fileName = content.server_filename;\\n        let hzm = getHzm(fileName);\\n        if (files.includes(hzm)) {\\n            img = root + hzm + '.png';\\n        } else {\\n            img = root + '文件.png'\\n        }\\n    }\\n    return img\\n}\\n$.exports.getHzm = function(fileName) {\\n    var ext = (fileName.substr(fileName.lastIndexOf('.') + 1)).toLowerCase();\\n    if (/^r\\\\d+|^7z/i.test(ext)) {\\n        ext = 'rar';\\n    } else if (/^md/i.test(ext)) {\\n        ext = 'iso';\\n    } else if (/^md/i.test(ext)) {\\n        ext = 'iso';\\n    } else if (/^ht|mht/i.test(ext)) {\\n        ext = 'html';\\n    } else if (/^xl|^et/i.test(ext)) {\\n        ext = 'xlsx';\\n    } else if (/^log|^lrc/i.test(ext)) {\\n        ext = 'txt';\\n    } else if (/^(3gp|avi|f4v|flv|kux|m3u8|m4v|mkv|mov|mp4|mpeg|mpg|pmp|qsv|ram|rm|rmvb|swf|ts|webm|wmv)/i.test(ext)) {\\n        ext = 'mkv';\\n    }\\n    return ext;\\n}\\n$.exports.getLink = function(ext, id, path, img) {\\n    return $('#noLoading#').lazyRule((ext, id, path, img) => {\\n        let history = storage0.getItem('history', []);\\n        let dataPath = `${path}@@${id}@@${ext}@@${img}`;\\n        if (!history.includes(dataPath)) {\\n            history.push(dataPath);\\n        }\\n        storage0.setItem('history', history);\\n        if (/share/.test(JSON.stringify(path)) && ext == 'movie') {\\n            var url = getVar('urlBaidu') || getVar('keyword');\\n            if (url && /\\\\/(s|share)\\\\//.test(url)) {\\n                var surl = /share/.test(url) ? '1' + url.split(/&|=/)[1] : url.split(/\\\\/|\\\\?/)[4];\\n            } else {\\n                if (/realurl=/.test(MY_URL)) {\\n                    MY_URL = MY_URL.split('realurl=')[1];\\n                }\\n                var surl = /share/.test(MY_URL) ? '1' + MY_URL.split(/&|=/)[1] : MY_URL.split(/\\\\/|\\\\?/)[4];\\n            }\\n\\n            var uk = getVar('share_uk');\\n            var shareid = getVar('share_id');\\n            var fs_id = id;\\n            var jsToken = getVar('jsToken');\\n\\n\\n            var header = {\\n                'Cookie': getVar('ck'),\\n                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36'\\n            }\\n            var url31 = 'https://pan.baidu.com/share/tplconfig?surl=' + surl + '&fields=cfrom_id,Espace_info,card_info,sign,timestamp'\\n            var html31 = request(url31, {\\n                headers: header,\\n                method: 'GET'\\n            });\\n            var html32 = JSON.parse(html31).data;\\n            var timestamp = html32.timestamp;\\n            var sign = html32.sign;\\n            var play480 = 'https://pan.baidu.com/share/streaming?uk=' + uk + '&fid=' + fs_id + '&sign=' + sign + '&timestamp=' + timestamp + '&shareid=' + shareid + '&type=M3U8_AUTO_480&jsToken=' + jsToken;\\n            var play720 = 'https://pan.baidu.com/share/streaming?uk=' + uk + '&fid=' + fs_id + '&sign=' + sign + '&timestamp=' + timestamp + '&shareid=' + shareid + '&type=M3U8_AUTO_720&jsToken=' + jsToken;\\n            var play1080 = 'https://pan.baidu.com/share/streaming?uk=' + uk + '&fid=' + fs_id + '&sign=' + sign + '&timestamp=' + timestamp + '&shareid=' + shareid + '&type=M3U8_AUTO_1080&jsToken=' + jsToken;\\n            var play2K = 'https://pan.baidu.com/share/streaming?uk=' + uk + '&fid=' + fs_id + '&sign=' + sign + '&timestamp=' + timestamp + '&shareid=' + shareid + '&type=M3U8_AUTO_2K&jsToken=' + jsToken;\\n            var play4K = 'https://pan.baidu.com/share/streaming?uk=' + uk + '&fid=' + fs_id + '&sign=' + sign + '&timestamp=' + timestamp + '&shareid=' + shareid + '&type=M3U8_AUTO_4K&jsToken=' + jsToken;\\n\\n            return JSON.stringify({\\n                urls: [play1080, play4K, play2K, play720, play480 + '#isVideo=true#'],\\n                names: ['1080P', '4K', '2K', '720P', '480P'],\\n                headers: [header, header, header, header, header]\\n            })\\n        } else if (/share/.test(JSON.stringify(path))) {\\n\\n        } else if (!/share/.test(JSON.stringify(path)) || ext != 'img') {\\n            //clearItem('jk');\\n            if (getItem('jk', '0') == '1' && ext == 'movie') {\\n                //播放接口来自百度网盘TV\\n                var bdtvm = request('https://pan.baidu.com/api/mediainfo?type=M3U8_FLV_264_480&path=' + encodeURIComponent(path) + '&clienttype=80&origin=dlna', {\\n                    headers: {\\n                        'Cookie': getItem(\\\"BDUSS\\\"),\\n                        'User-Agent': 'netdisk;1.4.2;22021211RC;android-android;12;JSbridge4.4.0;jointBridge;1.1.0;'\\n                    },\\n                    method: 'GET'\\n                }); //log(bdtvm)\\n                var restvm = JSON.parse(bdtvm).info.dlink; //log(restvm);\\n                let url2 = request(restvm, {\\n                    headers: {\\n                        \\\"User-Agent\\\": \\\"netdisk;1.4.2;22021211RC;android-android;12;JSbridge4.4.0;jointBridge;1.1.0;\\\",\\n                        \\\"Range\\\": \\\"bytes=0-0\\\"\\n                    },\\n                    method: 'GET',\\n                    onlyHeaders: true\\n                }); //log(url2)\\n                let url = JSON.parse(url2).url\\n                let u = startProxyServer($.toString(() => {\\n                    let url = base64Decode(MY_PARAMS.url);\\n                    //log(\\\"我在代理\\\" + url);\\n                    return JSON.stringify({\\n                        statusCode: 302,\\n                        headers: {\\n                            \\\"Location\\\": url\\n                        }\\n                    });\\n                }));\\n                return JSON.stringify({\\n                    urls: [u + \\\"?url=\\\" + base64Encode(url) + \\\"#isVideo=true##fastPlayMode##threads=10#\\\"],\\n                    headers: [{\\n                        \\\"User-Agent\\\": \\\"netdisk;1.4.2;22021211RC;android-android;12;JSbridge4.4.0;jointBridge;1.1.0;\\\"\\n                    }]\\n                });\\n            } else {\\n                var url = buildUrl('https://pan.baidu.com/rest/2.0/xpan/multimedia', {\\n                    'access_token': getItem('access_token'),\\n                    'method': 'filemetas',\\n                    'fsids': `[${id}]`,\\n                    'dlink': '1'\\n                });\\n                var html = request(url, {\\n                    headers: {\\n                        'User-Agent': 'pan.baidu.com'\\n                    }\\n                });\\n                var res = JSON.parse(html).list[0].dlink + '&access_token=' + getItem('access_token');\\n            }\\n        } else {\\n            var url = buildUrl('https://pan.baidu.com/rest/2.0/xpan/multimedia', {\\n                'access_token': getItem('access_token'),\\n                'method': 'filemetas',\\n                'fsids': `[${id}]`,\\n                'dlink': '1'\\n            });\\n            var html = request(url, {\\n                headers: {\\n                    'User-Agent': 'pan.baidu.com'\\n                }\\n            });\\n            var res = JSON.parse(html);\\n        }\\n        if (ext == 'movie') {\\n            return JSON.stringify({\\n                urls: [res + '#isVideo=true#'],\\n                headers: {\\n                    'User-Agent': 'pan.baidu.com'\\n                }\\n            });\\n        } else if (ext == 'mp3') {\\n            function buildResponse(res, lyric) {\\n                const response = {\\n                    urls: [res + '#isMusic=true#'],\\n                    headers: {\\n                        'User-Agent': 'pan.baidu.com'\\n                    }\\n                };\\n                if (lyric) {\\n                    response.lyric = lyric;\\n                }\\n                return JSON.stringify(response);\\n            }\\n            const _listid = path.replace(/\\\\/[^\\\\/]+$/, \\\"/\\\");\\n            const _list = storage0.getVar(_listid);\\n            if (_list && _list.length > 0) {\\n                const filename = path.split('/').at(-1).replace(/\\\\.mp3$/, '.lrc');\\n                let fs_id;\\n                for (var item of _list) {\\n                    if (item.server_filename === filename) {\\n                        fs_id = item.fs_id;\\n                        break;\\n                    }\\n                }\\n                if (fs_id) {\\n                    const urllyric = buildUrl('https://pan.baidu.com/rest/2.0/xpan/multimedia', {\\n                        'access_token': getItem('access_token'),\\n                        'method': 'filemetas',\\n                        'fsids': `[${fs_id}]`,\\n                        'dlink': '1'\\n                    });\\n                    const htmllyric = request(urllyric, {\\n                        headers: {\\n                            'User-Agent': 'pan.baidu.com'\\n                        }\\n                    });\\n                    const reslyric = JSON.parse(htmllyric).list[0].dlink + '&access_token=' + getItem('access_token');\\n                    let txtlyric = fetchPC(reslyric);\\n                    if (/�/.test(txtlyric)) {\\n                        txtlyric = fetchPC(reslyric, {\\n                            headers: {\\n                                'content-type': 'charset=GB2312'\\n                            }\\n                        });\\n                    }\\n                    if (/�/.test(txtlyric)) {\\n                        txtlyric = fetchPC(reslyric, {\\n                            headers: {\\n                                'content-type': 'charset=GBK'\\n                            }\\n                        });\\n                    }\\n                    return buildResponse(res, txtlyric);\\n                }\\n            }\\n            return buildResponse(res);\\n        } else if (ext == 'lrc') {\\n            return res;\\n        } else if (ext == 'audio') {\\n            return JSON.stringify({\\n                urls: [res + '#isMusic=true#'],\\n                headers: {\\n                    'User-Agent': 'pan.baidu.com'\\n                }\\n            });\\n        } else if (ext == 'img') {\\n            //if (typeof(res) != 'undefined') {\\n            //    return 'pics://' + res + `#.jpg;{User-Agent@pan.baidu.com}`\\n            //} else {\\n            return 'pics://' + img.replace(/c\\\\d+_u\\\\d+/, 'c3000_u2000');\\n            //}\\n        } else if (ext == 'txt') {\\n            var lazy = $('#readTheme#').rule(() => {\\n                var d = [];\\n                downloadFile(MY_URL, 'hiker://files/cache/tmp.txt');\\n                var data = fetch('hiker://files/cache/tmp.txt');\\n                d.push({\\n                    title: data.replace(/(　　|    )/g, '<p>　　'),\\n                    col_type: 'rich_text',\\n                    extra: {\\n                        textSize: 18,\\n                        click: true,\\n                    }\\n                });\\n                return setResult(d);\\n            });\\n            return res + lazy;\\n        } else {\\n            return 'download://' + res + `;{User-Agent@pan.baidu.com}`;\\n        }\\n    }, ext, id, path, img);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"list\",\"path\":\"list\",\"rule\":\"js:\\naddListener('onClose', $.toString(() => {\\n    clearVar('urlBaidu')\\n    clearVar('paths');\\n    clearVar('realurl');\\n\\n}));\\nrc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\nvar d = [];\\ntry {\\n    if (getVar('realurl')) {\\n        MY_URL = getVar('realurl');\\n    } else {\\n        MY_URL = MY_URL.split('realurl=')[1].replace(/hiker.*?##/, '');\\n        log('111:'+MY_URL);\\n        eval($.require(\\\"hiker://page/lists\\\").codeShare);\\n        putVar('realurl', MY_URL);\\n    }\\n    $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeList();\\n} catch (e) {\\n    log(e.message)\\n    toast('链接错误或者分享已失效!')\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"百度下载器\",\"path\":\"BaiduMultiThreadedDownloader\",\"rule\":\"//by LoyDgIk 佬\\nconst Files = java.nio.file.Files;\\nconst Paths = java.nio.file.Paths;\\nconst BufferedInputStream = java.io.BufferedInputStream\\nconst BufferedOutputStream = java.io.BufferedOutputStream\\nconst FileOutputStream = java.io.FileOutputStream;\\n//const java.util.ArrayList;\\n//const java.util.List;\\nconst ExecutorService = java.util.concurrent.ExecutorService;\\nconst Executors = java.util.concurrent.Executors;\\nconst TimeUnit = java.util.concurrent.TimeUnit\\nconst Runnable = java.lang.Runnable;\\nconst AtomicBoolean = java.util.concurrent.atomic.AtomicBoolean;\\nconst URL = java.net.URL;\\nconst Long = java.lang.Long;\\n\\nconst OkGo = com.lzy.okgo.OkGo;\\nconst HttpsUtils = com.lzy.okgo.https.HttpsUtils;\\nconst Arrays = java.util.Arrays;\\nconst Comparator = java.util.Comparator;\\nconst BUFFER_SIZE = 4096;\\nconst File = java.io.File;\\nconst Thread = java.lang.Thread;\\nconst RandomAccessFile = java.io.RandomAccessFile;\\nconst OkHttpClient = Packages.okhttp3.OkHttpClient;\\nconst FileInputStream = java.io.FileInputStream;\\n/**\\n * 使用多线程分块下载文件，支持自定义 Headers，并将分块先写入临时文件，再合并。\\n *\\n * @param url         文件下载地址\\n * @param outputPath  文件最终保存路径\\n * @param chunkSize   每个线程下载的分块大小（单位：字节）\\n * @param threadCount 下载使用的线程数\\n * @param retryCount  每个分块下载失败的最大重试次数\\n * @param headers     需要添加到请求中的自定义请求头（可为 null 表示不需要）\\n */\\nfunction downloadFile(\\n    url,\\n    outputPath,\\n    filename,\\n    config\\n) {\\n    let {\\n        chunkSize,\\n        threadCount,\\n        retryCount,\\n        headers\\n    } = config || {};\\n    let head = headers || {};\\n    chunkSize = chunkSize || 2 * 1024 * 1024;\\n    threadCount = threadCount || 4;\\n    retryCount = retryCount || 3;\\n    headers = new java.util.concurrent.ConcurrentHashMap();\\n    for (let k in head) {\\n        headers.put(k, head[k]);\\n    }\\n    let executorService = Executors.newFixedThreadPool(threadCount);\\n    let futures = []\\n    let downloadFailed = new AtomicBoolean(false);\\n    let fileSize;\\n    try {\\n        let fileinfo = getFileInfo(url, head);\\n        fileSize = fileinfo.size;\\n        filename = filename || fileinfo.name || md5(url);\\n        if (!fileSize || Number.isNaN(fileSize)) {\\n            throw Error(\\\"文件大小获取失败\\\");\\n        }\\n    } catch (e) {\\n        log(\\\"获取文件大小失败: \\\" + e.toString());\\n        executorService.shutdownNow();\\n        return;\\n    }\\n    if (fileSize <= 0) {\\n        log(\\\"无法获取文件大小或文件大小为0，下载终止。\\\");\\n        executorService.shutdownNow();\\n        return;\\n    }\\n    outputPath = outputPath + \\\"/\\\" + filename;\\n\\n    let tempDir = new File(outputPath + \\\".tmp\\\");\\n    if (!tempDir.exists()) {\\n        tempDir.mkdir();\\n    }\\n\\n    let chunkCount = Math.ceil(fileSize / chunkSize);\\n    let offset = 0;\\n    for (let i = 0; i < chunkCount; i++) {\\n        // 起始位置\\n        let start = offset;\\n        // 结束位置（最后一个线程可能到 fileSize - 1 ）\\n        let end = (i == chunkCount - 1) ? (fileSize - 1) : (offset + chunkSize - 1);\\n        offset = end + 1;\\n\\n\\n        let tempFile = new File(tempDir, \\\"chunk_\\\" + start + \\\"_\\\" + end + \\\".tmp\\\");\\n\\n\\n        let finalStart = start;\\n        let finalEnd = end;\\n        let finalTempFile = tempFile;\\n\\n        let future = executorService.submit(new Runnable(() => {\\n            let attempts = 0;\\n            let success = false;\\n\\n            while (!downloadFailed.get() && attempts < retryCount && !success) {\\n                try {\\n                    downloadChunk(url, finalStart, finalEnd, finalTempFile, headers);\\n                    success = true;\\n                } catch (e) {\\n                    attempts++;\\n                    log(\\\"线程 \\\" + Thread.currentThread().getName() +\\n                        \\\" 下载分块 [\\\" + finalStart + \\\" - \\\" + finalEnd + \\\"] 失败，重试 \\\" +\\n                        attempts + \\\"/\\\" + retryCount + \\\"，原因：\\\" + e.toString());\\n                    if (attempts >= retryCount) {\\n                        // 标记整个下载过程失败\\n                        downloadFailed.set(true);\\n                        // 抛出异常，终止当前任务\\n                        throw new Error(\\\"线程 \\\" + Thread.currentThread().getName() +\\n                            \\\" 超出最大重试次数，下载失败。Error:\\\" + e.toString());\\n                    }\\n                }\\n            }\\n            return null;\\n        }));\\n        futures.push(future);\\n    }\\n    try {\\n        for (let f of futures) {\\n            f.get(); // 如果有异常，会在这里抛出\\n        }\\n    } catch (e) {\\n        log(\\\"执行下载任务时出现异常: \\\" + e.toString());\\n        downloadFailed.set(true);\\n    } finally {\\n        // 关闭线程池\\n        executorService.shutdownNow();\\n    }\\n\\n    // 合并分块文件\\n    if (!downloadFailed.get()) {\\n        mergeChunks(tempDir, outputPath);\\n        // 删除临时文件夹及其中的文件\\n        deleteTempFiles(tempDir);\\n        log(\\\"文件下载并合并完成，保存路径：\\\" + outputPath);\\n    } else {\\n        // 如果下载失败，清空临时目录\\n        deleteTempFiles(tempDir);\\n        log(\\\"下载失败，临时文件已删除。\\\");\\n    }\\n}\\n\\nfunction getFileInfo(url, headers) {\\n    let head = JSON.parse(fetch(url, {\\n        headers: Object.assign({}, headers),\\n        onlyHeaders: true,\\n        method: \\\"HEAD\\\"\\n    })).headers;\\n    Object.keys(head).forEach(v => {\\n        head[v] = head[v][0];\\n    });\\n    let fileinfo = {\\n        md5: head[\\\"content-md5\\\"],\\n        size: Number(head[\\\"x-bs-file-size\\\"] || head[\\\"content-length\\\"]),\\n        name: /filename=\\\"(.*?)\\\"/.test(head[\\\"content-disposition\\\"]) ? RegExp.$1 : \\\"\\\"\\n    };\\n    return fileinfo;\\n}\\n\\nfunction mergeChunks(tempDir, outputPath) {\\n    let outputFile = new File(outputPath);\\n    let raf = null;\\n    try {\\n        let raf = new RandomAccessFile(outputFile, \\\"rw\\\");\\n\\n        let chunkFiles = tempDir.listFiles(new java.io.FilenameFilter((dir, name) => name.endsWith(\\\".tmp\\\")));\\n        if (chunkFiles == null) {\\n            throw new Error(\\\"无法获取临时文件夹中的分块文件。\\\");\\n        }\\n\\n        Arrays.sort(chunkFiles, Comparator.comparingLong(file => {\\n            let name = file.getName();\\n            let start = Long.parseLong(name.split(\\\"_\\\")[1]);\\n            return start;\\n        }));\\n\\n\\n        for (let chunkFile of chunkFiles) {\\n            let fis, bis;\\n            try {\\n                let fis = new FileInputStream(chunkFile);\\n                let bis = new BufferedInputStream(fis);\\n\\n                let buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, BUFFER_SIZE);\\n                let len;\\n                while ((len = bis.read(buffer)) != -1) {\\n                    raf.write(buffer, 0, len);\\n                }\\n            } finally {\\n                fis && fis.close();\\n                bis && bis.close();\\n            }\\n        }\\n    } catch (e) {\\n        log(\\\"合并分块文件时出错：\\\" + e.toString());\\n    } finally {\\n        raf && raf.close();\\n    }\\n}\\nconst downloadClient = new OkHttpClient.Builder()\\n    .connectTimeout(30, TimeUnit.SECONDS)\\n    .readTimeout(50, TimeUnit.SECONDS)\\n    .writeTimeout(40, TimeUnit.SECONDS)\\n    .sslSocketFactory(HttpsUtils.getSslSocketFactory().sSLSocketFactory, HttpsUtils.UnSafeTrustManager)\\n    .hostnameVerifier(HttpsUtils.UnSafeHostnameVerifier)\\n    .build();\\n\\nfunction downloadChunk(\\n    url,\\n    start,\\n    end,\\n    tempFile,\\n    headers\\n) {\\n\\n    let request = OkGo.get(url);\\n    // 如果有自定义 Headers，则添加\\n    if (headers != null) {\\n        for (let entry of headers.entrySet()) {\\n            request.headers(entry.getKey(), entry.getValue());\\n        }\\n    }\\n    //log(Object.keys(request))\\n    request.headers(\\\"Range\\\", \\\"bytes=\\\" + start + \\\"-\\\" + end);\\n    request.client(downloadClient);\\n    // 执行同步请求，获取响应\\n    let response = request.execute();\\n    if (response == null || ~~(response.code() / 100) != 2) {\\n        log(~~(response.code() / 100))\\n        throw new Error(\\\"服务器返回异常，HTTP code = \\\" +\\n            (response == null ? \\\"null\\\" : response.code()));\\n    }\\n\\n    // 将响应体写入临时文件\\n    let is = null,\\n        bis = null,\\n        fos = null;\\n    try {\\n        is = response.body();\\n        bis = new BufferedInputStream(is.byteStream());\\n        fos = new FileOutputStream(tempFile);\\n\\n        let buffer = java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, BUFFER_SIZE);\\n        let len;\\n        while ((len = bis.read(buffer)) != -1) {\\n            fos.write(buffer, 0, len);\\n        }\\n    } finally {\\n        is && is.close();\\n        bis && bis.close();\\n        fos && fos.close();\\n    }\\n}\\n\\nfunction deleteTempFiles(tempDir) {\\n    if (tempDir.exists() && tempDir.isDirectory()) {\\n        for (let file of tempDir.listFiles() || []) {\\n            file.delete();\\n        }\\n        tempDir.delete();\\n    }\\n}\\nlet isDownload = false;\\n$.exports.downloadFile = function(url,\\n    outputPath,\\n    filename,\\n    config) {\\n    if (isDownload) return false;\\n    isDownload = true;\\n    downloadFile(url,\\n        outputPath,\\n        filename,\\n        config);\\n    isDownload = false;\\n    return true;\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"lists\",\"path\":\"lists\",\"rule\":\"//狗浩大佬提供\\n//分享链接转码播放，接口来自百度网盘网页版pc ua\\n$.exports.codeHistoryView = function(myURL) {\\n    d.push({\\n        title: '观看记录',\\n        url: $().lazyRule((myURL) => {\\n            putMyVar('select', 'view');\\n            return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").selectHistory(myURL);\\n        }, myURL),\\n        col_type: 'scroll_button',\\n        extra: {\\n            longClick: [{\\n                title: '清除观看记录',\\n                js: $.toString(() => {\\n                    clearItem('historyView');\\n                    refreshPage(false);\\n                }),\\n            }]\\n        }\\n    });\\n}\\n$.exports.codeHistorySearch = function(myURL) {\\n    d.push({\\n        title: '搜索记录',\\n        url: $('').lazyRule((myURL) => {\\n            putMyVar('select', 'search');\\n            return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").selectHistory(myURL);\\n        }, myURL),\\n        col_type: 'scroll_button',\\n        extra: {\\n            longClick: [{\\n                title: '清除搜索记录',\\n                js: $.toString(() => {\\n                    clearItem('historySearch');\\n                    refreshPage(false);\\n                }),\\n            }]\\n        }\\n    });\\n}\\n$.exports.selectHistory = function(myURL) {\\n    if (typeof(myURL) == 'undefined') myURL = '';\\n    const hikerPop = $.require(\\\"https://gitee.com/mistywater/hiker_info/raw/master/Popup.js\\\");\\n    let sourceList = getMyVar('select') == 'search' ? storage0.getItem('historySearch', []) : storage0.getItem('historyView', []);\\n    sourceList = sourceList.reverse();\\n    hikerPop.setUseStartActivity(false);\\n    let spen = getMyVar('select') == 'search' ? 3 : 1;\\n    let inputBox;\\n    let pop = hikerPop.selectBottomRes({\\n        options: sourceList,\\n        columns: spen,\\n        title: \\\"当前合计:\\\" + sourceList.length,\\n        noAutoDismiss: true,\\n        //toPosition: index,\\n        extraInputBox: (inputBox = new hikerPop.ResExtraInputBox({\\n            hint: \\\"关键字筛选\\\",\\n            title: \\\"\\\",\\n            onChange(s, manage) {\\n                putMyVar(\\\"sourceListFilter\\\", s);\\n                tmpList = sourceList.filter(x => x.toLowerCase().includes(s.toLowerCase()));\\n                let flist = tmpList;\\n                manage.list.length = 0;\\n                flist.forEach(x => {\\n                    manage.list.push(x);\\n                });\\n                manage.change();\\n            },\\n            defaultValue: getMyVar(\\\"sourceListFilter\\\", \\\"\\\"),\\n            titleVisible: true\\n        })),\\n        longClick(s, i, manage) {},\\n        click(s, i, manage) {\\n            pop.dismiss();\\n            let input = s;\\n            if (tmpList[i] == input) {\\n                if (getMyVar('select') == 'search') {\\n                    putVar('keyword', input);\\n                    return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseSearchUrl(input, myURL);\\n                } else {\\n                    refreshPage(false);\\n                    input = /http/.test(input.split('@@')[0]) ? input.split('@@')[0] : input.split('@@')[1];\\n                    return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                }\\n            } else {\\n                return 'toast://源列表索引异常'\\n            }\\n        },\\n        menuClick(manage) {\\n            let menuarr = [\\\"样式\\\", getItem('selectOrder', 'asc') == \\\"asc\\\" ? \\\"正序\\\" : \\\"倒序\\\", \\\"排序\\\"];\\n            hikerPop.selectCenter({\\n                options: menuarr,\\n                columns: 2,\\n                title: \\\"请选择\\\",\\n                click(s, i) {\\n                    if (i === 0) {\\n                        spen = spen == 1 ? 2 : (spen == 2 ? 3 : 1);\\n                        manage.changeColumns(spen);\\n                        // manage.scrollToPosition(index, false);\\n                    } else if (i === 1) {\\n                        let selectOrder = getItem('selectOrder', 'asc');\\n                        manage.list.reverse();\\n                        selectOrder = selectOrder == 'asc' ? 'desc' : 'asc';\\n                        setItem('selectOrder', selectOrder);\\n                        manage.change();\\n                        //manage.scrollToPosition(index, true);\\n                    } else if (i === 2) {\\n                        let sorttype = [\\\"更新时间\\\", \\\"接口名称\\\", \\\"使用频率\\\"].map(v => v == getItem('sourceListSort', '更新时间') ? v + \\\"√\\\" : v);\\n                        showSelectOptions({\\n                            \\\"title\\\": \\\"选择排序方式\\\",\\n                            \\\"options\\\": sorttype,\\n                            \\\"col\\\": 1,\\n                            \\\"js\\\": `setItem('sourceListSort', input.replace(\\\"√\\\",\\\"\\\"));'toast://排序方式在下次生效：' + input.replace(\\\"√\\\",\\\"\\\")`\\n                        })\\n                    } else if (i === 3) {\\n                        if (hikerPop.canBiometric() !== 0) {\\n                            return \\\"toast://调用生物学验证出错\\\";\\n                        }\\n                        let pop = hikerPop.checkByBiometric(() => {\\n                            putMyVar('已验证指纹', '1');\\n                            toast(\\\"验证成功，重新点切换站源吧\\\");\\n                        });\\n                    }\\n                }\\n            });\\n        }\\n    });\\n    return 'hiker://empty';\\n}\\n$.exports.storeHistoryView = function(input, title) {\\n    let historyView = storage0.getItem('historyView', []);\\n    if (!historyView.includes(title + '@@' + input)) {\\n        historyView.push(title + '@@' + input);\\n    }\\n    storage0.setItem('historyView', historyView);\\n}\\n$.exports.storeHistorySearch = function(input) {\\n    let historySearch = storage0.getItem('historySearch', []);\\n    if (!historySearch.includes(input)) {\\n        historySearch.push(input);\\n    }\\n    storage0.setItem('historySearch', historySearch);\\n}\\n$.exports.codeParseUrl = function(input) {\\n    if (/baidu/.test(input)) {\\n        putVar('urlBaidu', input);\\n        return \\\"hiker://page/list?rule=百度网盘&realurl=\\\" + input;\\n    } else if (/aliyundrive|alipan|quark|uc\\\\./.test(input)) {\\n        const config = {\\n            //依赖: 'https://codeberg.org/src48597962/hk/raw/branch/Ju/SrcParseS.js'\\n            依赖: 'https://raw.gitcode.com/src48597962/hk/raw/Ju/SrcParseS.js'\\n        };\\n        require(config.依赖.match(/http(s)?:\\\\/\\\\/.*\\\\//)[0] + 'SrcParseS.js');\\n        return SrcParseS.聚阅(input);\\n    } else {\\n        return input;\\n    }\\n}\\n$.exports.codeParseSearchUrl = function(input, myURL) {\\n    if (typeof(myURL) == 'undefined') myURL = '';\\n    if (input.startsWith('https://pan.baidu.com')) {\\n        try {\\n            eval($.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeShare);\\n            refreshPage();\\n        } catch (e) {\\n            toast('链接错误或者无法访问!');\\n        }\\n    } else if (input.startsWith('https://www.aliyundrive.com') || input.startsWith('https://pan.quark.cn/') || input.startsWith('https://drive.uc.cn/')) {\\n        try {\\n            const config = {\\n                依赖: 'https://codeberg.org/src48597962/hk/raw/branch/Ju/SrcParseS.js'\\n            };\\n            require(config.依赖.match(/http(s)?:\\\\/\\\\/.*\\\\//)[0] + 'SrcParseS.js');\\n            return SrcParseS.聚阅(input);\\n        } catch (e) {\\n            toast('链接错误或者无法访问!');\\n        }\\n    } else if (input.startsWith('@')) {\\n        var html = fetchPC('https://pan.baidu.com/api/search?clienttype=0&app_id=&web=1&dp-logid=&order=name&desc=0&num=9999&page=1&recursion=1&key=' + input.slice(1).trim());\\n        var listSearch = JSON.parse(html).list;\\n        storage0.putVar('paths', [{\\n            path: '/search',\\n            name: '🏠'\\n        }]);\\n        storage0.putVar('file_list', listSearch);\\n        refreshPage();\\n        return 'hiker://empty';\\n    } else if (myURL.startsWith('hiker://page/search')) {\\n        refreshPage();\\n        return 'hiker://empty';\\n    } else {\\n        return 'hiker://page/search?fypage&rule=百度网盘';\\n\\n    }\\n}\\n$.exports.codeHistoryPan = $.toString(() => {\\n    let history = storage0.getItem('history', []);\\n    history1 = history.filter(x => /@@/.test(x));\\n    history2 = history.filter(x => !/@@/.test(x));\\n    history = getItem('folderOnly', '0') == 0 ? sortArray(history1).concat(history2) : history2;\\n    historyNew = history.map(h => /@@/.test(h) ? h.split('@@')[0].split('/').at(-1).replace(/\\\\?.*/, '') : h);\\n    d.push({\\n        title: '网盘记录',\\n        url: $(historyNew, 1, '选择目录').select((history, historyNew) => {\\n\\n            function generatePathObjects(path) {\\n                const parts = path.split('/').filter(p => p.trim() !== '');\\n                const result = [{\\n                    path: '/',\\n                    name: '🏠'\\n                }];\\n                let currentPath = '';\\n                parts.forEach(part => {\\n                    currentPath += `/${part}`;\\n                    result.push({\\n                        path: currentPath,\\n                        name: part\\n                    });\\n                });\\n                return result;\\n            }\\n            if (!/@@/.test(history[historyNew.indexOf(input)])) {\\n                storage0.putVar('paths', generatePathObjects(input));\\n                back();\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n            } else {\\n                const {\\n                    getIcon,\\n                    getHzm,\\n                    getLink\\n                } = $.require('hiker://page/code?rule=百度网盘');\\n                input = history[historyNew.indexOf(input)];\\n                setPageTitle(input);\\n                return getLink(input.split('@@')[2], input.split('@@')[1], input.split('@@')[0], input.split('@@')[3])\\n            }\\n        }, history, historyNew),\\n        col_type: 'scroll_button',\\n        extra: {\\n            cls: 'playlist 网盘记录',\\n            longClick: [{\\n                title: '清除网盘记录',\\n                js: $.toString(() => {\\n                    clearItem('history');\\n                    refreshPage(false);\\n                }),\\n            }, {\\n                title: getItem('folderOnly', '0') == 0 ? '只显示文件夹' : '显示全部',\\n                js: $.toString(() => {\\n                    setItem('folderOnly', getItem('folderOnly', '0') == 0 ? '1' : '0');\\n                    refreshPage(false);\\n                }),\\n            }]\\n        }\\n    });\\n});\\n\\n$.exports.codeNewPage = function(pathsNew) {\\n    return {\\n        title: '开新页面',\\n        js: $.toString((pathsNew) => {\\n            if (getMyVar('erji') == 1) {\\n                toast('已经是二级页面了!');\\n                return 'hiker://empty';\\n            } else {\\n                storage0.putVar('pathsTmp', storage0.getVar('paths'));\\n                return $('hiker://empty##fypage').rule((pathsNew) => {\\n                    addListener('onClose', $.toString(() => {\\n                        putMyVar('erji', '0');\\n                        clearMyVar('firstListNew');\\n                        clearMyVar('first');\\n                        let pathLast = storage0.getVar('paths').at(-1).path;\\n                        let history = storage0.getItem('history', []);\\n                        if (!history.includes(pathLast)) {\\n                            history = history.filter(x => pathLast.indexOf(x) == -1);\\n                            history.push(pathLast);\\n                        }\\n                        storage0.setItem('history', history);\\n                        storage0.putVar('paths', storage0.getVar('pathsTmp'));\\n\\n                    }));\\n                    putMyVar('erji', '1');\\n                    d = [];\\n                    if (!getMyVar('firstListNew')) {\\n                        storage0.putVar('paths', pathsNew);\\n                        putMyVar('firstListNew', '1');\\n                    }\\n                    rc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\n                    $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeList();\\n                    return setResult(d);\\n                }, pathsNew);\\n            }\\n        }, pathsNew),\\n    };\\n}\\n\\n$.exports.codeShare = $.toString(() => {\\n    if (typeof(input) != 'undefined' && input.startsWith('https://pan.baidu.com/share')) {\\n        input = input.replace('share/init?surl=', 's/1').replace('&pwd', '?pwd');\\n    }\\n    var html11 = request(typeof(input) != 'undefined' ? input : MY_URL, {\\n        headers: {\\n            Cookie: '#noCookie#'\\n        },\\n        method: 'HEAD',\\n        onlyHeaders: true\\n    });\\n    var url11 = JSON.parse(html11).url;\\n    var html21 = request('https://pan.baidu.com/share/verify?surl=' + url11.split('?surl=')[1].split('&pwd=')[0], {\\n        headers: {\\n            Referer: url11\\n        },\\n        body: 'pwd=' + url11.split('&pwd=')[1] + '&vcode=&vcode_str=',\\n        method: 'POST'\\n    });\\n    var randsk = JSON.parse(html21).randsk;\\n    var html31 = request(typeof(input) != 'undefined' ? input : MY_URL, {\\n        headers: {\\n            'Cookie': getItem('BDUSS') + '; ' + getItem('STOKEN') + '; ' + 'BDCLND=' + randsk,\\n            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36'\\n        },\\n        method: 'GET',\\n        redirect: false\\n    });\\n    var html32 = html31.match(/locals\\\\.mset\\\\((.*)\\\\)/)[1];\\n    var html33 = JSON.parse(html32);\\n    var file_list = html33.file_list;\\n    var isdir = file_list[0].isdir;\\n    var uk = html33.share_uk;\\n    var shareid = html33.shareid;\\n    var fs_id = file_list[0].fs_id;\\n    var path = file_list[0].path;\\n    if (!path.startsWith('/sharelink')) {\\n        path = `/sharelink${uk}-${fs_id}${path}`;\\n    }\\n    var jsToken = html31.split(\\\"jsToken%20%3D%20a%7D%3Bfn%28%22\\\")[1].split(\\\"%22%29'))\\\")[0];\\n    putVar('ck', getItem('BDUSS') + '; ' + getItem('STOKEN') + '; ' + 'BDCLND=' + randsk);\\n    putVar('randsk', randsk);\\n    putVar('jsToken', jsToken);\\n    putVar('share_uk', uk);\\n    putVar('share_id', shareid + '');\\n    storage0.putVar('paths', [{\\n        path: path,\\n        name: '🏠'\\n    }]);\\n    storage0.putVar('file_list', file_list);\\n});\\n\\n$.exports.codeList = function() {\\n\\n    paths = storage0.getVar('paths');\\n    if (!paths || paths.length == 0) {\\n        paths = [{\\n            path: '/',\\n            name: '🏠'\\n        }];\\n    }\\n    log(paths);\\n    var path = paths.at(-1).path;\\n    if (/search/.test(path) && !storage0.getVar('file_list')) {\\n        storage0.putVar('file_list', storage0.getVar('file_list_tmp'));\\n    }\\n    path = path.replace(/&/g, '%26').replace(/\\\\+/g, '%2B');\\n    if (MY_PAGE == 1) {\\n\\n        var ctypeTmp = getMyVar(path + 'ctypeIndex', '0');\\n        var ctypeStyle = ['avatar', 'movie_1_vertical_pic', 'movie_1', 'movie_2', 'movie_3', 'pic_1_center', 'pic_1_full', 'pic_1', 'pic_2', 'pic_3', 'pic_1_card', 'pic_2_card', 'pic_1_center', 'card_pic_1', 'card_pic_2', '设置全局样式', '取消全局样式'];\\n        ctypeStyle[ctypeTmp] = '➡️' + ctypeStyle[ctypeTmp];\\n        d.push({\\n            title: ctypeStyle[ctypeTmp].slice(1),\\n            url: $(ctypeStyle, 2, '样式').select((ctypeStyle, path) => {\\n                if (input == '设置全局样式') {\\n                    putMyVar('baiductype', getMyVar(path + 'ctype', 'avatar'));\\n                } else if (input == '取消全局样式') {\\n                    clearMyVar('baiductype');\\n                } else {\\n                    putMyVar(path + 'ctypeIndex', MY_INDEX);\\n                    putMyVar(path + 'ctype', input.replace('➡️', ''));\\n                }\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, ctypeStyle, path),\\n            col_type: 'scroll_button',\\n            extra: {\\n                id: 'ctype'\\n            }\\n        });\\n        d.push({\\n            title: getMyVar('media', '0') == '1' ? '影视' : '全部',\\n            url: $('#noLoading#').lazyRule(() => {\\n                putMyVar('media', String(1 - getMyVar('media', '0')));\\n                refreshPage();\\n                return 'hiker://empty';\\n            }),\\n            col_type: 'scroll_button'\\n        });\\n\\n\\n        var sortTmp = getMyVar(path + '_sort', '0');\\n        var sortStyle = ['默认正序', '默认倒序', '英文正序', '英文倒序', '拼音正序', '拼音倒序', '数字正序', '数字倒序', '时间正序', '时间倒序'];\\n        sortStyle[sortTmp] = '➡️' + sortStyle[sortTmp];\\n        d.push({\\n            title: sortStyle[sortTmp].slice(1),\\n            url: $(sortStyle, 2, '排序').select((sortStyle) => {\\n                var paths = storage0.getVar('paths');\\n                if (!paths || paths.length == 0) {\\n                    paths = [{\\n                        path: '/',\\n                        name: '🏠'\\n                    }];\\n                }\\n                var path = paths.at(-1).path;\\n                putMyVar(path + '_sort', MY_INDEX);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, sortStyle),\\n            col_type: 'scroll_button',\\n            extra: {\\n                id: 'sort'\\n            }\\n        });\\n        d.push({\\n            col_type: 'blank_block'\\n        });\\n        d.push({\\n            title: '🔍',\\n            url: $('#noLoading#fypage').lazyRule(() => {\\n                let input = getVar('keyword');\\n                return \\\"hiker://page/search?fypage&rule=百度网盘\\\" //.codeParseSearchUrl(input);\\n            }),\\n            col_type: 'scroll_button'\\n        });\\n        $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeHistorySearch(MY_URL);\\n        $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeHistoryView(MY_URL);\\n        eval($.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeHistoryPan);\\n\\n        d.push({\\n            title: '盘库吧',\\n            url: $().lazyRule(() => {\\n                let configPath = 'hiker://files/rules/Src/Ju/config.json';\\n                if (fetchPC(configPath)) {\\n                    writeFile(configPath, fetchPC(configPath).replace(/\\\"runMode\\\":\\\".*?\\\"/, '\\\"runMode\\\":\\\"影视\\\"').replace(/影视sourcename\\\":\\\".*?\\\"/, '影视sourcename\\\":\\\"盘库吧🐹\\\"'));\\n                    return 'hiker://home@聚阅√';\\n                } else {\\n                    toast('无聚阅√小程序~~');\\n                    return 'hiker://empty';\\n                }\\n\\n            }),\\n            col_type: 'scroll_button'\\n        });\\n        d.push({\\n            title: '七味网',\\n            url: $().lazyRule(() => {\\n                let configPath = 'hiker://files/rules/Src/Ju/config.json';\\n                if (fetchPC(configPath)) {\\n                    writeFile(configPath, fetchPC(configPath).replace(/\\\"runMode\\\":\\\".*?\\\"/, '\\\"runMode\\\":\\\"影视\\\"').replace(/影视sourcename\\\":\\\".*?\\\"/, '影视sourcename\\\":\\\"七味网⚓🐹\\\"'));\\n                    return 'hiker://home@聚阅√';\\n                } else {\\n                    toast('无聚阅√小程序~~');\\n                    return 'hiker://empty';\\n                }\\n\\n            }),\\n            col_type: 'scroll_button'\\n        });\\n        d.push({\\n            col_type: 'blank_block'\\n        });\\n        paths.forEach((item, i) => {\\n            let pathsNewParam = paths.slice(0, i + 1);\\n            d.push({\\n                title: item.name,\\n                url: $('#noLoading#').lazyRule((paths, i, path) => {\\n                    if (i == 0 && !/share/.test(path) && !/search/.test(paths[0].path)) {\\n                        clearMyVar('paths');\\n                    } else if (i == 0 && (/share/.test(path) || /search/.test(paths[0].path))) {\\n                        storage0.putVar('file_list', storage0.getVar('file_list_tmp'));\\n                        refreshPage();\\n                        return 'hiker://empty'\\n                    }\\n                    storage0.putVar('paths', paths.slice(0, i + 1));\\n                    refreshPage();\\n                    return 'hiker://empty'\\n                    //}\\n                }, paths, i, path),\\n                col_type: 'scroll_button',\\n                extra: {\\n                    longClick: [$.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeNewPage(pathsNewParam)]\\n                }\\n            });\\n        });\\n    }\\n\\n    try {\\n        const {\\n            getIcon,\\n            getHzm,\\n            getLink\\n        } = $.require('hiker://page/code?rule=百度网盘');\\n        if (!storage0.getVar('file_list')) {\\n            if (/share/.test(path)) {\\n                var url_tmp = 'https://pan.baidu.com/share/list?uk=' + getVar('share_uk') + '&shareid=' + getVar('share_id') + '&dir=' + path;\\n            } else {\\n                var url_tmp = buildUrl('https://pan.baidu.com/rest/2.0/xpan/file', {\\n                    'access_token': getItem('access_token'),\\n                    'method': 'list',\\n                    'dir': path,\\n                    'web': 'web',\\n                    'limit': 0,\\n                    'limit': 200\\n                });\\n            }\\n            //log(url_tmp);\\n            if (/share/.test(path)) {\\n                var res = JSON.parse(request('https://pan.baidu.com/share/list?uk=' + getVar('share_uk') + '&shareid=' + getVar('share_id') + '&dir=' + path, {\\n                    headers: {\\n                        'Cookie': 'BDCLND=' + getVar('randsk'),\\n                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36'\\n                    }\\n                }));\\n            } else {\\n                var res = JSON.parse(request(url_tmp, {\\n                    headers: {\\n                        //cookie: getVar('ck'),\\n                        'User-Agent': 'netdisk;11.10.4;Redmi+K30;android-android;9;JSbridge4.4.0;jointBridge;1.1.0;'\\n                    }\\n                }));\\n            }\\n            //log(res);\\n            if (getMyVar('media', '0') == '1') {\\n                var list = res.list.filter(h => h.category == '1' || h.isdir == '1' || h.category == '2');\\n            } else {\\n                var list = res.list;\\n            }\\n            if (/share/.test(path)) {\\n                list = list.filter(x => x.isdir === 1).reverse().concat(list.filter(x => x.isdir === 0).reverse());\\n            }\\n        } else {\\n            var list = storage0.getVar('file_list');\\n            storage0.putVar('file_list_tmp', list);\\n            clearVar('file_list');\\n        }\\n        list = list.slice((MY_PAGE - 1) * 200, MY_PAGE * 200);\\n        //log(list);\\n        /*if (list.length > 0&&sortTmp!=6) {\\n            for(var k in list){\\n                if (list[k].isdir == 1) {\\n                    break;\\n                } else {\\n                    if (k == list.length - 1) {\\n                        sortTmp = '6';\\n                        putMyVar(ss + '_sort', '6');\\n                        refreshPage(false);\\n                    }\\n                }\\n            }\\n        }*/\\n        const getSortedList = (list, key, order, isReverse) => {\\n            return sortArray(list.filter(x => x.isdir == 1), key, order, isReverse)\\n                .concat(sortArray(list.filter(x => x.isdir == 0), key, order, isReverse));\\n        };\\n        const sortMap = {\\n            '0': list => list,\\n            '1': list => list.filter(x => x.isdir === 1).reverse().concat(list.filter(x => x.isdir === 0).reverse()),\\n            '2': list => getSortedList(list, 'server_filename', 1),\\n            '3': list => getSortedList(list, 'server_filename', 1, 1),\\n            '4': list => getSortedList(list, 'server_filename', 2),\\n            '5': list => getSortedList(list, 'server_filename', 2, 1),\\n            '6': list => getSortedList(list, 'server_filename', 3),\\n            '7': list => getSortedList(list, 'server_filename', 3, 1),\\n            '8': list => getSortedList(list, 'server_mtime', 3, 1),\\n            '9': list => getSortedList(list, 'server_mtime', 3)\\n        };\\n        const _list = sortTmp ? sortMap[sortTmp](list) : list;\\n        if (_list.length > 0) {\\n            var _listid = _list.at(-1).path.replace(/\\\\/[^\\\\/]+$/, \\\"/\\\");\\n        }\\n        _list.forEach(item => {\\n            //log(item);\\n            item.path = item.path.replace(/&/g, '%26').replace(/\\\\+/g, '%2B');\\n            var title = item.server_filename;\\n            if (storage0.getVar(_listid) != 'undefined' && storage0.getVar(_listid) != '') {} else if (/\\\\.mp3$/i.test(title)) {\\n                storage0.putVar(_listid, _list);\\n            }\\n            if (typeof(item.thumbs) != 'undefined' && /\\\\.(3gp|avi|f4v|flv|kux|m3u8|m4v|mkv|mov|mp4|mpeg|mpg|pmp|qsv|ram|rm|rmvb|swf|ts|webm|wmv|jpg|jpeg|jpe|jxr|png|tif|tiff|avif|xbm|pjp|svgz|ico|svg|jfif|webp|pjpeg|gif|iff|ilbm|ppm|pcx|xcf|xpm|psd|mng|sai|psp|ufo)$/i.test(item.server_filename)) {\\n                var img = item.thumbs.url2;\\n            } else {\\n                var img = getIcon(item);\\n            }\\n            if (item.isdir == 1) {\\n                var url = $('#noLoading#').lazyRule((item, paths) => {\\n                    if (!/share|search/.test(item.path)) {\\n                        let history = storage0.getItem('history', []);\\n                        if (!history.includes(item.path)) {\\n                            history = history.filter(x => item.path.indexOf(x) == -1);\\n                            history.push(item.path);\\n                        }\\n                        storage0.setItem('history', history);\\n                    }\\n                    paths.push({\\n                        path: item.path,\\n                        name: item.server_filename\\n                    });\\n                    storage0.putVar('paths', paths);\\n                    refreshPage();\\n                    return 'hiker://empty';\\n                }, item, paths);\\n            } else if (/\\\\.(3gp|avi|f4v|flv|kux|m3u8|m4v|mkv|mov|mp4|mpeg|mpg|pmp|qsv|ram|rm|rmvb|swf|ts|webm|wmv)/i.test(title)) {\\n                var url = getLink('movie', item.fs_id, item.path);\\n            } else if (/\\\\.(flac|m4a|mp3|ogg|opus|wav)/i.test(title)) {\\n                if (/\\\\.mp3/i.test(title)) {\\n                    var url = getLink('mp3', item.fs_id, item.path);\\n                } else {\\n                    var url = getLink('audio', item.fs_id, item.path);\\n                }\\n            } else if ((/\\\\.(txt|log|json|lrc)/i.test(title)) || (/\\\\.(bat|reg)/i.test(title) && item.category == 6)) {\\n                var url = getLink('txt', item.fs_id, item.path);\\n            } else if (/\\\\.(jpg|jpeg|jpe|jxr|png|tif|tiff|avif|xbm|pjp|svgz|ico|svg|jfif|webp|pjpeg|gif|iff|ilbm|ppm|pcx|xcf|xpm|psd|mng|sai|psp|ufo)/i.test(title)) {\\n                var url = getLink('img', item.fs_id, item.path, img);\\n            } else {\\n                var url = getLink('', item.fs_id, item.path, img);\\n            }\\n            /*if (url_tmp.split('dir=')[1].match(/\\\\//g).length == 1) {\\n                putMyVar('ctype', 'avatar');\\n            }*/\\n            var ctype = getMyVar('baiductype');\\n            if (!ctype) {\\n                ctype = getMyVar(path + 'ctype', 'avatar');\\n            }\\n            var sj = timestampToDate(parseInt(item.server_mtime) * 1000);\\n            var desc = !item.isdir ? gfs(item.size) : sj;\\n            if (ctype == 'avatar') {\\n                title = colorR(title, 'FF3399');\\n            } else if (ctype == 'movie_1_vertical_pic') {\\n                title = color(title, 'FF3399');\\n            } else {\\n                title = title;\\n            }\\n            var zhuancun = function(uk, shareid, fs_id, randsk) {\\n                var html = request('https://pan.baidu.com/share/transfer', {\\n                    headers: {\\n                        'User-Agent': 'Android',\\n                        'Referer': 'https://pan.baidu.com',\\n                        'Cookie': getItem('BDUSS') + '; ' + 'BDCLND=' + randsk,\\n                    },\\n                    body: 'from=' + uk + '&shareid=' + shareid + '&ondup=newcopy&path=/我的资源/&fsidlist=[' + fs_id + ']',\\n                    method: 'POST'\\n                });\\n                var html1 = JSON.parse(html)\\n                if (html1.errno == '0') {\\n                    toast('已转存')\\n                } else {\\n                    toast(html1.show_msg)\\n                }\\n            }\\n            var shanchu = function(path) {\\n                var html = request('https://pan.baidu.com/api/filemanager?opera=delete&clienttype=1', {\\n                    headers: {\\n                        'User-Agent': 'Android',\\n                        'Cookie': getItem('BDUSS') + '; ' + getItem('STOKEN'),\\n                    },\\n                    body: 'filelist=[\\\"' + path + '\\\"]',\\n                    method: 'POST'\\n                });\\n                var html1 = JSON.parse(html);\\n                if (html1.errno == '0') {\\n                    toast('已删除')\\n                } else {\\n                    toast('删除失败')\\n                }\\n            }\\n            var rename = function(path) {\\n                return $(\\\"\\\", \\\"文件名加文件后缀\\\").input((path) => {\\n                    var taskid = JSON.parse(request('https://pan.baidu.com/api/filemanager?opera=rename&clienttype=1', {\\n                        headers: {\\n                            'User-Agent': 'Android',\\n                            'Cookie': getItem('BDUSS') + '; ' + getItem('STOKEN'),\\n                        },\\n                        body: 'filelist=[{\\\"path\\\":\\\"' + path.replace(/&/g, '%26') + '\\\",\\\"newname\\\":\\\"' + input + '\\\"}]&async=2',\\n                        method: 'POST'\\n                    })).taskid;\\n\\n                    var html = request('https://pan.baidu.com/api/taskquery?taskid=' + taskid + '&clienttype=1', {\\n                        headers: {\\n                            'User-Agent': 'Android',\\n                            'Cookie': getItem('BDUSS') + '; ' + getItem('STOKEN'),\\n                        },\\n                        method: 'POST'\\n                    });\\n                    var html1 = JSON.parse(html)\\n                    if (html1.errno == '0') {\\n                        toast('已重命名')\\n                    } else {\\n                        toast('重命名失败')\\n                    }\\n                    refreshPage();\\n                }, path);\\n            }\\n            var ylxz = function(path, restvi) {\\n                var bdtvi = request('https://d.pcs.baidu.com/rest/2.0/pcs/file?app_id=250528&method=locatedownload&path=' + encodeURIComponent(path) + '&clienttype=17&version=2.2.91.136&use=1', {\\n                    headers: {\\n                        'Cookie': getItem(\\\"BDUSS\\\"),\\n                        'User-Agent': 'netdisk;P2SP;2.2.91.136;netdisk;11.30.2;22021211RC;android-android;12;JSbridge4.4.0;jointBridge;1.1.0;'\\n                    },\\n                    method: 'GET'\\n                }); //log(bdtvi)\\n                var restvi = JSON.parse(bdtvi).urls[0].url; //log(restvi)\\n                var fpath = (path.match(/\\\\//g) || []).length <= 1 ? \\\"软件\\\" : path.match(/\\\\/(.*)\\\\//)[1]\\n                var restvi = (path.match(/\\\\//g) || []).length <= 1 ? restvi.replace('mt_scene', 'fpath=' + fpath + '&mt_scene') : restvi;\\n                //log(restvi)\\n                return $(restvi, \\\"下载地址\\\").input(() => {\\n                    toast(\\\"开始下载文件\\\");\\n                    var BaiduMultiThreadedDownloader = GM.defineModule(\\\"BaiduMultiThreadedDownloader\\\");\\n                    return BaiduMultiThreadedDownloader.downloadFile(input, \\\"/storage/emulated/0/Android/data/com.example.hikerview/files/Documents/download/\\\", null, {\\n                        headers: {\\n                            \\\"User-Agent\\\": \\\"netdisk;P2SP;2.2.91.136;netdisk;11.30.2;22021211RC;android-android;12;JSbridge4.4.0;jointBridge;1.1.0;\\\",\\n                            \\\"Range\\\": \\\"0-1\\\"\\n                        },\\n                        threadCount: 6\\n                    }) ? \\\"toast://下载完成\\\" : \\\"toast://请等待下载结束\\\";\\n                })\\n            }\\n            if (/share/.test(path)) {\\n                var extra = {\\n                    id: url,\\n                    longClick: [{\\n                        title: '转存播放',\\n                        js: $.toString((uk, shareid, fs_id, randsk, title, zhuancun, getLink) => {\\n\\n                            zhuancun(uk, shareid, fs_id, randsk);\\n                            storage0.putVar('paths', [{\\n                                path: '/',\\n                                name: '🏠'\\n                            }, {\\n                                path: '/我的资源/',\\n                                name: '我的资源'\\n                            }]);\\n                            refreshPage();\\n                        }, getVar('share_uk'), getVar('share_id'), item.fs_id, getVar('randsk'), item.server_filename, zhuancun, getLink)\\n                    }, {\\n                        title: '转存',\\n                        js: $.toString((uk, shareid, fs_id, randsk, zhuancun) => {\\n                            zhuancun(uk, shareid, fs_id, randsk);\\n                        }, getVar('share_uk'), getVar('share_id'), item.fs_id, getVar('randsk'), zhuancun)\\n                    }]\\n                }\\n            } else {\\n                var extra = {\\n                    longClick: [{\\n                        title: '删除',\\n                        js: $.toString((item, shanchu) => {\\n                            //log(item.path);\\n                            shanchu(item.path);\\n                            refreshPage(false);\\n                        }, item, shanchu)\\n                    }, {\\n                        title: '重命名',\\n                        js: $.toString((item, rename) => {\\n                            return rename(item.path);\\n                        }, item, rename)\\n                    }, {\\n                        title: '下载',\\n                        js: $.toString((item, ylxz) => {\\n                            return ylxz(item.path);\\n                        }, item, ylxz)\\n                    }]\\n                }\\n            }\\n            extra.longClick.unshift({\\n                title: '样式',\\n                js: $.toString((path) => {\\n                    var ctypeTmp = getMyVar(path + 'ctypeIndex', '0');\\n                    var ctypeStyle = ['avatar', 'movie_1_vertical_pic', 'movie_1', 'movie_2', 'movie_3', 'pic_1_center', 'pic_1_full', 'pic_1', 'pic_2', 'pic_3', 'pic_1_card', 'pic_2_card', 'pic_1_center', 'card_pic_1', 'card_pic_2', '设置全局样式', '取消全局样式'];\\n                    ctypeStyle[ctypeTmp] = '➡️' + ctypeStyle[ctypeTmp];\\n                    showSelectOptions({\\n                        title: \\\"选择样式\\\",\\n                        col: 2,\\n                        options: ctypeStyle,\\n                        js: $.toString((path) => {\\n                            if (input == '设置全局样式') {\\n                                putMyVar('baiductype', getMyVar(path + 'ctype', 'avatar'));\\n                            } else if (input == '取消全局样式') {\\n                                clearMyVar('baiductype');\\n                            } else {\\n                                putMyVar(path + 'ctypeIndex', MY_INDEX);\\n                                putMyVar(path + 'ctype', input.replace('➡️', ''));\\n                            }\\n                            refreshPage(false);\\n                            return 'hiker://empty';\\n                        }, path)\\n                    });\\n                    return \\\"hiker://empty\\\";\\n                }, path),\\n            });\\n            let styleAction = {\\n                title: (getMyVar('baiductype') ? '❌ 取消全局样式' : '✔️ 设置全局样式'),\\n                js: $.toString((path) => {\\n                    if (getMyVar('baiductype')) {\\n                        clearMyVar('baiductype');\\n                    } else {\\n                        putMyVar('baiductype', getMyVar(path + 'ctype', 'avatar'));\\n                    }\\n                    refreshPage(false);\\n                    return \\\"hiker://empty\\\";\\n                }, path),\\n            };\\n            extra.longClick.splice(1, 0, styleAction);\\n            if (item.isdir == 1) {\\n                let pathsItemNewTmp = paths.slice();\\n                pathsItemNewTmp.push({\\n                    path: item.path,\\n                    name: item.path.split('/').at(-1)\\n                });\\n                let pathsNewParam = pathsItemNewTmp;\\n                extra.longClick.push($.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeNewPage(pathsNewParam));\\n            }\\n            if (/pic/.test(ctype)) {\\n                img = img.replace(/c\\\\d+_u\\\\d+/, 'c3000_u2000');\\n            }\\n            d.push({\\n                title: title,\\n                desc: desc,\\n                img: img,\\n                url: url,\\n                col_type: ctype,\\n                extra: extra\\n            });\\n        });\\n    } catch (e) {\\n        log(e.message)\\n        toast('出现错误，请查看日志')\\n    }\\n    //}\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"search\",\"path\":\"search\",\"rule\":\"js:\\nrc(fetchPC('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\nvar d = [];\\nlet host = 'baiduyunpan';\\nconst path = \\\"hiker://files/rules/LoyDgIk/aliSimpleRules.json\\\";\\nlet jsonSearch = JSON.parse(readFile(path) || \\\"[]\\\");\\nlet localSearch = {\\n    title: '盘库吧&混合盘&七味网&DYD',\\n    id: 'https://panku8.com/&https://hunhepan.com&https://www.qnmp4.com&http://www.dydhhy.com'\\n};\\n\\nfunction yanzheng(str, url, t, s) {\\n    if (!t) t = host;\\n    if (!s) {\\n        s = '少女';\\n    }\\n    return $.toString((str, url, t, s) => {\\n        d.push({\\n            title: '‘‘’’<strong><font color= \\\"#FF0000\\\">' + '点击搜索',\\n            url: $('hiker://empty').rule((str, url, t, s) => {\\n                var d = [];\\n\\n                d.push({\\n                    col_type: 'x5_webview_single',\\n                    url: url,\\n                    desc: 'list&&screen',\\n                    extra: {\\n                        ua: MOBILE_UA,\\n                        showProgress: false,\\n                        js: $.toString((str, url, t, s) => {\\n                            setTimeout(function() {\\n                                var inputElement = document.getElementById('search-word');\\n                                if (inputElement) {\\n                                    inputElement.value = s;\\n                                    var searchButton = document.getElementById('search-btn'); // 通过选择器获取搜索按钮\\n                                    searchButton.click();\\n                                }\\n                            }, 1000);\\n\\n                            function check() {\\n\\n                                let nodes = document.querySelectorAll(str);\\n                                if (nodes && nodes.length > 0) {\\n                                    var currentUrl = window.location.href;\\n                                    fba.putVar(t + s, currentUrl);\\n                                    fba.parseLazyRule($$$().lazyRule(() => {\\n                                        back();\\n                                        back();\\n                                    }));\\n                                } else {\\n                                    setTimeout(check, 500);\\n                                }\\n                            }\\n                            check();\\n                        }, str, url, t, s),\\n                    }\\n                });\\n                return setResult(d);\\n            }, str, url, t, s),\\n            col_type: 'text_center_1'\\n        });\\n    }, str, url, t, s);\\n}\\n\\nfunction getHtmlContent(urlS, u) {\\n    let html = getMyVar(urlS);\\n    if (!html) {\\n        html = fetchPC(urlS);\\n        putMyVar(urlS, html);\\n    }\\n    return html;\\n}\\nif (MY_PAGE == 1) {\\n    d.push({\\n        title: '🔍',\\n        url: $.toString((r, myURL) => {\\n            if (!input) {\\n                clearVar('paths');\\n            } else {\\n                putVar('keyword', input);\\n                $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistorySearch(input);\\n                log(myURL);\\n                return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseSearchUrl(input, myURL);\\n            }\\n        }, MY_RULE.title, MY_URL),\\n        desc: '关键词|@关键词|分享链接|空白:清除',\\n        col_type: 'input',\\n        extra: {\\n            defaultValue: getVar('keyword', '少女'),\\n        }\\n    });\\n\\n    let dataClass = [{\\n        title: localSearch.title + jsonSearch.map(h => '&' + h.name).join(''),\\n        id: localSearch.id + jsonSearch.map(h => '&' + h.basicUrl).join(''),\\n    }, {\\n        title: '综合全部&百度云盘&夸克云盘&阿里云盘&UC网盘&迅雷网盘&115网盘&天翼网盘',\\n        id: '&baidu&quark&ali&uc&xunlei&115pan&tianyi'\\n    }, {\\n        title: '综合&文件夹&文档&视频&图片&压缩包&音频&其它',\\n        id: '&folder&doc&video&image&package&music&other'\\n    }];\\n    dataClass.forEach((item, index) => {\\n        classTop(index, item, host, d, 1, 0, 'c', '', '', 0, 2);\\n    });\\n\\n    d.push({\\n        col_type: 'blank_block'\\n    });\\n    d.push({\\n        title: '🔍',\\n        url: $('#noLoading#').lazyRule((myURL) => {\\n            let input = getVar('keyword', '少女');\\n            return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseSearchUrl(input, myURL);\\n        }, MY_URL),\\n        col_type: 'scroll_button'\\n    });\\n\\n    $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeHistorySearch(MY_URL);\\n    $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeHistoryView(MY_URL);\\n    eval($.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeHistoryPan);\\n    d.push({\\n        col_type: 'blank_block'\\n    });\\n}\\nlet index = getMyVar(host + 'cindex0', '0');\\nlet c0 = getMyVar(host + 'c0', 'https://panku8.com');\\nvar basicUrl = c0;\\nlet c1 = getMyVar(host + 'c1', '');\\nlet c2 = getMyVar(host + 'c2', '');\\nlet urlS;\\nvar s = getVar('keyword', '少女').trim();\\nlet keyword = s;\\nvar page = MY_PAGE;\\nlet html;\\nswitch (c0) {\\n    case 'https://www.qnmp4.com':\\n        {\\n\\n            urlS = `https://www.qnmp4.com/vs/${keyword}----------${MY_PAGE}---.html`;\\n            html = request(urlS, {\\n                headers: {\\n                    'Cookie': getVar(c0 + 'ck', ''),\\n                }\\n            });\\n            if (/输入验证码|系统安全验证/.test(html)) {\\n                MY_URL = urlS;\\n                yanzhengd(d, '.breadcrumbs', urlS, c0);\\n            } else {\\n                list = pdfa(html, '.sr_lists&&li');\\n                list.forEach((list) => {\\n                    d.push({\\n                        title: pdfh(list, 'h3&&Text'),\\n                        desc: pdfh(list, 'p&&Text'),\\n                        content: pdfh(list, \\\".p0&&Text\\\"),\\n                        img: pdfh(list, 'img&&data-original||src') + '@Referer=',\\n                        url: $('hiker://empty##https://www.qnmp4.com' + pdfh(list, 'a&&href')).rule((c0) => {\\n                            rc(fc('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\n                            MY_URL = MY_URL.split('##')[1];\\n                            let d = [];\\n                            let html = request(MY_URL, {\\n                                headers: {\\n                                    'Cookie': getVar(c0 + 'ck', ''),\\n                                }\\n                            });\\n                            ['https://www.alipan', 'https://pan.baidu', 'https://drive.uc', 'magnet:?xt='].forEach((it, index) => {\\n                                if (index <= 2) {\\n                                    var listExtendItems = pdfa(html, `body&&.gdt.content:has(a[href^='${it}'])&&li`);\\n                                } else {\\n                                    var listExtendItems = pdfa(html, `body&&.gdt.content:has(a[href^='${it}'])`).map(h => pdfa(h, 'body&&li'));\\n                                    listExtendItems = listExtendItems.flat(Infinity);\\n                                }\\n                                if (listExtendItems.length > 0) {\\n                                    let titleExtendItems = index == 0 ? '阿里网盘' : (index == 1 ? '百度网盘' : (index == 2 ? 'UC网盘' : ('磁力')))\\n                                    d.push({\\n                                        title: strongR(titleExtendItems, '07a7e1'),\\n                                        img: 'hiker://images/icon_down5',\\n                                        url: 'hiker://empty',\\n                                        col_type: 'text_icon',\\n                                    });\\n                                }\\n                                listExtendItems.forEach((item) => {\\n                                    d.push({\\n                                        title: pdfh(item, 'body&&Text'),\\n                                        url: $(pdfh(item, 'a&&href')).lazyRule(() => {\\n                                            if (/baidu/.test(input)) {\\n                                                putVar('urlBaidu', input);\\n                                                return \\\"hiker://page/list?rule=百度网盘&realurl=\\\" + input;\\n                                            } else if (/aliyundrive|alipan|quark|uc\\\\./.test(input)) {\\n                                                const config = {\\n                                                    依赖: 'https://codeberg.org/src48597962/hk/raw/branch/Ju/SrcParseS.js'\\n                                                };\\n                                                require(config.依赖.match(/http(s)?:\\\\/\\\\/.*\\\\//)[0] + 'SrcParseS.js');\\n                                                return SrcParseS.聚阅(input);\\n                                            } else {\\n                                                return input;\\n                                            }\\n                                        }),\\n                                        col_type: 'text_1',\\n                                    });\\n                                });\\n                            });\\n                            if (d.length <= 2) {\\n                                d.push({\\n                                    title: strongR(pdfh(html, '.py-tabs&&option&&Text'), '07a7e1'),\\n                                    img: 'hiker://images/icon_down5',\\n                                    url: 'hiker://empty',\\n                                    col_type: 'text_icon',\\n                                });\\n                                let list = pdfa(html, 'body&&.player-all-ul&&li&&a');\\n                                list.forEach((list) => {\\n                                    d.push({\\n                                        title: pdfh(list, 'body&&Text'),\\n                                        url: $(pd(list, 'a&&href')).lazyRule(() => {\\n                                            let html = fetchPC(input);\\n                                            if (/r player_/.test(html)) {\\n                                                let json = JSON.parse(html.match(/r player_.*?=(.*?)</)[1]);\\n                                                let url_t = json.url;\\n                                                if (json.encrypt == '1') {\\n                                                    url_t = unescape(url_t);\\n                                                } else if (json.encrypt == '2') {\\n                                                    url_t = unescape(base64Decode(url_t));\\n                                                }\\n                                                input = 'video://' + url_t;\\n                                            } else {\\n                                                input = 'video://' + input;\\n                                            }\\n                                            return input;\\n\\n                                        }),\\n                                        col_type: 'flex_button',\\n                                    });\\n\\n                                });\\n                            }\\n                            setResult(d);\\n                        }, c0),\\n                    });\\n                });\\n            }\\n            break;\\n        }\\n\\n    case 'https://www.melost.cn':\\n        {\\n            c1 = /ali/.test(c1) ? 'ALY' : (/baidu/.test(c1) ? 'BDY' : (/quark/.test(c1) ? 'QUARK' : (/uc/.test(c1) ? 'UC' : '')));\\n            urlS = 'https://www.melost.cn/search?q=' + keyword + '&type=' + c1 + '&format=' + c2 + '&page=' + page;\\n            log(urlS);html = getHtmlContent(urlS);\\n            try {\\n                let list = pdfa(html, 'body&&.rm-search-content>div');\\n                list.forEach((list) => {\\n                    let url = pd(list, 'a&&href', c0);\\n                    let title = pdfh(list, 'a&&title');\\n                    d.push({\\n                        title: title.replace(new RegExp(getVar('keyword'), 'gi'), m => colorR(m, 'FF0000')),\\n                        desc: pdfh(list, '.semi-icon + span&&Text'),\\n                        url: $(url + '#noHistory#').lazyRule((title) => {\\n                            var html = fetchPC(input);\\n                            input = pdfh(html, '.copy-url&&a,-1&&href');\\n                            $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(input, title);\\n                            return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                        }, title),\\n                        col_type: 'avatar',\\n                    });\\n                });\\n            } catch (e) {}\\n            break;\\n        }\\n    case 'https://panku8.com':\\n        {\\n            c1 = /ali/.test(c1) ? '/3' : (/baidu/.test(c1) ? '/1' : (/quark/.test(c1) ? '/2' : (/uc/.test(c1) ? '/7' : '/0')));\\n            urlS = 'https://panku8.com/s/' + keyword + c1 + '/' + page;\\n            log(urlS);html = getHtmlContent(urlS);\\n            try {\\n                let list = pdfa(html, 'body&&.mt-2>a');\\n                list.forEach((list) => {\\n                    let url = pd(list, 'a&&href', c0);\\n                    let title = pdfh(list, '.fs-5&&Text');\\n                    d.push({\\n                        title: title.replace(new RegExp(getVar('keyword'), 'gi'), m => colorR(m, 'FF0000')),\\n                        desc: pdfh(list, '.text-success&&Text') + ' ' + pdfh(list, '.align-items-center,-1&&Text').split(' ')[0],\\n                        url: $(url + '#noHistory#').lazyRule((title) => {\\n                            var html = fetchPC(input);\\n                            input = pdfh(html, '.copy-url&&a,-1&&href');\\n                            $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(input, title);\\n                            return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                        }, title),\\n                        col_type: 'avatar',\\n                    });\\n                });\\n            } catch (e) {}\\n            break;\\n        }\\n    case 'https://miaosou.fun':\\n        {\\n            let key = \\\"4OToScUFOaeVTrHE\\\";\\n            let iv = \\\"9CLGao1vHKqm17Oz\\\";\\n            urlS = 'https://miaosou.fun/api/secendsearch?name=' + keyword + '&pageNo=' + MY_PAGE + '&type=' + c2 + '&from=' + c1;\\n            log(urlS);\\n            html = getHtmlContent(urlS);\\n            try {\\n                let json = JSON.parse(html);\\n                let list = json.data.list;\\n                list.forEach((list) => {\\n                    let url = de(key, iv, list.url, 'AES/CBC/PKCS7Padding');\\n                    let title = list.name.replace(/<.*?>/g, '');\\n                    d.push({\\n                        title: title.replace(new RegExp(getVar('keyword'), 'gi'), m => colorR(m, 'FF0000')),\\n                        desc: list.from.replace(/ali.*/, '阿里云盘').replace(/baidu.*/, '百度网盘').replace(/quark.*/, '夸克网盘').replace(/uc.*/, 'UC网盘'),\\n                        url: $(url + '#noHistory#').lazyRule((title) => {\\n                            $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(input, title);\\n                            return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                        }, title),\\n                        col_type: 'avatar',\\n                    });\\n                });\\n            } catch (e) {}\\n            break;\\n        }\\n    case 'https://www.codelicence.cn':\\n        {\\n            urlS = c0 + '/' + s + '?page=' + page;\\n            log(urlS);\\n            if (getMyVar(host + urlS) && /data_size/.test(getMyVar(host + urlS))) {\\n                html = getMyVar(host + urlS);\\n            } else {\\n                if (page == 1) {\\n                    eval(yanzheng('.r', c0, c0, s));\\n                }\\n                let redirectUrl = getVar(c0 + s);\\n                if (redirectUrl) {\\n                    let searchUrl = redirectUrl + \\\"?p=\\\" + page;\\n                    html = request(searchUrl);\\n                    putMyVar(host + urlS, html);\\n                }\\n            }\\n            let arr = pdfa(html, \\\"body&&.list&&ul\\\");\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let utitle = pdfh(it, \\\"a&&Text\\\");\\n                let userial = pdfh(it, \\\"li&&data_size\\\");\\n                let u = pd(it, \\\"a&&href\\\", c0);\\n                d.push({\\n                    title: utitle,\\n                    url: $(u).lazyRule((c0, title) => {\\n                        let urlred = c0 + pdfh(request(input), \\\".down&&a&&href\\\");\\n                        let html = request(urlred, {\\n                            redirect: false,\\n                            withHeaders: true\\n                        });\\n                        let url = JSON.parse(html).headers.location[0];\\n                        $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(url, title);\\n                        return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(url);\\n                    }, c0, utitle),\\n                    desc: userial,\\n                    col_type: 'text_1',\\n                });\\n            }\\n            break;\\n        }\\n    case 'https://hunhepan.com':\\n        {\\n            let t = c1 == '' ? '' : (c1 == 'baidu' ? 'BDY' : (c1 == 'quark' ? 'QUARK' : (c1 == 'ali' ? 'ALY' : (c1 == 'uc' ? 'UC' : ''))));\\n            urlS = `https://hunhepan.com/search?from=web&q=${keyword}&page=${page}&size=50&type=${t}`;\\n            log(urlS);\\n            html = getMyVar(urlS);\\n            if (!html) {\\n                html = post('https://hunhepan.com/v1/search?from=web', {\\n                    headers: {\\n                        Referer: \\\"https://hunhepan.com/\\\"\\n                    },\\n                    body: `{\\\"q\\\":\\\"${keyword}\\\",\\\"exact\\\":false,\\\"page\\\":${MY_PAGE},\\\"size\\\":15,\\\"type\\\":\\\"${t}\\\",\\\"time\\\":\\\"\\\",\\\"from\\\":\\\"web\\\",\\\"user_id\\\":0,\\\"filter\\\":true}`,\\n                });\\n                putMyVar(urlS, html);\\n            }\\n            log(html);\\n            try {\\n                let json = JSON.parse(html);\\n                let list = json.data.list.filter(x => !/【年货节】/.test(x.disk_name));\\n                list.forEach(list => {\\n                    d.push({\\n                        title: list.disk_name.replace(/<em>(.*?)<\\\\/em>/g, m => colorR(m.replace(/<\\\\/?em>/g, ''), 'FF0000')),\\n                        desc: /ali/.test(list.link) ? '阿里云盘' : (/baidu.*/.test(list.link) ? '百度网盘' : (/quark.*/.test(list.link) ? '夸克网盘' : (/uc/.test(list.link) ? 'UC网盘' : ''))),\\n                        url: $(list.link + '#noHistory#').lazyRule((title) => {\\n                            $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(input, title);\\n                            return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                        }, list.disk_name.replace(/<\\\\/?em>/g, '')),\\n                        col_type: 'avatar',\\n                    });\\n                });\\n            } catch (e) {}\\n            break;\\n        }\\n    case 'http://www.dydhhy.com':\\n        {\\n            urlS = `http://www.dydhhy.com/page/${page}/?s=${s}`;\\n            log(urlS);\\n            html = getHtmlContent(urlS);\\n            let list = pdfa(html, '.content-list&&.post');\\n            list.forEach((list) => {\\n                d.push({\\n                    title: pdfh(list, \\\".entry-title&&Text\\\").replace(\\\"阿里云盘 - \\\", \\\"\\\"),\\n                    desc: pdfh(list, \\\".entry-summary&&Text\\\"),\\n                    img: pdfh(list, \\\"img&&data-src||src\\\"),\\n                    url: $('hiker://empty##' + pdfh(list, \\\"a&&href\\\") + '#noHistory#').rule((c0) => {\\n                        rc(fc('https://gitee.com/mistywater/hiker_info/raw/master/githubproxy.json') + 'https://raw.githubusercontent.com/mistywater/hiker/main/f', 24);\\n                        MY_URL = MY_URL.split('##')[1];\\n                        let d = [];\\n                        let html = request(MY_URL);\\n                        let titlePage = pdfh(html, 'h1.entry-title&&Text');\\n                        if (pdfa(html, 'body&&fieldset').length > 0) {\\n                            pdfa(html, 'body&&fieldset').forEach((it, index) => {\\n                                d.push({\\n                                    title: strongR((index == 0 ? '网盘下载' : '磁力下载'), '07a7e1'),\\n                                    img: 'hiker://images/icon_down5',\\n                                    url: 'hiker://empty',\\n                                    col_type: 'text_icon',\\n                                });\\n\\n                                pdfa(it, 'body&&fieldset>*').slice(1).forEach((item) => {\\n                                    if (pdfa(item, 'body&&li').length > 0) {\\n                                        pdfa(item, 'body&&li').forEach((li) => {\\n                                            d.push({\\n                                                title: small(pdfh(li, 'body&&Text'), 555555),\\n                                                url: $(pdfh(li, 'a&&href')).lazyRule((title) => {\\n                                                    $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(input, title);\\n                                                    return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                                                }, titlePage),\\n                                                col_type: 'text_1',\\n                                            });\\n                                        });\\n                                    } else {\\n                                        let url;\\n                                        if (pdfh(item, 'a&&href')) {\\n                                            url = $(pdfh(item, 'a&&href')).lazyRule((title) => {\\n                                                $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(input, title);\\n                                                return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                                            }, titlePage);\\n                                        } else {\\n                                            url = 'hiker://empty';\\n                                        }\\n                                        d.push({\\n                                            title: pdfh(item, 'a&&href') ? small(pdfh(item, 'body&&Text'), 555555) : small(pdfh(item, 'body&&Text'), '07a7e1'),\\n                                            url: url,\\n                                            col_type: 'text_1',\\n                                        });\\n                                    }\\n\\n                                });\\n                            });\\n                        } else {\\n                            pdfa(html, 'body&&.entry-content>*').filter(x => !/style|div/.test(x)).forEach(item => {\\n                                let url;\\n                                if (pdfh(item, 'a&&href')) {\\n                                    url = pdfh(item, 'a&&href');\\n                                    let pwd = /pan\\\\.baidu/.test(item) && !/pwd/.test(url) && /密码/.test(item) ? pdfh(item, 'body&&Text').match(/密码.*?([a-z0-9]{4})/)[1] : '';\\n                                    url = pwd ? url + '?pwd=' + pwd : url;\\n                                    url = $(url).lazyRule((title) => {\\n                                        $.require(\\\"hiker://page/lists?rule=百度网盘\\\").storeHistoryView(input, title);\\n                                        return $.require(\\\"hiker://page/lists?rule=百度网盘\\\").codeParseUrl(input);\\n                                    }, titlePage);\\n                                } else {\\n                                    url = 'hiker://empty';\\n                                }\\n                                d.push({\\n                                    title: pdfh(item, 'a&&href') ? small(pdfh(item, 'body&&Text'), 555555) : small(pdfh(item, 'body&&Text'), '07a7e1'),\\n                                    url: url,\\n                                    col_type: 'text_1',\\n                                });\\n                            });\\n                        }\\n                        d.push({\\n                            col_type: 'big_big_blank_block',\\n                        });\\n                        d.push({\\n                            col_type: 'big_big_blank_block',\\n                        });\\n                        setResult(d);\\n                    }, c0),\\n                });\\n            });\\n            break;\\n        }\\n    default:\\n        {\\n            //try {\\n            function convertToTemplateString(code) {\\n                let templateString = code\\n                    .replace(/\\\\\\\\\\\"/g, '\\\"')\\n                    .replace(/\\\\\\\\\\\\./g, '\\\\.')\\n                    .replace(/\\\\\\\\\\\\\\\\\\\\//g, '\\\\\\\\/')\\n                    .replace(/\\\\\\\\n/g, '\\\\n')\\n                    .replace(/^\\\"|\\\"$/g, '');\\n                return templateString;\\n            }\\n\\n            function parseFind(jsondata) {\\n                jsondata = `\\n                var basicUrl = ${JSON.stringify(basicUrl)};\\n                let s = ${JSON.stringify(s)};\\n                let page = ${JSON.stringify(page)};\\n                ${jsondata}\\n            `;\\n                //log(jsondata);\\n                let evalFunction = new Function(`\\n                return (function() {\\n                    ${jsondata}\\n                })();\\n            `);\\n                return evalFunction();;\\n            }\\n\\n            function dealRuleForHtml(html, rule, basicUrl) {\\n                if (!rule) return;\\n                rule = rule.split(\\\"@js=\\\");\\n                let rule0 = rule.at(0);\\n                let t = \\\"\\\";\\n                if (rule0) {\\n                    t = pdfh(html, rule0);\\n                } else {\\n                    t = html\\n                }\\n                if (rule.length > 1) {\\n                    return new Function(\\\"input\\\", \\\"$$\\\", \\\"basicUrl\\\", '\\\"use strict\\\";return ' + rule.at(1))(t, html, basicUrl);\\n                }\\n                return t;\\n            }\\n\\n            function parseSearchHtml(url, rule) {\\n                let html = fetch(url);\\n                let rules = rule.split(\\\"\\\\n\\\");\\n                let list = pdfa(html, rules.at(0));\\n                if (!list || !Array.isArray(list)) {\\n                    throw new Error(\\\"HTML:列表解析为空\\\");\\n                }\\n                let data = [];\\n                for (let it of list) {\\n                    let curl = dealRuleForHtml(it, rules.at(2), url);\\n                    data.push({\\n                        title: dealRuleForHtml(it, rules.at(1), url),\\n                        url: curl.startsWith(\\\"http\\\") ? curl : (getHome(url) + curl),\\n                        desc: dealRuleForHtml(it, rules.at(3), url),\\n                        pic_url: dealRuleForHtml(it, rules.at(4), url),\\n                    });\\n                }\\n                return data;\\n            }\\n            //try {\\n\\n            var jsondata = jsonSearch[index - localSearch.title.split('&').length];\\n            basicUrl = jsondata.basicUrl;\\n            let dataFindAliUrl;\\n            let dataFind = [];\\n            let url = basicUrl.replace('**', s).replace('fypage', page);\\n            try {\\n                if (jsondata.ruleType == 'HTML') {\\n                    dataFind = parseSearchHtml(url, jsondata.find);\\n                } else {\\n                    dataFind = parseFind(jsondata.find);\\n                }\\n                dataFind = dataFind.filter(x => /http|magnet/.test(x.url));\\n                dataFind.forEach(it => {\\n                    let txtLazyRule = \\\"@lazyRule=.js:(\\\\n() => {\\\\nlet title=input.split('@@')[1];input=input.split('@@')[0];\\\";\\n                    let txtHistoryView = \\\";let historyView = storage0.getItem('historyView', []);\\\\nif (!historyView.includes(title+'@@'+input)) {\\\\nhistoryView.push(title+'@@'+input);\\\\n}\\\\nstorage0.setItem('historyView', historyView);\\\";\\n                    let txtParseUrl = 'if (/baidu/.test(input)) {\\\\nputVar(\\\\\\\"urlBaidu\\\\\\\", input);\\\\nreturn \\\\\\\"hiker://page/list?rule=\\\\\\\\u767e\\\\\\\\u5ea6\\\\\\\\u7f51\\\\\\\\u76d8&realurl=\\\\\\\" + input;\\\\n} else {\\\\n if (/aliyundrive|alipan|quark|uc\\\\\\\\./.test(input)) {\\\\nconst config = {依赖: \\\\\\\"https://codeberg.org/src48597962/hk/raw/branch/Ju/SrcParseS.js\\\\\\\"};\\\\nrequire(config.依赖.match(/http(s)?:\\\\\\\\/\\\\\\\\/.*\\\\\\\\//)[0] + \\\\\\\"SrcParseS.js\\\\\\\");\\\\nreturn SrcParseS.聚阅(input);\\\\n} else {\\\\nreturn input;\\\\n}\\\\n}\\\\n}\\\\n)()';\\n                    let txtInputDeal = ';if(typeof(input)==\\\"object\\\"){input=input[0];}';\\n                    if (!it.img && !it.pic_url) {\\n                        it.col_type = 'text_1';\\n                    }\\n                    it.url = it.url + '@@' + it.title;\\n                    it.url = it.url + txtLazyRule;\\n                    if (!jsondata.findAliUrl) {\\n\\n                    } else if (jsondata.ruleType != 'HTML') {\\n                        it.url = it.url + jsondata.findAliUrl.replace(/return/, 'input=') + txtInputDeal;\\n                    } else if (jsondata.findAliUrl.startsWith(\\\"@js=\\\")) {\\n                        it.url = it.url + 'input=' + jsondata.findAliUrl.replace(/@js=/, '') + txtInputDeal;\\n                    } else {\\n                        if (/\\\\.js/.test(jsondata.findAliUrl)) {\\n                            var js = jsondata.findAliUrl.split('.js:')[1];\\n                        } else {\\n                            js = 'input';\\n                        }\\n                        it.url = it.url + 'input=pdfh(fetch(input),\\\"' + jsondata.findAliUrl.split('.js')[0] + '\\\");' + 'input=' + js + txtInputDeal;\\n                    }\\n                    it.url = it.url + txtHistoryView + txtParseUrl;\\n                });\\n                //log(dataFind);\\n                if (dataFind.length != 0) {\\n                    d = d.concat(dataFind);\\n                } else {\\n                    d.push({\\n                        title: '~~~没有了~~~',\\n                        url: 'hiker://empty',\\n                        col_type: 'text_center_1'\\n                    });\\n                }\\n            } catch (e) {\\n                d.push({\\n                    title: '~~~没有了~~~',\\n                    url: 'hiker://empty',\\n                    col_type: 'text_center_1'\\n                });\\n            }\\n        }\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"说明\",\"path\":\"说明\",\"rule\":\"js:\\nlet time = getItem(\\\"first\\\", \\\"\\\") ? 6 : 20;\\nlet id = Date.now();\\nlet content = `\\n    1. 本小程序所有代码全部开源，且本规则为学习目的，请于导入24小时内删除！！！\\n    2. 本小程序<b>完全免费</b>，如果你是付费购买的恭喜你被骗了。\\n    3. 本小程序的核心代码是在joe版「百度网盘」的基础上整合了zhao大佬的版本，感谢两位大佬。\\n    4. 搜索源调用了「云盘君.简」的搜索规则，感谢@LoyDgIk大佬。\\n    \\n    <b>开始使用本规则即代表遵守规则条例</b>\\n    当前版本：${MY_RULE.version}\\n        `;\\nlet updateInfo = '修复混合盘/七味网搜索';\\n\\nd.push({\\n    title: \\\"““””<strong>使用前须知</strong>\\\".big(),\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nd.push({\\n    title: content.trim().replace(/\\\\n\\\\s*?/g, \\\"<br>\\\"),\\n    \\\"col_type\\\": \\\"rich_text\\\"\\n}, {\\n    col_type: \\\"line\\\"\\n}, {\\n    title: time + \\\"秒后继续\\\",\\n    url: \\\"toast://请认真阅读以上内容\\\",\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n        id: id + \\\"timer\\\"\\n    }\\n});\\nif (updateInfo) {\\n    confirm({\\n        title: \\\"更新内容\\\",\\n        content: updateInfo,\\n        confirm() {},\\n        cancel() {}\\n    });\\n}\\nsetResult(d);\\nwhile (time != 0) {\\n    java.lang.Thread.sleep(1000);\\n    time -= 1;\\n    updateItem(id + \\\"timer\\\", {\\n        title: time + \\\"秒后继续\\\"\\n    });\\n}\\nupdateItem(id + \\\"timer\\\", {\\n    title: \\\"““我同意以上要求””\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((v) => {\\n        setItem(\\\"first\\\", String(v));\\n        refreshPage();\\n        return \\\"toast://感谢您的理解\\\";\\n    }, MY_RULE.version),\\n    col_type: \\\"text_center_1\\\"\\n});\"}]","icon":"https://api.xinac.net/icon/?url=https://pan.baidu.com/","proxy":""}
Add Comment
Please, Sign In to add comment
