API tools faq
paste
xiaomianao666

小程序：云盘君.简

xiaomianao666
Mar 2nd, 2024
84
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 283.16 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@云盘君.简@{"last_chapter_rule":"","title":"云盘君.简","author":"小棉袄🌞&@LoyDgIk","url":"hiker://empty##fypage","version":144,"col_type":"movie_3","class_name":"","type":"all","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:$.require(\"Main\");","search_url":"hiker://empty?searchTerms=**","group":"②搜索","searchFind":"js:\nsetResult([{\n    title: \"点我开始聚合搜索\" + MY_KEYWORD,\n    url: \"hiker://page/sou#noHistory#?p=fypage\",\n    extra: {\n        pageTitle: \"搜索\" + MY_KEYWORD,\n        searchTerms: MY_KEYWORD,\n        hideSetting: true\n    }\n}]);","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"","pages":"[{\"col_type\":\"movie_3\",\"name\":\"规则处理\",\"path\":\"data\",\"rule\":\"js:\\nfunction toRedirectTreating(config) {\\n    return $.require(\\\"redirect\\\").doubleTreating(config);\\n}\\n\\nfunction toRedirect(aliUrl, sharePwd) {\\n    return $.require(\\\"redirect\\\").getModeUrl(aliUrl, sharePwd);\\n}\\n\\nfunction getCompleteRule(rule) {\\n    let find = new Function(\\\"s\\\", \\\"page\\\", \\\"user\\\", \\\"basicUrl\\\", rule.find);\\n    rule.find = (s, page) => find(s, page, rule.user || {}, rule.basicUrl || \\\"\\\");\\n    /*if (rule.findAliUrl) {\\n        rule.findAliUrl = new Function(\\\"input\\\", \\\"basicUrl\\\", rule.findAliUrl);\\n    }*/\\n    return rule;\\n}\\n$.exports.carryRule = function(rule, s, page, searchMode) {\\n    rule = getCompleteRule(rule);\\n    let list = rule.find(s, page);\\n    if (!list) return [];\\n\\n    let descTips = \\\"““””\\\" + rule.name.fontcolor(\\\"#f13b66a\\\") + \\\"&nbsp;\\\";\\n    let resList = [];\\n\\n    for (let it of list) {\\n        if (it.skip) {\\n            resList.push(it);\\n            continue;\\n        }\\n        if (searchMode && !searchContains(it.title, s, true)) continue;\\n        if (rule.findAliUrl) {\\n            it.url = $(\\\"\\\").lazyRule(toRedirectTreating, {\\n                findAliUrl: rule.findAliUrl,\\n                basicUrl: rule.basicUrl,\\n                name: rule.name,\\n                aliUrl: it.url\\n            });\\n        } else {\\n            it.url = $(\\\"#noLoading#\\\").lazyRule(toRedirect, it.url, it.sharePwd || \\\"\\\");\\n        }\\n        resList.push({\\n            title: it.title.includes(\\\"““””\\\") ? it.title : \\\"““””\\\" + it.title.replace(new RegExp(\\\"<em>|</em>\\\", \\\"g\\\"), \\\"\\\").replace(new RegExp(\\\"(\\\"+s+\\\")\\\", \\\"gi\\\"), \\\"<strong><span style=\\\\\\\"color: #1E90FF\\\\\\\">$1</span></strong>\\\"),\\n            desc: descTips + (it.desc || \\\"\\\"),\\n            url: it.url,\\n            pic_url: it.pic_url,\\n            col_type: it.pic_url ? \\\"movie_1_vertical_pic\\\" : \\\"text_1\\\",\\n            extra: Object.assign({\\n                inheritTitle: false,\\n                noPic: true\\n            }, it.extra)\\n        });\\n    }\\n    return resList;\\n}\\nlet size = 10;\\n\\nlet rules;\\nfunction getRules(group) {\\n    let rulesTmp;\\n    if(!rules){\\n        rules = $.require(\\\"configs\\\").getUsefulJson();\\n    }\\n    if (group) {\\n        rulesTmp = rules.filter(v => v.group === group);\\n    } else {\\n        rulesTmp = rules;\\n    }\\n    return rulesTmp;\\n}\\n$.exports.getData = function(page, rule, group) {\\n    if (rule) {\\n        if (page != null && page > 1) {\\n            return getRules().filter(i => i.name == rule && i.page);\\n        }\\n        return getRules().filter(i => i.name == rule);\\n    }\\n    let rulesTmp = getRules(group);\\n    let start = (page - 1) * size;\\n    if (rulesTmp.length < start + 1) {\\n        return [];\\n    }\\n    let len = size;\\n    if (rulesTmp.length < page * size) {\\n        len = rulesTmp.length - start;\\n    }\\n    return rulesTmp.slice(start, start + len);\\n};\\n$.exports.getNames = function(group) {\\n    return getRules(group).map(it => [it.name, it.basicUrl]);\\n};\\n\\n$.exports.getGroupNames = function() {\\n    return Array.from(new Set(getRules().map(v => v.group))).filter(v => v);\\n};\\n$.exports.findModulo = function(input) {\\n    let oriMods = [2, 3];\\n    let mods = oriMods.map(v=>input%v);\\n    let zeroMods = mods.indexOf(0);\\n\\n    if (zeroMods > -1) {\\n        return oriMods[zeroMods];\\n    } else {\\n        return oriMods[mods.indexOf(Math.max.apply(null, mods))];\\n    }\\n}\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"搜索页面\",\"path\":\"sou\",\"rule\":\"js:\\nconst alitest = $.require(\\\"alitest\\\");\\n\\nfunction setClip() {\\n    function getCopy() {\\n        try {\\n            const Context = android.content.Context;\\n            const context = com.example.hikerview.ui.Application().getContext();\\n            // 获取系统剪贴板\\n            let clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE);\\n            // 返回数据\\n            let clipData = clipboard.getPrimaryClip();\\n            if (clipData != null && clipData.getItemCount() > 0) {\\n                // 从数据集中获取（粘贴）第一条文本数据\\n                let text = clipData.getItemAt(0).getText();\\n                if (text != null) {\\n                    return String(text.toString());\\n                }\\n            }\\n            return null;\\n        } catch (e) {\\n            return null;\\n        }\\n    }\\n    let text = getCopy() || \\\"\\\";\\n    let url = alitest.matchAliUrl(text);\\n    if (url) {\\n        let cache = getItem(\\\"clipboardCache\\\", \\\"\\\");\\n        if (url !== cache) {\\n            d.push({\\n                title: '““””<font color=\\\"#13B61B\\\">▐ </font><b>温馨提示<b>',\\n                desc: \\\"检测到剪贴板含有阿里链接是否打开?\\\\n\\\" + url,\\n                url: $(\\\"#noLoading#\\\").lazyRule((input, id) => {\\n                    deleteItem(id + \\\"clipboard\\\");\\n                    return \\\"hiker://page/aliyun?page=fypage&realurl=\\\" + encodeURIComponent(input) + \\\"&sharePwd=\\\";\\n                }, url, id),\\n                col_type: \\\"text_1\\\",\\n                extra: {\\n                    id: id + \\\"clipboard\\\",\\n                    pageTitle: \\\"打开链接\\\"\\n                }\\n            });\\n            setItem(\\\"clipboardCache\\\", url);\\n        }\\n    }\\n}\\n\\nfunction setPrepose() {\\n    if (openMode == \\\"本地解析\\\") {\\n        let aliTokensFilepath = $.require(\\\"hiker://page/tokenPath\\\").aliTokensFilepath;\\n        let a = fetch(aliTokensFilepath);\\n        if (!a || a == \\\"\\\") {\\n            d.push({\\n                title: '<font color=\\\"#13B61B\\\">▐ </font><b>温馨提示<b>',\\n                col_type: \\\"rich_text\\\",\\n            });\\n            d.push({\\n                url: $(\\\"#noLoading#\\\").lazyRule(() => $.require(\\\"loginMode\\\")),\\n                col_type: \\\"text_1\\\",\\n                title: \\\"未检测到登录信息，点我跳转登录账号页面，登录阿里云盘账号后方可使用本地解析模式\\\",\\n                extra: {\\n                    pageTitle: \\\"登录阿里云盘\\\"\\n                }\\n            });\\n        }\\n    }\\n    addListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"s\\\");\\n    }));\\n    addListener(\\\"onRefresh\\\", $.toString(() => {\\n        if (!getMyVar(\\\"refs\\\", \\\"\\\")) {\\n            clearMyVar(\\\"s\\\");\\n        }\\n    }));\\n}\\n\\nfunction setHead() {\\n    d.push({\\n        title: \\\"搜索：\\\" + [\\\"默认\\\", \\\"精准\\\"][searchMode],\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            setSearchMode(getSearchMode() ? 0 : 1);\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }),\\n        col_type: \\\"icon_2_round\\\",\\n        pic_url: \\\"hiker://images/icon_search6\\\"\\n    });\\n\\n    d.push({\\n        title: \\\"设置|\\\" + openMode,\\n        url: $([\\\"模式：本地解析\\\", \\\"模式：官方APP\\\", \\\"登录阿里账号\\\", \\\"登录信息\\\", \\\"规则管理\\\", \\\"支持作者\\\"], 1, \\\"云简设置\\\").select((ids) => {\\n            if (\\\"规则管理\\\" == input) {\\n                return \\\"hiker://page/ruleManage#noRecordHistory##noHistory#\\\";\\n            }\\n            if (\\\"支持作者\\\" == input) {\\n                return \\\"hiker://page/Donate.v#noRecordHistory##noHistory#\\\";\\n            }\\n            if (\\\"登录阿里账号\\\" == input) {\\n                return $.require(\\\"loginMode\\\");\\n            }\\n            if (\\\"登录信息\\\" == input) {\\n                const {\\n                    openTokensFilepath,\\n                    aliTokensFilepath\\n                } = $.require(\\\"tokenPath\\\");\\n                if (!fileExist(aliTokensFilepath)) return \\\"toast://还未登陆\\\";\\n                let ali = request(aliTokensFilepath);\\n                try {\\n                    ali = JSON.parse(ali);\\n                } catch (e) {\\n                    deleteFile(aliTokensFilepath);\\n                    return \\\"toast://获取失败\\\";\\n                }\\n                confirm({\\n                    title: '登录信息',\\n                    content: \\\"用户:\\\" + (ali.nick_name || ali.user_name || \\\"Token登录\\\") + \\\"\\\\nToken:\\\" + ali.refresh_token + \\\"\\\\n(取消：注销登录；确定：复制Token)\\\",\\n                    confirm: $.toString((token) => {\\n                        return \\\"copy://\\\" + token;\\n                    }, ali.refresh_token),\\n                    cancel: $.toString((path1, path2) => {\\n                        return $(\\\"确认注销登录\\\").confirm((path1, path2) => {\\n                            deleteFile(path1);\\n                            deleteFile(path2);\\n                            refreshPage();\\n                            return \\\"toast://已成功退出登陆\\\";\\n                        }, path1, path2);\\n                    }, aliTokensFilepath, openTokensFilepath)\\n                });\\n                return;\\n            }\\n            input = input.replace(\\\"模式：\\\", \\\"\\\");\\n            setItem(\\\"openMode\\\", input);\\n            updateItem(ids, {\\n                title: \\\"设置|\\\" + input\\n            });\\n            if (input == \\\"官方APP\\\") {\\n                return \\\"toast://修改成功，请确保手机有安装阿里云盘等官方APP\\\";\\n            }\\n        }, id + \\\"mode\\\"),\\n        col_type: \\\"icon_2_round\\\",\\n        pic_url: \\\"hiker://images/icon_menu6\\\",\\n        extra: {\\n            id: id + \\\"mode\\\"\\n        }\\n    });\\n\\n    d.push({\\n        title: '搜索',\\n        desc: '请输入关键词/链接',\\n        col_type: 'input',\\n        url: $.toString(() => {\\n            input = input.trim();\\n            if ($.require(\\\"alitest\\\").test(input)) {\\n                clearMyVar(\\\"s\\\");\\n                return \\\"hiker://page/aliyun?page=fypage&realurl=\\\" + encodeURIComponent(input) + \\\"&sharePwd=\\\";\\n            }\\n            putMyVar(\\\"s\\\", input);\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }),\\n        extra: {\\n            onChange: \\\"putMyVar('refs',input)\\\",\\n            id: id + \\\"ss\\\",\\n            defaultValue: s,\\n            pageTitle: \\\"打开链接\\\"\\n        }\\n    });\\n}\\n\\nfunction setRuleItem() {\\n    let rules = $.require(\\\"data\\\").getNames(ruleGroup);\\n    d.push({\\n        title: \\\"🌟\\\",\\n        url: \\\"hiker://collection?rule=\\\" + MY_RULE.title,\\n        col_type: \\\"scroll_button\\\",\\n    }, {\\n        title: \\\"📌\\\" + ruleGroup,\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            let group = $.require(\\\"data\\\").getGroupNames();\\n            group.unshift(\\\"💡全部💡\\\");\\n            let selectNum = $.require(\\\"data\\\").findModulo(group.length);\\n            return $(group, selectNum, \\\"请选择分组\\\").select(() => {\\n                if (!MY_INDEX) {\\n                    setItem(\\\"ruleGroup\\\", \\\"\\\");\\n                } else {\\n                    setItem(\\\"ruleGroup\\\", input);\\n                }\\n                clearItem(\\\"rule\\\");\\n                refreshPage();\\n            });\\n        }),\\n        col_type: \\\"scroll_button\\\"\\n    }, {\\n        title: \\\"\\\" == r ? \\\"““全部””\\\" : \\\"全部\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((s, id) => {\\n            let qr = getItem(\\\"rule\\\", \\\"\\\");\\n            clearItem(\\\"rule\\\");\\n            if (s) {\\n                refreshPage();\\n            } else {\\n                updateItem(\\\"全部\\\" + id, {\\n                    title: \\\"““全部””\\\"\\n                });\\n                if (qr) {\\n                    updateItem(id + qr, {\\n                        title: qr\\n                    });\\n                }\\n            }\\n            return \\\"hiker://empty\\\";\\n        }, s, id),\\n        col_type: \\\"scroll_button\\\",\\n        extra: {\\n            id: \\\"全部\\\" + id\\n        }\\n    });\\n    for (let [it, basicUrl] of rules) {\\n        d.push({\\n            title: it == r ? \\\"““\\\" + it + \\\"””\\\" : it,\\n            url: $((basicUrl || \\\"\\\") + \\\"#noLoading#\\\").lazyRule((r, s, id) => {\\n                let qr = getItem(\\\"rule\\\", \\\"\\\");\\n                setItem(\\\"rule\\\", r);\\n                if (s) {\\n                    refreshPage();\\n                } else {\\n                    updateItem(qr ? (id + qr) : (\\\"全部\\\" + id), {\\n                        title: qr || \\\"全部\\\"\\n                    });\\n                    updateItem(id + r, {\\n                        title: \\\"““\\\" + r + \\\"””\\\"\\n                    });\\n                }\\n                return \\\"hiker://empty\\\";\\n            }, it, s, id),\\n            col_type: \\\"scroll_button\\\",\\n            extra: {\\n                id: id + it\\n            }\\n        });\\n    }\\n\\n}\\n\\nfunction record() {\\n    let history = storage0.getItem(\\\"searchHistory\\\", []);\\n    let ii = history.indexOf(s);\\n    if (ii > -1) {\\n        history.splice(ii, 1);\\n    }\\n    if (history.length > 20) {\\n        history.splice(history.length - 1, 1);\\n    }\\n    history.unshift(s);\\n    storage0.setItem(\\\"searchHistory\\\", history);\\n}\\n\\nfunction searchEnd() {\\n    let p = MY_PAGE;\\n    let data = $.require(\\\"data\\\").getData(p, r, ruleGroup);\\n    let pageid = id + \\\"ypj-page\\\" + p;\\n    if (data.length > 0) {\\n        d.push({\\n            title: \\\"加载第\\\" + p + \\\"页中，进度：1/\\\" + data.length,\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                id: pageid\\n            }\\n        });\\n    }\\n    setResult(d);\\n    if (data.length > 0) {\\n        //多线程加载        \\n        let realPage = \\\"\\\" == r ? 1 : p;\\n        let tasks = data.map(it => {\\n            return {\\n                func: function(rule) {\\n                    try {\\n                        return $.require(\\\"data\\\").carryRule(rule, s, realPage, searchMode);\\n                    } catch (e) {\\n                        log(rule.name + \\\":\\\" + e.toString());\\n                        /*if(data.length===1&&p===1){\\n                            return [{\\n                                title:\\\"““\\\"+rule.name+\\\" ERROR””\\\",\\n                                desc: e.toString(),\\n                                col_type:\\\"text_center_1\\\",\\n                                url:\\\"hiker://empty\\\",\\n                                extra:{\\n                                    lineVisible: false\\n                                }\\n                            }];\\n                        }*/\\n                    }\\n                    //return rule.find(s, realPage);\\n                },\\n                param: it,\\n                id: \\\"rule@\\\" + it.name\\n            }\\n        });\\n\\n        batchExecute(tasks, {\\n            func: function(param, id, error, result) {\\n                param.i += 1;\\n                if (Array.isArray(result)) {\\n                    deleteItem(\\\"_nothave\\\");\\n                    addItemBefore(pageid, result);\\n                }\\n                if (param.i === param.all) {\\n                    if (!result || !result.length) {\\n                        deleteItem(\\\"_nothave\\\");\\n                        addItemBefore(pageid, {\\n                            col_type: \\\"text_center_1\\\",\\n                            url: \\\"hiker://empty\\\",\\n                            title: \\\"““””\\\" + \\\"~~~什么资源都没有哦~~~\\\".fontcolor(\\\"Gray\\\"),\\n                            extra: {\\n                                lineVisible: false,\\n                                id: \\\"_nothave\\\"\\n                            }\\n                        });\\n                    }\\n                    deleteItem(pageid);\\n                } else {\\n                    updateItem(pageid, {\\n                        title: \\\"加载第\\\" + MY_PAGE + \\\"页中，进度：\\\" + (param.i + 1) + \\\"/\\\" + param.all,\\n                        col_type: \\\"text_center_1\\\",\\n                        url: \\\"hiker://empty\\\"\\n                    });\\n                }\\n            },\\n            param: {\\n                all: data.length,\\n                i: 0,\\n            }\\n        })\\n    }\\n}\\n\\nfunction setHistory() {\\n    d.push({\\n        title: '<span style=\\\"color:#ff6601\\\"><b>历史记录</b></span>',\\n        pic_url: \\\"hiker://images/icon_clock\\\",\\n        col_type: \\\"avatar\\\",\\n        url: $([\\\"清除搜索记录\\\", \\\"打开观看记录\\\"]).select((id) => {\\n            if (input === \\\"清除搜索记录\\\") {\\n                return $(\\\"确定清除全部搜索记录？\\\").confirm((id) => {\\n                    clearItem(\\\"searchHistory\\\");\\n                    deleteItemByCls(id + \\\":key\\\");\\n                    addItemAfter(id + \\\":searchHistory\\\", {\\n                        col_type: \\\"text_center_1\\\",\\n                        url: \\\"hiker://empty\\\",\\n                        title: \\\"““””\\\" + \\\"~~~什么都没有哦~~~\\\".fontcolor(\\\"Gray\\\"),\\n                        extra: {\\n                            cls: id + \\\":key\\\",\\n                            lineVisible: false\\n                        }\\n                    });\\n                }, id);\\n            } else {\\n                return \\\"hiker://history?rule=\\\" + MY_RULE.title;\\n            }\\n        }, id),\\n        extra: {\\n            id: id + \\\":searchHistory\\\",\\n        }\\n    });\\n\\n    let history = storage0.getItem(\\\"searchHistory\\\", []);\\n    let i = 0;\\n    for (let key of history) {\\n        d.push({\\n            title: key,\\n            url: $(\\\"#noLoading#\\\").lazyRule((id, key) => {\\n                let extra = findItem(id + \\\"ss\\\").extra;\\n                extra.defaultValue = key;\\n                updateItem({\\n                    extra: extra\\n                });\\n                return \\\"hiker://empty\\\";\\n            }, id, key),\\n            col_type: \\\"flex_button\\\",\\n            extra: {\\n                id: id + \\\":key:\\\" + key,\\n                cls: id + \\\":key\\\",\\n                longClick: [{\\n                    title: \\\"删除关键词:\\\" + key,\\n                    js: $.toString((id, key, i) => {\\n                        let history = storage0.getItem(\\\"searchHistory\\\", []);\\n                        history.splice(i, 1);\\n                        storage0.setItem(\\\"searchHistory\\\", history);\\n                        deleteItem(id + \\\":key:\\\" + key);\\n                        //toast();\\n                    }, id, key, i)\\n                }]\\n            }\\n        });\\n        i++;\\n    }\\n    if (history.length === 0) {\\n        d.push({\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"““””\\\" + \\\"~~~什么都没有哦~~~\\\".fontcolor(\\\"Gray\\\"),\\n            extra: {\\n                cls: id + \\\":key\\\",\\n                lineVisible: false\\n            }\\n        });\\n    }\\n}\\n\\nfunction setTrendingTabEnd() {\\n    let hotClass = {\\n        \\\"百度\\\": {\\n            \\\"电视剧\\\": \\\"teleplay\\\",\\n            \\\"电影\\\": \\\"movie\\\"\\n        },\\n        \\\"夸克\\\": {\\n            \\\"电视剧\\\": \\\"电视剧\\\",\\n            \\\"电影\\\": \\\"电影\\\",\\n            \\\"动漫\\\": \\\"动漫\\\",\\n            \\\"综艺\\\": \\\"综艺\\\"\\n        }\\n    };\\n    let dataSource = Object.keys(hotClass);\\n    let selectsource = getItem(\\\"dataSource\\\", dataSource[0]);\\n    let hotkeys = Object.keys(hotClass[selectsource]);\\n    let selectkey = getItem(\\\"hotkey\\\", hotkeys[0]);\\n    let tabkey = hotClass[selectsource][selectkey];\\n\\n    d.push({\\n        title: '<span style=\\\"color:#ff6601\\\"><b>' + selectsource + selectkey + '热搜</b></span>',\\n        url: $(hotkeys, 1, \\\"切换热搜\\\").select(() => {\\n            setItem(\\\"hotkey\\\", input);\\n            refreshPage(false);\\n            return \\\"toast://已切换为\\\" + input;\\n        }),\\n        col_type: \\\"avatar\\\",\\n        pic_url: \\\"hiker://images/icon_fire\\\",\\n        extra: {\\n            longClick: [{\\n                title: \\\"切换数据源\\\",\\n                js: $.toString((dataSource) => {\\n                    return $(dataSource, 1, \\\"切换数据源\\\").select(() => {\\n                        setItem(\\\"dataSource\\\", input);\\n                        clearItem(\\\"hotkey\\\");\\n                        refreshPage(false);\\n                        return \\\"toast://已切换为\\\" + input;\\n                    });\\n                }, dataSource)\\n            }]\\n        }\\n    });\\n    d.push({\\n        title: \\\"正在加载...\\\",\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\",\\n        extra: {\\n            id: id + \\\":hotkey\\\",\\n            lineVisible: false\\n        }\\n    });\\n    setResult(d);\\n    let sd = [];\\n    let setSearchKey = name => {\\n        putMyVar('s', name);\\n        refreshPage();\\n        return 'hiker://empty'\\n    };\\n\\n    let getTitle = (i, name) => {\\n        let color;\\n        switch (i) {\\n            case 0:\\n                color = \\\"#ff3300\\\";\\n                break;\\n            case 1:\\n                color = \\\"#ff6600\\\";\\n                break;\\n            case 2:\\n                color = \\\"#ff9900\\\"\\n                break;\\n            default:\\n                color = \\\"black\\\";\\n        }\\n        return \\\"““””\\\" + String(i + 1).fontcolor(color) + \\\"\\\\t\\\\t\\\\t\\\" + name;\\n    }\\n    try {\\n        switch (selectsource) {\\n            case \\\"百度\\\":\\n                var json = request('https://top.baidu.com/api/board?platform=wise&tab=' + tabkey + '&tag=%7B%22category%22:%22%E5%85%A8%E9%83%A8%E7%B1%BB%E5%9E%8B%22%7D', {\\n                    headers: {\\n                        'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Mobile Safari/537.36',\\n                        'Host': 'top.baidu.com',\\n                        'Accept': 'application/json, text/plain, */*',\\n                        'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',\\n                        'Accept-Encoding': 'gzip, deflate, br',\\n                        'Referer': 'https://top.baidu.com/board?tab=novel',\\n                    }\\n                });\\n                //var s = Date.now();\\n                var list = JSON.parse(json).data.cards[0].content;\\n                for (let i = 0; i < list.length; i++) {\\n                    let item = list[i];\\n                    let name = item.word + ' (' + item.show[2] + ')';\\n                    let des = item.desc;\\n                    sd.push({\\n                        title: getTitle(i, name),\\n                        url: $('#noLoading#').lazyRule(setSearchKey, item.word),\\n                        desc: des,\\n                        img: item.img,\\n                        col_type: \\\"movie_1_vertical_pic\\\"\\n                    });\\n                }\\n                break;\\n            case \\\"夸克\\\":\\n                var json = request(\\\"https://news.myquark.cn/v2/toplist/movie?&channel=\\\" + tabkey + \\\"&rank_type=%E6%9C%80%E7%83%AD\\\");\\n                var xmlData = (JSON.parse(json).data || \\\"\\\").replace(/title>/g, \\\"h_title>\\\").replace(/src>/g, \\\"h_src>\\\").replace(/area>/g, \\\"h_area\\\");\\n                var list = pdfa(xmlData, \\\"body&&item\\\");\\n                var getText = t => t;\\n                var trend = [\\\"ㄧ\\\", \\\"↑\\\", \\\"↓\\\"];\\n                //var s = Date.now();\\n                for (let i = 0; i < list.length; i++) {\\n                    let item = list[i];\\n                    let name = pdfh(item, \\\"h_title&&Text\\\");\\n                    let des = \\\"热度：\\\" + pdfh(item, \\\"hot_score&&Text\\\") + \\\" \\\" + trend.at(pdfh(item, \\\"hot_trend&&Text\\\")) +\\n                        \\\"\\\\n评分：\\\" + pdfh(item, \\\"score_avg&&Text\\\").replace(/^0$/, \\\"暂无评分\\\") +\\n                        \\\"\\\\n\\\" + pdfh(item, \\\"year&&Text\\\") + \\\"·\\\" + pdfh(item, \\\"h_area&&Text\\\") + \\\"·\\\" + pdfh(item, \\\"category&&Text\\\").replace(\\\",\\\", \\\"·\\\");\\n                    sd.push({\\n                        title: getTitle(i, name),\\n                        url: $('#noLoading#').lazyRule(setSearchKey, name),\\n                        desc: des,\\n                        img: pdfh(item, \\\"h_src&&Text\\\"),\\n                        col_type: \\\"movie_1_vertical_pic\\\"\\n                    });\\n                }\\n                break;\\n        }\\n        addItemAfter(id + \\\":hotkey\\\", sd);\\n    } catch (e) {\\n        log(e.toString());\\n    } finally {\\n        deleteItem(id + \\\":hotkey\\\");\\n    }\\n}\\nlet r = getItem(\\\"rule\\\", \\\"\\\");\\nlet hideSetting = MY_PARAMS.hideSetting || getParam(\\\"searchTerms\\\", \\\"\\\") === \\\"true\\\";\\nlet s = getMyVar('s', '') || MY_PARAMS.searchTerms || decodeURIComponent(getParam(\\\"searchTerms\\\", \\\"\\\"));\\nlet searchMode = getSearchMode();\\nlet openMode = getItem(\\\"openMode\\\", \\\"本地解析\\\");\\nlet id = Date.now() + MY_RULE.title;\\nlet ruleGroup = getItem(\\\"ruleGroup\\\", \\\"\\\");\\nlet d = [];\\nif (MY_PAGE === 1) {\\n    setPrepose();\\n    if (!hideSetting) {\\n        setClip();\\n        setHead();\\n    }\\n    setRuleItem();\\n    if (!s) {\\n        setHistory();\\n    }\\n}\\nif (s) {\\n    record();\\n    searchEnd();\\n} else if (MY_PAGE === 1) {\\n    setTrendingTabEnd();\\n} else {\\n    setResult([]);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"网页浏览\",\"path\":\"ysfx\",\"rule\":\"js:\\nvar d = [];\\n\\nlet openMode = getItem(\\\"openMode\\\");\\nlet rule = MY_RULE.title;\\nlet url = decodeURIComponent(getParam(\\\"webUrl\\\",\\\"\\\"));\\n\\nfunction intercept(rule, origin, openMode) {\\n    let host = origin.replace(new RegExp(\\\"http://|https://\\\"), \\\"\\\").split(\\\"/\\\")[0];\\n    let hosts = host.split(\\\".\\\");\\n    if (hosts.length > 2) {\\n        host = hosts[hosts.length - 2] + \\\".\\\" + hosts[hosts.length - 1];\\n    }\\n    if (input.startsWith(\\\"magnet\\\")) {\\n        confirm({\\n            title: \\\"温馨提示\\\",\\n            content: \\\"检测到新的磁链地址，点击确定按钮即可播放，点击取消按钮可以复制链接\\\",\\n            confirm: $.toString((mag) => {\\n                return mag;\\n            }, input),\\n            cancel: $.toString((mag) => {\\n                return \\\"copy://\\\" + mag\\n            }, input)\\n        });\\n        return true;\\n    } else if ($.require(\\\"alitest?rule=\\\"+rule).test(input) && openMode != \\\"官方APP\\\") {\\n        log(input);\\n        if (input.includes('checkurl?url=') && input.includes('&urlrefer')) {\\n            input = decodeURIComponent(input.split('&urlrefer')[0].split('checkurl?url=')[1]);\\n            //log('贴吧'+input);\\n        }\\n        return $.toString((url, rule) => {\\n            fy_bridge_app.open(JSON.stringify({\\n                title: \\\"阿里云盘\\\",\\n                url: \\\"hiker://page/aliyun?page=fypage&realurl=\\\" + encodeURIComponent(url) + \\\"&rule=\\\" + rule,\\n            }))\\n        }, input, rule);\\n    } else if (/\\\\.(mp3|flac|m4a)$/.test(input)) {\\n        log(input);\\n        return $.toString((url, rule) => {\\n            fy_bridge_app.playVideo(url);\\n        }, input, rule);\\n    } else if (!input.includes(host) && input.startsWith(\\\"http\\\")) {\\n        log(input);\\n        return $.toString((url, rule) => {\\n            fy_bridge_app.open(JSON.stringify({\\n                title: \\\"详情\\\",\\n                url: \\\"hiker://page/ysfx?webUrl=\\\"+encodeURIComponent(url)+\\\"&rule=\\\"+rule,\\n            }))\\n        }, input, rule);\\n    } else if (!input.startsWith(\\\"http\\\")) {\\n        log(input);\\n        //能唤起APP的白名单\\n        let white = [\\n            \\\"qklink\\\",\\n            \\\"bdnetdisk\\\",\\n            \\\"xunleiapp\\\",\\n            \\\"smartdrive\\\"\\n        ];\\n        let inWhite = white.filter(it => input.startsWith(it)).length > 0;\\n        if (!inWhite) {\\n            return false;\\n        }\\n        return $.toString((url, rule) => {\\n            fy_bridge_app.openThirdApp && fy_bridge_app.openThirdApp(url);\\n        }, input, rule);\\n    }\\n}\\n\\nfunction loadJs() {\\n    try {\\n        if (document.title && document.title.length) {\\n            let r = $$$().lazyRule((t) => {\\n                setPageTitle(t);\\n            }, document.title);\\n            fy_bridge_app.parseLazyRule(r);\\n        }\\n    } catch (e) {\\n        fy_bridge_app.log(e.toString());\\n    }\\n}\\n\\nd.push({\\n    url: url,\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"100%&&float\\\",\\n    extra: {\\n        urlInterceptor: $.toString(intercept, rule, getHome(url), openMode),\\n        js: $.toString(loadJs),\\n        canBack: true,\\n        jsLoadingInject: true,\\n        floatVideo: true\\n    }\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"阿里Lazy\",\"path\":\"alilazy\",\"rule\":\"const AliAccessApi = $.require(\\\"aliPlayApi\\\");\\nconst {\\n    openTokensFilepath,\\n    aliTokensFilepath\\n} = $.require(\\\"tokenPath\\\");\\n\\nfunction aliM3u8Proxy(fileId, shareId, sharePwd, shareToken, aliToken, title) {\\n    //过期获取播放原始链接\\n    function getAliPlayUrl(fileId, line) {\\n        let aliurl;\\n        try {\\n            const AliAccessApi = $.require(\\\"hiker://page/aliPlayApi?rule=\\\" + title);\\n            let aliAccessApi = AliAccessApi.createDefault(shareId, sharePwd, shareToken, aliToken, null, title);\\n            let playUrlList = aliAccessApi.getShareVideoPreview(fileId) || [];\\n            aliurl = playUrlList.find(v => v.template_id == line).url;\\n        } catch (e) {\\n            log(e.toString());\\n            throw e;\\n        }\\n        return aliurl;\\n    }\\n\\n    function getM3u8Content(playurl) {\\n\\n        //log(\\\"我在代理\\\" + playurl);\\n        let home = playurl.split(\\\"media.m3u8\\\")[0];\\n        let f = fetch(playurl, {\\n            headers: {\\n                \\\"User-Agent\\\": PC_UA,\\n                \\\"Referer\\\": \\\"https://www.aliyundrive.com/\\\"\\n            },\\n            timeout: 3000\\n        }).split(\\\"\\\\n\\\");\\n        let ff = f.map(it => {\\n            if (it.startsWith(\\\"media-\\\")) {\\n                return \\\"/proxy?url=\\\" + base64Encode(home + it);\\n            }\\n            return it;\\n        }).join(\\\"\\\\n\\\");\\n        //log('ufid-' + fileid);\\n        writeFile(\\\"hiker://files/_cache/\\\" + fileId + \\\".m3u8\\\", ff);\\n        return ff;\\n    }\\n\\n    function updateTsUrl(url) {\\n        let fid = url.split('&f=')[1].split('&')[0];\\n        //log('sfid-' + fid);\\n        let f = fetch('hiker://files/_cache/' + fid + '.m3u8').split(\\\"\\\\n\\\");\\n        f.forEach(it => {\\n            if (it && it.startsWith('/proxy?url=')) {\\n                let furl = base64Decode(it.replace('/proxy?url=', ''));\\n                if (url.substr(url.indexOf('/media-'), url.indexOf('.ts')) == furl.substr(furl.indexOf('/media-'), furl.indexOf('.ts'))) {\\n                    url = furl;\\n                }\\n            }\\n        })\\n        let expires = url.split('x-oss-expires=')[1].split('&')[0];\\n        const lasttime = parseInt(expires) - Date.now() / 1000;\\n        if (lasttime < 60) {\\n            //log('过期更新')\\n            let line = url.split('/media')[0]; //取之前播放的ts段线路\\n            line = line.substring(line.lastIndexOf('/') + 1);\\n            let f = getM3u8Content(getAliPlayUrl(fid, line)).split(\\\"\\\\n\\\");\\n            f.forEach(it => {\\n                if (it && it.startsWith('/proxy?url=')) {\\n                    let furl = base64Decode(it.replace('/proxy?url=', ''));\\n                    if (url.substr(url.indexOf('/media-'), url.indexOf('.ts')) == furl.substr(furl.indexOf('/media-'), furl.indexOf('.ts'))) {\\n                        url = furl;\\n                    }\\n                }\\n            })\\n\\n        }\\n        return url;\\n    }\\n    try {\\n        let url = base64Decode(MY_PARAMS.url[0]);\\n        if (url.includes(\\\".ts\\\")) {\\n            return JSON.stringify({\\n                statusCode: 302,\\n                headers: {\\n                    \\\"Location\\\": updateTsUrl(url),\\n                    \\\"User-Agent\\\": PC_UA,\\n                    \\\"Referer\\\": \\\"https://www.aliyundrive.com/\\\"\\n                }\\n            });\\n        } else {\\n            let templateId = MY_PARAMS.templateId[0];\\n            let ff = getM3u8Content(getAliPlayUrl(fileId, templateId));\\n            return ff;\\n        }\\n    } catch (e) {\\n        log(\\\"代理播放失败#\\\\n错误信息>\\\" + e.toString() + \\\"\\\\n错误行>\\\" + e.lineNumber);\\n    }\\n}\\n\\n\\nfunction getVideo(aliAccessApi, fileId) {\\n\\n    let playUrlList = aliAccessApi.getShareVideoPreview(fileId) || [];\\n\\n    let serverAddress = startProxyServer($.toString(aliM3u8Proxy, fileId, aliAccessApi.shareId, aliAccessApi.sharePwd, aliAccessApi.shareToken, aliAccessApi.aliToken, MY_RULE.title));\\n    let transcoding = {\\n        UHD: \\\"4K 超清\\\",\\n        QHD: \\\"2K 超清\\\",\\n        FHD: \\\"1080 全高清\\\",\\n        HD: \\\"720 高清\\\",\\n        SD: \\\"540 标清\\\",\\n        LD: \\\"360 流畅\\\"\\n    };\\n\\n    if (playUrlList.length > 0) {\\n        let urls = [],\\n            names = [];\\n        playUrlList.forEach((item) => {\\n            urls.push(serverAddress + \\\"?url=\\\" + base64Encode(item.url) + \\\"&templateId=\\\" + item.template_id + \\\"#.m3u8\\\");\\n            names.push(transcoding[item.template_id] ? transcoding[item.template_id] : item.template_height);\\n        });\\n        let heads = new Array(playUrlList.length).fill({\\n            'Referer': 'https://www.aliyundrive.com/'\\n        });\\n        return {\\n            urls: urls,\\n            names: names,\\n            headers: heads,\\n        };\\n    } else {\\n        return {};\\n    }\\n\\n};\\n\\nfunction getPlayFormat(playUrl, title) {\\n    return {\\n        names: [title],\\n        urls: [playUrl + \\\"#isVideo=true##ignoreMusic=true#\\\"],\\n        headers: [{\\n            'Referer': 'https://www.aliyundrive.com/',\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36\\\"\\n        }]\\n    };\\n}\\n\\n\\n$.exports = function(shareId, sharePwd, shareToken, fileId, cate, zimu) {\\n    if (!fileExist(aliTokensFilepath)) {\\n        toast(\\\"请先登陆登录账号\\\");\\n        return \\\"hiker://page/login#noRecordHistory##noHistory#?noRefresh=1\\\";\\n    }\\n    let aliToken = $.require(aliTokensFilepath);\\n    if (cate === \\\"video\\\") {\\n        let playList = [];\\n        let aliAccessApi;\\n        let playMode = getItem(\\\"aliyun_playMode\\\", \\\"转码\\\");\\n        try {\\n            aliAccessApi = AliAccessApi.createDefault(shareId, sharePwd, shareToken, aliToken);\\n            if (playMode === \\\"转码\\\") {\\n                playList = getVideo(aliAccessApi, fileId) || {};\\n            } else if (playMode === \\\"原画\\\") {\\n                playList = getPlayFormat(aliAccessApi.getVideoTemPlayUrl(fileId), playMode);\\n            } else if (playMode === \\\"极速原画\\\") {\\n                playList = getPlayFormat(aliAccessApi.getFileToDownUrl(fileId) + \\\"#fastPlayMode##threads=\\\" + getItem(\\\"speedThread\\\", \\\"20\\\") + \\\"#\\\", playMode);\\n            }\\n        } catch (e) {\\n            log(\\\"#\\\" + playMode + \\\"播放失败#\\\\n错误信息>\\\" + e.toString() + \\\"\\\\n错误行>\\\" + e.lineNumber);\\n            if (e.code === \\\"InvalidParameter.RefreshToken\\\") {\\n                toast(\\\"登陆过期，请重新登陆\\\");\\n                return \\\"hiker://page/login#noRecordHistory##noHistory#?noRefresh=1\\\";\\n            } else if (e.code === \\\"QuotaExhausted.Drive\\\") {\\n                return \\\"toast://网盘空间不足，无法播放请清理。\\\";\\n            }\\n            return \\\"toast://播放失败，错误信息已打印。\\\\n请查看日志(LOG)\\\";\\n        }\\n        let mountsub = storage0.getMyVar('mountzimu', {});\\n        if (Object.keys(mountsub).length > 0) {\\n            zimu = mountsub;\\n        }\\n        let subtitle;\\n        if (Object.keys(zimu || {}).length > 0 && playList && playList.urls && playList.urls.length > 0) {\\n            java.lang.Thread.sleep(100);\\n            try {\\n                var zmurl = aliAccessApi.getFileToDownUrl(zimu.file_id);\\n                let path = 'hiker://files/cache/云盘君/sub.' + zimu.ext;\\n                downloadFile(zmurl, path, {\\n                    'Referer': 'https://www.aliyundrive.com/'\\n                });\\n                subtitle = getPath(path);\\n            } catch (e) {\\n                toast(\\\"字幕加载失败\\\");\\n                log(e.message);\\n            }\\n        }\\n        let dmlist = storage0.getMyVar(\\\"dmlist\\\", []);\\n        let dmlist_cache = getMyVar(\\\"dmlist_cache\\\", \\\"\\\");\\n        if (dmlist_cache && dmlist_cache.startsWith(fileId + \\\"#\\\")) {\\n            playList.danmu = dmlist_cache.replace(fileId + \\\"#\\\", \\\"\\\");\\n        } else if (dmlist.length > 0) {\\n            playList.danmu = \\\"hiker://files/cache/danmu/\\\" + dmlist.splice(0, 1)[0];\\n            putMyVar(\\\"dmlist_cache\\\", fileId + \\\"#\\\" + playList.danmu);\\n            storage0.putMyVar(\\\"dmlist\\\", dmlist);\\n            if (dmlist.length === 0) {\\n                toast(\\\"弹幕列表已全部挂载\\\");\\n            }\\n        } else {\\n            playList.danmu = getVar(\\\"dm_share\\\", \\\"\\\");\\n        }\\n        playList.subtitle = subtitle;\\n        return JSON.stringify(playList);\\n    }\\n\\n    let aliAccessApi = AliAccessApi.createDefault(shareId, sharePwd, shareToken, aliToken, null);\\n    let url = aliAccessApi.getFileToDownUrl(fileId);\\n\\n    if (cate === \\\"image\\\") {\\n        return url + \\\"#.jpg\\\";\\n    } else if (cate === \\\"audio\\\") {\\n        return url + \\\"#isMusic=true#\\\";\\n    } else {\\n        return \\\"download://\\\" + url;\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"阿里列表\",\"path\":\"aliyun\",\"rule\":\"js:\\n//@author LoyDgIk\\nconst AliShareApi = $.require(\\\"AliApi\\\");\\n\\n\\nlet openAPIList = [\\\"alist\\\", \\\"drive\\\", \\\"tvbox\\\", \\\"XBY\\\"];\\n\\nlet realurl = decodeURIComponent(getParam(\\\"realurl\\\", \\\"\\\")).split(\\\"?\\\")[0];\\nlet urlData = realurl.split(\\\"/\\\");\\n//https://www.aliyundrive.com/s/{shareId}/folder/{fileId}?;\\n\\nlet shareId = MY_PARAMS.shareId || urlData[4];\\nlet sharePwd = getParam(\\\"sharePwd\\\", MY_PARAMS.sharePwd || \\\"\\\");\\nlet shareToken = getParam(\\\"shareToken\\\", MY_PARAMS.shareToken);\\n\\nlet fileId = (urlData[5] === \\\"folder\\\" ? urlData[6] : void 0) || MY_PARAMS.fileId;\\nlet searchKey = decodeURIComponent(getParam(\\\"searchKey\\\", \\\"\\\")) || undefined;\\nlet isSearch = !!searchKey;\\n\\nlet pageId = String(Date.now()).slice(6);\\n\\nfunction formatDate(_date, fmt) {\\n    let date = !isNaN(_date) ? new Date(_date * 1000) : new Date(_date);\\n    return $.dateFormat(date, fmt || \\\"yyyy-MM-dd HH:mm:ss\\\")\\n}\\n\\nfunction formatSize(size) {\\n    if (!size) {\\n        return '';\\n    }\\n    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\\n    let i = 0;\\n    while (size >= 1024) {\\n        size /= 1024;\\n        i++;\\n    }\\n    size = i ? Number(size.toFixed(2)) : size;\\n    return `${size} ${units[i]}`;\\n}\\n\\nfunction setMyPaCache(key, value) {\\n    MY_PARAMS[key] = value;\\n}\\n\\nfunction saveMyPaCache() {\\n    setPageParams(MY_PARAMS);\\n}\\n\\nfunction setMarker(marker) {\\n    setMyPaCache(\\\"marker\\\", marker);\\n}\\n\\nfunction setToken(shareToken) {\\n    setMyPaCache(\\\"shareToken\\\", shareToken);\\n}\\nif (MY_PARAMS.noPic) {\\n    setPagePicUrl();\\n    setMyPaCache(\\\"noPic\\\", false);\\n}\\n/*\\nfunction setVideoItemCache(videoItemCache) {\\n    setMyPaCache(\\\"videoItemCache\\\", videoItemCache);\\n}\\n\\nfunction setSubtitleCache(subtitleCache) {\\n    setMyPaCache(\\\"subtitleCache\\\", subtitleCache);\\n}*/\\n\\nlet iconType = \\\"ai|apk|avi|css|dmg|exe|flv|gif|hiker|html|iso|jpg|js|json|log|mov|mp3|mp4|otf|php|png|ppt|psd|table|txt|wav|xls|zip|css|doc|epub|exc|htm|xlsx\\\".split('|');\\n\\nfunction getIcon(ext, type) {\\n    let root = \\\"https://gitcode.net/qq_32394351/dr/-/raw/master/img/文件类型2/\\\";\\n    if (type === \\\"folder\\\") {\\n        return root + \\\"文件夹.svg\\\";\\n    }\\n    if (iconType.includes((ext || \\\"\\\").toLowerCase())) {\\n        return root + ext + \\\".svg\\\";\\n    }\\n    return root + \\\"文件.svg\\\";\\n\\n}\\n\\nfunction load(items) {\\n    let aliShareApi = new AliShareApi(shareId, sharePwd, shareToken, (shareToken) => {\\n        setToken(shareToken);\\n        MY_PARAMS.shareToken = shareToken;\\n    });\\n    let orders = {\\n        \\\"名称正序\\\": \\\"name#ASC\\\",\\n        \\\"名称倒序\\\": \\\"name#DESC\\\",\\n        \\\"时间正序\\\": \\\"updated_at#ASC\\\",\\n        \\\"时间倒序\\\": \\\"updated_at#DESC\\\",\\n        \\\"大小正序\\\": \\\"size#ASC\\\",\\n        \\\"大小倒序\\\": \\\"size#DESC\\\"\\n    };\\n    let playMode = getItem(\\\"aliyun_playMode\\\", \\\"转码\\\");\\n    let ordersKeys = Object.keys(orders);\\n    let orderName = getItem(\\\"aliyun_order\\\", ordersKeys[0]);\\n    let order = orders[orderName].split(\\\"#\\\");\\n    let styles = [\\\"text_1\\\", \\\"movie_2\\\", \\\"card_pic_3\\\", \\\"avatar\\\", \\\"追剧\\\", \\\"看图\\\"];\\n    let style = getItem(\\\"aliyun_style\\\", styles[0]);\\n    if (MY_PAGE === 1) {\\n        if (!getMyVar(\\\"mountzimu\\\", \\\"\\\")) {\\n            storage0.putMyVar(\\\"mountzimu\\\", {});\\n            addListener(\\\"onClose\\\", $.toString(() => {\\n                clearMyVar(\\\"mountzimu\\\");\\n                clearMyVar(\\\"aliShareToken\\\");\\n                clearVar(\\\"dm_share\\\");\\n                clearMyVar(\\\"dmlist\\\");\\n                clearMyVar(\\\"listSearchKey\\\");\\n                clearMyVar(\\\"dm_listUrlList\\\");\\n            }));\\n        }\\n        setMarker();\\n        if (realurl && !isSearch) {\\n            let shareInfo = aliShareApi.getShareInfo();\\n            let fileInfo = shareInfo.file_infos || [];\\n            if (fileInfo.length === 1 && fileInfo[0].type === \\\"folder\\\" && !fileId) {\\n                fileId = fileInfo[0].file_id;\\n                setPageTitle(fileInfo[0].file_name);\\n            } else {\\n                setPageTitle(shareInfo.share_name);\\n            }\\n            let deadline = \\\"永久有效\\\";\\n\\n            if (shareInfo.expiration) {\\n                deadline = \\\"有效至：\\\" + formatDate(shareInfo.expiration);\\n                //shareInfo.updated_at\\n            }\\n            items.push({\\n                title: (shareInfo.creator_name || shareInfo.creator_phone) + \\\"&nbsp;&nbsp;\\\" + deadline.small(),\\n                url: realurl + \\\"#noHistory#\\\",\\n                img: shareInfo.avatar || \\\"hiker://images/icon_unknown\\\",\\n                col_type: \\\"avatar\\\"\\n            });\\n        }\\n        if (!isSearch) {\\n            items.push({\\n                title: \\\"搜索\\\",\\n                url: $.toString(() => {\\n                    input = input.trim();\\n                    if (!input) return \\\"toast://请输入关键词\\\";\\n                    return \\\"hiker://page/aliyun#noHistory##fullTheme#?page=fypage&searchKey=\\\" + encodeURIComponent(input);\\n                }),\\n                col_type: \\\"input\\\",\\n                extra: {\\n                    onChange: \\\"putMyVar('listSearchKey',input)\\\",\\n                    sharePwd: sharePwd,\\n                    shareId: shareId,\\n                    shareToken: shareToken\\n                }\\n            });\\n        } else {\\n            items.push({\\n                title: \\\"““\\\" + searchKey + \\\"””的搜索结果\\\",\\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"text_center_1\\\",\\n                extra: {\\n                    lineVisible: false\\n                }\\n            });\\n        }\\n        let funcItems = [];\\n        funcItems.push({\\n            title: style,\\n            url: $(styles, 1, \\\"排布样式\\\").select(() => {\\n                setItem(\\\"aliyun_style\\\", input);\\n                refreshPage();\\n                return \\\"toast://已切换\\\";\\n            }),\\n            pic_url: \\\"https://hikerfans.com/img/ali_icon.svg\\\"\\n        }, {\\n            title: orderName,\\n            url: $(ordersKeys, 2, \\\"排序方式\\\").select(() => {\\n                setItem(\\\"aliyun_order\\\", input);\\n                refreshPage();\\n                return \\\"toast://切换成功\\\";\\n            }),\\n            pic_url: \\\"https://hikerfans.com/img/ali_sort.svg\\\"\\n        }, {\\n            title: playMode,\\n            url: $([\\\"转码\\\", \\\"原画\\\", \\\"极速原画\\\"], 1, \\\"播放模式\\\").select(() => {\\n                setItem(\\\"aliyun_playMode\\\", input);\\n                refreshPage();\\n                return \\\"toast://切换成功\\\";\\n            }),\\n            pic_url: \\\"https://hikerfans.com/img/ali_play.svg\\\",\\n        });\\n        if (playMode === \\\"原画\\\") {\\n            funcItems.push({\\n                title: openAPIList[getItem(\\\"openApiMode\\\", \\\"0\\\")],\\n                url: $(openAPIList, 1, \\\"原画API(不要频繁切换)\\\").select((openAPIList) => {\\n                    setItem(\\\"openApiMode\\\", String(openAPIList.indexOf(input)));\\n                    deleteFile($.require(\\\"tokenPath\\\").openTokensFilepath);\\n                    refreshPage(false);\\n                    return \\\"toast://已切换为\\\" + input;\\n                }, openAPIList),\\n                pic_url: \\\"https://hikerfans.com/img/ali_api.svg\\\",\\n            });\\n        }\\n        if (!isSearch) {\\n            funcItems.push({\\n                title: \\\"功能\\\",\\n                url: $([\\\"转存云盘\\\", \\\"登陆账号\\\", \\\"复制分享链接\\\", \\\"查看手动挂载字幕\\\", \\\"获取弹幕搜索规则\\\", \\\"批量挂载本地弹幕\\\", \\\"推送到TVBox\\\", \\\"设置收藏封面\\\", \\\"获取投屏IP\\\", \\\"极速原画下载线程\\\"], 2, \\\"更多功能\\\").select((shareId, sharePwd, fileId) => {\\n                    switch (input) {\\n                        case \\\"转存云盘\\\":\\n                            return `smartdrive://share/browse?shareId=${shareId}&sharePwd=${sharePwd||\\\"\\\"}`;\\n                        case \\\"登陆账号\\\":\\n                            return \\\"hiker://page/login#noRecordHistory##noHistory#\\\";\\n                        case \\\"复制分享链接\\\":\\n                            return $([\\\"复制链接\\\", \\\"复制海阔口令\\\"], 1, \\\"分享方式\\\").select((url) => {\\n                                if (input === \\\"复制链接\\\") {\\n                                    return \\\"copy://\\\" + url;\\n                                } else {\\n                                    return \\\"copy://阿里云盘分享口令「\\\" + getPageTitle() + \\\"」\\\\n\\\" + url + \\\" @import=js:`hiker://page/aliyun?realurl=${input.trim()}&rule=\\\" + MY_RULE.title + \\\"`;\\\";\\n                                }\\n                            }, \\\"https://www.aliyundrive.com/s/\\\" + shareId + (fileId ? \\\"/folder/\\\" + fileId : \\\"\\\"));\\n                        case \\\"批量挂载本地弹幕\\\":\\n                            return \\\"hiker://page/dmMount#noHistory##noRecordHistory#\\\";\\n                        case \\\"查看手动挂载字幕\\\":\\n                            let zm = storage0.getMyVar(\\\"mountzimu\\\", {});\\n                            let tip = zm.name ? \\\"当前字幕文件\\\\n\\\" + zm.name + \\\".\\\" + zm.ext : \\\"还未手动挂载字幕\\\";\\n                            confirm({\\n                                title: '手动挂载字幕',\\n                                content: tip + \\\"\\\\n(点击取消可以清除挂载字幕)\\\",\\n                                cancel: () => {\\n                                    clearMyVar(\\\"mountzimu\\\");\\n                                    return \\\"toast://已清除手动挂载字幕\\\";\\n                                }\\n                            });\\n                            return;\\n                        case \\\"获取弹幕搜索规则\\\":\\n                            let rule = {\\n                                \\\"js\\\": JSON.stringify(\\\"hiker://page/loadDm?rule=\\\" + MY_RULE.title + \\\"&title=\\\") + \\\"+encodeURIComponent(playdata.title.split('-')[0]);\\\",\\n                                \\\"name\\\": MY_RULE.title + \\\"弹幕搜索\\\"\\n                            };\\n                            return \\\"rule://\\\" + base64Encode(\\\"￥projection_screen￥\\\" + JSON.stringify(rule));\\n                        case \\\"推送到TVBox\\\":\\n                            return \\\"hiker://page/tvboxPush#noHistory##noRecordHistory#\\\";\\n                        case \\\"设置收藏封面\\\":\\n                            return $([\\\"设置封面地址\\\", \\\"搜索封面\\\"], 1).select(() => {\\n                                if (input === \\\"设置封面地址\\\") {\\n                                    return $(\\\"\\\", \\\"请输入图片地址\\\").input(() => {\\n                                        input = input.trim();\\n                                        if (!input) return \\\"toast://请输入地址\\\";\\n                                        setPagePicUrl(input);\\n                                        return \\\"toast://修改成功\\\";\\n                                    });\\n                                } else {\\n                                    return \\\"hiker://page/frontCover#noHistory##noRecordHistory#\\\";\\n                                }\\n                            });\\n                        case \\\"获取投屏IP\\\":\\n                            let ip = $.require(\\\"aliUtil\\\").getIPv4Address();\\n                            if (ip.startsWith(\\\"192.168.\\\")) {\\n                                return $(ip + \\\"\\\\n该IP适用于流量+热点的投屏\\\\n请替换链接中的0.0.0.0\\\").confirm((ip) => {\\n                                    return \\\"copy://\\\" + ip;\\n                                }, ip);\\n                            } else {\\n                                toast(\\\"获取失败非稳定IP,请开启热点再使用\\\");\\n                            }\\n                        case \\\"极速原画下载线程\\\":\\n                            return $(getItem(\\\"speedThread\\\", \\\"20\\\"), \\\"请输入3-32之间的整数\\\").input(()=>{\\n                                let speedThread=parseInt(input);\\n                                if(speedThread<3||speedThread>32){\\n                                    return \\\"toast://设置不合法\\\";\\n                                }\\n                                setItem(\\\"speedThread\\\",String(speedThread));\\n                                return \\\"toast://设置成功\\\";\\n                            });\\n                    }\\n                }, shareId, sharePwd, fileId),\\n                pic_url: \\\"https://hikerfans.com/img/ali_fileinto.svg\\\",\\n                extra: {\\n                    pageId: pageId,\\n                    fileId: fileId,\\n                    shareId: shareId,\\n                    shareToken: shareToken,\\n                    sharePwd: sharePwd,\\n                    folderName: getPageTitle()\\n                }\\n            });\\n        }\\n        let funStyle = [\\\"\\\", \\\"\\\", \\\"\\\", \\\"icon_small_3\\\", \\\"icon_round_small_4\\\", \\\"icon_5\\\"][funcItems.length];\\n        items.push.apply(items, funcItems.map(v => (v.col_type = funStyle) && v));\\n        items.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n    }\\n    let rescod = {};\\n    let marker = MY_PARAMS.marker;\\n    if (isSearch) {\\n        rescod = aliShareApi.getSearchListFile(searchKey, marker, order[0], order[1]);\\n    } else {\\n        rescod = aliShareApi.getListFile(fileId, marker, order[0], order[1]);\\n    }\\n    if (rescod.next_marker) {\\n        setMarker(rescod.next_marker);\\n    } else {\\n        setMarker();\\n    }\\n\\n    var conts = rescod.items;\\n    //字幕匹配准备\\n    let subExts = [\\\"vtt\\\", \\\"srt\\\", \\\"ass\\\"];\\n    var zimulist = [];\\n    conts.forEach((item) => {\\n        if (subExts.includes(item.file_extension && item.file_extension.toLowerCase())) {\\n            let name = item.name.replace('.' + item.file_extension, '');\\n            zimulist.push({\\n                ext: item.file_extension,\\n                file_id: item.file_id,\\n                name: name\\n            });\\n        }\\n    });\\n    //处理夸页匹配字幕\\n    /*\\n    let hasSub = zimulist.length > 0;\\n    if (hasSub&&rescod.next_marker) {\\n        if (zimulist.length > 4) {\\n            setSubtitleCache(zimulist.slice(-4));\\n        } else {\\n            setSubtitleCache(zimulist);\\n        }\\n    }\\n    let lastItem = conts.at(-1);\\n    if (hasSub&&lastItem&&lastItem.category === \\\"video\\\") {\\n        setVideoItemCache(conts.splice(conts.length-1,1));\\n    }\\n    if (MY_PAGE > 1) {\\n        let subtitleCache = MY_PARAMS.subtitleCache || [];\\n        zimulist = zimulist.concat(subtitleCache);\\n        let videoItemCache = MY_PARAMS.videoItemCache || [];\\n        conts = videoItemCache.concat(conts);\\n        setSubtitleCache();\\n        setVideoItemCache();\\n    }*/\\n    //简体优先\\n    zimulist.sort((a, b) => (b.name.endsWith(\\\".sc\\\") || b.name.endsWith(\\\".chs\\\")) - (a.name.endsWith(\\\".sc\\\") || a.name.endsWith(\\\".chs\\\")));\\n    //end\\n    let titleHead = {\\n        video: \\\"🎬\\\",\\n        audio: \\\"🎵\\\",\\n        doc: \\\"📑\\\",\\n        image: \\\"🖼\\\",\\n        zip: \\\"📦\\\",\\n        folder: \\\"📂\\\"\\n    };\\n\\n    function getHead(type, ext) {\\n        let head = titleHead[type];\\n        if (subExts.includes(ext)) {\\n            head = \\\"🕸\\\";\\n        }\\n        return head || \\\"❓\\\";\\n    }\\n\\n    function getPreviewPic(fileItem) {\\n        if (fileItem.thumbnail) {\\n            return $(\\\"https://empty?\\\" + fileItem.file_id).image((pic) => {\\n                try {\\n                    return fetch(pic, {\\n                        inputStream: true\\n                    });\\n                } catch (e) {\\n                    return null;\\n                }\\n            }, fileItem.thumbnail);\\n        }\\n    }\\n    let folderStyle, fileStyle;\\n    let filterType = [];\\n    if (style === \\\"追剧\\\") {\\n        folderStyle = \\\"avatar\\\";\\n        fileStyle = \\\"movie_2\\\";\\n        filterType.push(\\\"video\\\");\\n        items.push({\\n            title: \\\"““””\\\" + \\\"追剧模式只显示文件夹和视频\\\".small().fontcolor(\\\"grey\\\"),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n    } else if (style === \\\"看图\\\") {\\n        folderStyle = \\\"avatar\\\";\\n        fileStyle = \\\"card_pic_3\\\";\\n        filterType.push(\\\"image\\\");\\n        items.push({\\n            title: \\\"““””\\\" + \\\"看图模式只显示文件夹和图片\\\".small().fontcolor(\\\"grey\\\"),\\n            url: \\\"hiker://empty\\\",\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n    } else {\\n        folderStyle = fileStyle = style;\\n    }\\n    for (let i = 0; i < conts.length; i++) {\\n        let fileItem = conts[i];\\n        let cate = fileItem.category;\\n        let desc = formatDate(fileItem.updated_at);\\n        let pic_url = getIcon(fileItem.file_extension, fileItem.type);\\n\\n        if (fileItem.type === \\\"folder\\\") {\\n            let title = (folderStyle === \\\"text_1\\\" ? titleHead.folder : \\\"\\\") + fileItem.name;\\n            items.push({\\n                title: title,\\n                url: 'hiker://page/aliyun?page=fypage',\\n                col_type: folderStyle,\\n                desc: formatDate(fileItem.updated_at),\\n                pic_url: pic_url,\\n                extra: {\\n                    shareId: shareId,\\n                    shareToken: MY_PARAMS.shareToken,\\n                    fileId: fileItem.file_id,\\n                    sharePwd: sharePwd,\\n                    pageTitle: fileItem.name,\\n                    noPic: true\\n                }\\n            });\\n        } else {\\n            if (filterType.length > 0 && !filterType.includes(cate)) {\\n                continue;\\n            }\\n            let subtitle, longc, cls;\\n            let title = fileItem.name;\\n            let nameNotExt = fileItem.name.replace('.' + fileItem.file_extension, '');\\n            if (subExts.includes(fileItem.file_extension)) {\\n                longc = [{\\n                    title: \\\"挂载字幕\\\",\\n                    js: $.toString((zm) => {\\n                        storage0.putMyVar('mountzimu', zm);\\n                        return 'toast://挂载完成，当前字幕文件: ' + zm.name + '.' + zm.ext;\\n                    }, {\\n                        ext: fileItem.file_extension,\\n                        file_id: fileItem.file_id,\\n                        name: nameNotExt\\n                    }),\\n                }];\\n            }\\n            if (cate === \\\"video\\\") {\\n                if (zimulist.length) {\\n                    subtitle = zimulist.find(v => v.name.includes(nameNotExt));\\n                }\\n                cls = \\\"playlist v\\\" + pageId;\\n            }\\n            if (fileStyle === \\\"text_1\\\") {\\n                desc += \\\"\\\\t\\\\t\\\" + formatSize(fileItem.size);\\n                title = getHead(cate, fileItem.file_extension) + title;\\n            } else if ([\\\"video\\\", \\\"image\\\"].includes(cate)) {\\n                pic_url = getPreviewPic(fileItem) || pic_url;\\n            }\\n            items.push({\\n                title: title,\\n                url: $(\\\"#noPre#\\\").lazyRule((shareId, sharePwd, shareToken, fileId, cate, subtitle) => {\\n                    return $.require(\\\"hiker://page/alilazy\\\")(shareId, sharePwd, shareToken, fileId, cate, subtitle);\\n                }, shareId, sharePwd, MY_PARAMS.shareToken, fileItem.file_id, cate, subtitle),\\n                desc: desc,\\n                pic_url: pic_url,\\n                extra: {\\n                    id: fileItem.file_id,\\n                    longClick: longc,\\n                    cls: cls,\\n                    //inheritTitle: false,\\n                    pageTitle: fileItem.name\\n                },\\n                col_type: fileStyle\\n            });\\n        }\\n    }\\n    if (conts.length === 0) {\\n        items.push({\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"““””\\\" + \\\"~~~什么都没有了哦~~~\\\".fontcolor(\\\"Gray\\\"),\\n            extra: {\\n                lineVisible: false,\\n            }\\n        });\\n    }\\n}\\n\\nlet items = [];\\ntry {\\n    if (MY_PAGE > 1 && !MY_PARAMS.marker) {\\n        items.push({\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            title: \\\"““””\\\" + \\\"~~~什么都没有了哦~~~\\\".fontcolor(\\\"Gray\\\"),\\n            extra: {\\n                lineVisible: false,\\n            }\\n        });\\n    } else {\\n        load(items);\\n    }\\n} catch (e) {\\n    if (e.name === \\\"AliError\\\") {\\n        if (e.code === \\\"InvalidResource.SharePwd\\\") {\\n            items.push({\\n                title: \\\"请输入提取码\\\",\\n                desc: sharePwd ? \\\"““提取码错误””\\\" : \\\"\\\",\\n                url: $().input((MY_PARAMS) => {\\n                    setPageParams(Object.assign({}, MY_PARAMS, {\\n                        sharePwd: input\\n                    }));\\n                    refreshPage();\\n                }, MY_PARAMS),\\n                col_type: \\\"text_center_1\\\"\\n            });\\n        } else {\\n            if (e.significance === 1) {\\n                items.push({\\n                    title: \\\"““””\\\" + e.message.big().big().fontcolor(\\\"red\\\"),\\n                    url: \\\"hiker://empty\\\",\\n                    col_type: 'text_center_1',\\n                });\\n            } else if (e.significance === 3) {\\n                items.push({\\n                    title: \\\"““””\\\" + e.message.big().fontcolor(\\\"green\\\"),\\n                    url: \\\"hiker://empty\\\",\\n                    col_type: 'text_center_1'\\n                });\\n            }\\n        }\\n\\n    } else {\\n        log(\\\"列表加载失败#\\\\n错误信息>\\\" + e.toString() + \\\"\\\\n错误行>\\\" + e.lineNumber);\\n        items.push({\\n            title: '欧欧，报错了。在刷新几次？或者更换文件夹。',\\n            url: \\\"hiker://empty\\\",\\n            desc: e.toString(),\\n            col_type: 'text_center_1'\\n        });\\n        //throw e;\\n    }\\n}\\nsaveMyPaCache();\\nsetResult(items);\"},{\"col_type\":\"movie_3\",\"name\":\"登录账号\",\"path\":\"login\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle(\\\"登录阿里云盘\\\");\\nlet index = Number(getParam(\\\"index\\\", \\\"1\\\"));\\nif (Number.isNaN(index)) {\\n    index = 1;\\n}\\n\\n\\nfunction getQRCode() {\\n    let json = fetch(\\\"https://passport.aliyundrive.com/newlogin/qrcode/generate.do?appName=aliyun_drive&fromSite=52&appName=aliyun_drive&appEntrance=web&isMobile=false&lang=zh_CN&returnUrl=&bizParams=&_bx-v=2.2.3\\\");\\n    let qr = JSON.parse(json);\\n    if (!openAppIntent('com.alicloud.databox', 'com.taobao.login4android.scan.QrScanActivity', {\\n            \\\"key_scanParam\\\": json\\n        })) {\\n        createQRCode(qr.content.data.codeContent, false);\\n    }\\n    return qr;\\n}\\n\\nfunction backHome(t, i) {\\n    back(i);\\n    toast(t);\\n}\\n\\nfunction fromAppGetToken(qr) {\\n    let qr = getQRCode();\\n    if (!qr) return backHome(\\\"获取失败\\\");\\n    let ckk = qr.content.data;\\n    let body = {\\n        ck: ckk.ck,\\n        t: ckk.t + \\\"\\\",\\n        appName: \\\"aliyun_drive\\\",\\n        appEntrance: \\\"web\\\",\\n        isMobile: false,\\n        lang: \\\"zh_CN\\\",\\n        navPlatform: \\\"MacIntel\\\",\\n        returnUrl: \\\"\\\",\\n        navlanguage: \\\"zh-CN\\\",\\n        fromSite: 52,\\n        bizParams: \\\"\\\"\\n\\n    };\\n    /*\\n     {\\n        NEW: \\\"待扫描\\\",\\n        CANCELED: \\\"取消\\\",\\n        SCANED:\\\"已扫描\\\",\\n        CANCELED: \\\"完成\\\"\\n    }*/\\n    let errorCount = 0;\\n    for (let i = 0; i < 30; i++) {\\n        try {\\n            let result = JSON.parse(post(\\\"https://passport.aliyundrive.com/newlogin/qrcode/query.do?appName=aliyun_drive&fromSite=52&_bx-v=2.2.3\\\", {\\n                body: body\\n            }));\\n            let qrCodeStatus = result.content.data.qrCodeStatus;\\n\\n            if (qrCodeStatus === \\\"CONFIRMED\\\") {\\n                if (result.content.data.bizExt) {\\n                    let info = JSON.parse(base64Decode(result.content.data.bizExt));\\n                    let aliTokensFilepath = $.require(\\\"hiker://page/tokenPath\\\").aliTokensFilepath;\\n                    let aliToken = {\\n                        refresh_token: info.pds_login_result.refreshToken\\n                    };\\n                    writeFile(aliTokensFilepath, JSON.stringify(aliToken));\\n                    addItemAfter(\\\"loginy\\\", {\\n                        title: \\\"登录成功(点击返回)\\\",\\n                        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n                            back(false);\\n                            return \\\"hiker://empty\\\";\\n                        }),\\n                        col_type: \\\"text_center_1\\\",\\n                    });\\n                    backHome(\\\"登录成功\\\", true);\\n                } else {\\n                    backHome(\\\"登录失败,请尝试其他的方法\\\");\\n                }\\n                return;\\n            } else if (qrCodeStatus === \\\"CANCELED\\\") {\\n                backHome(\\\"取消登录授权\\\");\\n                return;\\n            }\\n            if ([\\\"NEW\\\", \\\"SCANED\\\"].includes(qrCodeStatus)) {\\n                java.lang.Thread.sleep(2500);\\n            } else {\\n                backHome(\\\"超时\\\");\\n                return;\\n            }\\n        } catch (e) {\\n            errorCount++;\\n            if (errorCount > 4) {\\n                throw e;\\n            }\\n        }\\n    }\\n\\n}\\nif (index > -1) {\\n    let loginUrls = [\\\"https://www.aliyundrive.com/sign\\\", \\\"https://auth.aliyundrive.com/v2/oauth/authorize?login_type=custom&response_type=code&redirect_uri=https%3A%2F%2Fwww.aliyundrive.com%2Fsign%2Fcallback&client_id=25dzX3vbYqktVxyX&state=%7B%22origin%22%3A%22*%22%7D#/login\\\"];\\n    let url = loginUrls[index];\\n    let isRefresh = !getParam(\\\"noRefresh\\\");\\n    let aliTokensFilepath = $.require(\\\"tokenPath\\\").aliTokensFilepath;\\n\\n    var js = $.toString((isRefresh, aliTokensFilepath) => {\\n        setInterval(() => {\\n            var token = JSON.parse(localStorage.getItem('token'));\\n            if (token && token.user_id) {\\n                let token_url = aliTokensFilepath;\\n                fy_bridge_app.writeFile(token_url, JSON.stringify(token));\\n                localStorage.clear();\\n                fy_bridge_app.back(isRefresh);\\n                fy_bridge_app.toast('TOKEN获取成功，请勿泄漏个人隐私！！！');\\n                return;\\n            }\\n        }, 300);\\n    }, isRefresh, aliTokensFilepath);\\n\\n    d.push({\\n        url: url,\\n        col_type: 'x5_webview_single',\\n        desc: '100%&&float',\\n        extra: {\\n            canBack: false,\\n            js: js,\\n            urlInterceptor: $.toString(() => true)\\n        }\\n    });\\n    setResult(d);\\n} else {\\n    \\n    d.push({\\n        col_type: \\\"text_center_1\\\",\\n        title: \\\"““””\\\" + \\\"等待授权...\\\".big().big(),\\n        desc: \\\"如果升级了官方App，无法自动调起授权，请扫码登录\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n            id: \\\"loginy\\\",\\n        }\\n    });\\n    setResult(d);\\n    try {\\n        fromAppGetToken();\\n    } catch (e) {\\n        backHome(\\\"内部错误:\\\" + e.toString());\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"阿里列表API\",\"path\":\"AliApi\",\"rule\":\"js:\\n//@author LoyDgIk\\nfunction AliError(errorCode, message, significance) {\\n    let errorType = AliError.errorCodeMap.get(errorCode) || [];\\n    this.code = errorCode;\\n    this.message = errorType[0] || message || \\\"\\\";\\n    this.name = \\\"AliError\\\";\\n    this.significance = errorType[1] || significance || 1;\\n}\\nAliError.errorCodeMap = new Map([\\n    [\\\"ShareLink.Cancelled\\\", [\\\"分享链接已失效\\\"]],\\n    [\\\"ShareLink.Forbidden\\\", [\\\"违规资源已被封禁\\\"]],\\n    [\\\"NotFound.ShareLink\\\", [\\\"不存在该链接请核对\\\"]],\\n    [\\\"AccessTokenInvalid\\\", [\\\"访问令牌失效，请重新登陆\\\"]],\\n    [\\\"ShareLinkTokenInvalid\\\", [\\\"分享令牌失效\\\"]],\\n    [\\\"ParamFlowException\\\", [\\\"访问过于频繁，请稍后再试\\\", 3]]\\n]);\\n\\nAliError.prototype = Object.assign(new Error(), {\\n    constructor: AliError\\n});\\n\\nfunction postApi(api, body, headers) {\\n    let result = request('https://api.aliyundrive.com' + api, {\\n        headers: Object.assign({\\n            'Content-Type': 'application/json',\\n        }, headers),\\n        body: JSON.stringify(body),\\n        method: 'POST'\\n    });\\n    result = JSON.parse(result);\\n    if (result.code) {\\n        throw new AliError(result.code, result.message);\\n    }\\n    return result;\\n}\\n\\nfunction AliShareApi(shareId, sharePwd, shareToken, refreshCallBack) {\\n    this.shareId = shareId;\\n    this.sharePwd = sharePwd;\\n    this.refreshCallBack = refreshCallBack || (() => void 0);\\n    this.shareToken = shareToken || this.getShareToken();\\n}\\nObject.assign(AliShareApi.prototype, {\\n    getShareToken() {\\n        let result = postApi(\\\"/v2/share_link/get_share_token\\\", {\\n            \\\"share_id\\\": this.shareId,\\n            \\\"share_pwd\\\": this.sharePwd,\\n        });\\n        this.shareToken = result.share_token;\\n        this.refreshCallBack(result.share_token, this);\\n        return result.share_token;\\n    },\\n    postTokenApi(api, body, headers, isRetry) {\\n        let result;\\n        try {\\n            result = postApi(api, body, Object.assign({\\n                \\\"X-Share-Token\\\": this.shareToken || this.getShareToken()\\n            }, headers));\\n        } catch (e) {\\n            if ((e.code === \\\"AccessTokenInvalid\\\" || e.code === \\\"ShareLinkTokenInvalid\\\") && !isRetry) {\\n                this.getShareToken();\\n                return this.postTokenApi(api, body, headers, true);\\n            }\\n            throw e;\\n        }\\n        return result;\\n    },\\n    getListFile(fileId, marker, orderBy, orderDirection) {\\n        let result = this.postTokenApi(\\\"/adrive/v3/file/list\\\", {\\n            \\\"share_id\\\": this.shareId,\\n            \\\"parent_file_id\\\": fileId || \\\"root\\\",\\n            \\\"limit\\\": 100,\\n            \\\"image_thumbnail_process\\\": \\\"image/resize,w_160/format,jpeg\\\",\\n            \\\"image_url_process\\\": \\\"image\\\\/resize,w_1920/format,jpeg\\\",\\n            \\\"video_thumbnail_process\\\": \\\"video/snapshot,t_1000,f_jpg,ar_auto,w_300\\\",\\n            \\\"order_by\\\": orderBy || \\\"name\\\",\\n            \\\"order_direction\\\": orderDirection || \\\"ASC\\\",\\n            \\\"marker\\\": marker\\n        });\\n        return result;\\n    },\\n    getShareInfo() {\\n        let result = postApi(\\\"/adrive/v3/share_link/get_share_by_anonymous?share_id=\\\" + this.shareId, {\\n            \\\"share_id\\\": this.shareId,\\n        });\\n        return result;\\n    },\\n    getSearchListFile(key, marker, orderBy, orderDirection) {\\n        let result = this.postTokenApi(\\\"/recommend/v1/shareLink/search\\\", {\\n            \\\"share_id\\\": this.shareId,\\n            \\\"keyword\\\": key,\\n            \\\"limit\\\": 100,\\n            \\\"order_by\\\": orderBy + \\\" \\\" + orderDirection,\\n            \\\"marker\\\": marker || undefined\\n        });\\n        if (Object.keys(result).length === 0) {\\n            result.items = [];\\n        }\\n        return result;\\n    }\\n});\\n$.exports = AliShareApi;\"},{\"col_type\":\"movie_3\",\"name\":\"阿里播放API\",\"path\":\"aliPlayApi\",\"rule\":\"//@author LoyDgIk\\n\\nfunction AliAccessApi({\\n    shareId,\\n    sharePwd,\\n    shareToken,\\n    aliTokens,\\n    openTokens\\n}) {\\n    this.shareId = shareId;\\n    this.sharePwd = sharePwd;\\n    this.shareToken = shareToken;\\n    this.refreshShareCallBack = (() => void 0);\\n    this.refreshAccessCallBack = (() => void 0);\\n    this.refreshOpenCallBack = (() => void 0);\\n    this.aliTokens = aliTokens || {};\\n    if (!this.aliTokens.refresh_token) {\\n        throw new Error(\\\"未登陆\\\");\\n    }\\n    if (!this.aliTokens.access_token) {\\n        this.refreshAccessToken();\\n    }\\n    this.defDriveId = this.aliTokens.resource_drive_id || this.aliTokens.default_drive_id;\\n    this.reaccessTk = (this.aliTokens.token_type || \\\"Bearer\\\") + ' ' + this.aliTokens.access_token;\\n    Object.defineProperty(this, \\\"shareToken\\\", {\\n        get(){\\n            return this._shareToken|| this.getShareToken();\\n        },\\n        set(v){\\n            this._shareToken=v;\\n        }\\n    });\\n    Object.defineProperty(this, \\\"openTools\\\", {\\n        get(){\\n            if (this._openTools) return _openTools;\\n            let OpenApiTools;\\n            switch (getItem(\\\"openApiMode\\\", \\\"0\\\")) {\\n                case \\\"1\\\":\\n                    OpenApiTools = $.require(\\\"openApi_aliyundrive\\\");\\n                    break;\\n                case \\\"2\\\":\\n                    OpenApiTools = $.require(\\\"openApi_tvbox\\\");\\n                    break;\\n                case \\\"3\\\":\\n                    OpenApiTools = $.require(\\\"openApi_XBY\\\");\\n                    break;\\n                case \\\"0\\\":\\n                default:\\n                    OpenApiTools = $.require(\\\"openApi_alist\\\");\\n            }\\n            this._openTools = new OpenApiTools(this);\\n            return this._openTools;\\n        }\\n    });\\n    Object.defineProperty(this, \\\"openTokens\\\", {\\n        get(){\\n            if (this._openTokens) return this._openTokens;\\n            this._openTokens = Object.assign({\\n                'RefreshTokenOpen': '',\\n                'AccessTokenOpen': '',\\n                'BindRefreshToken': '',\\n            }, openTokens);\\n            if (openTokens !== null && !this._openTokens.AccessTokenOpen) {\\n                this.refreshOpenToken();\\n            }\\n            return this._openTokens;\\n        }\\n    });\\n}\\nObject.assign(AliAccessApi.prototype, {\\n    _openTools:void 0,\\n    _openTokens:void 0,\\n    _shareToken:void 0,\\n    refreshShareListener(refreshShareCallBack) {\\n        this.refreshShareCallBack = refreshShareCallBack;\\n        return this;\\n    },\\n    refreshAccessListener(refreshAccessCallBack) {\\n        this.refreshAccessCallBack = refreshAccessCallBack;\\n        return this;\\n    },\\n    refreshOpenListener(refreshOpenCallBack) {\\n        this.refreshOpenCallBack = refreshOpenCallBack;\\n        return this;\\n    },\\n    waitSleep(time) {\\n        java.lang.Thread.sleep(time || 600);\\n        return this;\\n    },\\n    postApi(api) {\\n        return httpRequest.post(api.startsWith(\\\"http\\\") ? api : 'https://api.aliyundrive.com' + api).bodyToString(true).error((err) => {\\n            throw err;\\n        }).errorType((err, res) => {\\n            let result = {};\\n            try {\\n                result = JSON.parse(res.body);\\n            } catch (e) {\\n                return err;\\n            }\\n            let rbody = (result.code ? result : (result && result.responses && result.responses[0] && result.responses[0].body)) || {};\\n            if (rbody.code) {\\n                let msg = rbody.display_message || rbody.message;\\n                let error = new Error(api + \\\"=>\\\" + rbody.code + \\\":\\\" + msg);\\n                error.code = rbody.code;\\n                error.judgeMsg = msg;\\n                return error;\\n            }\\n            return err;\\n        });\\n    },\\n\\n    trySolve(e) {\\n        if (e.code === \\\"ShareLinkTokenInvalid\\\" || e.code === \\\"InvalidParameterNotMatch.ShareId\\\") {\\n            this.waitSleep(20).getShareToken();\\n            return true;\\n        } else if (e.code === \\\"AccessTokenInvalid\\\" || e.code === \\\"AccessTokenExpired\\\") {\\n            this.waitSleep(20).refreshAccessToken();\\n            return true;\\n        } else if (e.code === \\\"ForbiddenNoPermission.File\\\" || (e.code === \\\"BadRequest\\\" && e.judgeMsg === \\\"仅可保存到转存空间\\\")) {\\n            this.aliTokens.resource_drive_id = undefined;\\n            this.waitSleep(20).refreshAccessToken();\\n            return true;\\n        }\\n        return false;\\n    },\\n    tryOpenApiSolve(e) {\\n        if (e.code === \\\"AccessTokenInvalid\\\" || e.code === \\\"AccessTokenExpired\\\") {\\n            this.waitSleep(20).refreshOpenToken();\\n            return true;\\n        } else {\\n            this.waitSleep(20).refreshAccessToken();\\n            this.waitSleep(20).refreshOpenToken();\\n            return true;\\n        }\\n        return false;\\n    },\\n    getShareToken() {\\n        let result = this.postApi(\\\"/v2/share_link/get_share_token\\\").body({\\n            \\\"share_id\\\": this.shareId,\\n            \\\"share_pwd\\\": this.sharePwd,\\n        }).start(true);\\n        this.shareToken = result.share_token;\\n        this.refreshShareCallBack(result.share_token, this);\\n        return result.share_token;\\n    },\\n    refreshAccessToken() {\\n        let result = this.postApi(\\\"https://auth.aliyundrive.com/v2/account/token\\\")\\n            .body({\\n                \\\"grant_type\\\": \\\"refresh_token\\\",\\n                \\\"refresh_token\\\": this.aliTokens.refresh_token,\\n            }).headers({\\n                \\\"User-Agent\\\": PC_UA,\\n                \\\"Referer\\\": \\\"https://www.aliyundrive.com/\\\"\\n            }).error((e) => {\\n                if (e.code === \\\"InvalidParameter.RefreshToken\\\") {\\n                    e.message = \\\"#登陆过期请重新登陆#\\\\n\\\" + e.message;\\n                    throw e;\\n                }\\n            }).start(true);\\n        delete result.user_data;\\n        let originDefdDriveId = this.aliTokens.default_drive_id;\\n        this.aliTokens = Object.assign(this.aliTokens, result);\\n        this.reaccessTk = this.aliTokens.token_type + ' ' + this.aliTokens.access_token;\\n        try {\\n            if ((originDefdDriveId !== this.aliTokens.default_drive_id) || this.aliTokens.resource_drive_id === undefined) {\\n                let resource_drive_id = this.getUserInfo().resource_drive_id;\\n                this.aliTokens.resource_drive_id = resource_drive_id;\\n                if (resource_drive_id) {\\n                    this.defDriveId = resource_drive_id;\\n                } else {\\n                    this.defDriveId = this.aliTokens.default_drive_id;\\n                }\\n            }\\n        } catch (e) {\\n            log(\\\"用户信息获取失败：\\\" + e.toString());\\n        }\\n        this.refreshAccessCallBack(result, this);\\n        return this.aliTokens;\\n    },\\n    getUserInfo() {\\n        let info = this.postApi(\\\"https://user.aliyundrive.com/v2/user/get\\\").headers({\\n            \\\"User-Agent\\\": PC_UA,\\n            \\\"authorization\\\": this.reaccessTk,\\n            \\\"Referer\\\": \\\"https://www.aliyundrive.com/\\\"\\n        }).errorWithRetry((e, _, http) => {\\n            this.trySolve(e);\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    'authorization': this.reaccessTk\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        return info;\\n    },\\n    cacheOpenToken(openResult) {\\n        this.openTokens.RefreshTokenOpen = openResult.refresh_token;\\n        this.openTokens.AccessTokenOpen = openResult.token_type + \\\" \\\" + openResult.access_token;\\n        this.openTokens.BindRefreshToken = this.aliTokens.refresh_token;\\n        this.refreshOpenCallBack(openResult, this);\\n    },\\n    refreshOpenToken() {\\n        try {\\n            let openResult;\\n            if (this.openTokens.RefreshTokenOpen && this.openTokens.BindRefreshToken === this.aliTokens.refresh_token) {\\n                openResult = this.openTools.refreshOpenToken() || {};\\n            } else {\\n                openResult = this.openTools.getOpenToken() || {};\\n            }\\n            if (openResult.refresh_token) {\\n                this.cacheOpenToken(openResult);\\n                return this.openTokens;\\n            } else {\\n                throw new Error(\\\"返回结果无Token\\\");\\n            }\\n        } catch (e) {\\n            throw new Error(\\\"OpenToken获取失败:\\\" + e.toString());\\n        }\\n    },\\n    _cloudFileOperate(body, cloudFileId, operateUrl) {\\n        let result = this.postApi('https://api.aliyundrive.com/adrive/v2/batch').body({\\n            \\\"requests\\\": [{\\n                \\\"body\\\": body,\\n                \\\"headers\\\": {\\n                    \\\"Content-Type\\\": \\\"application/json\\\"\\n                },\\n                \\\"id\\\": cloudFileId || \\\"0\\\",\\n                \\\"method\\\": \\\"POST\\\",\\n                \\\"url\\\": operateUrl\\n            }],\\n            \\\"resource\\\": \\\"file\\\"\\n        }).headers({\\n            'User-Agent': PC_UA,\\n            'Referer': 'https://www.aliyundrive.com/',\\n            'authorization': this.reaccessTk,\\n            //getAccessToken\\n            'x-canary': 'client=web,app=share,version=v2.3.1',\\n            'x-share-token': this.shareToken\\n        }).errorWithRetry((e, _, http) => {\\n            if (e.code === \\\"QuotaExhausted.Drive\\\") {\\n                throw e;\\n            }\\n\\n            if (!this.trySolve(e)) {\\n                this.waitSleep(20).refreshAccessToken();\\n            }\\n            let body = http.options.body.requests[0].body;\\n            if (body.drive_id) {\\n                body.drive_id = this.defDriveId\\n            }\\n            if (body.to_drive_id) {\\n                body.to_drive_id = this.defDriveId\\n            }\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    'authorization': this.reaccessTk,\\n                    'x-share-token': this.shareToken\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        return result;\\n    },\\n    copyFileToCloudFile(fileId, retry) {\\n        let result = this._cloudFileOperate({\\n            \\\"file_id\\\": fileId,\\n            \\\"share_id\\\": this.shareId,\\n            \\\"auto_rename\\\": true,\\n            \\\"to_parent_file_id\\\": \\\"root\\\",\\n            \\\"to_drive_id\\\": this.defDriveId\\n        }, \\\"0\\\", \\\"/file/copy\\\");\\n        let body = result && result.responses && result.responses[0] && result.responses[0].body || {};\\n        if (!body.file_id && !retry) {\\n            this.waitSleep(20).getShareToken();\\n            this.waitSleep(20).refreshAccessToken();\\n            return this.waitSleep(20).copyFileToCloudFile(fileId, true);\\n        } else if (!body.file_id) {\\n            let e = new Error(\\\"文件复制失败:\\\\n\\\" + JSON.stringify(result));\\n            e.code = body.code;\\n            throw e;\\n        }\\n        return result.responses[0].body.file_id;\\n    },\\n    openCloudFileToDownUrl(cloudFileId) {\\n        let fileInfo = this.postApi('https://open.aliyundrive.com/adrive/v1.0/openFile/getDownloadUrl').body({\\n            'file_id': cloudFileId,\\n            'drive_id': this.defDriveId\\n        }).headers({\\n            'User-Agent': PC_UA,\\n            'Referer': 'https://www.aliyundrive.com/',\\n            'authorization': this.openTokens.AccessTokenOpen\\n        }).errorWithRetry(2, (e, _, http) => {\\n            //this.waitSleep(30).trySolve(e);\\n            this.waitSleep(30).tryOpenApiSolve(e);\\n            http.mergeHeadAndBody({\\n                body: {\\n                    'drive_id': this.defDriveId,\\n                },\\n                headers: {\\n                    'authorization': this.openTokens.AccessTokenOpen\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        if (!fileInfo.url || fileInfo.code) throw new Error(\\\"下载链接获取失败\\\\n\\\" + fileInfo.code + \\\":\\\" + fileInfo.message);\\n        return fileInfo.url;\\n    },\\n    deleteeCloudFile(cloudFileId) {\\n        let result = this._cloudFileOperate({\\n            \\\"drive_id\\\": this.defDriveId,\\n            \\\"file_id\\\": cloudFileId\\n        }, cloudFileId, \\\"/file/delete\\\");\\n        return result;\\n    },\\n    getVideoTemPlayUrl(fileId) {\\n        let cloudFileId = this.copyFileToCloudFile(fileId);\\n        this.waitSleep(20);\\n        let playUrl = this.openCloudFileToDownUrl(cloudFileId);\\n        this.waitSleep(50);\\n        try {\\n            this.deleteeCloudFile(cloudFileId);\\n        } catch (e) {\\n            log(\\\"#文件删除失败#\\\\n错误信息>\\\" + e.toString() + \\\"\\\\n错误行>\\\" + e.lineNumber);\\n        }\\n        return playUrl;\\n    },\\n    getFileToDownUrl(fileId) {\\n        let downloadInfo = this.postApi(\\\"/v2/file/get_share_link_download_url\\\").body({\\n            \\\"expire_sec\\\": 600,\\n            \\\"file_id\\\": fileId,\\n            \\\"share_id\\\": this.shareId\\n        }).headers({\\n            \\\"X-Share-Token\\\": this.shareToken,\\n            \\\"authorization\\\": this.aliTokens.access_token\\n        }).errorWithRetry((e, _, http) => {\\n            this.trySolve(e);\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    \\\"X-Share-Token\\\": this.shareToken,\\n                    \\\"authorization\\\": this.aliTokens.access_token\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        return downloadInfo.download_url;\\n    },\\n    getSign() {\\n        if (!this.aliTokens.device_id) {\\n            this.waitSleep(20).refreshAccessToken();\\n        }\\n        let calculateNewSign = () => {\\n            let sign = justTestSign(\\\"5dde4e1bdf9e4966b387ba58f4b3fdc3\\\", this.aliTokens.device_id, this.aliTokens.user_id).split(\\\"##\\\");\\n            return {\\n                signature: sign.at(0),\\n                pubKey: sign.at(-1)\\n            };\\n        };\\n        let newSign = calculateNewSign();\\n        let result = this.postApi('/users/v1/users/device/create_session').body({\\n            \\\"deviceName\\\": \\\"Edge浏览器\\\",\\n            \\\"modelName\\\": \\\"Windows网页版\\\",\\n            \\\"pubKey\\\": newSign.pubKey,\\n        }).headers({\\n            'User-Agent': PC_UA,\\n            'Referer': 'https://www.aliyundrive.com',\\n            'Authorization': this.reaccessTk,\\n            'X-Share-Token': this.shareToken,\\n            'x-device-id': this.aliTokens.device_id,\\n            'x-signature': newSign.signature\\n        }).errorWithRetry(3, (e, _, http) => {\\n            if (e.message === \\\"x-device-id empty\\\") {\\n                this.waitSleep(20).refreshAccessToken();\\n            }\\n            this.trySolve(e);\\n            this.waitSleep(50);\\n            newSign = calculateNewSign();\\n            http.mergeHeadAndBody({\\n                body: {\\n                    \\\"pubKey\\\": newSign.pubKey\\n                },\\n                headers: {\\n                    'Authorization': this.reaccessTk,\\n                    'X-Share-Token': this.shareToken,\\n                    'x-device-id': this.aliTokens.device_id,\\n                    'x-signature': newSign.signature\\n                }\\n            });\\n            return true;\\n        }).error((err, res) => {\\n            return {};\\n        }).success((body) => {\\n            return body;\\n        }).start(true);\\n        if (result.success) {\\n            return newSign;\\n        } else {\\n            throw new Error(\\\"Sign获取失败，请重试。\\\\ncode:\\\" + (result.code || \\\"\\\") + \\\"\\\\nmessage:\\\" + (result.message || \\\"\\\"));\\n        }\\n    },\\n    getShareVideoPreview(fileId) {\\n        let sign = this.getSign();\\n        let json = this.postApi('https://api.aliyundrive.com/v2/file/get_share_link_video_preview_play_info').body({\\n            \\\"category\\\": \\\"live_transcoding\\\",\\n            \\\"file_id\\\": fileId,\\n            \\\"get_preview_url\\\": true,\\n            \\\"share_id\\\": this.shareId,\\n            \\\"template_id\\\": \\\"\\\",\\n            \\\"get_subtitle_info\\\": true\\n        }).headers({\\n            'content-type': 'application/json;charset=UTF-8',\\n            \\\"origin\\\": \\\"https://www.aliyundrive.com\\\",\\n            \\\"referer\\\": \\\"https://www.aliyundrive.com/\\\",\\n            \\\"user-agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.41\\\",\\n            \\\"x-canary\\\": \\\"client=web,app=adrive,version=v3.1.0\\\",\\n            \\\"x-share-token\\\": this.shareToken,\\n            \\\"fileid\\\": this.aliTokens.user_id,\\n            'Authorization': this.reaccessTk,\\n            'x-device-id': this.aliTokens.device_id,\\n            'x-signature': sign.signature\\n        }).errorWithRetry((e, _, http) => {\\n            this.trySolve(e);\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    'Authorization': this.reaccessTk,\\n                    'X-share-token': this.shareToken,\\n                    'x-device-id': this.aliTokens.device_id,\\n                    'x-signature': sign.signature\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        return json.video_preview_play_info.live_transcoding_task_list.reverse();\\n    }\\n});\\n\\nAliAccessApi.createDefault = function(shareId, sharePwd, shareToken, aliToken, openToken, MY_TITLE) {\\n    const {\\n        openTokensFilepath,\\n        aliTokensFilepath\\n    } = $.require(\\\"tokenPath\\\" + (MY_TITLE ? \\\"?rule=\\\" + MY_TITLE : \\\"\\\"));\\n    if (!openToken && openToken !== null && fileExist(openTokensFilepath)) {\\n        openToken = $.require(openTokensFilepath);\\n    }\\n    if (!aliToken && fileExist(aliTokensFilepath)) {\\n        aliToken = $.require(aliTokensFilepath);\\n    }\\n    if (MY_TITLE) {\\n        shareToken = getVar(MY_TITLE + \\\"@aliShareToken\\\", shareToken);\\n    } else {\\n        shareToken = getMyVar(\\\"aliShareToken\\\", shareToken);\\n    }\\n    return new AliAccessApi({\\n        shareId,\\n        sharePwd,\\n        shareToken,\\n        aliTokens: aliToken,\\n        openTokens: openToken\\n    }).refreshShareListener((result) => {\\n        if (MY_TITLE) {\\n            shareToken = putVar(MY_TITLE + \\\"@\\\" + \\\"aliShareToken\\\", result);\\n        } else {\\n            shareToken = putMyVar(\\\"aliShareToken\\\", result);\\n        }\\n    }).refreshAccessListener((result, api)=>{\\n        writeFile(aliTokensFilepath, JSON.stringify(api.aliTokens));\\n    }).refreshOpenListener((result, api) => {\\n        writeFile(openTokensFilepath, JSON.stringify(api.openTokens));\\n    });\\n}\\n$.exports = AliAccessApi;\\n\\nfunction httpRequest(url, options) {\\n    this.retryCount = 0;\\n    this.url = url;\\n    this.options = Object.assign({}, options, {\\n        withHeaders: true\\n    });\\n    this.errorCallback = (err, res) => {\\n        throw err\\n    };\\n    this.errorCallbackWithRetry = (err, res, tryRestart) => false;\\n    this.successCallback = (body, res) => body;\\n    this.errorTypeCallback = (err, res) => err;\\n    this.startRequest = fetch;\\n    this._bodyToString = false;\\n}\\n\\nObject.assign(httpRequest.prototype, {\\n    bodyToString(flag) {\\n        this._bodyToString = !!flag;\\n        return this;\\n    },\\n    body(body) {\\n        this.options.body = body || void 0;\\n        return this;\\n    },\\n    setStartRequestFunc(func) {\\n        this.startRequest = func;\\n        return this;\\n    },\\n    headers(headers) {\\n        this.options.headers = headers || void 0;\\n        return this;\\n    },\\n    success(successCallback) {\\n        if (typeof successCallback !== \\\"function\\\") return this;\\n        this.successCallback = successCallback;\\n        return this;\\n    },\\n    error(errorCallback) {\\n        if (typeof errorCallback !== \\\"function\\\") return this;\\n        this.errorCallback = errorCallback;\\n        return this;\\n    },\\n    errorType(errorTypeCallback) {\\n        if (typeof errorTypeCallback !== \\\"function\\\") return this;\\n        this.errorTypeCallback = errorTypeCallback;\\n        return this;\\n    },\\n    errorWithRetry(retryCount, errorCallbackWithRetry) {\\n        if (typeof retryCount === \\\"function\\\" && typeof errorCallbackWithRetry === \\\"undefined\\\") {\\n            errorCallbackWithRetry = retryCount;\\n            retryCount = 1;\\n        }\\n        if (typeof errorCallbackWithRetry !== \\\"function\\\") {\\n            return this;\\n        }\\n        this.retryCount = Number(retryCount);\\n        this.errorCallbackWithRetry = errorCallbackWithRetry;\\n        return this;\\n    },\\n    start(toJson) {\\n        let options = Object.assign({}, this.options);\\n        if (typeof options.body === \\\"object\\\" && this._bodyToString) {\\n            options.body = JSON.stringify(options.body);\\n        }\\n        var res = JSON.parse(this.startRequest(this.url, options));\\n        try {\\n            if (res.statusCode >= 200 && res.statusCode <= 300) {\\n                let body = res.body;\\n                if (toJson) {\\n                    body = JSON.parse(body);\\n                }\\n                return this.successCallback(body, res);\\n            } else {\\n                throw new Error(String(res.statusCode));\\n            }\\n        } catch (err) {\\n            try {\\n                err = this.errorTypeCallback(err, res);\\n            } catch (e) {\\n\\n            }\\n            if (this.retryCount) {\\n\\n                let tryResult = this.errorCallbackWithRetry(err, res, this);\\n                if (tryResult) {\\n                    this.retryCount--;\\n                    return this.start(toJson);\\n                } else {\\n                    this.retryCount = 0;\\n                    return this.errorCallback(err, res);\\n                }\\n            } else {\\n                return this.errorCallback(err, res);\\n            }\\n        }\\n    },\\n    setOptions(options) {\\n        this.options = Object.assign({}, options, {\\n            withHeaders: true\\n        });\\n        return this;\\n    },\\n    mergeHeadAndBody(options) {\\n        options = options || {};\\n        this.options.headers = Object.assign(this.options.headers, options.headers);\\n        if (typeof this.options.body === \\\"object\\\" && typeof options.body === \\\"object\\\") {\\n            this.options.body = Object.assign(this.options.body, options.body);\\n        }\\n        return this;\\n    }\\n});\\n\\nObject.assign(httpRequest, {\\n    fetch(url, options) {\\n        return new httpRequest(url, options);\\n    },\\n    post(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(post);\\n    },\\n    request(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(request);\\n    },\\n    postRequest(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(postRequest);\\n    },\\n    fetchCookie(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(fetchCookie);\\n    }\\n});\"},{\"col_type\":\"movie_3\",\"name\":\"Token路径\",\"path\":\"tokenPath\",\"rule\":\"$.exports={\\n    \\\"openTokensFilepath\\\": \\\"hiker://files/rules/LoyDgIk/aliOpenToken.json\\\",\\n    \\\"aliTokensFilepath\\\": \\\"hiker://files/rules/LoyDgIk/aliToken.json\\\"\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"弹弹play工具\",\"path\":\"danmu\",\"rule\":\"js:\\nlet basicUrl = \\\"https://api.dandanplay.net/\\\";\\nlet sevePath = \\\"hiker://files/cache/danmu/\\\";\\n\\nfunction getRefreshRate() {\\n    const Context = android.content.Context;\\n    const Display = android.view.Display;\\n    const WindowManager = android.view.WindowManager;\\n    const context = com.example.hikerview.ui.Application().getContext();\\n\\n    let windowManager = context.getSystemService(Context.WINDOW_SERVICE);\\n\\n    let display = windowManager.getDefaultDisplay();\\n\\n    let refreshRate = display.getRefreshRate();\\n    return refreshRate;\\n}\\n$.exports.getDanMu = function(key) {\\n    return JSON.parse(request(basicUrl + \\\"api/v2/search/episodes?anime=\\\" + encodeURIComponent(decodeURIComponent(key))));\\n}\\n\\nfunction encodeHtml(s) {\\n    let REGX_HTML_ENCODE = /“|&|’|\\\\u003C|>|[\\\\x00-\\\\x20]|[\\\\x7F-\\\\xFF]|[\\\\u0100-\\\\u2700]/g;\\n   return s.replace(REGX_HTML_ENCODE, function($0) {\\n        var c = $0.charCodeAt(0),\\n            r = [\\\"&#\\\"];\\n        c = (c == 0x20) ? 0xA0 : c;\\n        r.push(c);\\n        r.push(\\\";\\\");\\n        return r.join(\\\"\\\");\\n    });\\n}\\n\\n\\n\\n//0默认 1简体 2繁体\\n$.exports.downloadDanMu = function(episodeId, name) {\\n    let danMuData = JSON.parse(request(buildUrl(basicUrl + \\\"api/v2/comment/\\\" + episodeId, {\\n        withRelated: true,\\n        chConvert: 1\\n    })));\\n    let dMcontext = \\\"\\\";\\n    //let fpsm = getRefreshRate()/60*0.95;\\n    //danMuData.comments.sort((v,x)=>v.p.split(\\\",\\\")[0]-x.p.split(\\\",\\\")[0]);\\n    for (let comment of danMuData.comments) {\\n        //dMcontext += `<d p=\\\"${Math.round(timepoint)},${ct},${size},${color},0\\\">${content}</d>\\\\n`;\\n        let paramText = comment.p;\\n        let commentText = comment.m;\\n        if (paramText == null || commentText == null) continue;\\n        let params = paramText.split(\\\",\\\");\\n        let paramsT = [];\\n        for (let i in params) {\\n            /*if (i == 0) {\\n                paramsT.push(parseInt(params[i]));\\n                continue;\\n            }*/\\n            if (i == 2) {\\n                paramsT.push(\\\"25\\\");\\n            }\\n            if (i == 3) {\\n                //颜色值为0时，默认设置为白色\\n                if (params[i] == \\\"0\\\" || params[i] == \\\"-1\\\") {\\n                    paramsT.push(\\\"16777215\\\");\\n                    continue\\n                }\\n                break;\\n            }\\n            paramsT.push(params[i]);\\n        }\\n        paramsT.push(\\\"0\\\");\\n        let times=parseInt(params[0]/60)+\\\":\\\"+parseInt(params[0]%60);\\n        dMcontext += `<d p=\\\"${paramsT.join(',')}\\\">${encodeHtml(commentText)+\\\"#\\\"+times}</d>\\\\n`;\\n    }\\n    if (!dMcontext) return;\\n    dMcontext = `<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?><i>\\\\n${dMcontext}</i>`;\\n    let path = sevePath + name.replace(/\\\\//g, \\\"_\\\") + \\\"_\\\" + episodeId + \\\".xml\\\";\\n    writeFile(path, dMcontext);\\n    return path;\\n}\\n$.exports.getLocalDanMu = function(episodeId, name) {\\n    let path = sevePath + name.replace(/\\\\//g, \\\"_\\\") + \\\"_\\\" + episodeId + \\\".xml\\\";\\n    if (fileExist(path)) {\\n        return path;\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"弹幕搜索&加载\",\"path\":\"loadDm\",\"rule\":\"js:\\nlet d = [];\\nlet onlyDownload = !!MY_PARAMS.onlyDownload;\\nif (onlyDownload) {\\n    addListener(\\\"onClose\\\", () => {\\n        refreshPage(false);\\n    });\\n}\\nd.push({\\n    col_type: \\\"rich_text\\\",\\n    title: \\\"<font color='Gray'>❗关于<br><small> 内置搜索P数据来源于[弹弹play]</small></font>\\\"\\n});\\nd.push({\\n    col_type: \\\"line\\\"\\n});\\nlet key = MY_PARAMS.name || getMyVar(\\\"s\\\") || decodeURIComponent(getParam(\\\"title\\\", \\\"\\\")) || \\\"\\\";\\nd.push({\\n    title: \\\"内置搜索P\\\",\\n    url: $(key, \\\"请搜索番剧名称\\\").input((MY_PARAMS) => {\\n        setPageParams(Object.assign(MY_PARAMS, {\\n            name: input,\\n        }));\\n        refreshPage();\\n    }, MY_PARAMS),\\n    col_type: \\\"text_3\\\"\\n});\\nd.push({\\n    title: \\\"内置搜索T\\\",\\n    url: $(key, \\\"格式：搜索关键词[回车]集数\\\").input((onlyDownload) => {\\n        try {\\n            showLoading(\\\"正在搜索并下载...\\\");\\n            let [name, pos] = input.split(\\\"\\\\n\\\");\\n            if (!name || !pos) {\\n                throw \\\"格式错误\\\";\\n            }\\n            let urlInfo = fetch(buildUrl(\\\"https://azure.leuse.top/searchdm\\\", {\\n                params: {\\n                    \\\"name\\\": name,\\n                    \\\"pos\\\": pos\\n                }\\n            }));\\n            urlInfo = JSON.parse(urlInfo);\\n            if (!urlInfo.url) throw \\\"暂时没有找到该视频的弹幕\\\";\\n            let xml = fetch(buildUrl(\\\"https://azure.leuse.top/danmu\\\", {\\n                params: urlInfo\\n            }));\\n            hideLoading();\\n            if (!xml) {\\n                throw \\\"还没有弹幕哟~\\\";\\n            }\\n            let path = \\\"hiker://files/cache/danmu/\\\" + urlInfo.platform + \\\"_\\\" + name + \\\"_\\\" + pos + \\\".xml\\\";\\n            writeFile(path, '<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n' + xml);\\n            if (onlyDownload) return \\\"toast://下载完成\\\";\\n            refreshVideoUrl({\\n                danmu: path\\n            });\\n            back(false);\\n            return \\\"toast://加载完成\\\";\\n        } catch (e) {\\n            hideLoading();\\n            return \\\"toast://\\\" + e.toString();\\n        }\\n    }, onlyDownload),\\n    col_type: \\\"text_3\\\"\\n});\\nd.push({\\n    title: \\\"dm盒子搜索\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((key, onlyDownload) => {\\n        let dm = getVar(\\\"dm_share\\\");\\n        if (dm && !onlyDownload) {\\n            clearVar(\\\"dm_share\\\");\\n            refreshVideoUrl({\\n                danmu: dm\\n            });\\n            back(false);\\n            return \\\"toast://加载完成\\\";\\n        } else {\\n            return $(key, \\\"dm盒子搜索\\\").input(() => {\\n                toast(\\\"下载完成弹幕后请重新点击搜索\\\");\\n                return \\\"hiker://search?rule=dm盒子&s=\\\" + input;\\n            });\\n        }\\n    }, key, onlyDownload),\\n    col_type: \\\"text_3\\\"\\n});\\n\\nfunction search(d, name) {\\n    const danmu = $.require(\\\"danmu\\\");\\n    d.push({\\n        col_type: \\\"line\\\"\\n    });\\n    d.push({\\n        col_type: \\\"line\\\"\\n    });\\n    d.push({\\n        col_type: \\\"line\\\"\\n    });\\n    let dmList = danmu.getDanMu(name);\\n\\n    for (let anime of dmList.animes) {\\n        d.push({\\n            title: anime.animeTitle,\\n            desc: anime.typeDescription,\\n            col_type: \\\"avatar\\\",\\n            url: $(\\\"\\\", \\\"请输入下载范围(1,\\\" + anime.episodes.length + \\\")\\\").input((animeTitle, episodes) => {\\n                let [a, b] = input.split(/,|，/);\\n                a = Number(a), b = Number(b);\\n                if (Number.isNaN(a) || Number.isNaN(b)) {\\n                    return \\\"toast://请按格式输入数字\\\";\\n                }\\n                if (a < 1 || b > episodes.length) {\\n                    return \\\"toast://请输入规定范围内的数字\\\";\\n                }\\n                const danmu = $.require(\\\"danmu\\\");\\n                try {\\n                    for (let i = a - 1, j = 1; i < b; i++, j++) {\\n                        let episode = episodes[i];\\n                        let dmTitle = animeTitle + \\\"_\\\" + episode.episodeTitle;\\n                        showLoading(\\\"正在下载：\\\" + episode.episodeTitle + \\\"\\\\t(\\\" + j + \\\"/\\\" + (b - a + 1) + \\\")\\\");\\n                        danmu.downloadDanMu(episode.episodeId, dmTitle);\\n                    }\\n                } catch (e) {\\n                    log(e.toString());\\n                    hideLoading();\\n                    return \\\"toast://哦哦下载失败...\\\";\\n                }\\n                hideLoading();\\n                return \\\"toast://下载完成\\\";\\n            }, anime.animeTitle, anime.episodes),\\n            pic_url: \\\"https://hikerfans.com/tubiao/movie/14.svg\\\"\\n        });\\n        d.push({\\n            col_type: \\\"line\\\"\\n        });\\n        for (let episode of anime.episodes) {\\n            let dmTitle = anime.animeTitle + \\\"_\\\" + episode.episodeTitle;\\n            d.push({\\n                title: episode.episodeTitle,\\n                url: $(episode.episodeId).lazyRule((url, title, onlyDownload) => {\\n                    const danmu = $.require(\\\"danmu\\\");\\n                    let path = danmu.getLocalDanMu(input, title) || danmu.downloadDanMu(input, title);\\n                    if (onlyDownload) return \\\"toast://下载完成\\\";\\n                    let danmuText = fetch(path);\\n                    if (!danmuText) return \\\"toast://还没有弹幕哟~\\\";\\n                    refreshVideoUrl({\\n                        danmu: path\\n                    });\\n                    back(false);\\n                    return \\\"toast://加载完成\\\";\\n                }, MY_PARAMS.durl, dmTitle, onlyDownload),\\n                col_type: \\\"text_1\\\",\\n                extra: {\\n                    longClick: [{\\n                        title: \\\"强制下载\\\",\\n                        js: $.toString((episodeTitle, episodeId) => {\\n                            showLoading(\\\"请等待\\\");\\n                            const danmu = $.require(\\\"danmu\\\");\\n                            danmu.downloadDanMu(episodeId, episodeTitle);\\n                            hideLoading();\\n                            return \\\"toast://重新下载完成，单击挂载。\\\";\\n                        }, dmTitle, episode.episodeId)\\n                    }]\\n                }\\n            });\\n        }\\n        d.push({\\n            col_type: \\\"line_blank\\\"\\n        });\\n    }\\n    if (!dmList.animes.length) {\\n        d.push({\\n            title: \\\"没有找到与[\\\" + name + \\\"]相关的弹幕\\\",\\n            url: \\\"hiker://empty\\\",\\n            desc: \\\"搜不到怎么办？\\\\n检查名称是否正确；可以尝试删除部分限定词，如第一季等；而且只能搜索番剧哦！其他弹幕可用dm盒子。\\\",\\n            col_type: \\\"text_center_1\\\"\\n        });\\n    }\\n}\\nlet name = getParam(\\\"name\\\", MY_PARAMS.name);\\nif (name) {\\n    try {\\n        search(d, name);\\n    } catch (e) {\\n        d.push({\\n            title: \\\"““ERROR””\\\",\\n            desc: e.toString(),\\n            col_type: \\\"text_1\\\"\\n        });\\n    }\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"公开工具\",\"path\":\"aliUtil\",\"rule\":\"//提供给规则使用的常用函数\\n$.exports = {\\n    checkali(realurl) {\\n        try {\\n            if (realurl.includes(\\\"com/s/\\\") && realurl != \\\"\\\") {\\n                let shareId = realurl.split(\\\"?\\\")[0].split(\\\"/\\\")[4];\\n                let share = fetch(\\\"https://api.aliyundrive.com/adrive/v3/share_link/get_share_by_anonymous\\\", {\\n                    headers: {\\n                        'content-type': 'application/json',\\n                        \\\"User-Agent\\\": PC_UA,\\n                        \\\"Referer\\\": \\\"https://www.aliyundrive.com/\\\"\\n                    },\\n                    body: {\\n                        \\\"share_id\\\": shareId\\n                    },\\n                    method: 'POST'\\n                });\\n                if (share.includes(\\\"share_link is\\\") || share.includes(\\\"share_link cannot\\\")) return false;\\n            }\\n        } catch (e) {}\\n        return true;\\n    },\\n    bytesToSize(size) {\\n        if (!size) {\\n            return '0';\\n        }\\n        const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\\n        let i = 0;\\n        while (size >= 1024) {\\n            size /= 1024;\\n            i++;\\n        }\\n        size = i ? Number(size.toFixed(2)) : size;\\n        return `${size} ${units[i]}`;\\n    },\\n    getCryptoJS() {\\n        if (typeof CryptoJS === \\\"undefined\\\") {\\n            eval(getCryptoJS());\\n            return CryptoJS;\\n        }\\n        return CryptoJS;\\n    },\\n    matchAliUrl(text, isG) {\\n        return $.require(\\\"alitest\\\").matchAliUrl(text, isG);\\n    },\\n    getIPv4Address() {\\n        const NetworkInterface = java.net.NetworkInterface;\\n        try {\\n            for (let en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements();) {\\n                let intf = en.nextElement();\\n                for (let enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements();) {\\n                    let inetAddress = enumIpAddr.nextElement();\\n                    if (!inetAddress.isLoopbackAddress() && inetAddress instanceof java.net.Inet4Address) {\\n                        return String(inetAddress.getHostAddress());\\n                    }\\n                }\\n            }\\n        } catch (ex) {\\n            log(ex.toString());\\n        }\\n        return \\\"0.0.0.0\\\";\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"弹幕批量挂载\",\"path\":\"dmMount\",\"rule\":\"js:\\nlet d = [];\\naddListener(\\\"onClose\\\", () => clearMyVar(\\\"dllastTime\\\"));\\nsetPageTitle(\\\"弹幕挂载:\\\"+(MY_PARAMS.folderName||\\\"?\\\"));\\nd.push({\\n    title: \\\"清空挂载列表\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        clearMyVar(\\\"dmlist\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }),\\n    col_type: \\\"text_3\\\",\\n});\\nif(!MY_PARAMS.automaticadd){\\n    MY_PARAMS.automaticadd = getItem(\\\"automaticadd\\\",\\\"1\\\");\\n    setPageParams(MY_PARAMS);\\n}\\nd.push({\\n    title: \\\"检测新增:\\\"+[\\\"关闭\\\",\\\"开启\\\"][MY_PARAMS.automaticadd||\\\"0\\\"],\\n    url: $(\\\"#noLoading#\\\").lazyRule((v) => {\\n       setItem(\\\"automaticadd\\\", v.automaticadd===\\\"1\\\"?\\\"0\\\":\\\"1\\\");\\n       v.automaticadd = undefined;\\n       setPageParams(v);\\n       refreshPage(false);\\n       return \\\"hiker://empty\\\";\\n    }, MY_PARAMS),\\n    col_type: \\\"text_3\\\",\\n});\\nd.push({\\n    title: \\\"下载弹幕\\\",\\n    col_type: \\\"text_3\\\",\\n    url: \\\"hiker://page/loadDm#noHistory##noRecordHistory#\\\",\\n    extra: {\\n        onlyDownload: true\\n    }\\n});\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    title: \\\"““””\\\" + \\\"已挂载\\\".big(),\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        let dmlist = storage0.getMyVar(\\\"dmlist\\\", []);\\n        let FileSorting = $.require(\\\"FileSorting\\\");\\n        dmlist.sort((a, b) => FileSorting.nameCompare(a, b));\\n        storage0.putMyVar(\\\"dmlist\\\", dmlist);\\n        refreshPage(false);\\n        return \\\"toast://排序完成\\\";\\n    }),\\n    col_type: \\\"text_center_1\\\"\\n});\\nlet file = $.require(\\\"https://hikerfans.com/weisyr/js/file.js?v=1\\\");\\nlet dmlist = storage0.getMyVar(\\\"dmlist\\\", []);\\n\\nfor (let i = 0; i < dmlist.length; i++) {\\n    let dmname = dmlist[i];\\n    d.push({\\n        title: \\\"[\\\" + (i + 1) + \\\"]\\\\t\\\" + dmname,\\n        url: $(\\\"#noLoading#\\\").lazyRule((i) => {\\n            let dmlist = storage0.getMyVar(\\\"dmlist\\\", []);\\n            dmlist.splice(i, 1);\\n            storage0.putMyVar(\\\"dmlist\\\", dmlist);\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, i),\\n        col_type: \\\"text_1\\\"\\n    });\\n}\\nd.push({\\n    col_type: \\\"line_blank\\\"\\n});\\nd.push({\\n    title: \\\"““””\\\" + \\\"本地未挂载\\\".big(),\\n    url: $(\\\"是否清除所有本地弹幕文件?\\\\n(弹幕文件每三天会自动清除)\\\").confirm(() => {\\n        let file = $.require(\\\"https://hikerfans.com/weisyr/js/file.js?v=1\\\");\\n        file.deleteFiles(getPath(\\\"hiker://files/cache/danmu/\\\").slice(7));\\n        clearMyVar(\\\"dmlist\\\");\\n        refreshPage(false);\\n        return \\\"toast://已删除\\\";\\n    }),\\n    col_type: \\\"text_center_1\\\"\\n});\\nlet dmListPath = getPath(\\\"hiker://files/cache/danmu/\\\").slice(7);\\nlet fileList = file.getFilePath(dmListPath, \\\"file\\\", \\\".xml\\\");\\nlet lastTime = 0;\\n\\nfor (let i = 0; i < fileList.length; i++) {\\n    let dmfile = fileList[i];\\n    lastTime = Math.max(lastTime, dmfile.lastModified);\\n    if (dmlist.includes(dmfile.name)) continue;\\n    d.push({\\n        title: dmfile.name,\\n        url: $(\\\"#noLoading#\\\").lazyRule((name) => {\\n            let dmlist = storage0.getMyVar(\\\"dmlist\\\", []);\\n            if (!dmlist.includes(name)) {\\n                dmlist.push(name);\\n            }\\n            storage0.putMyVar(\\\"dmlist\\\", dmlist);\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        }, dmfile.name),\\n        col_type: \\\"text_1\\\"\\n    });\\n}\\nlet lastRecord = Number(getMyVar(\\\"dllastTime\\\", \\\"-1\\\"));\\n\\nif (MY_PARAMS.automaticadd===\\\"1\\\"&&lastRecord!=-1&&lastRecord < lastTime) {\\n    confirm({\\n        title: \\\"新弹幕文件\\\",\\n        content: \\\"检查到新下载的弹幕是否全部挂载？\\\",\\n        confirm: $.toString((lastRecord, dmListPath) => {\\n            let file = $.require(\\\"https://hikerfans.com/weisyr/js/file.js?v=1\\\");\\n            let fileList = file.getFilePath(dmListPath, \\\"file\\\", \\\".xml\\\");\\n            let dmlist = storage0.getMyVar(\\\"dmlist\\\", []);\\n            fileList.forEach(v => {\\n                if (!dmlist.includes(v.name)&&v.lastModified > lastRecord) {\\n                    dmlist.push(v.name);\\n                }\\n            });\\n            storage0.putMyVar(\\\"dmlist\\\", dmlist);\\n            refreshPage(false);\\n            return \\\"toast://挂载成功。\\\";\\n        }, lastRecord, dmListPath),\\n    });\\n}\\nif(lastTime>=0){\\n    putMyVar(\\\"dllastTime\\\", \\\"\\\" + lastTime);\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"主页处理\",\"path\":\"Main\",\"rule\":\"if (getItem(\\\"first\\\") == MY_RULE.version) {\\n    $.require(\\\"sou\\\");\\n} else if (MY_PAGE === 1) {\\n    let d = []\\n    let time = getItem(\\\"first\\\", \\\"\\\") ? 6 : 20;\\n    let id = Date.now();\\n    d.push({\\n        title: \\\"““””<strong>使用前须知</strong>\\\".big(),\\n        col_type: \\\"text_center_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n    d.push({\\n        title: \\\"1. 本小程序所有代码全部开源，且本规则为学习目的，请于导入24小时内删除！！！<br>2. 本小程序<b>完全免费</b>，如果你是付费购买的恭喜你被骗了。<br>当然如果有能力想鼓励作者的可以<a href='hiker://page/Donate.v#noHistory##noRecordHistory#'>支持一下</a>(<small>点击可进入捐赠，可在主页菜单进入</small>)。<br>3. 本小程序是在原版「云盘君」的基础进行的二次修改，请支持原版。<br>4. 请「云盘君.简」的二次修改尊重一下原版，谢谢。<br><br><b>开始使用本规则即代表遵守规则条例</b><br>当前版本：\\\" + MY_RULE.version,\\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    });\\n    setResult(d);\\n    while (time != 0) {\\n        java.lang.Thread.sleep(1000);\\n        time -= 1;\\n        updateItem(id + \\\"timer\\\", {\\n            title: time + \\\"秒后继续\\\"\\n        });\\n    }\\n    updateItem(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    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"捐赠\",\"path\":\"Donate.v\",\"rule\":\"js:\\nlet d = [];\\nsetPageTitle(\\\"捐赠/支持\\\");\\nd.push({\\n    title: \\\"捐赠/支持\\\",\\n    desc: \\\"这个捐赠不能为你带来特权，但您的支持是我更新创作的动力。\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"toast://感谢您的支持\\\"\\n});\\nd.push({\\n    col_type: \\\"pic_1_full\\\",\\n    url: \\\"https://gitee.com/LoyDgIk/LoyDgIk_Rule/raw/master/67d8f0187f0186c1.png\\\",\\n    pic_url: \\\"https://gitee.com/LoyDgIk/LoyDgIk_Rule/raw/master/67d8f0187f0186c1.png\\\"\\n});\\nd.push({\\n    col_type: \\\"text_center_1\\\",\\n    title: \\\"““””\\\" + \\\"图片加载缓慢请稍等\\\".small().fontcolor(\\\"Gray\\\"),\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"TVBOX推送\",\"path\":\"tvboxPush\",\"rule\":\"js:\\n(function() {\\n    let d = [];\\n    const {\\n        pageId,\\n        shareId,\\n        folderName,\\n        fileId\\n    } = MY_PARAMS;\\n    setPageTitle(\\\"TVBOX推送:\\\" + folderName);\\n    const {\\n        aliTokensFilepath\\n    } = $.require(\\\"tokenPath\\\");\\n    let refreshToken = \\\"\\\";\\n    if (!fileExist(aliTokensFilepath)) {\\n        toast(\\\"请先登陆登录账号\\\");\\n        back(false);\\n        return;\\n    } else {\\n        refreshToken = $.require(aliTokensFilepath).refresh_token;\\n    }\\n\\n    function getPush(name, url) {\\n        let push = {\\n            \\\"share_id\\\": shareId,\\n            \\\"refresh_token\\\": refreshToken,\\n            \\\"name\\\": name,\\n            \\\"url\\\": url\\n        };\\n        return \\\"hiker://page/push#noHistory##noRecordHistory#?rule=XYQ推送&pushurl=\\\" + encodeURIComponent(JSON.stringify(push));\\n    }\\n    d.push({\\n        title: \\\"推送阿里分享链接\\\",\\n        url: \\\"hiker://page/push#noHistory##noRecordHistory#?rule=XYQ推送&pushurl=\\\" + encodeURIComponent(\\\"https://www.aliyundrive.com/s/\\\" + shareId + (fileId ? \\\"/folder/\\\" + fileId : \\\"\\\")),\\n        col_type: \\\"text_2\\\",\\n        extra: {\\n            inheritTitle: false\\n        }\\n    });\\n    let all = {\\n        title: \\\"推送全部已加载视频\\\",\\n        col_type: \\\"text_2\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n            inheritTitle: false\\n        }\\n    }\\n    d.push(all);\\n    let allUrls = [];\\n    let list = findItemsByCls(\\\"v\\\" + pageId);\\n    if (!Array.isArray(list) || list.length === 0) {\\n        /*toast(\\\"还没有加载完成的视频\\\");\\n        back(false);\\n        return;*/\\n        d.push({\\n            title: \\\"““””\\\" + \\\"~~~还木有视频哦~~~\\\".fontcolor(\\\"grey\\\"),\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n        all.url = \\\"toast://没有视频无法推送\\\";\\n    } else {\\n        list.forEach(v => {\\n            v.col_type = v.type;\\n            let name = v.extra.pageTitle;\\n            let url = name.replace(/\\\\#/g, '_').replace(/\\\\$/g, '_') + \\\"$video|\\\" + v.extra.id;\\n            allUrls.push(url);\\n            v.url = getPush(name, url);\\n            v.extra.cls = v.extra.id = undefined;\\n            d.push(v);\\n        });\\n        all.url = getPush(folderName, allUrls.join(\\\"#\\\"));\\n    }\\n    setResult(d);\\n})();\"},{\"col_type\":\"movie_3\",\"name\":\"封面搜索\",\"path\":\"frontCover\",\"rule\":\"js:\\nlet d = [];\\nlet key = getMyVar(\\\"frontcoverkey\\\", \\\"\\\");\\nd.push({\\n    title: \\\"搜索\\\",\\n    col_type: \\\"input\\\",\\n    url: $.toString(() => {\\n        putMyVar(\\\"frontcoverkey\\\", input.trim());\\n        refreshPage(false);\\n    }),\\n    extra: {\\n        defaultValue: key || getMyVar(\\\"s\\\", \\\"\\\")\\n    }\\n});\\nif (key) {\\n    let r = request('https://m.douban.com/search/?query=' + encodeURIComponent(key))\\n    let list = pdfa(r, \\\".search-results&&img\\\");\\n    for (let it of list) {\\n        let pic = pdfh(it, \\\"img&&src\\\");\\n        d.push({\\n            pic_url: pic,\\n            url: $(\\\"#noLoading#\\\").lazyRule((pic) => {\\n                putMyVar(\\\"frontcoverpic\\\", pic);\\n                back(false);\\n                return \\\"toast://设置成功\\\";\\n            }, pic),\\n            col_type: \\\"pic_2_card\\\"\\n        });\\n    }\\n\\n}\\naddListener(\\\"onClose\\\", () => {\\n    let pic = getMyVar(\\\"frontcoverpic\\\");\\n    clearMyVar(\\\"frontcoverpic\\\");\\n    clearMyVar(\\\"frontcoverkey\\\");\\n    setPagePicUrl(pic);\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"规则文件\",\"path\":\"configs\",\"rule\":\"const path = \\\"hiker://files/rules/LoyDgIk/aliSimpleRules.json\\\";\\nlet data;\\n\\nfunction getJson() {\\n    if (Array.isArray(data)) {\\n        return data;\\n    }\\n    try {\\n        data = JSON.parse(readFile(path) || \\\"[]\\\");\\n    } catch (e) {\\n        deleteFile(path);\\n        data = [];\\n    }\\n    return data;\\n}\\n\\nfunction saveJson(json) {\\n    saveFile(path, JSON.stringify(json));\\n}\\n\\nfunction getUsefulJson() {\\n    return getJson().filter(v => !v.forbidden);\\n}\\n\\nfunction getForbiddenJson() {\\n    return getJson().filter(v => v.forbidden);\\n}\\n\\nfunction getGroupJson(group) {\\n    return getJson().filter(v => v.group === group);\\n}\\n\\nfunction getGroupNames() {\\n    return Array.from(new Set(getJson().map(v => v.group))).filter(v => v);\\n}\\n\\nif (!fileExist(path) && MY_RULE) {\\n    let rules = $.require(\\\"rules\\\");\\n    $.hiker.window = {};\\n    eval.call(null, fetch('hiker://assets/beautify.js'));\\n    rules = rules.map((v) => {\\n        v.find = window.js_beautify(v.find.toString().replace(/function.*?\\\\(s.*?page\\\\).*?\\\\{/, \\\"\\\").replace(/(\\\\}[\\\\s\\\\S].*?)$/, \\\"\\\"));\\n        if (v.findAliUrl) {\\n            v.findAliUrl = window.js_beautify(v.findAliUrl.toString().replace(/function.*?\\\\(input\\\\).*?\\\\{/, \\\"\\\").replace(/(\\\\}[\\\\s\\\\S].*?)$/, \\\"\\\"));\\n        }\\n        return v;\\n    });\\n    saveJson(rules);\\n    toast(\\\"已初始化\\\");\\n}\\n$.exports = {\\n    getJson,\\n    saveJson,\\n    getUsefulJson,\\n    getForbiddenJson,\\n    path,\\n    getGroupNames,\\n    getGroupJson\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"规则管理\",\"path\":\"ruleManage\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle(\\\"规则管理\\\");\\nlet configs = $.require(\\\"configs\\\");\\nlet arr = configs.getJson();\\nlet length = arr.length;\\nlet groups = configs.getGroupNames();\\nlet group = getItem(\\\"ruleManage_group\\\", \\\"\\\");\\nif (!groups.includes(group)) {\\n    clearItem(\\\"ruleManage_group\\\");\\n    group = \\\"\\\";\\n}\\nd.push({\\n    title: \\\"新增\\\",\\n    url: \\\"hiker://page/ruleEdit#noRecordHistory##noHistory##noRefresh#\\\",\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_domain_config\\\",\\n    extra: {\\n        pageTitle: \\\"新增规则\\\"\\n    }\\n});\\n\\nd.push({\\n    title: \\\"分享\\\",\\n    url: $(\\\"-1\\\", \\\"输入你要分享规则的序号\\\\n-1全部，-2已启用的，-3已禁用的，-4,组名分享组，多个用'，'隔开\\\").input((length) => {\\n        let indexc = input.split(/,|，/);\\n        let indexs = [];\\n        let mo = parseInt(indexc[0]);\\n        if (!(indexc.length !== 0 && mo < 0 && mo > -5)) {\\n            for (let it of indexc) {\\n                let num = parseInt(it);\\n                if (Number.isNaN(num) || num >= length || num < 0) {\\n                    return \\\"toast://数字不合法\\\";\\n                }\\n                indexs.push(num);\\n            }\\n        }\\n        return $([\\\"HIKER\\\", \\\"TXT\\\"].concat(getPastes()), 2, \\\"分享方式\\\").select((mo, indexs, ext) => {\\n            function up(rules) {\\n                let ruleb64 = base64Encode(JSON.stringify(rules));\\n                let getPass = (length, rule, type) => \\\"海阔视界云简搜索引擎，共「\\\" + length + \\\"」条，复制整条口令打开软件就会自动导入$\\\" + rule + \\\"$\\\" + type + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input)\\\";\\n                if (getPastes().includes(input)) {\\n                    let u = sharePaste(ruleb64, input);\\n                    return \\\"copy://\\\" + getPass(rules.length, u, \\\"b\\\");\\n                } else {\\n                    let path = \\\"hiker://files/rules/LoyDgIk/share/云简搜索引擎规则「\\\" + rules.length + \\\"」条.\\\" + (input === \\\"HIKER\\\" ? \\\"hiker\\\" : \\\"txt\\\");\\n                    writeFile(path, getPass(rules.length, ruleb64, \\\"a\\\"));\\n                    return \\\"share://\\\" + path;\\n                }\\n            }\\n            let rules;\\n            if (mo === -1) {\\n                rules = $.require(\\\"configs\\\").getJson();\\n            } else if (mo === -2) {\\n                rules = $.require(\\\"configs\\\").getUsefulJson();\\n            } else if (mo === -3) {\\n                rules = $.require(\\\"configs\\\").getForbiddenJson();\\n            } else if (mo === -4) {\\n                let group = ext;\\n                rules = $.require(\\\"configs\\\").getGroupJson(ext);\\n                if (!rules.length) return \\\"toast://不存在该组\\\";\\n            } else {\\n                rules = $.require(\\\"configs\\\").getJson().filter((v, i) => indexs.includes(i));\\n            }\\n            rules = rules.map((v) => {\\n                v.user = undefined;\\n                v.forbidden = undefined;\\n                return v;\\n            });\\n            return up(rules);\\n        }, mo, indexs, indexc[1]);\\n\\n    }, length),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_share_green\\\"\\n});\\nd.push({\\n    title: \\\"重置\\\",\\n    url: $(\\\"你确定重置？\\\\n该操作会删除现有规则，恢复自带规则。\\\").confirm((path) => {\\n        deleteFile(path);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, $.require(\\\"configs\\\").path),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_refresh\\\"\\n});\\nd.push({\\n    title: \\\"清空\\\",\\n    url: $(\\\"你确定全部删除？\\\\n该操作会删除现有规则。\\\").confirm((path) => {\\n        writeFile(path, \\\"[]\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }, $.require(\\\"configs\\\").path),\\n    col_type: \\\"icon_small_4\\\",\\n    pic_url: \\\"hiker://images/icon_code_view\\\"\\n});\\n\\nd.push({\\n    //title: '<font color=\\\"#13B61B\\\">▐ </font><b>规则列表<b> (' + String(length).fontcolor(\\\"#ff6601\\\") + \\\")\\\",\\n    col_type: \\\"rich_text\\\",\\n});\\nlet countTitle = d.at(-1);\\nd.push({\\n    title: group ? \\\"全部\\\" : \\\"““全部””\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((group, length) => {\\n        if (group) {\\n            clearItem(\\\"ruleManage_group\\\");\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\";\\n        } else {\\n            return $(\\\"\\\", \\\"批量删除\\\\n格式:开始位置，结束位置(区间[0,\\\" + (length - 1) + \\\"])\\\").input((length) => {\\n                let [start, end] = input.split(/,|，/);\\n                start = parseInt(start), end = parseInt(end);\\n                if (Number.isNaN(start) || Number.isNaN(end) || start < 0 || end > length - 1 || start > end) {\\n                    return \\\"toast://数字不合法\\\";\\n                }\\n                let number = end - start + 1;\\n                return $(\\\"确认删除：[\\\" + start + \\\",\\\" + end + \\\"]\\\\n共\\\" + number + \\\"条搜索引擎\\\").confirm((start, number) => {\\n                    let rules = $.require(\\\"configs\\\").getJson();\\n                    rules.splice(start, number);\\n                    $.require(\\\"configs\\\").saveJson(rules);\\n                    refreshPage(false);\\n                }, start, number);\\n            }, length);\\n        }\\n    }, group, length),\\n    col_type: \\\"scroll_button\\\"\\n});\\nfor (let it of groups) {\\n    d.push({\\n        title: it === group ? \\\"““\\\" + it + \\\"””\\\" : it,\\n        url: $(\\\"#noLoading#\\\").lazyRule((it, group) => {\\n            if (group !== it) {\\n                setItem(\\\"ruleManage_group\\\", it);\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n            } else {\\n                return $([\\\"置顶\\\", \\\"置底\\\", \\\"改名\\\", \\\"删除\\\"]).select((it) => {\\n                    if (\\\"改名\\\" === input) {\\n                        return $(it, \\\"请输入新名称\\\").input((it) => {\\n                            let rules = $.require(\\\"configs\\\").getJson();\\n                            rules.forEach(v => {\\n                                if (it === v.group) {\\n                                    v.group = input;\\n                                }\\n                            });\\n                            $.require(\\\"configs\\\").saveJson(rules);\\n                            clearItem(\\\"ruleManage_group\\\");\\n                            refreshPage(false);\\n                        }, it);\\n                    } else if (\\\"删除\\\" === input) {\\n                        return $(\\\"是否删除该组搜索引擎：\\\" + it).confirm((it) => {\\n                            let rules = $.require(\\\"configs\\\").getJson();\\n                            rules = rules.filter(v => v.group !== it);\\n                            $.require(\\\"configs\\\").saveJson(rules);\\n                            clearItem(\\\"ruleManage_group\\\");\\n                            refreshPage(false);\\n                        }, it);\\n                    }\\n                    let rules = $.require(\\\"configs\\\").getJson();\\n                    let tgRules = [],\\n                        txRules = [];\\n                    rules.forEach((v) => {\\n                        if (it === v.group) {\\n                            tgRules.push(v);\\n                        } else {\\n                            txRules.push(v);\\n                        }\\n                    });\\n                    if (input === \\\"置顶\\\") {\\n                        tgRules = tgRules.concat(txRules);\\n                    } else {\\n                        tgRules = txRules.concat(tgRules);\\n                    }\\n                    $.require(\\\"configs\\\").saveJson(tgRules);\\n                    refreshPage(false);\\n                }, it);\\n            }\\n\\n        }, it, group),\\n        col_type: \\\"scroll_button\\\"\\n    });\\n}\\n\\nlet count = d.length;\\n\\nfor (let i = 0; i < length; i++) {\\n    let it = arr[i];\\n    if (group && group !== it.group) continue;\\n    let user = it.user || {};\\n\\n    d.push({\\n        title: '““””[' + i + ']<b>  ' + it.name + (it.group ? \\\"|\\\" + it.group.small() : \\\"\\\") + '<b>' + (it.forbidden ? \\\" #““禁用””\\\".small() : \\\"\\\") + (it.registerUrl && !(user.password || user.account || user.extra) ? \\\" #需要登录\\\".small() : \\\"\\\"),\\n        url: $([\\\"编辑\\\", \\\"账号\\\", \\\"分享\\\", \\\"禁用/启用\\\", \\\"移动\\\", \\\"置顶\\\"], 1, \\\"操作：\\\" + it.name).select((index, length, group) => {\\n            if (input === \\\"编辑\\\") {\\n                return \\\"hiker://page/ruleEdit#noRecordHistory##noHistory##noRefresh#\\\";\\n            } else if (input === \\\"账号\\\") {\\n                return \\\"hiker://page/password#noRecordHistory##noHistory##noRefresh#\\\";\\n            } else if (input === \\\"分享\\\") {\\n                let ops = getPastes();\\n                ops.unshift(\\\"完整口令\\\");\\n                return $(ops, 2, \\\"分享方式\\\").select((index) => {\\n                    let rule = $.require(\\\"configs\\\").getJson()[index];\\n                    rule.user = undefined;\\n                    rule.forbidden = undefined;\\n                    let ruleb64 = base64Encode(JSON.stringify(rule));\\n                    let getPass = (name, rule, type) => \\\"海阔视界，「\\\" + name + \\\"」云简搜索引擎，复制整条口令打开软件就会自动导入$\\\" + rule + \\\"$\\\" + type + \\\"@import=js:$.require('import?rule='+\\\" + JSON.stringify(MY_RULE.title) + \\\")(input)\\\";\\n                    if (input == \\\"完整口令\\\") {\\n                        return \\\"copy://\\\" + getPass(rule.name, ruleb64, \\\"a\\\");\\n                    } else {\\n                        let u = sharePaste(ruleb64, input);\\n                        return \\\"copy://\\\" + getPass(rule.name, u, \\\"b\\\");\\n                    }\\n                }, index);\\n            } else if (input === \\\"移动\\\") {\\n                return $(index + \\\"\\\", \\\"输入位置\\\").input((index, length) => {\\n                    let newIndex = Number(input);\\n                    if (Number.isNaN(newIndex) || newIndex >= length) {\\n                        return \\\"toast://不和规的位置\\\";\\n                    }\\n                    let rules = $.require(\\\"configs\\\").getJson();\\n                    let rule = rules.splice(index, 1)[0];\\n                    rules.splice(newIndex, 0, rule);\\n                    $.require(\\\"configs\\\").saveJson(rules);\\n                    refreshPage(false);\\n                }, index, length);\\n            } else if (input === \\\"置顶\\\") {\\n                let newIndex = 0;\\n                let rules = $.require(\\\"configs\\\").getJson();\\n                if (group) {\\n                    newIndex = rules.findIndex(v => v.group === group);\\n                    newIndex = newIndex === -1 ? 0 : newIndex;\\n                }\\n                let rule = rules.splice(index, 1)[0];\\n                rules.splice(newIndex, 0, rule);\\n                $.require(\\\"configs\\\").saveJson(rules);\\n                refreshPage(false);\\n            } else {\\n                let arr = $.require(\\\"configs\\\").getJson();\\n                let rule = arr[index];\\n                rule.forbidden = !rule.forbidden;\\n                $.require(\\\"configs\\\").saveJson(arr);\\n                refreshPage(false);\\n                //return \\\"toast://\\\" + (rule.forbidden ? \\\"禁用\\\" : \\\"启用\\\") + rule.name;\\n            }\\n        }, i, length, group),\\n        col_type: \\\"text_1\\\",\\n        extra: {\\n            i: i,\\n            pageTitle: it.name\\n        }\\n    });\\n}\\ncountTitle.title = '<font color=\\\"#13B61B\\\">▐ </font><b>规则列表<b> (' + ((d.length - count) + \\\"/\\\" + length).fontcolor(\\\"#ff6601\\\") + \\\")\\\";\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"规则编辑\",\"path\":\"ruleEdit\",\"rule\":\"js:\\nvar d = [];\\n\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    clearMyVar(\\\"ps_name\\\");\\n    clearMyVar(\\\"ps_find\\\");\\n    clearMyVar(\\\"ps_findAliUrl\\\");\\n    clearMyVar(\\\"ps_page\\\");\\n    clearMyVar(\\\"ps_registerUrl\\\");\\n    clearMyVar(\\\"ps_basicUrl\\\");\\n    clearMyVar(\\\"ps_group\\\");\\n}));\\nlet urlIndex = parseInt(getParam(\\\"index\\\", \\\"\\\"));\\nurlIndex = Number.isNaN(urlIndex) ? void(0) : urlIndex;\\nlet index = void(0) === urlIndex ? MY_PARAMS.i : urlIndex;\\nlet isImport=!!getParam(\\\"isImport\\\", \\\"\\\");\\nlet arr = $.require(\\\"configs\\\").getJson();\\nlet obj;\\nif (isImport) {\\n    try {\\n        obj = $.require(\\\"hiker://files/_cache/yunSimpleImport.json\\\");\\n        let tip = index !== void(0) ? \\\"更新规则\\\" : \\\"导入规则\\\";\\n        setPageTitle(tip + \\\":\\\" + obj.name);\\n        d.push({\\n            title: \\\"‘‘\\\" + tip + \\\"’’\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n\\n    } catch (e) {\\n        obj = {};\\n        back();\\n        toast(\\\"导入错误\\\");\\n    }\\n} else if (index !== void(0)) {\\n    obj = arr[index];\\n    setPageTitle(\\\"编辑规则:\\\" + obj.name);\\n    if (obj.lastModify) {\\n        d.push({\\n            title: \\\"上次修改：\\\" + $.dateFormat(obj.lastModify, \\\"yyyy-MM-dd HH:mm:ss\\\"),\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n    }\\n} else {\\n    obj = {\\n        page: true\\n    };\\n    setPageTitle(\\\"新建规则\\\");\\n}\\n\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"名字(必填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_name\\\", input);\\n        }),\\n        defaultValue: obj.name,\\n        titleVisible: false\\n    }\\n});\\nd.push({\\n    title:\\\"选择\\\",    \\n    col_type: \\\"input\\\",\\n    desc: \\\"分组(选填)\\\",\\n    url:$.toString(()=>{\\n        let group = $.require(\\\"configs\\\").getGroupNames();\\n        if(!group.length){\\n            return \\\"\\\";\\n        }\\n        return $(group).select(()=>{\\n            let extra=findItem(\\\"ruleEditGroup\\\").extra;\\n            updateItem(\\\"ruleEditGroup\\\",{\\n                extra:Object.assign(extra, {\\n                    defaultValue: input\\n                })\\n            });\\n        });\\n    }),\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_group\\\", input);\\n        }),\\n        id: \\\"ruleEditGroup\\\",\\n        defaultValue: obj.group,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"搜索规则(必填)\\\\n内置变量：s搜索关键词，page页数，basicUrl基本链接，user用户账号信息(user.account,user.password)\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 3,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_find\\\", input);\\n        }),\\n        defaultValue: obj.find,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"URL规则(选填)\\\\n内置变量：input链接，basicUrl基本链接\\\",\\n    extra: {\\n        type: \\\"textarea\\\",\\n        height: 3,\\n        highlight: true,\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_findAliUrl\\\", input);\\n        }),\\n        defaultValue: obj.findAliUrl,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"基本链接(选填) 代码中用basicUrl引用\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_basicUrl\\\", input);\\n        }),\\n        defaultValue: obj.basicUrl,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    col_type: \\\"input\\\",\\n    desc: \\\"注册地址(选填)\\\",\\n    extra: {\\n        onChange: $.toString(() => {\\n            putMyVar(\\\"ps_registerUrl\\\", input);\\n        }),\\n        defaultValue: obj.registerUrl,\\n        titleVisible: false,\\n    }\\n});\\nd.push({\\n    title: \\\"是否可以翻页：\\\" + obj.page,\\n    col_type: \\\"text_1\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((page) => {\\n        let isPage = !!getMyVar(\\\"ps_page\\\", page ? \\\"1\\\" : \\\"\\\");\\n        putMyVar(\\\"ps_page\\\", isPage ? \\\"\\\" : \\\"1\\\");\\n        updateItem(\\\"ruleedps_page\\\", {\\n            title: \\\"是否可以翻页：\\\" + !isPage\\n        });\\n        return \\\"hiker://empty\\\";\\n    }, obj.page),\\n    extra: {\\n        id: \\\"ruleedps_page\\\"\\n    }\\n});\\nd.push({\\n    title: \\\"删除\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((index, urlIndex) => {\\n        if (index === void(0)) {\\n            return \\\"toast://此项无法删除\\\";\\n        }\\n        if (urlIndex !== void(0)) {\\n            return \\\"toast://正在更新规则，删除请从规则管理进入\\\";\\n        }\\n        confirm({\\n            title: \\\"温馨提示\\\",\\n            content: \\\"确定要删除此规则吗？注意删除后无法恢复\\\",\\n            confirm: $.toString((index) => {\\n                let arr = $.require(\\\"configs\\\").getJson();\\n                arr.splice(index, 1);\\n                $.require(\\\"configs\\\").saveJson(arr);\\n                back(true);\\n                return \\\"toast://删除成功\\\";\\n            }, index)\\n        });\\n        return \\\"hiker://empty\\\"\\n    }, index, urlIndex),\\n    col_type: \\\"text_3\\\",\\n});\\nd.push({\\n    title: \\\"测试\\\",\\n    url: $(\\\"\\\",\\\"请输入关键词\\\").input((page) => {\\n        let name = getMyVar(\\\"ps_name\\\", \\\"\\\");\\n        let find = getMyVar(\\\"ps_find\\\", \\\"\\\");\\n        if (!find) {\\n            return \\\"toast://搜索规则不能为空\\\";\\n        }\\n        let arr = $.require(\\\"configs\\\").getJson();\\n        let testRule = {\\n            name: name,\\n            find: find,\\n            basicUrl: getMyVar(\\\"ps_basicUrl\\\", \\\"\\\"),\\n            findAliUrl: getMyVar(\\\"ps_findAliUrl\\\", \\\"\\\"),\\n            page: !!getMyVar(\\\"ps_page\\\", page ? \\\"1\\\" : \\\"\\\"),\\n        };\\n        return $(\\\"hiker://empty#noRecordHistory##noHistory#?fypage\\\").rule((testRule, key)=>{\\n            if(MY_PAGE>1&&!testRule.page) setResult([]);\\n            setResult($.require(\\\"data\\\").carryRule(testRule, key, MY_PAGE, 0));\\n        }, testRule, input);\\n    }, obj.page),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nd.push({\\n    title: \\\"保存\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule((index, page, isImport) => {\\n        let name = getMyVar(\\\"ps_name\\\", \\\"\\\");\\n        if (!name) {\\n            return \\\"toast://名字得有一个吧\\\";\\n        }\\n        let find = getMyVar(\\\"ps_find\\\", \\\"\\\");\\n        if (!find) {\\n            return \\\"toast://搜索规则不能为空\\\";\\n        }\\n        let arr = $.require(\\\"configs\\\").getJson();\\n        let obj1 = {\\n            name: name,\\n            find: find,\\n            basicUrl: getMyVar(\\\"ps_basicUrl\\\", \\\"\\\"),\\n            findAliUrl: getMyVar(\\\"ps_findAliUrl\\\", \\\"\\\"),\\n            page: !!getMyVar(\\\"ps_page\\\", page ? \\\"1\\\" : \\\"\\\"),\\n            registerUrl: getMyVar(\\\"ps_registerUrl\\\", \\\"\\\") || undefined,\\n            lastModify: Date.now(),\\n            group: getMyVar(\\\"ps_group\\\", \\\"\\\")\\n        };\\n        if (index === void(0)) {\\n            if (arr.some(v => v.name === name)) {\\n                return \\\"toast://已经存在该规则\\\";\\n            }\\n            if(isImport){\\n                arr.push(obj1);\\n            }else{\\n                arr.unshift(obj1);\\n            }\\n        } else {\\n            let namey = arr[index].name;\\n            if (name !== namey) {\\n                if (arr.some(v => v.name === name)) {\\n                    return \\\"toast://已经存在该规则\\\";\\n                }\\n            }\\n            obj1 = Object.assign(arr[index], obj1);\\n            arr.splice(index, 1, obj1);\\n        }\\n        $.require(\\\"configs\\\").saveJson(arr);\\n        back(true);\\n        return \\\"toast://保存成功\\\";\\n    }, index, obj.page, isImport),\\n    col_type: \\\"text_3\\\",\\n});\\n\\nsetResult(d);\\n\"},{\"col_type\":\"movie_3\",\"name\":\"规则账号\",\"path\":\"password\",\"rule\":\"js:\\n(function() {\\n    var d = [];\\n    addListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"ps_account\\\");\\n        clearMyVar(\\\"ps_password\\\");\\n        clearMyVar(\\\"ps_extra\\\");\\n    }));\\n    let index = MY_PARAMS.i;\\n    let arr = $.require(\\\"configs\\\").getJson();\\n    let obj = arr[index] || {};\\n    setPageTitle(\\\"设置账号:\\\" + obj.name);\\n    let registerUrl = obj.registerUrl;\\n    if (registerUrl) {\\n        d.push({\\n            col_type: \\\"text_center_1\\\",\\n            title: \\\"前往注册\\\",\\n            url: $(\\\"hiker://empty#noRecordHistory##noHistory#\\\").rule((registerUrl)=>{\\n                setResult([{\\n                    col_type:\\\"x5_webview_single\\\",\\n                    url:registerUrl,\\n                    desc:\\\"float&&100%\\\"\\n                }]);\\n            }, registerUrl),\\n            extra:{\\n                pageTitle: \\\"注册账号:\\\" + obj.name\\n            }\\n        });\\n    }\\n    obj = obj.user || {};\\n    d.push({\\n        col_type: \\\"input\\\",\\n        desc: \\\"用户名\\\",\\n        extra: {\\n            onChange: $.toString(() => {\\n                putMyVar(\\\"ps_account\\\", input);\\n            }),\\n            defaultValue: obj.account,\\n            titleVisible: false\\n        }\\n    });\\n    d.push({\\n        col_type: \\\"input\\\",\\n        desc: \\\"密码\\\",\\n        extra: {\\n            type: \\\"password\\\",\\n            onChange: $.toString(() => {\\n                putMyVar(\\\"ps_password\\\", input);\\n            }),\\n            defaultValue: obj.password,\\n            titleVisible: false,\\n        }\\n    });\\n    d.push({\\n        col_type: \\\"input\\\",\\n        desc: \\\"额外\\\",\\n        extra: {\\n            type: \\\"textarea\\\",\\n            onChange: $.toString(() => {\\n                putMyVar(\\\"ps_extra\\\", input);\\n            }),\\n            defaultValue: obj.extra,\\n            titleVisible: false,\\n            height: -1\\n        }\\n    });\\n    d.push({\\n        title: \\\"保存\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule((index) => {\\n            let account = getMyVar(\\\"ps_account\\\", \\\"\\\");\\n            let password = getMyVar(\\\"ps_password\\\", \\\"\\\");\\n            let extra = getMyVar(\\\"ps_extra\\\", \\\"\\\");\\n            /*if (!(account||password||extra)) {\\n                return \\\"toast://不能全部为空\\\";\\n            }*/\\n            let arr = $.require(\\\"configs\\\").getJson();\\n            let item = arr[index];\\n            item.user = {};\\n            item.user.account = account\\n            item.user.password = password;\\n            item.user.extra = extra;\\n            if (index === void(0)) {\\n                return \\\"toast://id错误\\\";\\n            } else {\\n                arr.splice(index, 1, item);\\n            }\\n            $.require(\\\"configs\\\").saveJson(arr);\\n            back(true);\\n            return \\\"toast://保存成功\\\";\\n        }, index),\\n        col_type: \\\"text_center_1\\\",\\n    });\\n    setResult(d);\\n})()\"},{\"col_type\":\"movie_3\",\"name\":\"规则导入\",\"path\":\"import\",\"rule\":\"js:\\nfunction saveCache(json) {\\n    writeFile(\\\"hiker://files/_cache/yunSimpleImport.json\\\", JSON.stringify(json));\\n}\\n$.exports = function(pass) {\\n    try {\\n        let [_, rule, type] = pass.split(\\\"$\\\");\\n        if (type === \\\"b\\\") {\\n            rule = parsePaste(rule);\\n        }\\n        let rules = JSON.parse(base64Decode(rule));\\n        if (!Array.isArray(rules)) {\\n            rules = [rules];\\n        }\\n        //rules.reverse();\\n        MY_URL = module.id;\\n        let ruleTitle = getParam(\\\"rule\\\");\\n        log(ruleTitle)\\n        let arr = $.require(\\\"configs?rule=\\\" + ruleTitle).getJson();\\n        let newI = 0;\\n        for (let rule of rules) {\\n            let index = arr.findIndex(v => v.name === rule.name);\\n            if (index > -1) {\\n                rule = Object.assign(arr[index], rule);\\n                arr.splice(index, 1, rule);\\n                if (rules.length === 1) {\\n                    saveCache(rule);\\n                    return \\\"hiker://page/ruleEdit#noHistory##noRecordHistory#?isImport=true&index=\\\" + index + \\\"&rule=\\\" + ruleTitle;\\n                    //toast(\\\"已更新规则：\\\" + rule.name);\\n                } else {\\n                    log(\\\"已更新规则：\\\" + rule.name)\\n                }\\n            } else {\\n                newI++;\\n                arr.push(rule);\\n                if (rules.length === 1) {\\n                    saveCache(rule);\\n                    return \\\"hiker://page/ruleEdit#noHistory##noRecordHistory#?isImport=true&rule=\\\" + ruleTitle;\\n                    //toast(\\\"已导入规则：\\\" + rule.name);\\n                } else {\\n                    log(\\\"已导入规则：\\\" + rule.name)\\n                }\\n            }\\n        }\\n        if (rules.length > 1) {\\n            $.require(\\\"configs?rule=\\\" + ruleTitle).saveJson(arr);\\n            toast(\\\"新增：\\\" + newI + \\\" 覆盖更新：\\\" + (rules.length - newI));\\n        }\\n    } catch (e) {\\n        log(e.toString());\\n        toast(\\\"导入失败\\\");\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"规则列表\",\"path\":\"rules\",\"rule\":\"js:\\n$.exports = [{\\n        name: \\\"小云\\\",\\n        page: true,\\n        find(s, page) {\\n            let basicUrl = \\\"https://www.yunso.net\\\";\\n            let api = \\\"/api/validate/search?wd=\\\" + encodeURIComponent(s) + \\\"&mode=90001&stype=20100&uk=&page=\\\" + page + \\\"&limit=20&screen_filetype=undefined\\\";\\n            let json = post(basicUrl + api, {\\n                body: \\\"data=\\\" + api,\\n                headers: {\\n                    Referer: \\\"https://www.yunso.net/index/user/s?wd=\\\" + encodeURIComponent(s)\\n                }\\n            });\\n            let html = JSON.parse(json).data;\\n            let list = pdfa(html, \\\"body&&.layui-card:has(a)\\\");\\n            let d = [];\\n            for (let item of list) {\\n                let title = pdfh(item, \\\"a&&Text\\\").replace(\\\"#文件夹 \\\", \\\"\\\");\\n                //let time = /\\\\d{4}(-\\\\d{2}){2} \\\\d{2}(\\\\:\\\\d{2}){2}/.exec(pdfh(item, \\\".layui-card-body&&Text\\\")) || [];\\n                d.push({\\n                    title: title,\\n                    //desc: time[0],\\n                    url: base64Decode(pdfh(item, \\\"a&&url\\\"))\\n                });\\n            }\\n            return d;\\n        }\\n    }, {\\n        name: \\\"混合盘\\\",\\n        page: true,\\n        find(s, page) {\\n            let url = \\\"https://api.hunhepan.com/v1/search\\\";\\n            let json = post(url, {\\n                headers: {\\n                    Referer: \\\"https://hunhepan.com/\\\"\\n                },\\n                body: JSON.stringify({\\n                    \\\"q\\\": s,\\n                    \\\"page\\\": page,\\n                    \\\"size\\\": 15\\n                })\\n            });\\n            json = JSON.parse(json);\\n            let list = json.data.list;\\n            let d = [];\\n            for (let i = 0; i < list.length; i++) {\\n                let it = list[i];\\n                if (it.disk_type !== \\\"ALY\\\" || it.share_user === \\\"丶***丶\\\") continue;\\n                d.push({\\n                    title: it.disk_name,\\n                    pic_url: pd(it, \\\"img&&src\\\", url),\\n                    url: it.link,\\n                    desc: it.update_time + \\\"\\\\n\\\" + it.link,\\n                });\\n            }\\n            return d;\\n        }\\n    }, {\\n        name: \\\"资源帮\\\",\\n        page: true,\\n        find(s, page) {\\n            function search() {\\n                let rtnList = [];\\n                let resp = request(\\\"https://zyb.upyunso.com/v15/search?keyword=\\\" + en_aes(s) + \\\"&s_type=2&page=\\\" + page + \\\"&atk=&did=\\\" + generateRandomHexString(64), {\\n                    headers: {\\n                        \\\"user-agent\\\": \\\"Mozilla/5.0 (Linux; Android 10; Redmi Note 7 Build/QKQ1.190910.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/81.0.4044.138 Mobile Safari/537.36 uni-app Html5Plus/1.0 (Immersed/29.09091)\\\",\\n                    },\\n                });\\n                let respData = de_aes(resp);\\n                let jsonData = JSON.parse(respData) || {};\\n                let result = jsonData.result || {};\\n                let items = result.items || [];\\n\\n                for (let i = 0; i < items.length; i++) {\\n                    let item = items[i];\\n                    let content = item.content || [];\\n                    if (content.length == 0 || !item.page_url) continue;\\n                    let url = de_aes(item.page_url) || \\\"\\\";\\n                    if (!url) continue;\\n                    rtnList.push({\\n                        title: (item.title.length > 30 ? item.title.slice(0, 27) + \\\"...\\\" : item.title) || \\\"\\\",\\n                        desc: \\\"分享时间：\\\" + item.insert_time,\\n                        url: url\\n                    });\\n                }\\n\\n                return rtnList;\\n            }\\n\\n            function generateRandomHexString(length) {\\n                let result = \\\"\\\";\\n                const characters = \\\"0123456789abcdef\\\";\\n                const charactersLength = characters.length;\\n                for (let i = 0; i < length; i++) {\\n                    result += characters.charAt(Math.floor(Math.random() * charactersLength));\\n                }\\n                return result;\\n            }\\n            let aliUtil = $.require(\\\"aliUtil\\\");\\n            let CryptoJS = aliUtil.getCryptoJS();\\n\\n            function en_aes(e) {\\n                let i = \\\"qq1920520460qqzz\\\";\\n                // en_aes\\n                let key = CryptoJS.enc.Utf8.parse(i);\\n                var t = CryptoJS.enc.Utf8.parse(e),\\n                    r = CryptoJS.AES.encrypt(t, key, {\\n                        iv: key,\\n                        mode: CryptoJS.mode.CBC,\\n                    });\\n                return r.ciphertext.toString();\\n            }\\n\\n            function de_aes(vv) {\\n                let i = \\\"qq1920520460qqzz\\\";\\n                // de_aes\\n                let key = CryptoJS.enc.Utf8.parse(i);\\n                let hexVal = CryptoJS.enc.Hex.parse(vv),\\n                    val = CryptoJS.enc.Base64.stringify(hexVal),\\n                    decrypted = CryptoJS.AES.decrypt(val, key, {\\n                        iv: key,\\n                        mode: CryptoJS.mode.CBC,\\n                    });\\n                return decrypted.toString(CryptoJS.enc.Utf8);\\n            }\\n            return search();\\n        }\\n    }, {\\n        name: \\\"云盘资源\\\",\\n        page: true,\\n        find: function(s, page) {\\n            let url = \\\"https://res.yunpan.win/?PageIndex=\\\" + page + \\\"&PageSize=12&Keyword=\\\" + s + \\\"&Type=&Tag=\\\";\\n            let html = request(url, {\\n                headers: {\\n                    \\\"Referer\\\": \\\"https://res.yunpan.win/\\\"\\n                }\\n            });\\n\\n            let arr = pdfa(html, \\\"main&&.card\\\");\\n            //log(arr);\\n            let d = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let u = pdfh(it, \\\".card-link,1&&onclick\\\").match(/https:\\\\/\\\\/(www\\\\.aliyundrive\\\\.com\\\\/s|alywp\\\\.net)\\\\/\\\\w*/g) || [];\\n                u = u.length > 0 ? u[0] : url;\\n                d.push({\\n                    title: pdfh(it, \\\".card-title&&Text\\\"),\\n                    pic_url: pd(it, \\\"img&&src\\\", url),\\n                    url: u,\\n                    desc: pdfh(it, \\\".card-text,-1&&Text\\\") + \\\"\\\\n\\\" + u,\\n                });\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"UP云搜\\\",\\n        page: true,\\n        find: function(s, page) {\\n            let url = \\\"https://api.upyunso2.com/search?keyword=\\\" + s + \\\"&page=\\\" + page + \\\"&s_type=1\\\";\\n            let html = request(url, {\\n                headers: {\\n                    \\\"Referer\\\": \\\"https://www.upyunso.com\\\",\\n                    \\\"Cookie\\\": \\\"code=1919\\\"\\n                }\\n            });\\n            //log(base64Decode(html));\\n            let arr = JSON.parse(base64Decode(html)).result.items;\\n            //log(arr);\\n            let d = [];\\n            if (!arr) return [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let u = it.page_url;\\n                //u = u.length > 0 ? u[0] : url;\\n                if (!u.includes(\\\"aliyundrive\\\")) {\\n                    continue;\\n                }\\n                d.push({\\n                    title: it.title,\\n                    url: u,\\n                    desc: \\\"\\\\n\\\" + (u),\\n                });\\n\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"猫狸盘搜\\\",\\n        page: false,\\n        find: function(s, page) {\\n            let html = request(\\\"https://www.alipansou.com/search?k=\\\" + s, {\\n                headers: {\\n                    \\\"Referer\\\": \\\"https://www.alipansou.com/search?k=\\\" + s\\n                }\\n            });\\n            let arr = pdfa(html, \\\"#app&&a\\\");\\n            //log(arr);\\n            let d = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = \\\"<div>\\\" + arr[i] + \\\"</div>\\\";\\n                let u = pdfh(it, \\\"a&&href\\\");\\n                //log(u);\\n                if (!u.includes(\\\"/s/\\\")) {\\n                    continue;\\n                }\\n                u = \\\"https://www.alipansou.com\\\" + u.replace(\\\"/s/\\\", \\\"/cv/\\\");\\n                d.push({\\n                    title: pdfh(it, \\\"template&&Text\\\"),\\n                    url: u,\\n                    desc: pdfh(it, \\\"template,1&&Text\\\"),\\n                });\\n            }\\n            return d;\\n        },\\n        findAliUrl(input) {\\n            let html = request(input, {\\n                headers: {\\n                    \\\"Cookie\\\": \\\"no_show_donate=1\\\",\\n                    \\\"Referer\\\": input.replace(\\\"/cv/\\\", \\\"/s/\\\")\\n                },\\n                redirect: false\\n            });\\n            html = parseDomForHtml(html, 'a&&href');\\n            if (html.length > 0) {\\n                return html;\\n            } else {\\n                return input;\\n            }\\n        }\\n    },\\n    {\\n        name: \\\"易搜\\\",\\n        page: true,\\n        registerUrl: \\\"https://yiso.fun\\\",\\n        find: function(s, page) {\\n            let aliUtil = $.require(\\\"aliUtil\\\");\\n            let CryptoJS = aliUtil.getCryptoJS();\\n\\n            function keyen(str) {\\n                var key = CryptoJS.enc.Utf8.parse(\\\"4OToScUFOaeVTrHE\\\"),\\n                    iv = CryptoJS.enc.Utf8.parse(\\\"9CLGao1vHKqm17Oz\\\");\\n                var encrypted = CryptoJS.AES.decrypt({\\n                    ciphertext: CryptoJS.enc.Base64.parse(str)\\n                }, key, {\\n                    iv: iv,\\n                    mode: CryptoJS.mode.CBC,\\n                    padding: CryptoJS.pad.Pkcs7\\n                }).toString(CryptoJS.enc.Utf8);\\n                return encrypted;\\n            }\\n            let html = request(\\\"https://yiso.fun/api/search?name=\\\" + s + \\\"&pageNo=\\\" + page, {\\n                headers: {\\n                    \\\"Referer\\\": \\\"https://yiso.fun/info?searchKey=\\\" + s,\\n                    \\\"Cookie\\\": getItem('yisoucooke', '')\\n                }\\n            });\\n            //log(html);\\n            if (html.includes('登录用户无限制')) {\\n                var i = 0;\\n                do {\\n                    var tyimglin = 'https://yiso.fun/api/user/login/captcha?t=' + parseInt(new Date().getTime()) + '';\\n                    let img = convertBase64Image(tyimglin).split(',')[1];\\n                    let cod = request('https://api.xhofe.top/ocr/b64/text', {\\n                        headers: {\\n                            'Content-Type': 'text/plain'\\n                        },\\n                        body: img,\\n                        method: 'POST'\\n                    });\\n                    var ver = JSON.parse(request('https://yiso.fun/api/user/login', {\\n                        headers: {\\n                            'content-type': 'application/json',\\n                            'referer': 'https://yiso.fun/login',\\n                            'Cookie': getCookie(tyimglin)\\n                        },\\n                        body: {\\n                            \\\"userName\\\": user.account,\\n                            \\\"password\\\": user.password,\\n                            \\\"code\\\": cod\\n                        },\\n                        method: 'POST'\\n                    }));\\n                    if (ver.code == 200) {\\n                        log('易搜登入验证成功');\\n                        setItem('yisoucooke', getCookie('https://yiso.fun'));\\n                        html = request(\\\"https://yiso.fun/api/search?name=\\\" + s + \\\"&pageNo=\\\" + page, {\\n                            headers: {\\n                                \\\"Referer\\\": \\\"https://yiso.fun/info?searchKey=\\\" + s,\\n                                \\\"Cookie\\\": getItem('yisoucooke', '')\\n                            }\\n                        });\\n                        break;\\n                    }\\n                    i++;\\n                } while (i < 4);\\n\\n            }\\n            let arr = JSON.parse(html).data.list;\\n            //log(arr);\\n            let d = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let u = keyen(it.url);\\n                //log(u);\\n                if (u == null || !u.includes(\\\"aliyun\\\")) {\\n                    continue;\\n                }\\n                d.push({\\n                    title: it.name,\\n                    url: u,\\n                    desc: (it.gmtShare || it.gmtCreate) + \\\"\\\\n\\\" + (u),\\n                });\\n\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"小纸条\\\",\\n        page: false,\\n        find: function(s, page) {\\n            let aliUtil = $.require(\\\"aliUtil\\\");\\n\\n            function gettoken() {\\n                if (getMyVar('xzytoken', '').length == 0) {\\n                    let token = JSON.parse(post('https://gitcafe.net/tool/alipaper/', {\\n                        headers: {\\n                            'Referer': 'https://u.gitcafe.ink/'\\n                        },\\n                        body: {\\n                            action: 'get_token'\\n                        }\\n                    })).data;\\n                    putMyVar('xzttoken', token);\\n                }\\n                return getMyVar('xzttoken', '');\\n            }\\n\\n            function cat_code(a) {\\n                var d, e, b = [\\\"华语电视\\\", \\\"日韩电视\\\", \\\"欧美电视\\\", \\\"其他电视\\\", \\\"华语电影\\\", \\\"日韩电影\\\", \\\"欧美电影\\\", \\\"其他电影\\\", \\\"华语动漫\\\", \\\"日韩动漫\\\", \\\"欧美动漫\\\", \\\"纪录片\\\", \\\"综艺片\\\", \\\"教育培训\\\", \\\"其他视频\\\", \\\"华语音乐\\\", \\\"日韩音乐\\\", \\\"欧美音乐\\\", \\\"其他音乐\\\", \\\"娱乐软件\\\", \\\"系统软件\\\", \\\"网络软件\\\", \\\"办公软件\\\", \\\"其他软件\\\", \\\"漫画\\\", \\\"小说\\\", \\\"出版书\\\", \\\"知识培训\\\", \\\"其他文档\\\", \\\"壁纸\\\", \\\"人物\\\", \\\"风景\\\", \\\"其他图片\\\", \\\"其他\\\"],\\n                    c = [\\\"hyds\\\", \\\"rhds\\\", \\\"omds\\\", \\\"qtds\\\", \\\"hydy\\\", \\\"rhdy\\\", \\\"omdy\\\", \\\"qtdy\\\", \\\"hydm\\\", \\\"rhdm\\\", \\\"omdm\\\", \\\"jlp\\\", \\\"zyp\\\", \\\"jypx\\\", \\\"qtsp\\\", \\\"hyyy\\\", \\\"rhyy\\\", \\\"omyy\\\", \\\"qtyy\\\", \\\"kfrj\\\", \\\"xtrj\\\", \\\"wlrj\\\", \\\"bgrj\\\", \\\"qtrj\\\", \\\"mh\\\", \\\"xs\\\", \\\"cbs\\\", \\\"zspx\\\", \\\"qtwd\\\", \\\"bz\\\", \\\"rw\\\", \\\"fj\\\", \\\"qttp\\\", \\\"qt\\\"];\\n                for (d = 0, e = c.length; e > d; d++)\\n                    if (c[d] == a) return b[d];\\n            }\\n            let d = [];\\n            let html = post(\\\"https://gitcafe.net/tool/alipaper/\\\", {\\n                headers: {\\n                    'Referer': 'https://u.gitcafe.ink/'\\n                },\\n                body: {\\n                    action: \\\"search\\\",\\n                    from: \\\"web\\\",\\n                    token: gettoken(),\\n                    keyword: s\\n                }\\n            })\\n            let list = JSON.parse(html);\\n            if (list.data) {\\n                list = list.data;\\n            }\\n            for (let i = 0; i < list.length; i++) {\\n                let it = list[i]\\n                let title = it.title;\\n                let murl = 'https://www.aliyundrive.com/s/' + it.alikey\\n                if (!aliUtil.checkali(murl)) {\\n                    continue;\\n                }\\n                if (title.includes(s)) {\\n                    d.push({\\n                        title: \\\"√ \\\" + title,\\n                        desc: cat_code(it.cat),\\n                        extra: {\\n                            des: it.des\\n                        },\\n                        url: murl\\n                    });\\n                }\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"玩偶哥哥\\\",\\n        page: true,\\n        basicUrl: \\\"http://wogg.xyz\\\",\\n        find: function(s, page) {\\n            let url = basicUrl + \\\"/index.php/vodsearch/\\\" + s + \\\"----------\\\" + page + \\\"---.html\\\";\\n            let html = request(url);\\n            let arr = parseDomForArray(html, \\\".module-items&&.module-search-item\\\");\\n\\n            let bet = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let utitle = pdfh(it, \\\"h3&&a&&Text\\\");\\n                let userial = pdfh(it, \\\".video-serial&&Text\\\");\\n                let uimage = pdfh(it, \\\"img&&data-src\\\");\\n                let u = pd(it, \\\"h3&&a&&href\\\", basicUrl);\\n                bet.push({\\n                    title: utitle,\\n                    url: u,\\n                    pic_url: uimage,\\n                    desc: userial\\n                });\\n            }\\n\\n            return bet;\\n        },\\n        findAliUrl(input) {\\n            return pdfa(request(input), \\\"body&&.module-row-text.copy\\\").map(v => pdfh(v, \\\"a&&data-clipboard-text\\\"));\\n        }\\n    },\\n    {\\n        name: \\\"阿里云盘网\\\",\\n        page: true,\\n        basicUrl: \\\"https://www.alypw.cn\\\",\\n        find: function(s, page) {\\n            let url = basicUrl + \\\"/search.php?q=\\\" + s + \\\"&page=\\\" + page;\\n            let html = request(url, {});\\n            let arr = pdfa(html, \\\".list&&li\\\");\\n            let bet = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let utitle = pdfh(it, \\\"a&&title\\\");\\n                let userial = pdfh(it, \\\".fa-clock-o&&Text\\\");\\n                let uimage = pdfh(it, \\\"img&&src\\\");\\n                let u = pd(it, \\\"a&&href\\\", basicUrl);\\n                if (!utitle.includes(s)) {\\n                    continue;\\n                }\\n                bet.push({\\n                    title: utitle,\\n                    url: u,\\n                    pic_url: uimage,\\n                    desc: userial\\n                });\\n            }\\n\\n            return bet;\\n        },\\n        findAliUrl(input) {\\n            return pdfa(request(input), \\\"body&&a[href^=https://www.aliyundrive.com/s/]\\\").map(v => pdfh(v, \\\"a&&href\\\"));\\n        }\\n    },\\n    {\\n        name: \\\"土拨鼠\\\",\\n        page: false,\\n        find: function(s, page) {\\n            let html = fetch('https://www.tbsdy.com/search.html?keyword=' + s + '&category=983920&data_type=987910', {\\n                headers: {\\n                    'User-Agent': PC_UA\\n                }\\n            });\\n\\n            let arr = parseDomForArray(html, '.search_result_netdisk_list&&a');\\n            let d = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                //log(it);\\n                let u = parseDomForHtml(it, 'a&&href');\\n                let tit = parseDomForHtml(it, '.netdisk_item_detail_name&&Text');\\n                if (!tit.includes(s)) {\\n                    continue;\\n                }\\n                //log(u);\\n                d.push({\\n                    title: tit,\\n                    url: u,\\n                    desc: \\\"\\\\n\\\" + u,\\n                });\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"阿里搜\\\",\\n        page: true,\\n        find: function(s, page) {\\n            let d = [];\\n            let html = request('https://aliso.cc/s/' + s + '-' + page + '-0.html', {});\\n\\n            let list = parseDomForArray(html, '.search-result&&.resource-item');\\n            for (let j = 0; j < list.length; j++) {\\n                let u = list[j];\\n                let tit = parseDomForHtml(u, 'h3&&Text');\\n                if (!tit.includes(s)) {\\n                    continue;\\n                }\\n                d.push({\\n                    title: tit,\\n                    url: parseDom(u, 'h3&&a&&href', 'https://aliso.cc/'),\\n                    desc: parseDomForHtml(u, '.time&&Text'),\\n                });\\n\\n            }\\n            return d;\\n        },\\n        findAliUrl(input) {\\n            eval(getCryptoJS());\\n\\n            function decry(str) {\\n                var key = CryptoJS.enc.Utf8.parse(\\\"9EB20DDFD6AFBD68\\\");\\n                var encrypted = CryptoJS.AES.decrypt(str, key, {\\n                    iv: key,\\n                    mode: CryptoJS.mode.CBC,\\n                    padding: CryptoJS.pad.Pkcs7\\n                }).toString(CryptoJS.enc.Utf8);\\n                return encrypted;\\n            }\\n\\n            let html = request(input);\\n            let but = parseDom(html, '.button&&href', 'https://aliso.cc/');\\n            //log(but);\\n            let got = request(but);\\n            //log(got);\\n            eval(parseDomForHtml(got, 'head&&script,1&&Html'));\\n            return decry(base64.split('!')[0]);\\n        }\\n    },\\n    {\\n        name: \\\"云盘分享社\\\",\\n        page: false,\\n        find: function(s, page) {\\n            let aliUtil = $.require(\\\"aliUtil\\\");\\n            let CryptoJS = aliUtil.getCryptoJS();\\n\\n            function decry(str) {\\n                var key = CryptoJS.enc.Utf8.parse(\\\"5F6B2AK33DASD123\\\");\\n                var encrypted = CryptoJS.AES.decrypt(str, key, {\\n                    mode: CryptoJS.mode.ECB,\\n                    padding: CryptoJS.pad.Pkcs7\\n                }).toString(CryptoJS.enc.Utf8);\\n                return encrypted;\\n            }\\n            let html = request(\\\"https://www.yunpanfenxiang.cn/api/bbs/api/getdata?key=\\\" + s + \\\"&type=video\\\", {\\n                headers: {\\n                    \\\"Referer\\\": \\\"https://www.yunpanfenxiang.cn/\\\"\\n                }\\n            });\\n            let json = decry(JSON.parse(html).data);\\n            let arr = JSON.parse(json);\\n\\n            let bet = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let url = it.pid;\\n                bet.push({\\n                    url: \\\"https://www.yunpanfenxiang.cn/api/bbs/api/getarticle?id=\\\" + url,\\n                    title: it.title,\\n                    desc: it.createtime\\n                });\\n            }\\n\\n            return bet;\\n        },\\n        findAliUrl(input) {\\n            let json = JSON.parse(request(input, {\\n                headers: {\\n                    \\\"Referer\\\": \\\"https://www.yunpanfenxiang.cn/\\\"\\n                }\\n            })).data;\\n            let list = json.download.split(\\\"@\\\");\\n            let alist = new Set();\\n            for (let j = 0; j < list.length; j++) {\\n                alist.add(\\\"https://www.aliyundrive.com/s/\\\" + list[j]);\\n            }\\n            return Array.from(alist);\\n        }\\n    },\\n    {\\n        name: \\\"盘搜\\\",\\n        page: true,\\n        find: function(s, page) {\\n            page = (page - 1) * 10;\\n            let url = \\\"https://www.pansearch.me/search?keyword=\\\" + s + \\\"&offset=\\\" + page + \\\"&pan=aliyundrive\\\";\\n            let html = request(url, {});\\n\\n            let arr = parseDomForArray(html, '.grid&&.shadow:has(a[href^=https://www.aliyundrive.com/s/])');\\n            //log(arr);\\n            let d = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let u = parseDomForHtml(it, 'a[href^=https://www.aliyundrive.com/s/]&&href');\\n                let pic_url = parseDomForHtml(it, 'img&&src');\\n                d.push({\\n                    title: parseDomForHtml(it, '.break-all&&Text').split('http')[0],\\n                    pic_url: pic_url === \\\"/favicon.png\\\" ? \\\"https://www.pansearch.me/\\\" + pic_url : pic_url,\\n                    url: u,\\n                    desc: parseDomForHtml(it, 'p&&Text') + \\\"\\\\n\\\" + u,\\n                });\\n\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"DOVX搜\\\",\\n        page: false,\\n        find: function(s, page) {\\n            let url = \\\"https://api.dovx.tk/ali/search?wd=\\\" + s;\\n            let html = request(url);\\n            let arr = JSON.parse(html).list;\\n            let d = [];\\n            let aliUtil = $.require(\\\"aliUtil\\\");\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let u = it.vod_content;\\n                if (!u.includes(\\\"aliyundrive\\\") || !aliUtil.checkali(u)) {\\n                    continue;\\n                }\\n                d.push({\\n                    title: \\\"√ \\\" + it.vod_name,\\n                    pic_url: it.vod_pic,\\n                    url: u,\\n                    desc: \\\"\\\\n\\\" + u,\\n                });\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"必应\\\",\\n        page: true,\\n        find: function(s, page) {\\n            let url = \\\"https://cn.bing.com/search?q=\\\" + s + \\\"+aliyundrive&qs=ds&form=QBRE\\\";\\n            if (page != 1) {\\n                url = getMyVar(\\\"bing\\\", url);\\n            }\\n            let html = request(url, {\\n                headers: {\\n                    \\\"Referer\\\": \\\"https://cn.bing.com/\\\",\\n                    //\\\"X-Requested-With\\\": \\\"com.example.hikerview\\\",\\n                    \\\"Accept\\\": \\\"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\\\"\\n                }\\n            });\\n            let arr = pdfa(html, \\\"body&&a\\\");\\n            //log(arr);\\n            let d = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let u = pd(it, \\\"a&&href\\\", url);\\n                let t = pdfh(it, \\\"a&&Text\\\");\\n                if (it.includes(\\\"Next page\\\") || it.includes(\\\"下一页\\\")) {\\n                    let u2 = pd(it, \\\"a&&href\\\", url);\\n                    //log(\\\"next page\\\");\\n                    //log(u2);\\n                    putMyVar(\\\"bing\\\", u2);\\n                }\\n                if (u == null || t == null || !it.includes(s)) {\\n                    continue;\\n                }\\n                if (!it.includes(\\\"网盘\\\") && !it.includes(\\\"云盘\\\") &&\\n                    !it.includes(\\\"aliyundrive\\\") && !it.includes(\\\"yunpan\\\")) {\\n                    continue;\\n                }\\n                if (u.startsWith(\\\"https://cn.bing.com/\\\")) {\\n                    continue;\\n                }\\n                let dom = getHome(u).replace(\\\"http://\\\", \\\"\\\").replace(\\\"https://\\\", \\\"\\\");\\n                let _links = t.match(/https:\\\\/\\\\/(www\\\\.aliyundrive\\\\.com\\\\/s|alywp\\\\.net)\\\\/\\\\w*/g) || [];\\n                let c = null;\\n                if (_links.length > 1 && _links[1].replace(_links[0], \\\"\\\").replace(/[a-zA-Z0-9]+/g, \\\"\\\") == \\\"\\\") {\\n                    c = _links[1];\\n                } else if (_links.length > 0) {\\n                    c = _links[0];\\n                }\\n                d.push({\\n                    title: t,\\n                    desc: dom,\\n                    url: c != null ? c : u,\\n                    extra: {\\n                        longClick: [{\\n                            title: \\\"进入网站\\\",\\n                            js: JSON.stringify(\\\"hiker://page/ysfx?webUrl=\\\" + encodeURIComponent(u))\\n                        }]\\n                    }\\n                });\\n            }\\n            return d;\\n        },\\n        findAliUrl(input) {\\n            if (input.includes(\\\"aliyundrive\\\")) return input;\\n            let html = request(input);\\n            var _links = html.match(/https:\\\\/\\\\/(www\\\\.aliyundrive\\\\.com\\\\/s|alywp\\\\.net)\\\\/\\\\w*/g) || [];\\n            if (_links.length > 1 && _links[1].replace(_links[0], \\\"\\\").replace(/[a-zA-Z0-9]+/g, \\\"\\\") == \\\"\\\") {\\n                return _links[1];\\n            } else if (_links.length > 0) {\\n                return _links[0];\\n            } else {\\n                return \\\"hiker://page/ysfx?webUrl=\\\" + encodeURIComponent(input);\\n            }\\n\\n        }\\n    },\\n    {\\n        name: 'CCOF',\\n        page: true,\\n        find: function(s, page) {\\n            let d = []\\n            let aliUtil = $.require(\\\"aliUtil\\\");\\n            let html = fetch('https://pan.ccof.cc/api/search', {\\n                headers: {\\n                    \\\"content-type\\\": 'application/json',\\n                    'Referer': 'https://pan.ccof.cc/search?keyword=' + s\\n                },\\n                body: {\\n                    \\\"pageSize\\\": 20,\\n                    \\\"pageNum\\\": page,\\n                    \\\"keyword\\\": s,\\n                    \\\"fromMobile\\\": true\\n                },\\n                method: 'POST'\\n            })\\n            let list = JSON.parse(html)\\n                .data.rows\\n            for (let i = 0; i < list.length; i++) {\\n                let it = list[i];\\n                let title = it.fileName\\n                let murl = it.url\\n                let type = it.type.replace(/folder/, '文件夹').replace(/file/, '文件')\\n                if (title.includes(s)) {\\n                    d.push({\\n                        title: title,\\n                        desc: '文件类型：' + type + '，文件大小：' + aliUtil.bytesToSize(it.size),\\n                        url: murl\\n                    })\\n                }\\n            }\\n            return d\\n        }\\n    },\\n    {\\n        name: '阿里小站',\\n        page: true,\\n        find: function(s, page) {\\n            let home = \\\"https://pan666.net\\\";\\n            let d = [];\\n            let html = request(buildUrl(home + \\\"/api/discussions\\\", {\\n                \\\"include\\\": \\\"user,lastPostedUser,mostRelevantPost,mostRelevantPost.user,tags,tags.parent,firstPost\\\",\\n                \\\"filter[q]\\\": s /* + \\\" tag:video,comic\\\"*/ ,\\n                //\\\"filter[tag]\\\": \\\"video,comic\\\",\\n                \\\"page[offset]\\\": 20 * (page - 1)\\n            }), {\\n                headers: {\\n                    \\\"content-type\\\": \\\"application/json\\\",\\n                    \\\"Referer\\\": \\\"https://pan666.net/?q=\\\" + s\\n                }\\n            });\\n            let list = JSON.parse(html).data;\\n            for (let i = 0; i < list.length; i++) {\\n                let item = list[i].attributes;\\n                let url = home + \\\"/d/\\\" + item.slug;\\n                d.push({\\n                    title: item.title,\\n                    desc: '发布时间：' + $.dateFormat(new Date(item.createdAt), \\\"yyyy-MM-dd HH:mm:ss\\\"),\\n                    url: url,\\n                    extra: {\\n                        longClick: [{\\n                            title: \\\"进入帖子\\\",\\n                            js: JSON.stringify(\\\"hiker://page/ysfx?webUrl=\\\" + encodeURIComponent(url))\\n                        }]\\n                    }\\n                });\\n            }\\n            return d;\\n        },\\n        findAliUrl(input) {\\n            let html = pdfh(request(input), \\\"Text\\\");\\n            let _links = html.match(/https:\\\\/\\\\/(www\\\\.aliyundrive\\\\.com\\\\/s|alywp\\\\.net)\\\\/\\\\w*/g) || [];\\n            let sharePwd = html.match(/提取码[:：]\\\\s*?(\\\\w{4})/);\\n            sharePwd = Array.isArray(sharePwd) && sharePwd.length > 0 ? sharePwd[1] : \\\"\\\";\\n            if (_links.length > 1 && _links[1].replace(_links[0], \\\"\\\").replace(/[a-zA-Z0-9]+/g, \\\"\\\") == \\\"\\\") {\\n                return {\\n                    aliUrl: _links[1],\\n                    sharePwd: sharePwd\\n                };\\n            } else if (_links.length > 0) {\\n                return {\\n                    aliUrl: _links[0],\\n                    sharePwd: sharePwd\\n                };\\n            } else {\\n                return \\\"hiker://page/ysfx?webUrl=\\\" + encodeURIComponent(input);\\n            }\\n        }\\n    },\\n    {\\n        name: '云盘分享社区',\\n        page: true,\\n        find: function(s, page) {\\n            let home = \\\"https://yunpan1.cc\\\";\\n            let d = [];\\n            let html = request(buildUrl(home + \\\"/api/discussions\\\", {\\n                \\\"include\\\": \\\"user,lastPostedUser,mostRelevantPost,mostRelevantPost.user,tags,tags.parent,firstPost\\\",\\n                \\\"filter[q]\\\": s /* + \\\" tag:video,comic\\\"*/ ,\\n                //\\\"filter[tag]\\\": \\\"video,comic\\\",\\n                \\\"page[offset]\\\": 20 * (page - 1)\\n            }), {\\n                headers: {\\n                    \\\"content-type\\\": \\\"application/json\\\",\\n                    \\\"Referer\\\": \\\"https://pan666.net/?q=\\\" + s\\n                }\\n            });\\n            let list = JSON.parse(html).data;\\n            for (let i = 0; i < list.length; i++) {\\n                let item = list[i].attributes;\\n                let url = home + \\\"/d/\\\" + item.slug;\\n                d.push({\\n                    title: item.title,\\n                    desc: '发布时间：' + $.dateFormat(new Date(item.createdAt), \\\"yyyy-MM-dd HH:mm:ss\\\"),\\n                    url: url,\\n                    extra: {\\n                        longClick: [{\\n                            title: \\\"进入帖子\\\",\\n                            js: JSON.stringify(\\\"hiker://page/ysfx?webUrl=\\\" + encodeURIComponent(url))\\n                        }]\\n                    }\\n                });\\n            }\\n            return d;\\n        },\\n        findAliUrl(input) {\\n            let html = pdfh(request(input), \\\"Text\\\");\\n            let _links = html.match(/https:\\\\/\\\\/(www\\\\.aliyundrive\\\\.com\\\\/s|alywp\\\\.net)\\\\/\\\\w*/g) || [];\\n            let sharePwd = html.match(/提取码[:：]\\\\s*?(\\\\w{4})/);\\n            sharePwd = Array.isArray(sharePwd) && sharePwd.length > 0 ? sharePwd[1] : \\\"\\\";\\n            if (_links.length > 1 && _links[1].replace(_links[0], \\\"\\\").replace(/[a-zA-Z0-9]+/g, \\\"\\\") == \\\"\\\") {\\n                return {\\n                    aliUrl: _links[1],\\n                    sharePwd: sharePwd\\n                };\\n            } else if (_links.length > 0) {\\n                return {\\n                    aliUrl: _links[0],\\n                    sharePwd: sharePwd\\n                };\\n            } else {\\n                return \\\"hiker://page/ysfx?webUrl=\\\" + encodeURIComponent(input);\\n            }\\n        }\\n    }, {\\n        name: \\\"爱看美剧\\\",\\n        page: true,\\n        find: function(s, page) {\\n            let url = \\\"https://www.2kmj.cn/search.php?q=\\\" + s + \\\"&page/\\\" + page + \\\"/\\\";\\n            let html = request(url);\\n            let arr = parseDomForArray(html, \\\".list-it&&li\\\");\\n\\n            let bet = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let utitle = parseDomForHtml(it, \\\"a&&title\\\");\\n                let userial = parseDomForHtml(it, \\\".info&&span:not(:has(a))--i&&Text\\\");\\n                let uimage = parseDom(it, \\\"img&&src\\\");\\n                let u = parseDom(it, \\\"a&&href\\\");\\n                bet.push({\\n                    title: utitle,\\n                    url: u,\\n                    pic_url: uimage,\\n                    desc: userial\\n                });\\n            }\\n\\n            return bet;\\n\\n        },\\n        findAliUrl(input) {\\n            return pdfa(request(input), \\\"body&&#download\\\").map(v => pdfh(v, \\\".down&&href\\\"));\\n        }\\n    },\\n    {\\n        name: \\\"奇妙搜索\\\",\\n        page: true,\\n        find(s, page) {\\n            let url;\\n            if (page === 1) {\\n                url = buildUrl(\\\"https://www.magicalsearch.top/api/pshou/getData\\\", {\\n                    word: s,\\n                    type: \\\"阿里网盘\\\"\\n                });\\n            } else {\\n                url = buildUrl(\\\"https://www.magicalsearch.top/api/pshou/getNextPage\\\", {\\n                    url: \\\"https://api.upyunso2.com/search?s_type=2@page=\\\" + page + \\\"@keyword=\\\" + encodeURIComponent(s),\\n                    website: \\\"阿里网盘\\\"\\n                });\\n            }\\n            let result = request(url, {\\n                headers: {\\n                    Referer: buildUrl(\\\"https://www.magicalsearch.top/search\\\", {\\n                        word: s,\\n                        cpage: 0\\n                    })\\n                }\\n            });\\n            result = JSON.parse(JSON.parse(result));\\n            let list = result.result.items;\\n            let d = [];\\n            for (let it of list) {\\n                if (it.id == -1) {\\n                    continue;\\n                }\\n                d.push({\\n                    title: it.title,\\n                    desc: \\\"日期：\\\" + it.insert_time + \\\"\\\\n路径：\\\" + it.path,\\n                    url: it.page_url\\n                });\\n            }\\n            return d;\\n        }\\n    }\\n];\"},{\"col_type\":\"movie_3\",\"name\":\"文件排序\",\"path\":\"FileSorting\",\"rule\":\"let chnNumChar = {\\n    零: 0,\\n    一: 1,\\n    二: 2,\\n    三: 3,\\n    四: 4,\\n    五: 5,\\n    六: 6,\\n    七: 7,\\n    八: 8,\\n    九: 9\\n};\\n\\nlet chnNameValue = {\\n    十: {\\n        value: 10,\\n        secUnit: false\\n    },\\n    百: {\\n        value: 100,\\n        secUnit: false\\n    },\\n    千: {\\n        value: 1000,\\n        secUnit: false\\n    },\\n    万: {\\n        value: 10000,\\n        secUnit: true\\n    },\\n    亿: {\\n        value: 100000000,\\n        secUnit: true\\n    }\\n}\\n\\nfunction ChineseToNumber(chnStr) {\\n    let rtn = 0;\\n    let section = 0;\\n    let number = 0;\\n    let secUnit = false;\\n    let str = chnStr.split('');\\n\\n    for (let i = 0; i < str.length; i++) {\\n        let num = chnNumChar[str[i]];\\n        if (typeof num !== 'undefined') {\\n            number = num;\\n            if (i === str.length - 1) {\\n                section += number;\\n            }\\n        } else {\\n            let unit = chnNameValue[str[i]].value;\\n            secUnit = chnNameValue[str[i]].secUnit;\\n            if (secUnit) {\\n                section = (section + number) * unit;\\n                rtn += section;\\n                section = 0;\\n            } else {\\n                section += (number * unit);\\n            }\\n            number = 0;\\n        }\\n    }\\n    return rtn + section;\\n}\\n\\nfunction nameCompare(a, b) {\\n    if (a == null || b == null)\\n        return a == null ? b == null ? 0 : -1 : 1;\\n\\n    a = a.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return ChineseToNumber(p1);\\n    })\\n    b = b.replace(/([零一二三四五六七八九十百千万亿])/g, function(match, p1, p2, p3, offset, string) {\\n        // p1 is nondigits, p2 digits, and p3 non-alphanumerics\\n        return ChineseToNumber(p1);\\n    })\\n\\n    let NUMBERS = java.util.regex.Pattern.compile(\\\"(?<=\\\\\\\\D)(?=\\\\\\\\d)|(?<=\\\\\\\\d)(?=\\\\\\\\D)\\\")\\n    let split1 = NUMBERS.split(new java.lang.String(a));\\n    let split2 = NUMBERS.split(new java.lang.String(b));\\n\\n    for (let i = 0; i < Math.min(split1.length, split2.length); i++) {\\n        let c1 = split1[i].charCodeAt(0);\\n        let c2 = split2[i].charCodeAt(0);\\n        let cmp = 0;\\n        let zeroCharCode = '0'.charCodeAt(0);\\n        let nineCharCode = '9'.charCodeAt(0);\\n\\n        if (c1 >= zeroCharCode && c1 <= nineCharCode && c2 >= zeroCharCode && c2 <= nineCharCode) {\\n            cmp = new java.math.BigInteger(split1[i]).compareTo(new java.math.BigInteger(split2[i]));\\n        }\\n\\n        if (cmp === 0) {\\n            let regex = /[a-zA-Z0-9]/\\n            let s1 = String(split1[i])\\n            let s2 = String(split2[i])\\n            if (regex.test(s1) || regex.test(s2)) {\\n                cmp = new java.lang.String(split1[i]).compareTo(new java.lang.String(split2[i]));\\n                // cmp = s1.localeCompare(s2, 'en')\\n            } else {\\n                cmp = s1.localeCompare(s2, 'zh')\\n            }\\n        }\\n\\n        if (cmp !== 0) {\\n            return cmp;\\n        }\\n    }\\n    let lengthCmp = split1.length - split2.length;\\n    // if (lengthCmp !== 0) lengthCmp = lengthCmp > 0 ? -1 : 1;\\n    return lengthCmp;\\n}\\n$.exports.nameCompare = nameCompare;\"},{\"col_type\":\"movie_3\",\"name\":\"登录方式\",\"path\":\"loginMode\",\"rule\":\"$.exports = $([\\\"APP授权登录\\\", \\\"网页登录①\\\", \\\"网页登录②\\\", \\\"TOKEN登录\\\"], 1, \\\"登录方式\\\").select(() => {\\n    if (\\\"网页登录①\\\" == input) {\\n        return \\\"hiker://page/login#noRecordHistory##noHistory#?pageTitle=登录阿里云盘\\\"\\n    }\\n    if (\\\"网页登录②\\\" == input) {\\n        return \\\"hiker://page/login#noRecordHistory##noHistory#?index=0&pageTitle=登录阿里云盘\\\"\\n    }\\n    if (\\\"APP授权登录\\\" == input) {\\n        return \\\"hiker://page/login#noRefresh##noRecordHistory##noHistory#?index=-1&pageTitle=登录阿里云盘\\\"\\n    }\\n    if (\\\"TOKEN登录\\\" == input) {\\n        return $(\\\"\\\", \\\"输入TOKEN\\\").input(() => {\\n            let aliTokensFilepath = $.require(\\\"hiker://page/tokenPath\\\").aliTokensFilepath;\\n            let aliToken = {\\n                refresh_token: input.trim()\\n            };\\n            writeFile(aliTokensFilepath, JSON.stringify(aliToken));\\n            refreshPage();\\n        });\\n    }\\n    if (\\\"原画登录\\\" == input) {\\n        return \\\"hiker://page/openApiLogin#noRefresh##noRecordHistory##noHistory#\\\";\\n    }\\n});\"},{\"col_type\":\"movie_3\",\"name\":\"阿里链接匹配\",\"path\":\"alitest\",\"rule\":\"js:\\nlet matchReg = /https?:\\\\/\\\\/www.ali(pan|yundrive).com\\\\/s\\\\/[a-zA-Z0-9]{11}(\\\\/folder\\\\/[a-z0-9]{40})?/;\\nlet matchRegG = /https?:\\\\/\\\\/www.ali(pan|yundrive).com\\\\/s\\\\/[a-zA-Z0-9]{11}(\\\\/folder\\\\/[a-z0-9]{40})?/g;\\nlet testReg = /www.ali(pan|yundrive).com\\\\/s\\\\//;\\n$.exports = {\\n    matchAliUrl(text, isG) {\\n        if (isG) {\\n            let url = text.match(matchRegG);\\n            if (url) return url;\\n            else return [];\\n        } else {\\n            let url = text.match(matchReg);\\n            return url = url && url[0] || \\\"\\\";\\n        }\\n    },\\n    test(text){\\n        return testReg.test(text);\\n    }\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"openApi登录-废弃\",\"path\":\"openApiLogin\",\"rule\":\"js:\\nsetPageTitle(\\\"openApi登录\\\");\\naddListener(\\\"onClose\\\", () => clearMyVar(\\\"Loggingin\\\"));\\n\\nlet d = [];\\nd.push({\\n    title: \\\"点击获取扫码登录二维码\\\",\\n    desc: \\\"点击图片可以保存\\\",\\n    col_type: \\\"text_center_1\\\",\\n    extra: {\\n        cls: \\\"login\\\",\\n        id:\\\"getQC\\\"\\n    },\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        putMyVar(\\\"Loggingin\\\", \\\"true\\\");\\n        showLoading(\\\"正在获取二维码\\\");\\n\\n        function get_qrcode_status(sid) {\\n            let res = fetch(\\\"https://openapi.aliyundrive.com/oauth/qrcode/\\\" + sid + \\\"/status\\\");\\n            return JSON.parse(res);\\n        }\\n\\n        function get_refresh_token(code) {\\n            let res = post(\\\"https://aliyundrive-oauth.messense.me/oauth/access_token\\\", {\\n                body: JSON.stringify({\\n                    \\\"grant_type\\\": \\\"authorization_code\\\",\\n                    \\\"code\\\": code,\\n                }),\\n            });\\n            let data = JSON.parse(res);\\n            return data[\\\"refresh_token\\\"];\\n        }\\n        let res = post(\\\"https://aliyundrive-oauth.messense.me/oauth/authorize/qrcode\\\", {\\n            body: JSON.stringify({\\n                \\\"scopes\\\": [\\\"user:base\\\", \\\"file:all:read\\\", \\\"file:all:write\\\"],\\n                \\\"width\\\": 300,\\n                \\\"height\\\": 300,\\n            }),\\n        });\\n        let data = JSON.parse(res);\\n        let sid = data[\\\"sid\\\"];\\n        let qrcode_url = data[\\\"qrCodeUrl\\\"];\\n        updateItem(\\\"infoOutput\\\", {\\n            pic_url: qrcode_url,\\n            url: qrcode_url + \\\"#.jpg\\\",\\n            col_type: \\\"pic_1_full\\\"\\n        });\\n        addItemAfter(\\\"infoOutput\\\", {\\n            title: \\\"‘‘’’\\\" + \\\"使用阿里云盘 App 扫码\\\".fontcolor(\\\"grey\\\"),\\n            col_type: \\\"text_center_1\\\",\\n            extra: {\\n                cls: \\\"login\\\"\\n            }\\n        });\\n        deleteItem(\\\"getQC\\\");\\n        hideLoading();\\n        let refresh_token;\\n        while (true) {\\n            let data;\\n            try {\\n                data = get_qrcode_status(sid);\\n            } catch (e) {\\n                return \\\"toast://查询扫码结果超时, 可能是触发了阿里云盘接口限制, 请稍后再试.\\\";\\n            }\\n            let status = data[\\\"status\\\"];\\n            if (status == \\\"LoginSuccess\\\") {\\n                refresh_token = get_refresh_token(data[\\\"authCode\\\"]);\\n                break\\n            } else if (status == \\\"QRCodeExpired\\\") {\\n                return \\\"toast://二维码已过期, 请刷新页面后重试\\\";\\n            }\\n            if (!getMyVar(\\\"Loggingin\\\", \\\"\\\")) {\\n                return \\\"toast://cancel\\\";\\n            }\\n            java.lang.Thread.sleep(1500);\\n        }\\n        if (refresh_token) {\\n            const {\\n                openTokensFilepath,\\n            } = $.require(\\\"tokenPath\\\");\\n            let open = {\\n                RefreshTokenOpen: refresh_token,\\n                isV2: true\\n            };\\n            writeFile(openTokensFilepath, JSON.stringify(open));\\n            addItemAfter(\\\"infoOutput\\\", {\\n                title: \\\"登录成功(点击返回)\\\",\\n                url:$(\\\"#noLoading#\\\").lazyRule(()=>{\\n                    back(false);\\n                    return \\\"hiker://empty\\\";\\n                }),\\n                col_type: \\\"text_center_1\\\",\\n            });\\n            deleteItemByCls(\\\"login\\\");\\n\\n            return \\\"toast://success\\\";\\n        }\\n        return \\\"toast://fail\\\";\\n    })\\n});\\n\\nd.push({\\n    col_type: \\\"blank_block\\\",\\n    extra: {\\n        id: \\\"infoOutput\\\",\\n        cls: \\\"login\\\"\\n    }\\n});\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"openApi:alist\",\"path\":\"openApi_alist\",\"rule\":\"\\nfunction OpenApiAlist($this) {\\n    this.$this = $this;\\n}\\nObject.assign(OpenApiAlist.prototype, {\\n    getOpenTokenCode() {\\n        let result = this.$this.postApi('https://open.aliyundrive.com/oauth/users/authorize?client_id=' + '76917ccccd4441c39457a04f6084fb2f' + '&redirect_uri=https://alist.nn.ci/tool/aliyundrive/callback' + '&scope=user:base,file:all:read,file:all:write&state=').body({\\n            \\\"authorize\\\": 1,\\n            \\\"scope\\\": \\\"user:base,file:all:read,file:all:write\\\"\\n        }).headers({\\n            'User-Agent': PC_UA,\\n            'Referer': 'https://www.aliyundrive.com/',\\n            'authorization': this.$this.reaccessTk, //getAccessToken\\n            'x-canary': 'client=web,app=share,version=v2.3.1',\\n            'x-share-token': this.$this.shareToken\\n        }).errorWithRetry((e,_,http) => {\\n            this.$this.trySolve(e);\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    'authorization': this.$this.reaccessTk,\\n                    'x-share-token': this.$this.shareToken\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        let code = result.redirectUri.split(\\\"code=\\\")[1];\\n        return code;\\n    },\\n    getToken(body) {\\n        let json = post('https://api.xhofe.top/alist/ali_open/code', {\\n            headers: {\\n                'User-Agent': PC_UA,\\n                'Referer': 'https://www.aliyundrive.com/'\\n            },\\n            body: JSON.stringify(body),\\n        });\\n        if (!json) {\\n            json = post('https://api-cf.nn.ci/alist/ali_open/code', {\\n                headers: headers,\\n                body: JSON.stringify(body),\\n            });\\n        }\\n        if (json.includes('Too Many Requests') || json.includes(\\\"502 Bad Gateway\\\")) {\\n            throw new Error(\\\"频繁请求暂时被封禁\\\\n\\\" + json);\\n        } else {\\n            let openResult = JSON.parse(json);\\n            return openResult;\\n        }\\n    },\\n    getOpenToken() {\\n        return this.getToken({\\n            code: this.getOpenTokenCode(),\\n            grant_type: \\\"authorization_code\\\"\\n        });\\n    },\\n    refreshOpenToken() {\\n        return this.getToken({\\n            grant_type: \\\"refresh_token\\\",\\n            refresh_token: this.$this.openTokens.RefreshTokenOpen,\\n        });\\n    }\\n});\\n$.exports = OpenApiAlist;\"},{\"col_type\":\"movie_3\",\"name\":\"openApi:aliyundrive\",\"path\":\"openApi_aliyundrive\",\"rule\":\"js:\\nfunction OpenApi($this, postApi) {\\n    this.$this = $this;\\n}\\n\\nObject.assign(OpenApi.prototype, {\\n    getOpenTokenCode() {\\n        function get_qrcode_code(sid) {\\n            let res = fetch(\\\"https://openapi.aliyundrive.com/oauth/qrcode/\\\" + sid + \\\"/status\\\");\\n            return JSON.parse(res).authCode;\\n        }\\n\\n        let res = post(\\\"https://aliyundrive-oauth.messense.me/oauth/authorize/qrcode\\\", {\\n            body: JSON.stringify({\\n                \\\"scopes\\\": [\\\"user:base\\\", \\\"file:all:read\\\", \\\"file:all:write\\\"],\\n                \\\"width\\\": 300,\\n                \\\"height\\\": 300,\\n            }),\\n        });\\n        let data = JSON.parse(res);\\n        let sid = data[\\\"sid\\\"];\\n        let body = {\\n            \\\"authorize\\\": 1,\\n            \\\"scope\\\": \\\"user:base,file:all:read,file:all:write\\\",\\n            \\\"drives\\\": [\\\"backup\\\", \\\"resource\\\"],\\n            \\\"scopes\\\": [\\\"user:base\\\", \\\"file:all:read\\\", \\\"file:all:write\\\"],\\n            \\\"sid\\\": sid\\n        }\\n        let headers = {\\n            'authorization': this.$this.reaccessTk\\n        };\\n        let res2 = this.$this.postApi(\\\"https://open.aliyundrive.com/oauth/users/qrcode/authorize?sid=\\\" + sid).body(body).headers(headers).errorWithRetry((e, _, http) => {\\n            this.$this.trySolve(e);\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    'authorization': this.$this.reaccessTk,\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        return get_qrcode_code(sid);\\n    },\\n    getToken(body) {\\n        let res = post(\\\"https://aliyundrive-oauth.messense.me/oauth/access_token\\\", {\\n            body: JSON.stringify(body),\\n        });\\n        let data = JSON.parse(res);\\n\\n        return data;\\n    },\\n    getOpenToken() {\\n        return this.getToken({\\n            code: this.getOpenTokenCode(),\\n            grant_type: \\\"authorization_code\\\"\\n        });\\n    },\\n    refreshOpenToken() {\\n        return this.getToken({\\n            grant_type: \\\"refresh_token\\\",\\n            refresh_token: this.$this.openTokens.RefreshTokenOpen,\\n        });\\n    }\\n});\\n$.exports = OpenApi;\"},{\"col_type\":\"movie_3\",\"name\":\"openApi:tvbox\",\"path\":\"openApi_tvbox\",\"rule\":\"function OpenApi($this) {\\n    this.$this = $this;\\n}\\n\\nObject.assign(OpenApi.prototype, {\\n    getOpenTokenCode() {\\n        function get_qrcode_code(sid) {\\n            let res = fetch(\\\"https://openapi.aliyundrive.com/oauth/qrcode/\\\" + sid + \\\"/status\\\");\\n            return JSON.parse(res).authCode;\\n        }\\n\\n        let res = fetch(\\\"http://159.75.208.47/cloudisk/api/oauth/authorize/qrcode\\\");\\n        let data = JSON.parse(res);\\n        let sid = data[\\\"sid\\\"];\\n        let body = {\\n            \\\"authorize\\\": 1,\\n            \\\"scope\\\": \\\"user:base,file:all:read,file:all:write\\\",\\n            \\\"drives\\\": [\\\"backup\\\", \\\"resource\\\"],\\n            \\\"scopes\\\": [\\\"user:base\\\", \\\"file:all:read\\\", \\\"file:all:write\\\"],\\n            \\\"sid\\\": sid\\n        }\\n        let headers = {\\n            'authorization': this.$this.reaccessTk\\n        };\\n        let res2 = this.$this.postApi(\\\"https://open.aliyundrive.com/oauth/users/qrcode/authorize?sid=\\\" + sid).body(body).headers(headers).errorWithRetry((e, _, http) => {\\n            this.$this.trySolve(e);\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    'authorization': this.$this.reaccessTk,\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        return get_qrcode_code(sid);\\n    },\\n    getToken(body) {\\n        let url = \\\"\\\";\\n        if (body.code) {\\n            url = buildUrl(\\\"http://159.75.208.47/cloudisk/api/oauth/accessToken\\\", {\\n                authCode: body.code\\n            });\\n        } else {\\n            url = buildUrl(\\\"http://159.75.208.47/cloudisk/api/oauth/accessToken\\\", {\\n                refreshToken: body.refresh_token\\n            });\\n        }\\n        let res = fetch(url);\\n        let data = JSON.parse(res);\\n        let ret = {\\n            refresh_token: data.refreshToken,\\n            token_type: data.tokenType,\\n            access_token: data.accessToken\\n        };\\n        return ret;\\n    },\\n    getOpenToken() {\\n        return this.getToken({\\n            code: this.getOpenTokenCode(),\\n            grant_type: \\\"authorization_code\\\"\\n        });\\n    },\\n    refreshOpenToken() {\\n        return this.getToken({\\n            grant_type: \\\"refresh_token\\\",\\n            refresh_token: this.$this.openTokens.RefreshTokenOpen,\\n        });\\n    }\\n});\\n$.exports = OpenApi;\"},{\"col_type\":\"movie_3\",\"name\":\"openApi:XBY\",\"path\":\"openApi_XBY\",\"rule\":\"js:\\nfunction OpenApi($this, postApi) {\\n    this.$this = $this;\\n}\\n\\nObject.assign(OpenApi.prototype, {\\n    client_secret: \\\"63f06c3c5c5d4e1196e2c13e8588ae29\\\",\\n    client_id: \\\"df43e22f022d4c04b6e29964f3b8b46d\\\",\\n    getOpenTokenCode() {\\n        function get_qrcode_code(sid) {\\n            let res = fetch(\\\"https://openapi.aliyundrive.com/oauth/qrcode/\\\" + sid + \\\"/status\\\");\\n            return JSON.parse(res).authCode;\\n        }\\n\\n        let res = post(\\\"https://openapi.aliyundrive.com/oauth/authorize/qrcode\\\", {\\n            body: JSON.stringify({\\n                \\\"scopes\\\": [\\\"user:base\\\", \\\"file:all:read\\\", \\\"file:all:write\\\"],\\n                \\\"client_secret\\\": this.client_secret,\\n                \\\"client_id\\\": this.client_id,\\n                \\\"width\\\": 350,\\n                \\\"height\\\": 350,\\n            }),\\n        });\\n        let data = JSON.parse(res);\\n        let sid = data[\\\"sid\\\"];\\n        let body = {\\n            \\\"authorize\\\": 1,\\n            \\\"scope\\\": \\\"user:base,file:all:read,file:all:write\\\",\\n            \\\"drives\\\": [\\\"backup\\\", \\\"resource\\\"],\\n            \\\"scopes\\\": [\\\"user:base\\\", \\\"file:all:read\\\", \\\"file:all:write\\\"],\\n            \\\"sid\\\": sid\\n        }\\n        let headers = {\\n            'authorization': this.$this.reaccessTk\\n        };\\n        let res2 = this.$this.postApi(\\\"https://open.aliyundrive.com/oauth/users/qrcode/authorize?sid=\\\" + sid).body(body).headers(headers).errorWithRetry((e, _, http) => {\\n            this.$this.trySolve(e);\\n            http.mergeHeadAndBody({\\n                headers: {\\n                    'authorization': this.$this.reaccessTk,\\n                }\\n            });\\n            return true;\\n        }).start(true);\\n        return get_qrcode_code(sid);\\n    },\\n    getToken(body) {\\n        let res = post(\\\"https://openapi.aliyundrive.com/oauth/access_token\\\", {\\n            body: JSON.stringify(body),\\n        });\\n        let data = JSON.parse(res);\\n\\n        return data;\\n    },\\n    getOpenToken() {\\n        return this.getToken({\\n            code: this.getOpenTokenCode(),\\n            grant_type: \\\"authorization_code\\\",\\n            client_secret: this.client_secret,\\n            client_id: this.client_id,\\n        });\\n    },\\n    refreshOpenToken() {\\n        return this.getToken({\\n            grant_type: \\\"refresh_token\\\",\\n            refresh_token: this.$this.openTokens.RefreshTokenOpen,\\n            client_secret: this.client_secret,\\n            client_id: this.client_id,\\n        });\\n    }\\n});\\n$.exports = OpenApi;\"},{\"col_type\":\"movie_3\",\"name\":\"链接定向\",\"path\":\"redirect\",\"rule\":\"js:\\nconst openMode = getItem(\\\"openMode\\\", \\\"本地解析\\\");\\n\\nfunction dealArray(array) {\\n    let isString = typeof array[0] === \\\"string\\\";\\n    if (array.length === 1) {\\n        return dealResult(array[0]);\\n    } else if (isString) {\\n        array = array.map(aliUrl => ({\\n            aliUrl\\n        }));\\n    }\\n    let select = array.map((v, i) => v.title || v.aliUrl.replace(/http.*?\\\\/s\\\\//, \\\"\\\"));\\n    return $(select).select((result) => {\\n        let index = MY_INDEX;\\n        return $.require(\\\"redirect\\\").dealResult(result[index]);\\n    }, array);\\n}\\n\\nfunction dealResult(result) {\\n    let resultType = typeof result;\\n    if (resultType === \\\"string\\\") {\\n        return getModeUrl(result);\\n    } else if (Array.isArray(result)) {\\n        return dealArray(result);\\n    } else if(result instanceof EasyNextPage){\\n        return result.toNextPage();\\n    }else if (resultType === \\\"object\\\") {\\n        return getModeUrl(result.aliUrl, result.sharePwd);\\n    }\\n    return \\\"toast://错误类型：\\\" + resultType;\\n}\\n\\nfunction EasyNextPage(list, col) {\\n    //this.list = list;\\n    col = col||\\\"text_3\\\";\\n    this.toNextPage = function(){\\n        return $().rule((list, col_type)=>{\\n            setResult(list.map(v=>({\\n                col_type,\\n                url: $().lazyRule(v=>$.require(\\\"redirect\\\").dealResult(v), v),\\n                title: v.title || v.aliUrl.replace(/http.*?\\\\/s\\\\//, \\\"\\\")\\n            })));\\n        }, list, col);\\n    }\\n}\\n\\nfunction setErrorPop(name) {\\n    return $(\\\"搜索引擎「\\\" + name + \\\"」失效请联系搜索引擎作者修复或删除\\\\n\\\\n引擎作者可以去官方频道询问\\\\n点击确定快速删除\\\").confirm((name) => {\\n        confirm({\\n            title: \\\"温馨提示\\\",\\n            content: \\\"确定要删除\\\" + name + \\\"吗？注意删除后无法恢复\\\",\\n            confirm: $.toString((name) => {\\n                let arr = $.require(\\\"configs\\\").getJson();\\n                let index = arr.findIndex(v => v.name === name);\\n                arr.splice(index, 1);\\n                $.require(\\\"configs\\\").saveJson(arr);\\n                clearItem(\\\"rule\\\");\\n                refreshPage(true);\\n                return \\\"toast://删除成功\\\";\\n            }, name)\\n        });\\n    }, name);\\n}\\n\\nfunction doubleTreating({\\n    findAliUrl,\\n    basicUrl,\\n    name,\\n    aliUrl\\n}) {\\n    if (!findAliUrl) return getModeUrl(aliUrl);\\n    findAliUrl = new Function(\\\"input\\\", \\\"basicUrl\\\", \\\"EasyNextPage\\\", findAliUrl);\\n    try {\\n        let result = findAliUrl(aliUrl, basicUrl, EasyNextPage);\\n        return dealResult(result);\\n    } catch (e) {\\n        log(e.toString());\\n        return setErrorPop(name);\\n    }\\n}\\n\\nfunction getModeUrl(aliUrl, sharePwd) {\\n    if ($.require(\\\"alitest\\\").test(aliUrl)) {\\n        if (openMode === \\\"本地解析\\\") {\\n            return \\\"hiker://page/aliyun?page=fypage&realurl=\\\" + encodeURIComponent(aliUrl) + \\\"&sharePwd=\\\" + (sharePwd || \\\"\\\");\\n        } else {\\n            shareId = aliUrl.split(\\\"/\\\")[4];\\n            return \\\"smartdrive://share/browse?shareId=\\\" + shareId + \\\"&sharePwd=\\\" + (sharePwd || \\\"\\\");\\n        }\\n    } else if (aliUrl.includes(\\\"pan.quark.cn/s/\\\")) {\\n        if (openMode === \\\"本地解析\\\") {\\n            let has = fetch(\\\"hiker://home@Quark.简\\\") != \\\"null\\\";\\n            if (has) {\\n                return \\\"hiker://page/quarkList?rule=Quark.简&realurl=\\\" + encodeURIComponent(aliUrl) + \\\"&sharePwd=\\\" + (sharePwd || \\\"\\\");\\n            } else {\\n                return aliUrl;\\n            }\\n        } else {\\n            return \\\"qklink://www.uc.cn/b20b84fd735a8dd3f7541129bacc4e9a?action=open_url&url=\\\" + aliUrl;\\n        }\\n    } else if (aliUrl.startsWith(\\\"http\\\")) {\\n        return \\\"web://\\\" + aliUrl;\\n    } else if (aliUrl.startsWith(\\\"magnet\\\")) {\\n        if (openMode === \\\"本地解析\\\") {\\n            return aliUrl;\\n        } else {\\n            return \\\"download://\\\" + aliUrl;\\n        }\\n    } else {\\n        return aliUrl;\\n    }\\n}\\n$.exports.getModeUrl = getModeUrl;\\n$.exports.doubleTreating = doubleTreating;\\n$.exports.dealResult = dealResult;\"}]","icon":"","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!