API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：宁安如梦

xiaomianao666
Nov 10th, 2023
119
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 429.63 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥宁安如梦@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"规则处理\",\"path\":\"data\",\"rule\":\"js:\\nfunction doubleTreating(openMode, findAliUrl, title) {\\n    let aliUrl = input;\\n    let sharePwd;\\n    if (findAliUrl) {\\n        let result = findAliUrl(aliUrl);\\n        if (typeof result === \\\"string\\\")\\n            aliUrl = result;\\n        else\\n            aliUrl = result.aliUrl, sharePwd = result.sharePwd;\\n    }\\n    if (aliUrl.includes(\\\"www.aliyundrive.com/s/\\\")) {\\n        if (openMode === \\\"本地转码\\\") {\\n            return 'hiker://page/aliyun?page=fypage&rule=' + title + '&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.startsWith(\\\"http\\\")) {\\n        return \\\"web://\\\" + aliUrl;\\n    } else {\\n        return aliUrl;\\n    }\\n}\\n\\nfunction getModeUrl(aliUrl, sharePwd, openMode) {\\n    if (aliUrl.includes(\\\"www.aliyundrive.com/s/\\\")) {\\n        if (openMode === \\\"本地转码\\\") {\\n            return 'hiker://page/aliyun?page=fypage&rule=' + MY_RULE.title + '&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.startsWith(\\\"http\\\")) {\\n        return \\\"web://\\\" + aliUrl;\\n    } else {\\n        return aliUrl;\\n    }\\n}\\n\\n$.exports.carryRule = function(rule, s, page, searchMode, openMode) {\\n    let list = rule.find(s, page);\\n    if (!list) return [];\\n    let urlLazy = $(\\\"\\\").lazyRule(doubleTreating, openMode, rule.findAliUrl, MY_RULE.title);\\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        it.url = rule.findAliUrl ? it.url + urlLazy : getModeUrl(it.url, it.sharePwd || \\\"\\\", openMode);\\n        resList.push({\\n            title: it.title.includes(\\\"““””\\\") ? it.title : \\\"““””\\\" + it.title.replace(new RegExp(\\\"<em>|</em>\\\", \\\"g\\\"), \\\"\\\").replace(new RegExp(s, \\\"g\\\"), \\\"<strong><span style=\\\\\\\"color: #1E90FF\\\\\\\">\\\" + s + \\\"</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            }, it.extra)\\n        });\\n    }\\n    return resList;\\n}\\nlet size = 10;\\n\\nlet rules = $.require(\\\"hiker://page/rules\\\");\\nlet forbidden = storage0.getItem(\\\"forbidden\\\", []);\\nrules=rules.filter(v => !forbidden.includes(v.name));\\n\\n$.exports.getData = function(page, rule) {\\n    if (!page && !rule) {\\n        return rules.map(it => it.name);\\n    }\\n    if (rule != null) {\\n        if (page != null && page > 1) {\\n            return rules.filter(i => i.name == rule && i.page);\\n        }\\n        return rules.filter(i => i.name == rule);\\n    }\\n    let start = (page - 1) * size;\\n    if (rules.length < start + 1) {\\n        return [];\\n    }\\n    let len = size;\\n    if (rules.length < page * size) {\\n        len = rules.length - start\\n    }\\n    return rules.slice(start, start + len);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索页面\",\"path\":\"sou\",\"rule\":\"js:\\nfunction setHead() {\\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                url: \\\"hiker://empty\\\",\\n                col_type: \\\"rich_text\\\",\\n            });\\n            d.push({\\n                url: \\\"hiker://page/login#noRecordHistory##noHistory#\\\",\\n                col_type: \\\"text_1\\\",\\n                title: \\\"未检测到登录信息，点我跳转登录账号页面，登录阿里云盘账号后方可使用本地转码模式\\\",\\n                extra: {\\n                    pageTitle: \\\"登录阿里云盘\\\"\\n                }\\n            });\\n        }\\n    }\\n    addListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"s\\\");\\n    }));\\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        desc: \\\"\\\",\\n        pic_url: \\\"hiker://images/icon_search6\\\"\\n    });\\n\\n    d.push({\\n        title: \\\"模式：\\\" + openMode,\\n        url: \\\"select://\\\" + JSON.stringify({\\n            title: \\\"选择模式\\\",\\n            options: [\\\"模式：本地转码\\\", \\\"模式：官方APP\\\", \\\"登录账号1\\\", \\\"登录账号2\\\", \\\"Token登录\\\", \\\"登录信息\\\", \\\"规则禁用\\\", \\\"支持作者\\\"],\\n            col: 1,\\n            js: $.toString(() => {\\n                if (\\\"登录账号1\\\" == input) {\\n                    return \\\"hiker://page/login#noRecordHistory##noHistory#?pageTitle=登录阿里云盘\\\"\\n                }\\n                if (\\\"登录账号2\\\" == input) {\\n                    return \\\"hiker://page/login#noRecordHistory##noHistory#?index=0&pageTitle=登录阿里云盘\\\"\\n                }\\n                if (\\\"规则禁用\\\" == input) {\\n                    return \\\"hiker://page/RuleDisable#noRecordHistory##noHistory#\\\";\\n                }\\n                if (\\\"支持作者\\\" == input) {\\n                    return \\\"hiker://page/Donate.v#noRecordHistory##noHistory#\\\";\\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                    let aliTokensFilepath = $.require(\\\"hiker://page/tokenPath\\\").aliTokensFilepath;\\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((path) => {\\n                            return $(\\\"确认注销登录\\\").confirm((path) => {\\n                                deleteFile(path);\\n                                refreshPage();\\n                            }, path);\\n                        }, aliTokensFilepath)\\n                    });\\n                    return;\\n                }\\n                input = input.replace(\\\"模式：\\\", \\\"\\\");\\n                setItem(\\\"openMode\\\", input);\\n                refreshPage();\\n                if (input == \\\"官方APP\\\") {\\n                    return \\\"toast://修改成功，请确保手机有安装阿里云盘官方APP\\\";\\n                }\\n            })\\n        }),\\n        col_type: \\\"icon_2_round\\\",\\n        desc: \\\"\\\",\\n        pic_url: \\\"hiker://images/icon_menu6\\\"\\n    });\\n\\n    d.push({\\n        title: '搜索',\\n        desc: '请输入关键词/链接',\\n        col_type: 'input',\\n        url: $.toString(() => {\\n            input = getMyVar(\\\"s\\\", \\\"\\\") || input;\\n            input = input.trim();\\n            if (input.startsWith(\\\"https://www.aliyundrive.com/s/\\\")) {\\n                clearMyVar(\\\"s\\\");\\n                return \\\"hiker://page/aliyun?pageTitle=打开链接&page=fypage&realurl=\\\" + encodeURIComponent(input);\\n            }\\n            putMyVar('s', input);\\n            refreshPage();\\n            return 'hiker://empty'\\n        }),\\n        extra: {\\n            onChange: \\\"putMyVar('s',input)\\\",\\n            id: id + \\\"ss\\\",\\n            defaultValue: s\\n        }\\n    });\\n    let rules = $.require(\\\"hiker://page/data\\\").getData();\\n    d.push({\\n        title: \\\"🌟\\\",\\n        url: \\\"hiker://collection?rule=\\\" + MY_RULE.title,\\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 of rules) {\\n        d.push({\\n            title: it == r ? \\\"““\\\" + it + \\\"””\\\" : it,\\n            url: $(\\\"#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            desc: \\\"\\\",\\n            pic_url: \\\"\\\",\\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(\\\"hiker://page/data\\\").getData(p, r != \\\"\\\" ? r : null);\\n    let pageid = \\\"ypj-page\\\" + p;\\n    if (data.length > 0) {\\n        d.push({\\n            title: \\\"加载第\\\" + p + \\\"页中，进度：1/\\\" + data.length,\\n            url: \\\"\\\",\\n            col_type: \\\"text_center_1\\\",\\n            desc: \\\"\\\",\\n            pic_url: \\\"\\\",\\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, openMode);\\n                    } catch (e) {\\n                        log(rule.name + \\\":\\\" + e.toString())\\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: $(\\\"确定清除全部搜索记录？\\\").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        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        deleteItem(id + \\\":hotkey\\\");\\n    } catch (e) {\\n        deleteItem(id + \\\":hotkey\\\");\\n        log(e.toString());\\n    }\\n}\\nlet r = getItem(\\\"rule\\\", \\\"\\\");\\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 d = [];\\nif (MY_PAGE === 1) {\\n    setHead();\\n    if (!s) {\\n        setHistory();\\n    }\\n}\\nif (s) {\\n    record()\\n    searchEnd();\\n} else if (MY_PAGE === 1) {\\n    setTrendingTabEnd();\\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 (input.includes(\\\"aliyundrive.com\\\") && 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    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            playUrlList.forEach((item) => {\\n                if (item.template_id == line) {\\n                    aliurl = item.url;\\n                }\\n            });\\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                '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);\\n        if (url.includes(\\\".ts\\\")) {\\n            return JSON.stringify({\\n                statusCode: 302,\\n                headers: {\\n                    \\\"Location\\\": updateTsUrl(url),\\n                    'Referer': 'https://www.aliyundrive.com/'\\n                }\\n            });\\n        } else {\\n            //log(url);\\n            let ff = getM3u8Content(getAliPlayUrl(fileId, MY_PARAMS.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\\n\\nfunction getOriVideo(aliAccessApi, fileId) {\\n    return {\\n        names: [\\\"原画\\\"],\\n        urls: [aliAccessApi.getVideoTemPlayUrl(fileId) + \\\"#isVideo=true#\\\"],\\n        headers: [{\\n            'Referer': 'https://www.aliyundrive.com/'\\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 {\\n                playList = getOriVideo(aliAccessApi, fileId);\\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\\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\\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\\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}\\nsetPagePicUrl();\\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}\\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 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            }));\\n        }\\n        setMarker();\\n        if (realurl && !isSearch) {\\n            let shareInfo = aliShareApi.getShareInfo();\\n\\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,\\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                    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 funStyle = isSearch ? \\\"icon_small_3\\\" : \\\"icon_round_small_4\\\";\\n        items.push({\\n            title: style,\\n            url: $(styles, 1, \\\"排布样式\\\").select(() => {\\n                setItem(\\\"aliyun_style\\\", input);\\n                refreshPage();\\n                return \\\"toast://已切换\\\";\\n            }),\\n            col_type: funStyle,\\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            col_type: funStyle,\\n            pic_url: \\\"https://hikerfans.com/img/ali_sort.svg\\\"\\n        }, {\\n            title: getItem(\\\"aliyun_playMode\\\", \\\"转码\\\"),\\n            url: $([\\\"转码\\\", \\\"原画\\\"], 2, \\\"播放模式\\\").select(() => {\\n                setItem(\\\"aliyun_playMode\\\", input);\\n                refreshPage();\\n                return \\\"toast://切换成功\\\";\\n            }),\\n            col_type: funStyle,\\n            pic_url: \\\"https://hikerfans.com/img/ali_play.svg\\\"\\n        });\\n        if (!isSearch) {\\n            items.push({\\n                title: \\\"功能\\\",\\n                url: $([\\\"转存云盘\\\", \\\"登陆账号\\\", \\\"复制分享链接\\\", \\\"查看手动挂载字幕\\\", \\\"获取弹幕搜索规则\\\", \\\"批量挂载本地弹幕\\\"], 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 \\\"copy://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                    }\\n                }, shareId, sharePwd, fileId),\\n                col_type: \\\"icon_round_small_4\\\",\\n                pic_url: \\\"https://hikerfans.com/img/ali_fileinto.svg\\\",\\n            });\\n        }\\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    let folderStyle, fileStyle, isWatching = style === \\\"追剧\\\";\\n    if (isWatching) {\\n        folderStyle = \\\"avatar\\\";\\n        fileStyle = \\\"movie_2\\\";\\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                }\\n            });\\n        } else {\\n            let subtitle, longc, cls;\\n            let title = (fileStyle === \\\"text_1\\\" ? (titleHead[cate] || \\\"❓\\\") : \\\"\\\") + 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\\\";\\n                pic_url = fileItem.thumbnail || pic_url;\\n            } else if (isWatching) {\\n                continue;\\n            }\\n\\n            if (fileStyle === \\\"text_1\\\") {\\n                desc += \\\"\\\\t\\\\t\\\" + formatSize(fileItem.size);\\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 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\\\"];\\nlet index = Number(getParam(\\\"index\\\", \\\"1\\\"));\\nif (Number.isNaN(index)) {\\n    index = 1;\\n}\\nlet url = loginUrls[index];\\nlet isRefresh = !getParam(\\\"noRefresh\\\");\\nlet aliTokensFilepath= $.require(\\\"tokenPath\\\").aliTokensFilepath;\\n\\nvar 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\\nd.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});\\nsetResult(d);\"},{\"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\\nfunction postApi(api, body, headers, againTry, tryFre) {\\n    let result;\\n    try {\\n        result = request(api.startsWith(\\\"http\\\") ? api : '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            let msg = result.display_message || result.message;\\n            let error = new Error(api + \\\"=>\\\" + result.code + \\\":\\\" + msg);\\n            error.code = result.code;\\n            error.judgeMsg = msg\\n            throw error;\\n        }\\n        let rbody = 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            throw error;\\n        }\\n    } catch (e) {\\n        tryFre = tryFre === undefined ? 1 : tryFre;\\n        if (againTry && tryFre > 0) {\\n            if (typeof againTry === \\\"function\\\") {\\n                let newData = againTry(e, result, body, headers, tryFre);\\n                if (newData) {\\n                    Object.assign(body, newData.body);\\n                    Object.assign(headers, newData.headers);\\n                }\\n            }\\n            return postApi(api, body, headers, againTry, tryFre - 1);\\n        }\\n        throw e;\\n    }\\n    return result;\\n}\\n\\nfunction AliAccessApi(shareId, sharePwd, shareToken, aliTokens, openTokens, refreshShareCallBack, refreshAccessCallBack, refreshOpenCallBack) {\\n    this.shareId = shareId;\\n    this.sharePwd = sharePwd;\\n    this.refreshShareCallBack = refreshShareCallBack || (() => void 0);\\n    this.refreshAccessCallBack = refreshAccessCallBack || (() => void 0);\\n    this.refreshOpenCallBack = refreshOpenCallBack || (() => void 0);\\n    this.shareToken = shareToken || this.getShareToken();\\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    this.openTokens = openTokens || {\\n        'RefreshTokenOpen': '',\\n        'AccessTokenOpen': '',\\n        'BindRefreshToken': '',\\n    };\\n    if (openTokens !== null && !this.openTokens.AccessTokenOpen) {\\n        this.refreshOpenToken();\\n    }\\n}\\nObject.assign(AliAccessApi.prototype, {\\n    waitSleep(time) {\\n        java.lang.Thread.sleep(time || 600);\\n        return this;\\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\\\") {\\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    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.refreshShareCallBack(result.share_token, this);\\n        return result.share_token;\\n    },\\n    refreshAccessToken() {\\n        let result = postApi(\\\"https://auth.aliyundrive.com/v2/account/token\\\", {\\n            \\\"grant_type\\\": \\\"refresh_token\\\",\\n            \\\"refresh_token\\\": this.aliTokens.refresh_token,\\n        }, {\\n            \\\"User-Agent\\\": PC_UA,\\n            \\\"Referer\\\": \\\"https://www.aliyundrive.com/\\\"\\n        }, (e) => {\\n            if (e.code === \\\"InvalidParameter.RefreshToken\\\") {\\n                e.message = \\\"#登陆过期请重新登陆#\\\\n\\\" + e.message;\\n                throw e;\\n            }\\n        });\\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 = postApi(\\\"https://user.aliyundrive.com/v2/user/get\\\", {}, {\\n            \\\"User-Agent\\\": PC_UA,\\n            \\\"authorization\\\": this.reaccessTk,\\n            \\\"Referer\\\": \\\"https://www.aliyundrive.com/\\\"\\n        }, (e) => {\\n            this.trySolve(e);\\n            return {\\n                headers: {\\n                    'authorization': this.reaccessTk\\n                }\\n            }\\n        });\\n        return info;\\n    },\\n    _getOpenToken(code) {\\n        let body = {},\\n            headers = {\\n                'User-Agent': PC_UA,\\n                'Referer': 'https://www.aliyundrive.com/'\\n            };\\n        if (code) {\\n            body = {\\n                code: code,\\n                grant_type: \\\"authorization_code\\\"\\n            };\\n        } else {\\n            body = {\\n                grant_type: \\\"refresh_token\\\",\\n                refresh_token: this.openTokens.RefreshTokenOpen,\\n            }\\n        }\\n        let json = post('https://api.xhofe.top/alist/ali_open/code', {\\n            headers: headers,\\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            if (openResult.refresh_token) {\\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                return this.openTokens;\\n            }\\n        }\\n        if (!code) {\\n            return this.waitSleep(50).cacheOpenToken();\\n        }\\n        throw new Error(\\\"openToken获取失败\\\\n\\\" + json);\\n    },\\n    cacheOpenToken() {\\n        let result = 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=', {\\n            \\\"authorize\\\": 1,\\n            \\\"scope\\\": \\\"user:base,file:all:read,file:all:write\\\"\\n        }, {\\n            'User-Agent': PC_UA,\\n            'Referer': 'https://www.aliyundrive.com/',\\n            'authorization': this.reaccessTk, //getAccessToken\\n            'x-canary': 'client=web,app=share,version=v2.3.1',\\n            'x-share-token': this.shareToken\\n        }, (e) => {\\n            this.trySolve(e);\\n            return {\\n                headers: {\\n                    'authorization': this.reaccessTk,\\n                    'x-share-token': this.shareToken\\n                }\\n            }\\n        });\\n        let code = result.redirectUri.split(\\\"code=\\\")[1];\\n        return this._getOpenToken(code);\\n    },\\n    refreshOpenToken() {\\n        if (this.openTokens.RefreshTokenOpen && this.openTokens.BindRefreshToken === this.aliTokens.refresh_token) {\\n            return this._getOpenToken();\\n        } else {\\n            return this.cacheOpenToken();\\n        }\\n    },\\n    _cloudFileOperate(body, cloudFileId, operateUrl) {\\n        let result = postApi('https://api.aliyundrive.com/adrive/v2/batch', {\\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        }, {\\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\\n        }, (e, r, b) => {\\n            if (e.code === \\\"QuotaExhausted.Drive\\\") {\\n                throw e;\\n            }\\n            if (!this.trySolve(e)) {\\n                this.waitSleep(20).refreshAccessToken();\\n            }\\n            let body = b.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            return {\\n                body: b,\\n                headers: {\\n                    'authorization': this.reaccessTk,\\n                    'x-share-token': this.shareToken\\n                }\\n            };\\n        });\\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 = postApi('https://open.aliyundrive.com/adrive/v1.0/openFile/getDownloadUrl', {\\n            'file_id': cloudFileId,\\n            'drive_id': this.defDriveId\\n        }, {\\n            'User-Agent': PC_UA,\\n            'Referer': 'https://www.aliyundrive.com/',\\n            'authorization': this.openTokens.AccessTokenOpen\\n        }, () => {\\n            this.waitSleep(30).refreshOpenToken();\\n            return {\\n                body: {\\n                    'drive_id': this.defDriveId,\\n                },\\n                headers: {\\n                    'authorization': this.openTokens.AccessTokenOpen\\n                }\\n            };\\n        }, 2);\\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 = postApi(\\\"/v2/file/get_share_link_download_url\\\", {\\n            \\\"expire_sec\\\": 600,\\n            \\\"file_id\\\": fileId,\\n            \\\"share_id\\\": this.shareId\\n        }, {\\n            \\\"X-Share-Token\\\": this.shareToken,\\n            \\\"authorization\\\": this.aliTokens.access_token\\n        }, (e) => {\\n            this.trySolve(e);\\n            return {\\n                headers: {\\n                    \\\"X-Share-Token\\\": this.shareToken,\\n                    \\\"authorization\\\": this.aliTokens.access_token\\n                }\\n            };\\n        });\\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 = postApi('/users/v1/users/device/create_session', {\\n            \\\"deviceName\\\": \\\"Edge浏览器\\\",\\n            \\\"modelName\\\": \\\"Windows网页版\\\",\\n            \\\"pubKey\\\": newSign.pubKey,\\n        }, {\\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        }, (e) => {\\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            return {\\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        }, 3);\\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 = JSON.parse(request('https://api.aliyundrive.com/v2/file/get_share_link_video_preview_play_info', {\\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            },\\n            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            },\\n            method: 'POST',\\n            timeout: 3000\\n        }));\\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\\n    function saveAliToken(result, api) {\\n        writeFile(aliTokensFilepath, JSON.stringify(api.aliTokens));\\n    }\\n\\n    function saveOpenToken(result, api) {\\n        writeFile(openTokensFilepath, JSON.stringify(api.openTokens));\\n    }\\n\\n    function putShareToken(result) {\\n        if (MY_TITLE) {\\n            shareToken = putVar(MY_TITLE + \\\"@\\\" + \\\"aliShareToken\\\", result);\\n        } else {\\n            shareToken = putMyVar(\\\"aliShareToken\\\", result);\\n        }\\n    }\\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(shareId, sharePwd, shareToken, aliToken, openToken, putShareToken, saveAliToken, saveOpenToken);\\n}\\n$.exports = AliAccessApi;\"},{\"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\":\"弹幕工具\",\"path\":\"danmu\",\"rule\":\"js:\\nlet basicUrl = \\\"https://api.dandanplay.net/\\\";\\nlet sevePath = \\\"hiker://files/cache/danmu/\\\";\\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    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 == 3) {\\n                //颜色值为0时，默认设置为白色\\n                if (params[i] == \\\"0\\\" || params[i] == \\\"-1\\\") {\\n                    paramsT.push(\\\"16777215\\\");\\n                    continue\\n                }\\n\\n            }\\n            if (i == 2) {\\n                paramsT.push(\\\"25\\\");\\n            }\\n            paramsT.push(params[i]);\\n\\n        }\\n        paramsT.push(\\\"0\\\", \\\"0\\\", \\\"0\\\");\\n        dMcontext += `<d p=\\\"${paramsT.join(',')}\\\">${encodeHtml(commentText)}</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> 内置弹幕搜索数据来源于[弹弹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: \\\"内置搜索弹幕\\\",\\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_2\\\"\\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_2\\\"\\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\":\"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        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\\\": \\\"tvbox2023\\\",\\n                            \\\"password\\\": \\\"Tvbox2023\\\",\\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: true,\\n        find: function(s, page) {\\n            function gethtml() {\\n                let html = request(\\\"https://zhaoziyuan.me/so?filename=\\\" + s + \\\"&page=\\\" + page, {\\n                    headers: {\\n                        \\\"Referer\\\": \\\"https://zhaoziyuan.me/stop.html\\\",\\n                        \\\"origin\\\": \\\"https://zhaoziyuan.me\\\",\\n                        \\\"Cookie\\\": getItem(\\\"zzycooke\\\", \\\"\\\"),\\n                        \\\"upgrade-insecure-requests\\\": \\\"1\\\",\\n                        \\\"content-type\\\": \\\"application/x-www-form-urlencoded\\\"\\n                    }\\n                });\\n                return html;\\n            };\\n            var html = gethtml();\\n            if (!html.includes(\\\"search_box\\\")) {\\n                let user = 'dXNlcm5hbWU9eXBqMjAyMyZwYXNzd29yZD15cGoyMDIz';\\n                let cook = JSON.parse(fetchCookie('https://zhaoziyuan.me/logiu.html', {\\n                    headers: {\\n                        'User-Agent': MOBILE_UA,\\n                        'Content-Type': 'application/x-www-form-urlencoded',\\n                        'Origin': 'https://zhaoziyuan.me',\\n                        'Referer': 'https://zhaoziyuan.me/login.html',\\n                        \\\"upgrade-insecure-requests\\\": \\\"1\\\"\\n                    },\\n                    body: base64Decode(user),\\n                    method: 'POST',\\n                    onlyHeaders: true,\\n                    withHeaders: true\\n                })).join(';');\\n                setItem(\\\"zzycooke\\\", cook);\\n                log(\\\"找资源登入\\\");\\n                html = gethtml();\\n            }\\n\\n            let arr = pdfa(html, \\\"body&&.newsList&&li:not(:first-child)\\\");\\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, \\\"a&&href\\\");\\n                if (u == null) {\\n                    continue;\\n                }\\n                u = \\\"https://zhaoziyuan.me/\\\" + u;\\n                //log(u);\\n                let title = pdfh(it, \\\".news_text&&h3&&Text\\\");\\n                if (!title) continue;\\n                d.push({\\n                    title: title,\\n                    desc: pdfh(it, \\\".news_text&&p&&Text\\\"),\\n                    url: u\\n                });\\n            }\\n            return d;\\n        },\\n        findAliUrl(input) {\\n            let html = request(input);\\n            var _links = html.match(/https:\\\\/\\\\/(www\\\\.aliyundrive\\\\.com\\\\/s|alywp\\\\.net)\\\\/\\\\w*/g) || [];\\n\\n            if (_links.length > 0) {\\n\\n                return _links[0];\\n            } else {\\n                return input;\\n            }\\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        find: function(s, page) {\\n            let url = \\\"http://wogg.xyz/index.php/vodsearch/\\\" + s + \\\"----------\\\" + page + \\\"---.html\\\";\\n            let html = request(url, {});\\n            let arr = parseDomForArray(html, '.module-items&&.module-search-item');\\n            //log(arr);\\n            let d = [];\\n            let bet = [];\\n            for (let i = 0; i < arr.length; i++) {\\n                let it = arr[i];\\n                let utitle = parseDomForHtml(it, 'h3&&a&&Text');\\n                let userial = parseDomForHtml(it, '.video-serial&&Text');\\n                let uimage = parseDom(it, '.lazyload&&data-src', 'http://wogg.xyz/');\\n                let u = parseDom(it, 'h3&&a&&href', 'http://wogg.xyz/');\\n                //let det = request(u, {});\\n                bet.push({\\n                    title: utitle,\\n                    url: u,\\n                    image: uimage,\\n                    desc: userial\\n                });\\n            }\\n            if (bet.length > 0) {\\n                let beth = batchFetch(bet);\\n                for (let i = 0; i < beth.length; i++) {\\n                    let list = parseDomForArray(beth[i], '.module-player-list&&p')\\n                    for (let j = 0; j < list.length; j++) {\\n                        let u = parseDomForHtml(list[j], 'p&&Text');\\n                        if (!u.includes(\\\"/s/\\\")) {\\n                            continue;\\n                        }\\n                        d.push({\\n                            title: bet[i].title,\\n                            pic_url: bet[i].image,\\n                            url: u,\\n                            desc: bet[i].desc + '\\\\n' + u,\\n                        });\\n\\n                    }\\n                }\\n            }\\n            return d;\\n        }\\n    },\\n    {\\n        name: \\\"阿里云盘网\\\",\\n        page: true,\\n        find: function(s, page) {\\n            let url = \\\"https://www.alypw.cn/search.php?q=\\\" + s + \\\"&page=\\\" + page;\\n            let html = request(url, {});\\n            let arr = parseDomForArray(html, '.list&&li');\\n            //log(arr);\\n            let d = [];\\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, '.fa-clock-o&&Text');\\n                let uimage = parseDom(it, 'img&&src', 'https://www.alypw.cn/');\\n                let u = parseDom(it, 'a&&href', 'https://www.alypw.cn/');\\n                //let det = request(u, {});\\n                if (!utitle.includes(s)) {\\n                    continue;\\n                }\\n                bet.push({\\n                    title: utitle,\\n                    url: u,\\n                    image: uimage,\\n                    desc: userial\\n                });\\n            }\\n            //log(bet);\\n            if (bet.length > 0) {\\n                let beth = batchFetch(bet);\\n                for (let i = 0; i < beth.length; i++) {\\n                    let list = parseDomForArray(beth[i], 'body&&a[href^=https://www.aliyundrive.com/s/]')\\n                    //log(list);\\n                    for (let j = 0; j < list.length; j++) {\\n                        let u = parseDomForHtml(list[j], 'a&&href');\\n                        d.push({\\n                            title: bet[i].title,\\n                            pic_url: bet[i].image,\\n                            url: u,\\n                            desc: bet[i].desc + '\\\\n' + u,\\n                        });\\n\\n                    }\\n                }\\n            }\\n            return d;\\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            //log(json);\\n            let arr = JSON.parse(json); //[0].result.items;\\n            //log(arr);\\n\\n            let d = [];\\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                    options: {\\n                        headers: {\\n                            \\\"Referer\\\": \\\"https://www.yunpanfenxiang.cn/\\\"\\n                        }\\n                    }\\n                });\\n            }\\n            //log(u);\\n            let beth = batchFetch(bet);\\n\\n            //log(article);\\n            for (let i = 0; i < beth.length; i++) {\\n                let json = JSON.parse(beth[i]).data;\\n                //log(json);\\n                let list = json.download.split('@');\\n                for (let j = 0; j < list.length; j++) {\\n                    let u = list[j];\\n                    d.push({\\n                        title: json.title,\\n                        url: 'https://www.aliyundrive.com/s/' + u,\\n                        desc: json.createtime + \\\"\\\\n\\\" + 'https://www.aliyundrive.com/s/' + u,\\n                    });\\n                }\\n            }\\n\\n            return d;\\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    /*,\\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\":\"aliUtil\",\"rule\":\"$.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    getNamesSort() {\\n        let chnNumChar = {\\n            零: 0,\\n            一: 1,\\n            二: 2,\\n            三: 3,\\n            四: 4,\\n            五: 5,\\n            六: 6,\\n            七: 7,\\n            八: 8,\\n            九: 9\\n        };\\n\\n        let 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\\n        function 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\\n        function 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        return nameCompare;\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"弹幕批量挂载\",\"path\":\"dmMount\",\"rule\":\"js:\\nlet d = [];\\naddListener(\\\"onClose\\\", () => clearMyVar(\\\"dllastTime\\\"))\\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 aliUtil = $.require(\\\"aliUtil\\\");\\n        let nameCompare = aliUtil.getNamesSort();\\n        dmlist.sort((a, b) => 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\\\", \\\"0\\\"));\\n\\nif (MY_PARAMS.automaticadd===\\\"1\\\"&&lastRecord && 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 = 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><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\":\"text_icon\",\"name\":\"规则禁用\",\"path\":\"RuleDisable\",\"rule\":\"js:\\nsetPageTitle(\\\"禁用规则\\\");\\naddListener(\\\"onClose\\\",()=>refreshPage());\\nlet data = $.require(\\\"hiker://page/rules\\\").map(v=>v.name);\\nlet d = [];\\nd.push({\\n    title: \\\"全部取消禁用\\\",\\n    url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n        clearItem(\\\"forbidden\\\");\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\";\\n    }),\\n    col_type: \\\"text_center_1\\\"\\n});\\nlet forbidden = storage0.getItem(\\\"forbidden\\\", []);\\nlet qid = String(Date.now());\\nfor (let i = 0; i < data.length; i++) {\\n    let it = data[i];\\n    d.push({\\n        title: it,\\n        url: $(\\\"#noLoading#\\\").lazyRule((it, id) => {\\n            let forbidden = storage0.getItem(\\\"forbidden\\\", []);\\n            let index = forbidden.indexOf(it);\\n            if (index > -1) {\\n                forbidden.splice(index, 1);\\n                updateItem(id, {\\n                    pic_url: \\\"hiker://images/icon_rect\\\"\\n                });\\n            } else {\\n                forbidden.push(it);\\n                updateItem(id, {\\n                    pic_url: \\\"hiker://images/icon_rect_fill\\\"\\n                });\\n            }\\n            storage0.setItem(\\\"forbidden\\\", forbidden);\\n            return \\\"hiker://empty\\\";\\n        }, it, qid + i),\\n        pic_url: forbidden.includes(it) ? \\\"hiker://images/icon_rect_fill\\\" : \\\"hiker://images/icon_rect\\\",\\n        extra: {\\n            id: qid + i\\n        }\\n    });\\n}\\nsetResult(d);\"}],\"params\":\"{\\\"inheritTitle\\\":false,\\\"shareToken\\\":\\\"eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJjdXN0b21Kc29uIjoie1wiZG9tYWluX2lkXCI6XCJiajI5XCIsXCJzaGFyZV9pZFwiOlwiRExGWDNQUUJINndcIixcImNyZWF0b3JcIjpcImJhNTIzYTU2OGEzYjRlZDA4NzcxM2ExOGE1MTU2MDAzXCIsXCJ1c2VyX2lkXCI6XCJhbm9ueW1vdXNcIn0iLCJjdXN0b21UeXBlIjoic2hhcmVfbGluayIsImV4cCI6MTY5OTYzNTI4NCwiaWF0IjoxNjk5NjI4MDI0fQ.nH9lYXwgsusRH47oaYlPQ2q3AP2JAq1tZAaBGbFeaHeMPrLVzUNs9qkw9SEsYDnl2fqaTdRNl7bT3DBLaAt2cIAdcGsEpf3faNsJXfbjCy-NHnMjIN3N8HnZfPW33f8JvfngYiimW_AkzN85ETFR3UzkOjOhiAEYHiWAmKODaZ8\\\"}\",\"saved\":false,\"title\":\"云盘君.简\",\"version\":0,\"url\":\"hiker://page/aliyun?page=fypage&rule=云盘君.简&realurl=https%3A%2F%2Fwww.aliyundrive.com%2Fs%2FDLFX3PQBH6w%2Ffolder%2F654dbd8fda1692870c384e9ebc43e8599b240623&sharePwd=\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\n//@author LoyDgIk\\nconst AliShareApi = $.require(\\\"AliApi\\\");\\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\\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}\\nsetPagePicUrl();\\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}\\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 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            }));\\n        }\\n        setMarker();\\n        if (realurl && !isSearch) {\\n            let shareInfo = aliShareApi.getShareInfo();\\n\\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,\\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                    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 funStyle = isSearch ? \\\"icon_small_3\\\" : \\\"icon_round_small_4\\\";\\n        items.push({\\n            title: style,\\n            url: $(styles, 1, \\\"排布样式\\\").select(() => {\\n                setItem(\\\"aliyun_style\\\", input);\\n                refreshPage();\\n                return \\\"toast://已切换\\\";\\n            }),\\n            col_type: funStyle,\\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            col_type: funStyle,\\n            pic_url: \\\"https://hikerfans.com/img/ali_sort.svg\\\"\\n        }, {\\n            title: getItem(\\\"aliyun_playMode\\\", \\\"转码\\\"),\\n            url: $([\\\"转码\\\", \\\"原画\\\"], 2, \\\"播放模式\\\").select(() => {\\n                setItem(\\\"aliyun_playMode\\\", input);\\n                refreshPage();\\n                return \\\"toast://切换成功\\\";\\n            }),\\n            col_type: funStyle,\\n            pic_url: \\\"https://hikerfans.com/img/ali_play.svg\\\"\\n        });\\n        if (!isSearch) {\\n            items.push({\\n                title: \\\"功能\\\",\\n                url: $([\\\"转存云盘\\\", \\\"登陆账号\\\", \\\"复制分享链接\\\", \\\"查看手动挂载字幕\\\", \\\"获取弹幕搜索规则\\\", \\\"批量挂载本地弹幕\\\"], 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 \\\"copy://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                    }\\n                }, shareId, sharePwd, fileId),\\n                col_type: \\\"icon_round_small_4\\\",\\n                pic_url: \\\"https://hikerfans.com/img/ali_fileinto.svg\\\",\\n            });\\n        }\\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    let folderStyle, fileStyle, isWatching = style === \\\"追剧\\\";\\n    if (isWatching) {\\n        folderStyle = \\\"avatar\\\";\\n        fileStyle = \\\"movie_2\\\";\\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                }\\n            });\\n        } else {\\n            let subtitle, longc, cls;\\n            let title = (fileStyle === \\\"text_1\\\" ? (titleHead[cate] || \\\"❓\\\") : \\\"\\\") + 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\\\";\\n                pic_url = fileItem.thumbnail || pic_url;\\n            } else if (isWatching) {\\n                continue;\\n            }\\n\\n            if (fileStyle === \\\"text_1\\\") {\\n                desc += \\\"\\\\t\\\\t\\\" + formatSize(fileItem.size);\\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);\",\"group\":\"②网盘\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"规则处理\\\",\\\"path\\\":\\\"data\\\",\\\"rule\\\":\\\"js:\\\\nfunction doubleTreating(openMode, findAliUrl, title) {\\\\n    let aliUrl = input;\\\\n    let sharePwd;\\\\n    if (findAliUrl) {\\\\n        let result = findAliUrl(aliUrl);\\\\n        if (typeof result === \\\\\\\"string\\\\\\\")\\\\n            aliUrl = result;\\\\n        else\\\\n            aliUrl = result.aliUrl, sharePwd = result.sharePwd;\\\\n    }\\\\n    if (aliUrl.includes(\\\\\\\"www.aliyundrive.com/s/\\\\\\\")) {\\\\n        if (openMode === \\\\\\\"本地转码\\\\\\\") {\\\\n            return 'hiker://page/aliyun?page=fypage&rule=' + title + '&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.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n        return \\\\\\\"web://\\\\\\\" + aliUrl;\\\\n    } else {\\\\n        return aliUrl;\\\\n    }\\\\n}\\\\n\\\\nfunction getModeUrl(aliUrl, sharePwd, openMode) {\\\\n    if (aliUrl.includes(\\\\\\\"www.aliyundrive.com/s/\\\\\\\")) {\\\\n        if (openMode === \\\\\\\"本地转码\\\\\\\") {\\\\n            return 'hiker://page/aliyun?page=fypage&rule=' + MY_RULE.title + '&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.startsWith(\\\\\\\"http\\\\\\\")) {\\\\n        return \\\\\\\"web://\\\\\\\" + aliUrl;\\\\n    } else {\\\\n        return aliUrl;\\\\n    }\\\\n}\\\\n\\\\n$.exports.carryRule = function(rule, s, page, searchMode, openMode) {\\\\n    let list = rule.find(s, page);\\\\n    if (!list) return [];\\\\n    let urlLazy = $(\\\\\\\"\\\\\\\").lazyRule(doubleTreating, openMode, rule.findAliUrl, MY_RULE.title);\\\\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        it.url = rule.findAliUrl ? it.url + urlLazy : getModeUrl(it.url, it.sharePwd || \\\\\\\"\\\\\\\", openMode);\\\\n        resList.push({\\\\n            title: it.title.includes(\\\\\\\"““””\\\\\\\") ? it.title : \\\\\\\"““””\\\\\\\" + it.title.replace(new RegExp(\\\\\\\"<em>|</em>\\\\\\\", \\\\\\\"g\\\\\\\"), \\\\\\\"\\\\\\\").replace(new RegExp(s, \\\\\\\"g\\\\\\\"), \\\\\\\"<strong><span style=\\\\\\\\\\\\\\\"color: #1E90FF\\\\\\\\\\\\\\\">\\\\\\\" + s + \\\\\\\"</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            }, it.extra)\\\\n        });\\\\n    }\\\\n    return resList;\\\\n}\\\\nlet size = 10;\\\\n\\\\nlet rules = $.require(\\\\\\\"hiker://page/rules\\\\\\\");\\\\nlet forbidden = storage0.getItem(\\\\\\\"forbidden\\\\\\\", []);\\\\nrules=rules.filter(v => !forbidden.includes(v.name));\\\\n\\\\n$.exports.getData = function(page, rule) {\\\\n    if (!page && !rule) {\\\\n        return rules.map(it => it.name);\\\\n    }\\\\n    if (rule != null) {\\\\n        if (page != null && page > 1) {\\\\n            return rules.filter(i => i.name == rule && i.page);\\\\n        }\\\\n        return rules.filter(i => i.name == rule);\\\\n    }\\\\n    let start = (page - 1) * size;\\\\n    if (rules.length < start + 1) {\\\\n        return [];\\\\n    }\\\\n    let len = size;\\\\n    if (rules.length < page * size) {\\\\n        len = rules.length - start\\\\n    }\\\\n    return rules.slice(start, start + len);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索页面\\\",\\\"path\\\":\\\"sou\\\",\\\"rule\\\":\\\"js:\\\\nfunction setHead() {\\\\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                url: \\\\\\\"hiker://empty\\\\\\\",\\\\n                col_type: \\\\\\\"rich_text\\\\\\\",\\\\n            });\\\\n            d.push({\\\\n                url: \\\\\\\"hiker://page/login#noRecordHistory##noHistory#\\\\\\\",\\\\n                col_type: \\\\\\\"text_1\\\\\\\",\\\\n                title: \\\\\\\"未检测到登录信息，点我跳转登录账号页面，登录阿里云盘账号后方可使用本地转码模式\\\\\\\",\\\\n                extra: {\\\\n                    pageTitle: \\\\\\\"登录阿里云盘\\\\\\\"\\\\n                }\\\\n            });\\\\n        }\\\\n    }\\\\n    addListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\n        clearMyVar(\\\\\\\"s\\\\\\\");\\\\n    }));\\\\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        desc: \\\\\\\"\\\\\\\",\\\\n        pic_url: \\\\\\\"hiker://images/icon_search6\\\\\\\"\\\\n    });\\\\n\\\\n    d.push({\\\\n        title: \\\\\\\"模式：\\\\\\\" + openMode,\\\\n        url: \\\\\\\"select://\\\\\\\" + JSON.stringify({\\\\n            title: \\\\\\\"选择模式\\\\\\\",\\\\n            options: [\\\\\\\"模式：本地转码\\\\\\\", \\\\\\\"模式：官方APP\\\\\\\", \\\\\\\"登录账号1\\\\\\\", \\\\\\\"登录账号2\\\\\\\", \\\\\\\"Token登录\\\\\\\", \\\\\\\"登录信息\\\\\\\", \\\\\\\"规则禁用\\\\\\\", \\\\\\\"支持作者\\\\\\\"],\\\\n            col: 1,\\\\n            js: $.toString(() => {\\\\n                if (\\\\\\\"登录账号1\\\\\\\" == input) {\\\\n                    return \\\\\\\"hiker://page/login#noRecordHistory##noHistory#?pageTitle=登录阿里云盘\\\\\\\"\\\\n                }\\\\n                if (\\\\\\\"登录账号2\\\\\\\" == input) {\\\\n                    return \\\\\\\"hiker://page/login#noRecordHistory##noHistory#?index=0&pageTitle=登录阿里云盘\\\\\\\"\\\\n                }\\\\n                if (\\\\\\\"规则禁用\\\\\\\" == input) {\\\\n                    return \\\\\\\"hiker://page/RuleDisable#noRecordHistory##noHistory#\\\\\\\";\\\\n                }\\\\n                if (\\\\\\\"支持作者\\\\\\\" == input) {\\\\n                    return \\\\\\\"hiker://page/Donate.v#noRecordHistory##noHistory#\\\\\\\";\\\\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                    let aliTokensFilepath = $.require(\\\\\\\"hiker://page/tokenPath\\\\\\\").aliTokensFilepath;\\\\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((path) => {\\\\n                            return $(\\\\\\\"确认注销登录\\\\\\\").confirm((path) => {\\\\n                                deleteFile(path);\\\\n                                refreshPage();\\\\n                            }, path);\\\\n                        }, aliTokensFilepath)\\\\n                    });\\\\n                    return;\\\\n                }\\\\n                input = input.replace(\\\\\\\"模式：\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                setItem(\\\\\\\"openMode\\\\\\\", input);\\\\n                refreshPage();\\\\n                if (input == \\\\\\\"官方APP\\\\\\\") {\\\\n                    return \\\\\\\"toast://修改成功，请确保手机有安装阿里云盘官方APP\\\\\\\";\\\\n                }\\\\n            })\\\\n        }),\\\\n        col_type: \\\\\\\"icon_2_round\\\\\\\",\\\\n        desc: \\\\\\\"\\\\\\\",\\\\n        pic_url: \\\\\\\"hiker://images/icon_menu6\\\\\\\"\\\\n    });\\\\n\\\\n    d.push({\\\\n        title: '搜索',\\\\n        desc: '请输入关键词/链接',\\\\n        col_type: 'input',\\\\n        url: $.toString(() => {\\\\n            input = getMyVar(\\\\\\\"s\\\\\\\", \\\\\\\"\\\\\\\") || input;\\\\n            input = input.trim();\\\\n            if (input.startsWith(\\\\\\\"https://www.aliyundrive.com/s/\\\\\\\")) {\\\\n                clearMyVar(\\\\\\\"s\\\\\\\");\\\\n                return \\\\\\\"hiker://page/aliyun?pageTitle=打开链接&page=fypage&realurl=\\\\\\\" + encodeURIComponent(input);\\\\n            }\\\\n            putMyVar('s', input);\\\\n            refreshPage();\\\\n            return 'hiker://empty'\\\\n        }),\\\\n        extra: {\\\\n            onChange: \\\\\\\"putMyVar('s',input)\\\\\\\",\\\\n            id: id + \\\\\\\"ss\\\\\\\",\\\\n            defaultValue: s\\\\n        }\\\\n    });\\\\n    let rules = $.require(\\\\\\\"hiker://page/data\\\\\\\").getData();\\\\n    d.push({\\\\n        title: \\\\\\\"🌟\\\\\\\",\\\\n        url: \\\\\\\"hiker://collection?rule=\\\\\\\" + MY_RULE.title,\\\\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 of rules) {\\\\n        d.push({\\\\n            title: it == r ? \\\\\\\"““\\\\\\\" + it + \\\\\\\"””\\\\\\\" : it,\\\\n            url: $(\\\\\\\"#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            desc: \\\\\\\"\\\\\\\",\\\\n            pic_url: \\\\\\\"\\\\\\\",\\\\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(\\\\\\\"hiker://page/data\\\\\\\").getData(p, r != \\\\\\\"\\\\\\\" ? r : null);\\\\n    let pageid = \\\\\\\"ypj-page\\\\\\\" + p;\\\\n    if (data.length > 0) {\\\\n        d.push({\\\\n            title: \\\\\\\"加载第\\\\\\\" + p + \\\\\\\"页中，进度：1/\\\\\\\" + data.length,\\\\n            url: \\\\\\\"\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            desc: \\\\\\\"\\\\\\\",\\\\n            pic_url: \\\\\\\"\\\\\\\",\\\\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, openMode);\\\\n                    } catch (e) {\\\\n                        log(rule.name + \\\\\\\":\\\\\\\" + e.toString())\\\\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: $(\\\\\\\"确定清除全部搜索记录？\\\\\\\").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        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        deleteItem(id + \\\\\\\":hotkey\\\\\\\");\\\\n    } catch (e) {\\\\n        deleteItem(id + \\\\\\\":hotkey\\\\\\\");\\\\n        log(e.toString());\\\\n    }\\\\n}\\\\nlet r = getItem(\\\\\\\"rule\\\\\\\", \\\\\\\"\\\\\\\");\\\\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 d = [];\\\\nif (MY_PAGE === 1) {\\\\n    setHead();\\\\n    if (!s) {\\\\n        setHistory();\\\\n    }\\\\n}\\\\nif (s) {\\\\n    record()\\\\n    searchEnd();\\\\n} else if (MY_PAGE === 1) {\\\\n    setTrendingTabEnd();\\\\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 (input.includes(\\\\\\\"aliyundrive.com\\\\\\\") && 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    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            playUrlList.forEach((item) => {\\\\n                if (item.template_id == line) {\\\\n                    aliurl = item.url;\\\\n                }\\\\n            });\\\\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                '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);\\\\n        if (url.includes(\\\\\\\".ts\\\\\\\")) {\\\\n            return JSON.stringify({\\\\n                statusCode: 302,\\\\n                headers: {\\\\n                    \\\\\\\"Location\\\\\\\": updateTsUrl(url),\\\\n                    'Referer': 'https://www.aliyundrive.com/'\\\\n                }\\\\n            });\\\\n        } else {\\\\n            //log(url);\\\\n            let ff = getM3u8Content(getAliPlayUrl(fileId, MY_PARAMS.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\\\\n\\\\nfunction getOriVideo(aliAccessApi, fileId) {\\\\n    return {\\\\n        names: [\\\\\\\"原画\\\\\\\"],\\\\n        urls: [aliAccessApi.getVideoTemPlayUrl(fileId) + \\\\\\\"#isVideo=true#\\\\\\\"],\\\\n        headers: [{\\\\n            'Referer': 'https://www.aliyundrive.com/'\\\\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 {\\\\n                playList = getOriVideo(aliAccessApi, fileId);\\\\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\\\\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\\\\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\\\\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}\\\\nsetPagePicUrl();\\\\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}\\\\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 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            }));\\\\n        }\\\\n        setMarker();\\\\n        if (realurl && !isSearch) {\\\\n            let shareInfo = aliShareApi.getShareInfo();\\\\n\\\\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,\\\\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                    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 funStyle = isSearch ? \\\\\\\"icon_small_3\\\\\\\" : \\\\\\\"icon_round_small_4\\\\\\\";\\\\n        items.push({\\\\n            title: style,\\\\n            url: $(styles, 1, \\\\\\\"排布样式\\\\\\\").select(() => {\\\\n                setItem(\\\\\\\"aliyun_style\\\\\\\", input);\\\\n                refreshPage();\\\\n                return \\\\\\\"toast://已切换\\\\\\\";\\\\n            }),\\\\n            col_type: funStyle,\\\\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            col_type: funStyle,\\\\n            pic_url: \\\\\\\"https://hikerfans.com/img/ali_sort.svg\\\\\\\"\\\\n        }, {\\\\n            title: getItem(\\\\\\\"aliyun_playMode\\\\\\\", \\\\\\\"转码\\\\\\\"),\\\\n            url: $([\\\\\\\"转码\\\\\\\", \\\\\\\"原画\\\\\\\"], 2, \\\\\\\"播放模式\\\\\\\").select(() => {\\\\n                setItem(\\\\\\\"aliyun_playMode\\\\\\\", input);\\\\n                refreshPage();\\\\n                return \\\\\\\"toast://切换成功\\\\\\\";\\\\n            }),\\\\n            col_type: funStyle,\\\\n            pic_url: \\\\\\\"https://hikerfans.com/img/ali_play.svg\\\\\\\"\\\\n        });\\\\n        if (!isSearch) {\\\\n            items.push({\\\\n                title: \\\\\\\"功能\\\\\\\",\\\\n                url: $([\\\\\\\"转存云盘\\\\\\\", \\\\\\\"登陆账号\\\\\\\", \\\\\\\"复制分享链接\\\\\\\", \\\\\\\"查看手动挂载字幕\\\\\\\", \\\\\\\"获取弹幕搜索规则\\\\\\\", \\\\\\\"批量挂载本地弹幕\\\\\\\"], 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 \\\\\\\"copy://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                    }\\\\n                }, shareId, sharePwd, fileId),\\\\n                col_type: \\\\\\\"icon_round_small_4\\\\\\\",\\\\n                pic_url: \\\\\\\"https://hikerfans.com/img/ali_fileinto.svg\\\\\\\",\\\\n            });\\\\n        }\\\\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    let folderStyle, fileStyle, isWatching = style === \\\\\\\"追剧\\\\\\\";\\\\n    if (isWatching) {\\\\n        folderStyle = \\\\\\\"avatar\\\\\\\";\\\\n        fileStyle = \\\\\\\"movie_2\\\\\\\";\\\\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                }\\\\n            });\\\\n        } else {\\\\n            let subtitle, longc, cls;\\\\n            let title = (fileStyle === \\\\\\\"text_1\\\\\\\" ? (titleHead[cate] || \\\\\\\"❓\\\\\\\") : \\\\\\\"\\\\\\\") + 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\\\\\\\";\\\\n                pic_url = fileItem.thumbnail || pic_url;\\\\n            } else if (isWatching) {\\\\n                continue;\\\\n            }\\\\n\\\\n            if (fileStyle === \\\\\\\"text_1\\\\\\\") {\\\\n                desc += \\\\\\\"\\\\\\\\t\\\\\\\\t\\\\\\\" + formatSize(fileItem.size);\\\\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 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\\\\\\\"];\\\\nlet index = Number(getParam(\\\\\\\"index\\\\\\\", \\\\\\\"1\\\\\\\"));\\\\nif (Number.isNaN(index)) {\\\\n    index = 1;\\\\n}\\\\nlet url = loginUrls[index];\\\\nlet isRefresh = !getParam(\\\\\\\"noRefresh\\\\\\\");\\\\nlet aliTokensFilepath= $.require(\\\\\\\"tokenPath\\\\\\\").aliTokensFilepath;\\\\n\\\\nvar 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\\\\nd.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});\\\\nsetResult(d);\\\"},{\\\"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\\\\nfunction postApi(api, body, headers, againTry, tryFre) {\\\\n    let result;\\\\n    try {\\\\n        result = request(api.startsWith(\\\\\\\"http\\\\\\\") ? api : '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            let msg = result.display_message || result.message;\\\\n            let error = new Error(api + \\\\\\\"=>\\\\\\\" + result.code + \\\\\\\":\\\\\\\" + msg);\\\\n            error.code = result.code;\\\\n            error.judgeMsg = msg\\\\n            throw error;\\\\n        }\\\\n        let rbody = 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            throw error;\\\\n        }\\\\n    } catch (e) {\\\\n        tryFre = tryFre === undefined ? 1 : tryFre;\\\\n        if (againTry && tryFre > 0) {\\\\n            if (typeof againTry === \\\\\\\"function\\\\\\\") {\\\\n                let newData = againTry(e, result, body, headers, tryFre);\\\\n                if (newData) {\\\\n                    Object.assign(body, newData.body);\\\\n                    Object.assign(headers, newData.headers);\\\\n                }\\\\n            }\\\\n            return postApi(api, body, headers, againTry, tryFre - 1);\\\\n        }\\\\n        throw e;\\\\n    }\\\\n    return result;\\\\n}\\\\n\\\\nfunction AliAccessApi(shareId, sharePwd, shareToken, aliTokens, openTokens, refreshShareCallBack, refreshAccessCallBack, refreshOpenCallBack) {\\\\n    this.shareId = shareId;\\\\n    this.sharePwd = sharePwd;\\\\n    this.refreshShareCallBack = refreshShareCallBack || (() => void 0);\\\\n    this.refreshAccessCallBack = refreshAccessCallBack || (() => void 0);\\\\n    this.refreshOpenCallBack = refreshOpenCallBack || (() => void 0);\\\\n    this.shareToken = shareToken || this.getShareToken();\\\\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    this.openTokens = openTokens || {\\\\n        'RefreshTokenOpen': '',\\\\n        'AccessTokenOpen': '',\\\\n        'BindRefreshToken': '',\\\\n    };\\\\n    if (openTokens !== null && !this.openTokens.AccessTokenOpen) {\\\\n        this.refreshOpenToken();\\\\n    }\\\\n}\\\\nObject.assign(AliAccessApi.prototype, {\\\\n    waitSleep(time) {\\\\n        java.lang.Thread.sleep(time || 600);\\\\n        return this;\\\\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\\\\\\\") {\\\\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    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.refreshShareCallBack(result.share_token, this);\\\\n        return result.share_token;\\\\n    },\\\\n    refreshAccessToken() {\\\\n        let result = postApi(\\\\\\\"https://auth.aliyundrive.com/v2/account/token\\\\\\\", {\\\\n            \\\\\\\"grant_type\\\\\\\": \\\\\\\"refresh_token\\\\\\\",\\\\n            \\\\\\\"refresh_token\\\\\\\": this.aliTokens.refresh_token,\\\\n        }, {\\\\n            \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.aliyundrive.com/\\\\\\\"\\\\n        }, (e) => {\\\\n            if (e.code === \\\\\\\"InvalidParameter.RefreshToken\\\\\\\") {\\\\n                e.message = \\\\\\\"#登陆过期请重新登陆#\\\\\\\\n\\\\\\\" + e.message;\\\\n                throw e;\\\\n            }\\\\n        });\\\\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 = postApi(\\\\\\\"https://user.aliyundrive.com/v2/user/get\\\\\\\", {}, {\\\\n            \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n            \\\\\\\"authorization\\\\\\\": this.reaccessTk,\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.aliyundrive.com/\\\\\\\"\\\\n        }, (e) => {\\\\n            this.trySolve(e);\\\\n            return {\\\\n                headers: {\\\\n                    'authorization': this.reaccessTk\\\\n                }\\\\n            }\\\\n        });\\\\n        return info;\\\\n    },\\\\n    _getOpenToken(code) {\\\\n        let body = {},\\\\n            headers = {\\\\n                'User-Agent': PC_UA,\\\\n                'Referer': 'https://www.aliyundrive.com/'\\\\n            };\\\\n        if (code) {\\\\n            body = {\\\\n                code: code,\\\\n                grant_type: \\\\\\\"authorization_code\\\\\\\"\\\\n            };\\\\n        } else {\\\\n            body = {\\\\n                grant_type: \\\\\\\"refresh_token\\\\\\\",\\\\n                refresh_token: this.openTokens.RefreshTokenOpen,\\\\n            }\\\\n        }\\\\n        let json = post('https://api.xhofe.top/alist/ali_open/code', {\\\\n            headers: headers,\\\\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            if (openResult.refresh_token) {\\\\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                return this.openTokens;\\\\n            }\\\\n        }\\\\n        if (!code) {\\\\n            return this.waitSleep(50).cacheOpenToken();\\\\n        }\\\\n        throw new Error(\\\\\\\"openToken获取失败\\\\\\\\n\\\\\\\" + json);\\\\n    },\\\\n    cacheOpenToken() {\\\\n        let result = 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=', {\\\\n            \\\\\\\"authorize\\\\\\\": 1,\\\\n            \\\\\\\"scope\\\\\\\": \\\\\\\"user:base,file:all:read,file:all:write\\\\\\\"\\\\n        }, {\\\\n            'User-Agent': PC_UA,\\\\n            'Referer': 'https://www.aliyundrive.com/',\\\\n            'authorization': this.reaccessTk, //getAccessToken\\\\n            'x-canary': 'client=web,app=share,version=v2.3.1',\\\\n            'x-share-token': this.shareToken\\\\n        }, (e) => {\\\\n            this.trySolve(e);\\\\n            return {\\\\n                headers: {\\\\n                    'authorization': this.reaccessTk,\\\\n                    'x-share-token': this.shareToken\\\\n                }\\\\n            }\\\\n        });\\\\n        let code = result.redirectUri.split(\\\\\\\"code=\\\\\\\")[1];\\\\n        return this._getOpenToken(code);\\\\n    },\\\\n    refreshOpenToken() {\\\\n        if (this.openTokens.RefreshTokenOpen && this.openTokens.BindRefreshToken === this.aliTokens.refresh_token) {\\\\n            return this._getOpenToken();\\\\n        } else {\\\\n            return this.cacheOpenToken();\\\\n        }\\\\n    },\\\\n    _cloudFileOperate(body, cloudFileId, operateUrl) {\\\\n        let result = postApi('https://api.aliyundrive.com/adrive/v2/batch', {\\\\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        }, {\\\\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\\\\n        }, (e, r, b) => {\\\\n            if (e.code === \\\\\\\"QuotaExhausted.Drive\\\\\\\") {\\\\n                throw e;\\\\n            }\\\\n            if (!this.trySolve(e)) {\\\\n                this.waitSleep(20).refreshAccessToken();\\\\n            }\\\\n            let body = b.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            return {\\\\n                body: b,\\\\n                headers: {\\\\n                    'authorization': this.reaccessTk,\\\\n                    'x-share-token': this.shareToken\\\\n                }\\\\n            };\\\\n        });\\\\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 = postApi('https://open.aliyundrive.com/adrive/v1.0/openFile/getDownloadUrl', {\\\\n            'file_id': cloudFileId,\\\\n            'drive_id': this.defDriveId\\\\n        }, {\\\\n            'User-Agent': PC_UA,\\\\n            'Referer': 'https://www.aliyundrive.com/',\\\\n            'authorization': this.openTokens.AccessTokenOpen\\\\n        }, () => {\\\\n            this.waitSleep(30).refreshOpenToken();\\\\n            return {\\\\n                body: {\\\\n                    'drive_id': this.defDriveId,\\\\n                },\\\\n                headers: {\\\\n                    'authorization': this.openTokens.AccessTokenOpen\\\\n                }\\\\n            };\\\\n        }, 2);\\\\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 = postApi(\\\\\\\"/v2/file/get_share_link_download_url\\\\\\\", {\\\\n            \\\\\\\"expire_sec\\\\\\\": 600,\\\\n            \\\\\\\"file_id\\\\\\\": fileId,\\\\n            \\\\\\\"share_id\\\\\\\": this.shareId\\\\n        }, {\\\\n            \\\\\\\"X-Share-Token\\\\\\\": this.shareToken,\\\\n            \\\\\\\"authorization\\\\\\\": this.aliTokens.access_token\\\\n        }, (e) => {\\\\n            this.trySolve(e);\\\\n            return {\\\\n                headers: {\\\\n                    \\\\\\\"X-Share-Token\\\\\\\": this.shareToken,\\\\n                    \\\\\\\"authorization\\\\\\\": this.aliTokens.access_token\\\\n                }\\\\n            };\\\\n        });\\\\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 = postApi('/users/v1/users/device/create_session', {\\\\n            \\\\\\\"deviceName\\\\\\\": \\\\\\\"Edge浏览器\\\\\\\",\\\\n            \\\\\\\"modelName\\\\\\\": \\\\\\\"Windows网页版\\\\\\\",\\\\n            \\\\\\\"pubKey\\\\\\\": newSign.pubKey,\\\\n        }, {\\\\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        }, (e) => {\\\\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            return {\\\\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        }, 3);\\\\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 = JSON.parse(request('https://api.aliyundrive.com/v2/file/get_share_link_video_preview_play_info', {\\\\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            },\\\\n            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            },\\\\n            method: 'POST',\\\\n            timeout: 3000\\\\n        }));\\\\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\\\\n    function saveAliToken(result, api) {\\\\n        writeFile(aliTokensFilepath, JSON.stringify(api.aliTokens));\\\\n    }\\\\n\\\\n    function saveOpenToken(result, api) {\\\\n        writeFile(openTokensFilepath, JSON.stringify(api.openTokens));\\\\n    }\\\\n\\\\n    function putShareToken(result) {\\\\n        if (MY_TITLE) {\\\\n            shareToken = putVar(MY_TITLE + \\\\\\\"@\\\\\\\" + \\\\\\\"aliShareToken\\\\\\\", result);\\\\n        } else {\\\\n            shareToken = putMyVar(\\\\\\\"aliShareToken\\\\\\\", result);\\\\n        }\\\\n    }\\\\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(shareId, sharePwd, shareToken, aliToken, openToken, putShareToken, saveAliToken, saveOpenToken);\\\\n}\\\\n$.exports = AliAccessApi;\\\"},{\\\"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\\\":\\\"弹幕工具\\\",\\\"path\\\":\\\"danmu\\\",\\\"rule\\\":\\\"js:\\\\nlet basicUrl = \\\\\\\"https://api.dandanplay.net/\\\\\\\";\\\\nlet sevePath = \\\\\\\"hiker://files/cache/danmu/\\\\\\\";\\\\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    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 == 3) {\\\\n                //颜色值为0时，默认设置为白色\\\\n                if (params[i] == \\\\\\\"0\\\\\\\" || params[i] == \\\\\\\"-1\\\\\\\") {\\\\n                    paramsT.push(\\\\\\\"16777215\\\\\\\");\\\\n                    continue\\\\n                }\\\\n\\\\n            }\\\\n            if (i == 2) {\\\\n                paramsT.push(\\\\\\\"25\\\\\\\");\\\\n            }\\\\n            paramsT.push(params[i]);\\\\n\\\\n        }\\\\n        paramsT.push(\\\\\\\"0\\\\\\\", \\\\\\\"0\\\\\\\", \\\\\\\"0\\\\\\\");\\\\n        dMcontext += `<d p=\\\\\\\"${paramsT.join(',')}\\\\\\\">${encodeHtml(commentText)}</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> 内置弹幕搜索数据来源于[弹弹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: \\\\\\\"内置搜索弹幕\\\\\\\",\\\\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_2\\\\\\\"\\\\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_2\\\\\\\"\\\\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\\\":\\\"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        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\\\\\\\": \\\\\\\"tvbox2023\\\\\\\",\\\\n                            \\\\\\\"password\\\\\\\": \\\\\\\"Tvbox2023\\\\\\\",\\\\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: true,\\\\n        find: function(s, page) {\\\\n            function gethtml() {\\\\n                let html = request(\\\\\\\"https://zhaoziyuan.me/so?filename=\\\\\\\" + s + \\\\\\\"&page=\\\\\\\" + page, {\\\\n                    headers: {\\\\n                        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://zhaoziyuan.me/stop.html\\\\\\\",\\\\n                        \\\\\\\"origin\\\\\\\": \\\\\\\"https://zhaoziyuan.me\\\\\\\",\\\\n                        \\\\\\\"Cookie\\\\\\\": getItem(\\\\\\\"zzycooke\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n                        \\\\\\\"upgrade-insecure-requests\\\\\\\": \\\\\\\"1\\\\\\\",\\\\n                        \\\\\\\"content-type\\\\\\\": \\\\\\\"application/x-www-form-urlencoded\\\\\\\"\\\\n                    }\\\\n                });\\\\n                return html;\\\\n            };\\\\n            var html = gethtml();\\\\n            if (!html.includes(\\\\\\\"search_box\\\\\\\")) {\\\\n                let user = 'dXNlcm5hbWU9eXBqMjAyMyZwYXNzd29yZD15cGoyMDIz';\\\\n                let cook = JSON.parse(fetchCookie('https://zhaoziyuan.me/logiu.html', {\\\\n                    headers: {\\\\n                        'User-Agent': MOBILE_UA,\\\\n                        'Content-Type': 'application/x-www-form-urlencoded',\\\\n                        'Origin': 'https://zhaoziyuan.me',\\\\n                        'Referer': 'https://zhaoziyuan.me/login.html',\\\\n                        \\\\\\\"upgrade-insecure-requests\\\\\\\": \\\\\\\"1\\\\\\\"\\\\n                    },\\\\n                    body: base64Decode(user),\\\\n                    method: 'POST',\\\\n                    onlyHeaders: true,\\\\n                    withHeaders: true\\\\n                })).join(';');\\\\n                setItem(\\\\\\\"zzycooke\\\\\\\", cook);\\\\n                log(\\\\\\\"找资源登入\\\\\\\");\\\\n                html = gethtml();\\\\n            }\\\\n\\\\n            let arr = pdfa(html, \\\\\\\"body&&.newsList&&li:not(:first-child)\\\\\\\");\\\\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, \\\\\\\"a&&href\\\\\\\");\\\\n                if (u == null) {\\\\n                    continue;\\\\n                }\\\\n                u = \\\\\\\"https://zhaoziyuan.me/\\\\\\\" + u;\\\\n                //log(u);\\\\n                let title = pdfh(it, \\\\\\\".news_text&&h3&&Text\\\\\\\");\\\\n                if (!title) continue;\\\\n                d.push({\\\\n                    title: title,\\\\n                    desc: pdfh(it, \\\\\\\".news_text&&p&&Text\\\\\\\"),\\\\n                    url: u\\\\n                });\\\\n            }\\\\n            return d;\\\\n        },\\\\n        findAliUrl(input) {\\\\n            let html = request(input);\\\\n            var _links = html.match(/https:\\\\\\\\/\\\\\\\\/(www\\\\\\\\.aliyundrive\\\\\\\\.com\\\\\\\\/s|alywp\\\\\\\\.net)\\\\\\\\/\\\\\\\\w*/g) || [];\\\\n\\\\n            if (_links.length > 0) {\\\\n\\\\n                return _links[0];\\\\n            } else {\\\\n                return input;\\\\n            }\\\\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        find: function(s, page) {\\\\n            let url = \\\\\\\"http://wogg.xyz/index.php/vodsearch/\\\\\\\" + s + \\\\\\\"----------\\\\\\\" + page + \\\\\\\"---.html\\\\\\\";\\\\n            let html = request(url, {});\\\\n            let arr = parseDomForArray(html, '.module-items&&.module-search-item');\\\\n            //log(arr);\\\\n            let d = [];\\\\n            let bet = [];\\\\n            for (let i = 0; i < arr.length; i++) {\\\\n                let it = arr[i];\\\\n                let utitle = parseDomForHtml(it, 'h3&&a&&Text');\\\\n                let userial = parseDomForHtml(it, '.video-serial&&Text');\\\\n                let uimage = parseDom(it, '.lazyload&&data-src', 'http://wogg.xyz/');\\\\n                let u = parseDom(it, 'h3&&a&&href', 'http://wogg.xyz/');\\\\n                //let det = request(u, {});\\\\n                bet.push({\\\\n                    title: utitle,\\\\n                    url: u,\\\\n                    image: uimage,\\\\n                    desc: userial\\\\n                });\\\\n            }\\\\n            if (bet.length > 0) {\\\\n                let beth = batchFetch(bet);\\\\n                for (let i = 0; i < beth.length; i++) {\\\\n                    let list = parseDomForArray(beth[i], '.module-player-list&&p')\\\\n                    for (let j = 0; j < list.length; j++) {\\\\n                        let u = parseDomForHtml(list[j], 'p&&Text');\\\\n                        if (!u.includes(\\\\\\\"/s/\\\\\\\")) {\\\\n                            continue;\\\\n                        }\\\\n                        d.push({\\\\n                            title: bet[i].title,\\\\n                            pic_url: bet[i].image,\\\\n                            url: u,\\\\n                            desc: bet[i].desc + '\\\\\\\\n' + u,\\\\n                        });\\\\n\\\\n                    }\\\\n                }\\\\n            }\\\\n            return d;\\\\n        }\\\\n    },\\\\n    {\\\\n        name: \\\\\\\"阿里云盘网\\\\\\\",\\\\n        page: true,\\\\n        find: function(s, page) {\\\\n            let url = \\\\\\\"https://www.alypw.cn/search.php?q=\\\\\\\" + s + \\\\\\\"&page=\\\\\\\" + page;\\\\n            let html = request(url, {});\\\\n            let arr = parseDomForArray(html, '.list&&li');\\\\n            //log(arr);\\\\n            let d = [];\\\\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, '.fa-clock-o&&Text');\\\\n                let uimage = parseDom(it, 'img&&src', 'https://www.alypw.cn/');\\\\n                let u = parseDom(it, 'a&&href', 'https://www.alypw.cn/');\\\\n                //let det = request(u, {});\\\\n                if (!utitle.includes(s)) {\\\\n                    continue;\\\\n                }\\\\n                bet.push({\\\\n                    title: utitle,\\\\n                    url: u,\\\\n                    image: uimage,\\\\n                    desc: userial\\\\n                });\\\\n            }\\\\n            //log(bet);\\\\n            if (bet.length > 0) {\\\\n                let beth = batchFetch(bet);\\\\n                for (let i = 0; i < beth.length; i++) {\\\\n                    let list = parseDomForArray(beth[i], 'body&&a[href^=https://www.aliyundrive.com/s/]')\\\\n                    //log(list);\\\\n                    for (let j = 0; j < list.length; j++) {\\\\n                        let u = parseDomForHtml(list[j], 'a&&href');\\\\n                        d.push({\\\\n                            title: bet[i].title,\\\\n                            pic_url: bet[i].image,\\\\n                            url: u,\\\\n                            desc: bet[i].desc + '\\\\\\\\n' + u,\\\\n                        });\\\\n\\\\n                    }\\\\n                }\\\\n            }\\\\n            return d;\\\\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            //log(json);\\\\n            let arr = JSON.parse(json); //[0].result.items;\\\\n            //log(arr);\\\\n\\\\n            let d = [];\\\\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                    options: {\\\\n                        headers: {\\\\n                            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.yunpanfenxiang.cn/\\\\\\\"\\\\n                        }\\\\n                    }\\\\n                });\\\\n            }\\\\n            //log(u);\\\\n            let beth = batchFetch(bet);\\\\n\\\\n            //log(article);\\\\n            for (let i = 0; i < beth.length; i++) {\\\\n                let json = JSON.parse(beth[i]).data;\\\\n                //log(json);\\\\n                let list = json.download.split('@');\\\\n                for (let j = 0; j < list.length; j++) {\\\\n                    let u = list[j];\\\\n                    d.push({\\\\n                        title: json.title,\\\\n                        url: 'https://www.aliyundrive.com/s/' + u,\\\\n                        desc: json.createtime + \\\\\\\"\\\\\\\\n\\\\\\\" + 'https://www.aliyundrive.com/s/' + u,\\\\n                    });\\\\n                }\\\\n            }\\\\n\\\\n            return d;\\\\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    /*,\\\\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\\\":\\\"aliUtil\\\",\\\"rule\\\":\\\"$.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    getNamesSort() {\\\\n        let chnNumChar = {\\\\n            零: 0,\\\\n            一: 1,\\\\n            二: 2,\\\\n            三: 3,\\\\n            四: 4,\\\\n            五: 5,\\\\n            六: 6,\\\\n            七: 7,\\\\n            八: 8,\\\\n            九: 9\\\\n        };\\\\n\\\\n        let 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\\\\n        function 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\\\\n        function 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        return nameCompare;\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"弹幕批量挂载\\\",\\\"path\\\":\\\"dmMount\\\",\\\"rule\\\":\\\"js:\\\\nlet d = [];\\\\naddListener(\\\\\\\"onClose\\\\\\\", () => clearMyVar(\\\\\\\"dllastTime\\\\\\\"))\\\\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 aliUtil = $.require(\\\\\\\"aliUtil\\\\\\\");\\\\n        let nameCompare = aliUtil.getNamesSort();\\\\n        dmlist.sort((a, b) => 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\\\\\\\", \\\\\\\"0\\\\\\\"));\\\\n\\\\nif (MY_PARAMS.automaticadd===\\\\\\\"1\\\\\\\"&&lastRecord && 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 = 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><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\\\":\\\"text_icon\\\",\\\"name\\\":\\\"规则禁用\\\",\\\"path\\\":\\\"RuleDisable\\\",\\\"rule\\\":\\\"js:\\\\nsetPageTitle(\\\\\\\"禁用规则\\\\\\\");\\\\naddListener(\\\\\\\"onClose\\\\\\\",()=>refreshPage());\\\\nlet data = $.require(\\\\\\\"hiker://page/rules\\\\\\\").map(v=>v.name);\\\\nlet d = [];\\\\nd.push({\\\\n    title: \\\\\\\"全部取消禁用\\\\\\\",\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule(() => {\\\\n        clearItem(\\\\\\\"forbidden\\\\\\\");\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n    }),\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n});\\\\nlet forbidden = storage0.getItem(\\\\\\\"forbidden\\\\\\\", []);\\\\nlet qid = String(Date.now());\\\\nfor (let i = 0; i < data.length; i++) {\\\\n    let it = data[i];\\\\n    d.push({\\\\n        title: it,\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((it, id) => {\\\\n            let forbidden = storage0.getItem(\\\\\\\"forbidden\\\\\\\", []);\\\\n            let index = forbidden.indexOf(it);\\\\n            if (index > -1) {\\\\n                forbidden.splice(index, 1);\\\\n                updateItem(id, {\\\\n                    pic_url: \\\\\\\"hiker://images/icon_rect\\\\\\\"\\\\n                });\\\\n            } else {\\\\n                forbidden.push(it);\\\\n                updateItem(id, {\\\\n                    pic_url: \\\\\\\"hiker://images/icon_rect_fill\\\\\\\"\\\\n                });\\\\n            }\\\\n            storage0.setItem(\\\\\\\"forbidden\\\\\\\", forbidden);\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }, it, qid + i),\\\\n        pic_url: forbidden.includes(it) ? \\\\\\\"hiker://images/icon_rect_fill\\\\\\\" : \\\\\\\"hiker://images/icon_rect\\\\\\\",\\\\n        extra: {\\\\n            id: qid + i\\\\n        }\\\\n    });\\\\n}\\\\nsetResult(d);\\\"}]\",\"proxy\":\"\"}","picUrl":"undefined","title":"宁安如梦"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!