API tools faq
paste
xiaomianao666

邀您一起看：规则管理

xiaomianao666
Feb 18th, 2024
83
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 278.92 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\":\"Ⓛ列表API\",\"path\":\"QuarkShareApi\",\"rule\":\"js:\\n//@author LoyDgIk\\nlet httpRequest = $.require(\\\"httpRequest\\\");\\nconst baseUrl = \\\"https://pan.quark.cn\\\";\\n\\nfunction QuarkShareApi(shareId, sharePwd) {\\n    this.shareId = shareId;\\n    this.sharePwd = sharePwd;\\n    this.refreshCallBack = (() => void 0);\\n    //this.shareToken = shareToken || this.getShareToken();\\n}\\nObject.assign(QuarkShareApi.prototype, {\\n    setRefresh(refreshCallBack) {\\n        this.refreshCallBack = refreshCallBack;\\n        return this;\\n    },\\n    setToken(shareToken) {\\n        this.shareToken = shareToken;\\n        return this;\\n    },\\n    requestHttp(api) {\\n        return new httpRequest(baseUrl+api).success((body) => {\\n            if (body.status !== 200) {\\n                throw new Error(body.message);\\n            }\\n            return body;\\n        });\\n    },\\n    getToken() {\\n        return this.shareToken || this.getShareToken();\\n    },\\n\\n    getShareToken() {\\n        let result = this.requestHttp(\\\"/1/clouddrive/share/sharepage/token\\\").body({\\n            \\\"pwd_id\\\": this.shareId,\\n            \\\"passcode\\\": this.sharePwd,\\n        }).bodyToString(true).setStartRequestFunc(post).start(true);\\n        this.shareToken = result.data.stoken;\\n        this.refreshCallBack(result.data.stoken, this);\\n        return this.shareToken;\\n    },\\n    getListFile(fileId, page, orderBy) {\\n        let result = this.requestHttp(\\\"/1/clouddrive/share/sharepage/detail\\\").buildUrl({\\n            pwd_id: this.shareId || \\\"\\\",\\n            stoken: encodeURIComponent(this.getToken() || \\\"\\\"),\\n            pdir_fid: fileId || \\\"\\\",\\n            force: 0,\\n            _page: page,\\n            _size: 50,\\n            _fetch_banner: 1,\\n            _fetch_share: 1,\\n            _fetch_total: 1,\\n            _sort: \\\"file_type:asc,\\\" + orderBy\\n        }).errorWithRetry((err, res, http) => {\\n            if (JSON.parse(res.body).message.includes('stoken')) {\\n                http.mergeHeadAndBody({\\n                    buildUrl: {\\n                        stoken: encodeURIComponent(this.getShareToken()||\\\"\\\")\\n                    }\\n                });\\n                return true;\\n            }\\n        }).start(true);\\n        return result;\\n    }\\n});\\n$.exports = QuarkShareApi;\"},{\"col_type\":\"movie_3\",\"name\":\"Ⓛ请求函数\",\"path\":\"httpRequest\",\"rule\":\"function httpRequest(url, options) {\\n    this.retryCount = 0;\\n    this.url = url;\\n    this.options = Object.assign({}, options, {\\n        withHeaders: true\\n    });\\n    this.errorCallback = (err, res) => {throw err};\\n    this.errorCallbackWithRetry = (err, res, tryRestart) => false;\\n    this.successCallback = (body, statusCode, headers) => body;\\n    this.errorTypeCallback = (err, res) => err;\\n    this.startRequest = fetch;\\n    this._bodyToString = false;\\n    this.buildParam = void(0);\\n}\\n\\nObject.assign(httpRequest.prototype, {\\n    bodyToString(flag) {\\n        this._bodyToString = !!flag;\\n        return this;\\n    },\\n    body(body) {\\n        this.options.body = body || void 0;\\n        return this;\\n    },\\n    buildUrl(buildParam) {\\n        this.buildParam = buildParam || {};\\n        return this;\\n    },\\n    setStartRequestFunc(func) {\\n        this.startRequest = func;\\n        return this;\\n    },\\n    headers(headers) {\\n        this.options.headers = headers || void 0;\\n        return this;\\n    },\\n    success(successCallback) {\\n        if (typeof successCallback !== \\\"function\\\") return this;\\n        this.successCallback = successCallback;\\n        return this;\\n    },\\n    error(errorCallback) {\\n        if (typeof errorCallback !== \\\"function\\\") return this;\\n        this.errorCallback = errorCallback;\\n        return this;\\n    },\\n    errorType(errorTypeCallback) {\\n        if (typeof errorTypeCallback !== \\\"function\\\") return this;\\n        this.errorTypeCallback = errorTypeCallback;\\n        return this;\\n    },\\n    errorWithRetry(retryCount, errorCallbackWithRetry) {\\n        if (typeof retryCount === \\\"function\\\" && typeof errorCallbackWithRetry === \\\"undefined\\\") {\\n            errorCallbackWithRetry = retryCount;\\n            retryCount = 1;\\n        }\\n        if (typeof errorCallbackWithRetry !== \\\"function\\\") {\\n            return this;\\n        }\\n        this.retryCount = Number(retryCount);\\n        this.errorCallbackWithRetry = errorCallbackWithRetry;\\n        return this;\\n    },\\n    start(toJson) {\\n        let options = Object.assign({}, this.options);\\n        if (typeof options.body === \\\"object\\\" && this._bodyToString) {\\n            options.body = JSON.stringify(options.body);\\n        }\\n        var res = JSON.parse(this.startRequest(this.buildParam?buildUrl(this.url, this.buildParam):this.url, options));\\n        try {\\n            if (res.statusCode >= 200 && res.statusCode <= 300) {\\n                let body = res.body;\\n                if (toJson) {\\n                    body = JSON.parse(body);\\n                }\\n                return this.successCallback(body, res);\\n            } else {\\n                throw new Error(String(res.statusCode));\\n            }\\n        } catch (err) {\\n            try {\\n                err = this.errorTypeCallback(err, res);\\n            } catch (e) {\\n\\n            }\\n            if (this.retryCount) {\\n                let tryResult = this.errorCallbackWithRetry(err, res, this);\\n                if (tryResult) {\\n                    this.retryCount--;\\n                    return this.start(toJson);\\n                } else {\\n                    this.retryCount = 0;\\n                    return this.errorCallback(err, res);\\n                }\\n            } else {\\n                return this.errorCallback(err, res);\\n            }\\n        }\\n    },\\n    setOptions(options) {\\n        this.options = Object.assign({}, options, {\\n            withHeaders: true\\n        });\\n        return this;\\n    },\\n    mergeHeadAndBody(options) {\\n        options = options || {};\\n        Object.assign(this.options.headers||{}, options.headers);\\n        if (typeof this.options.body === \\\"object\\\" && typeof options.body === \\\"object\\\") {\\n            Object.assign(this.options.body||{}, options.body);\\n        }\\n        if (typeof options.buildUrl === \\\"object\\\") {\\n            Object.assign(this.buildParam||{}, options.buildUrl);\\n        }\\n        return this;\\n    }\\n});\\n\\nObject.assign(httpRequest, {\\n    fetch(url, options) {\\n        return new httpRequest(url, options);\\n    },\\n    post(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(post);\\n    },\\n    request(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(request);\\n    },\\n    postRequest(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(postRequest);\\n    },\\n    fetchCookie(url, options) {\\n        return new httpRequest(url, options).setStartRequestFunc(fetchCookie);\\n    }\\n});\\n$.exports = httpRequest;\"},{\"col_type\":\"movie_3\",\"name\":\"Ⓛ列表页面\",\"path\":\"quarkList\",\"rule\":\"js:\\nlet d = [];\\n\\naddListener(\\\"onClose\\\", () => clearMyVar(\\\"playUrlCache\\\"));\\naddListener(\\\"onRefresh\\\", () => clearMyVar(\\\"playUrlCache\\\"));\\n\\nlet realurl = decodeURIComponent(getParam(\\\"realurl\\\", \\\"\\\")).split(\\\"?\\\")[0];\\nlet urlData = realurl.split(\\\"/\\\");\\n\\nlet shareId = MY_PARAMS.shareId || urlData[4].replace(\\\"#\\\", \\\"\\\");\\nlet sharePwd = getParam(\\\"sharePwd\\\", MY_PARAMS.sharePwd || \\\"\\\");\\nlet shareToken = getParam(\\\"shareToken\\\", MY_PARAMS.shareToken || \\\"\\\");\\n\\nlet fileId = MY_PARAMS.fileId;\\n\\nlet sort = {\\n    \\\"名称正序\\\": \\\"file_name:asc\\\",\\n    \\\"名称倒序\\\": \\\"file_name:desc\\\",\\n    \\\"时间正序\\\": \\\"updated_at:asc\\\",\\n    \\\"时间倒序\\\": \\\"updated_at:desc\\\"\\n};\\nlet styles = [\\\"text_1\\\", \\\"avatar\\\"];\\n\\nlet sortValue = sort[getItem(\\\"sortKey\\\", \\\"名称正序\\\")];\\nlet style = getItem(\\\"style\\\", styles[0]);\\nif (MY_PAGE == 1) {\\n    d.push({\\n        title: style,\\n        url: $(styles, 1, '请选择').select(() => {\\n            setItem('style', input);\\n            refreshPage();\\n        }),\\n        pic_url: \\\"https://hikerfans.com/img/ali_icon.svg\\\",\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    d.push({\\n        title: getItem(\\\"sortKey\\\", \\\"名称正序\\\"),\\n        url: $(Object.keys(sort), 1, '请选择').select(() => {\\n            setItem(\\\"sortKey\\\", input)\\n            refreshPage();\\n        }),\\n        pic_url: \\\"https://hikerfans.com/img/ali_sort.svg\\\",\\n        col_type: \\\"icon_small_4\\\"\\n    });\\n    d.push({\\n        title: getItem(\\\"quark_playMode\\\", \\\"转码\\\"),\\n        url: $([\\\"转码\\\", \\\"原画\\\"], 2, \\\"播放模式\\\").select(() => {\\n            setItem(\\\"quark_playMode\\\", input);\\n            refreshPage();\\n            return \\\"toast://切换成功\\\";\\n        }),\\n        col_type: \\\"icon_small_4\\\",\\n        pic_url: \\\"https://hikerfans.com/img/ali_play.svg\\\",\\n    });\\n    d.push({\\n        title: \\\"功能\\\",\\n        url: $([\\\"跳转夸克APP\\\", \\\"登录\\\", \\\"原画下载线程\\\"]).select((shareId) => {\\n            if (input === \\\"跳转夸克APP\\\") {\\n                return \\\"qklink://www.uc.cn/b20b84fd735a8dd3f7541129bacc4e9a?action=open_url&url=https://pan.quark.cn/s/\\\" + shareId;\\n            } else if (input === \\\"登录\\\") {\\n                return $([\\\"输入Cookie\\\", \\\"网页登录\\\"]).select(() => {\\n                    if (input === \\\"网页登录\\\") {\\n                        return \\\"hiker://page/login\\\";\\n                    } else {\\n                        return $(\\\"\\\", \\\"请输入Cookie\\\").input(() => {\\n                            if ($.require(\\\"tool\\\").isLoginCookie(input)) {\\n                                setItem(\\\"quarkCookie\\\", input.replace(/\\\\s/g, \\\"\\\"));\\n                                return \\\"toast://设置成功\\\";\\n                            } else {\\n                                return \\\"toast://Cookie格式错误\\\";\\n                            }\\n                        });\\n                    }\\n                })\\n            } else if (input === \\\"原画下载线程\\\") {\\n                return $(getItem(\\\"speedThread\\\", \\\"10\\\"), \\\"请输入3-32之间的整数\\\").input(() => {\\n                    let speedThread = parseInt(input);\\n                    if (speedThread < 3 || speedThread > 32) {\\n                        return \\\"toast://设置不合法\\\";\\n                    }\\n                    setItem(\\\"speedThread\\\", String(speedThread));\\n                    return \\\"toast://设置成功\\\";\\n                });\\n            }\\n        }, shareId),\\n        col_type: \\\"icon_small_4\\\",\\n        pic_url: \\\"https://hikerfans.com/img/ali_fileinto.svg\\\",\\n    });\\n    d.push({\\n        col_type: 'line_blank'\\n    });\\n}\\n\\n\\nlet QuarkShareApi = $.require(\\\"QuarkShareApi\\\");\\nlet quarkShareApi = new QuarkShareApi(shareId, sharePwd).setToken(shareToken).setRefresh((shareToken) => {\\n    MY_PARAMS.shareToken = shareToken;\\n    setPageParams(MY_PARAMS);\\n});\\n\\nfunction formatSize(size) {\\n    if (!size) {\\n        return '';\\n    }\\n    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\\n    let i = 0;\\n    while (size >= 1024) {\\n        size /= 1024;\\n        i++;\\n    }\\n    size = i ? Number(size.toFixed(2)) : size;\\n    return `${size} ${units[i]}`;\\n}\\n\\nlet subExts = [\\\"vtt\\\", \\\"srt\\\", \\\"ass\\\"];\\nlet titleHead = {\\n    video: \\\"🎬\\\",\\n    audio: \\\"🎵\\\",\\n    doc: \\\"📑\\\",\\n    image: \\\"🖼\\\",\\n    archive: \\\"📦\\\",\\n    \\\"default\\\": \\\"❓\\\"\\n};\\n\\nfunction getHead(type, ext) {\\n    let head = titleHead[type];\\n    /*if (subExts.includes(ext)) {\\n        head = \\\"🕸\\\";\\n    }*/\\n    return head || \\\"❓\\\";\\n}\\ntry {\\n    var res = quarkShareApi.getListFile(fileId, MY_PAGE, sortValue);\\n    //设置标题\\n    setPageTitle(res.data.share.title);\\n    var list = res.data.list;\\n    list.forEach(item => {\\n        //判断是否文件夹\\n        if (item.dir) {\\n            d.push({\\n                title: \\\"📂\\\" + item.file_name,\\n                desc: $.dateFormat(item.updated_at, 'yyyy-MM-dd') + '  ' + item.include_items + '项  ',\\n                pic_url: \\\"https://hikerfans.com/tubiao/messy/27.svg\\\",\\n                url: \\\"hiker://page/quarkList?page=fypage\\\",\\n                col_type: style,\\n                extra: {\\n                    shareId,\\n                    sharePwd,\\n                    shareToken: quarkShareApi.getToken(),\\n                    fileId: item.fid,\\n                    inheritTitle: false\\n                }\\n            });\\n        } else {\\n            d.push({\\n                title: getHead(item.obj_category) + item.file_name,\\n                desc: $.dateFormat(item.updated_at, 'yyyy-MM-dd') + '  ' + formatSize(item.size),\\n                pic_url: item.thumbnail,\\n                url: $().lazyRule((fid, fid_token, pwd_id, stoken, category) => {\\n                    let playUrlCache = storage0.getMyVar(\\\"playUrlCache\\\", {});\\n                    if (playUrlCache[fid]) {\\n                        return playUrlCache[fid];\\n                    } else {\\n                        let url = $.require(\\\"play\\\").getPlayUrl(fid, fid_token, pwd_id, stoken, category);\\n                        playUrlCache[fid] = url;\\n                        storage0.putMyVar(\\\"playUrlCache\\\", playUrlCache);\\n                        return url;\\n                    }\\n                }, item.fid, item.share_fid_token, shareId, quarkShareApi.getToken(), item.obj_category),\\n                col_type: style,\\n                extra: {\\n                    id: item.fid,\\n                    inheritTitle: false,\\n                    cls: 'playlist ' + item.obj_category\\n                }\\n            })\\n        }\\n        d.push({\\n            col_type: 'line'\\n        });\\n    });\\n} catch (e) {\\n    d.push({\\n        title: e.message,\\n        url: 'hiker://empty',\\n        col_type: 'text_center_1',\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n    if (e.message.includes(\\\"提取码\\\")) {\\n        d.push({\\n            title: \\\"输入提取码\\\",\\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    }\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"Ⓛ获取链接\",\"path\":\"play\",\"rule\":\"js:\\nconst cookie = getItem(\\\"quarkCookie\\\", \\\"\\\");\\nlet httpRequest = $.require(\\\"httpRequest\\\");\\n\\nfunction CookieManage(cookie) {\\n    this.cookie = {};\\n    this.add(cookie);\\n}\\nObject.assign(CookieManage.prototype, {\\n    add(cookie) {\\n        let cookies = [];\\n        if (typeof cookie === \\\"string\\\") {\\n            cookies = cookie.split(\\\";\\\");\\n        } else if (Array.isArray(cookie)) {\\n            cookies = cookie;\\n        }\\n        cookies.forEach(v => {\\n            v = v.split(\\\"=\\\");\\n            if(v.length<2) return;\\n            this.cookie[v[0].trim()] = v[1].trim();\\n        });\\n    },\\n    get() {\\n        return Object.entries(this.cookie).map(v => v[0] + \\\"=\\\" + v[1]).join(\\\";\\\");\\n    }\\n});\\nconst cookieManage = new CookieManage(cookie);\\n\\nfunction waitSleep(time) {\\n    java.lang.Thread.sleep(time || 600);\\n}\\n\\nfunction requestHttp(url) {\\n    return new httpRequest(url)\\n        .success((body, res) => {\\n            if (body.status !== 200) {\\n                throw new Error(body.message);\\n            }\\n            cookieManage.add(res.headers[\\\"set-cookie\\\"]);\\n            return body;\\n        })\\n        .errorType((err, res) => {\\n            return new Error(JSON.parse(res.body).message);\\n        })\\n        .bodyToString(true)\\n        .headers({\\n            cookie: cookieManage.get(),\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) quark-cloud-drive/2.5.20 Chrome/100.0.4896.160 Electron/18.3.5.4-b478491100 Safari/537.36 Channel/pckk_other_ch\\\",\\n            \\\"referer\\\": \\\"https://drive.quark.cn/\\\"\\n        });\\n}\\n\\nfunction getDriveInfo() {\\n    return requestHttp(\\\"https://drive.quark.cn/1/clouddrive/share/sharepage/dir?pr=ucpro&fr=pc&aver=1\\\").start(true);\\n}\\n\\nfunction createSaveTask(fid, fid_token, pwd_id, stoken) {\\n    let driveInfo = getDriveInfo();\\n    return requestHttp(\\\"https://drive.quark.cn/1/clouddrive/share/sharepage/save?pr=ucpro&fr=pc\\\").setStartRequestFunc(post).body({\\n        \\\"fid_list\\\": [\\n            fid\\n        ],\\n        \\\"fid_token_list\\\": [\\n            fid_token\\n        ],\\n        \\\"to_pdir_fid\\\": driveInfo.data.dir.fid,\\n        \\\"pwd_id\\\": pwd_id,\\n        \\\"stoken\\\": stoken,\\n        \\\"pdir_fid\\\": driveInfo.data.dir.pdir_fid\\n    }).start(true);\\n}\\n\\nfunction createDeleteTask(fid) {\\n    let driveInfo = getDriveInfo();\\n    return requestHttp(\\\"https://drive.quark.cn/1/clouddrive/file/delete?pr=ucpro&fr=pc\\\").setStartRequestFunc(post).body({\\n        \\\"action_type\\\": 2,\\n        \\\"filelist\\\": [\\n            fid\\n        ],\\n        \\\"exclude_fids\\\": []\\n    }).start(true);\\n}\\n\\nfunction task(task_id, retry_index) {\\n    return requestHttp(\\\"https://drive.quark.cn/1/clouddrive/task\\\").buildUrl({\\n        pr: \\\"ucpro\\\",\\n        fr: \\\"pc\\\",\\n        task_id: task_id,\\n        retry_index: retry_index\\n    }).start(true);\\n}\\n\\nfunction queryTask(task_id) {\\n    for (let i = 0; i < 6; i++) {\\n        try {\\n            let res = task(task_id, i + \\\"\\\");\\n            if (res.data.status === 2) {\\n                waitSleep(1000);\\n                return res.data.save_as.save_as_top_fids[0];\\n            }\\n            waitSleep(300);\\n        } catch (e) {}\\n    }\\n    return void(0);\\n}\\n\\nfunction queryTaskStatus(task_id) {\\n    for (let i = 0; i < 6; i++) {\\n        try {\\n            let res = task(task_id, i + \\\"\\\");\\n            if (res.data.status === 2) {\\n                waitSleep(1000);\\n                return true;\\n            }\\n            waitSleep(300);\\n        } catch (e) {}\\n    }\\n    return false;\\n}\\n\\nfunction getPreviewVideo(fid) {\\n    return requestHttp(\\\"https://drive.quark.cn/1/clouddrive/file/v2/play?pr=ucpro&fr=pc\\\").body({\\n        \\\"fid\\\": fid,\\n        \\\"resolutions\\\": \\\"normal,low,high,super,2k,4k\\\",\\n        \\\"supports\\\": \\\"fmp4,m3u8\\\"\\n    }).setStartRequestFunc(post).start(true);\\n}\\n\\nfunction getDownloadUrl(fid) {\\n    return requestHttp(\\\"https://drive.quark.cn/1/clouddrive/file/download?pr=ucpro&fr=pc\\\").body({\\n        \\\"fids\\\": [fid]\\n    }).setStartRequestFunc(post).start(true);\\n}\\n\\nfunction getPlayUrl(fid, fid_token, pwd_id, stoken, category) {\\n    try {\\n        if (!cookie) return \\\"toast://请登录账号\\\";\\n        if (category != \\\"video\\\") return \\\"toast://不支持\\\";\\n        let taskId = createSaveTask(fid, fid_token, pwd_id, stoken).data.task_id;\\n        let asfid = queryTask(taskId);\\n        if (!asfid) {\\n            return \\\"toast://获取失败\\\";\\n        }\\n        let playMode = getItem(\\\"quark_playMode\\\", \\\"转码\\\");\\n        if (playMode === \\\"转码\\\") {\\n            let videoRes = getPreviewVideo(asfid);\\n            let videoList = videoRes.data.video_list;\\n            let playList = {\\n                names: [],\\n                urls: [],\\n                headers: []\\n            };\\n            let playCookie = cookieManage.get();\\n            videoList.filter(v => v.accessable).forEach(v => {\\n                playList.names.push(v.resolution);\\n                playList.urls.push(v.video_info.url + \\\"#isVideo=true#\\\");\\n                playList.headers.push({\\n                    Referer: \\\"http://pan.quark.cn/\\\",\\n                    cookie: playCookie,\\n                    \\\"User-Agent\\\": \\\"com.stub.StubApp/1.3.0 (Linux;Android 14) AndroidXMedia3/1.1.1\\\"\\n                });\\n            });\\n            createDeleteTask(asfid);\\n            return JSON.stringify(playList);\\n        } else {\\n            let playUrl = getDownloadUrl(asfid).data[0].download_url;\\n            let playCookie = cookieManage.get();\\n            let playList = {\\n                names: [\\\"原画\\\"],\\n                urls: [playUrl + \\\"#isVideo=true##fastPlayMode##threads=\\\"+getItem(\\\"speedThread\\\", \\\"10\\\")+\\\"#\\\"],\\n                headers: [{\\n                    Referer: \\\"http://pan.quark.cn/\\\",\\n                    cookie: playCookie,\\n                    \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) quark-cloud-drive/2.5.20 Chrome/100.0.4896.160 Electron/18.3.5.4-b478491100 Safari/537.36 Channel/pckk_other_ch\\\"\\n                }]\\n            }\\n            createDeleteTask(asfid);\\n            return JSON.stringify(playList);\\n        }\\n    } catch (e) {\\n        if (e.message.includes(\\\"require login\\\")) {\\n            toast(\\\"未登录或登录过期，请重新登录\\\");\\n            return \\\"hiker://page/login\\\";\\n        }\\n        return \\\"toast://\\\" + e.toString();\\n    }\\n}\\n\\n$.exports = {\\n    getPlayUrl\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"Ⓛ登录账号\",\"path\":\"login\",\"rule\":\"js:\\nlet d = [];\\naddListener(\\\"onClose\\\", () => {\\n    let cookie = getVar(\\\"quarkCookie\\\", \\\"\\\");\\n    if (cookie) {\\n        setItem(\\\"quarkCookie\\\", cookie);\\n        toast(\\\"Cookie获取成功\\\");\\n        refreshPage();\\n    }\\n    clearVar(\\\"quarkCookie\\\");\\n});\\nd.push({\\n    col_type: \\\"x5_webview_single\\\",\\n    url: \\\"https://pan.quark.cn/\\\",\\n    desc: \\\"float&&100%\\\",\\n    extra: {\\n        js: $.toString((ApiRootUrl) => {\\n            let timeInter = setInterval(() => {\\n                let Cookie = fba.getCookie(ApiRootUrl);\\n                if (Cookie.includes(\\\"_UP_F7E_8D_=\\\") && Cookie.includes(\\\"__uid=\\\")&&Cookie.includes(\\\"__puus=\\\")) {\\n                    fba.putVar(\\\"quarkCookie\\\", Cookie)\\n                    clearInterval(timeInter);\\n                    fba.log(Cookie);\\n                    fba.back(false);\\n                }\\n            }, 600);\\n        }, \\\"https://pan.quark.cn\\\"),\\n        ua: PC_UA,\\n        jsLoadingInject: false\\n    }\\n});\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"Ⓛ登录检测\",\"path\":\"tool\",\"rule\":\"js:\\n$.exports = {\\n    isLoginCookie(cookie) {\\n        return !!(cookie && cookie.includes(\\\"_UP_F7E_8D_=\\\") && cookie.includes(\\\"__uid=\\\") && cookie.includes(\\\"__puus=\\\"));\\n    },\\n\\n\\n\\n\\n    setRule(input) {\\n        try {\\n            // 格式化\\n            [logT, type, text] = String(input).split(\\\"￥\\\");\\n            switch (String(type)) {\\n                case 'Paste':\\n                    text = parsePaste(text);\\n                    break;\\n                case 'Lanzou':\\n                    [url, pwd] = text.split(\\\"##\\\");\\n                    durl = $.require('lanzou?rule=uckk云').one_url(url, pwd, 1);\\n                    text = String(fetch(durl));\\n                    if ((sp = text.split(\\\"￥\\\")).length == 3) {\\n                        text = sp[2].split(\\\"@\\\")[0].trim();\\n                    }\\n                    break;\\n            }\\n            arr1 = JSON.parse(base64Decode(text));\\n\\n\\n            // 合并，去重\\n            arr2 = $.require(\\\"configs?rule=uckk云\\\").getJson();\\n            arr3 = arr1.concat(arr2).filter((obj, index, arr) => {\\n                return arr.findIndex(o => obj.group === o.group && obj.title === o.title && (obj.time > o.time || obj.time == o.time)) === index;\\n            });\\n            $.require(\\\"configs?rule=uckk云\\\").saveJson(arr3);\\n\\n\\n            // 计算余量\\n            x = arr3.length - arr2.length;\\n            f = arr1.length - x\\n            refreshPage();\\n            toast(\\\"导入成功，新增：\\\" + x + \\\" 覆盖：\\\" + f);\\n        } catch (e) {\\n            log(e.toString());\\n            toast(\\\"导入失败\\\");\\n        }\\n    },\\n\\n\\n\\n\\n    setEdit() {\\n        _ = {\\n            group: getMyVar(\\\"group\\\", \\\"夸克\\\").trim(), // 规则 类别\\n            search_enabled: getMyVar(\\\"search_enabled\\\", \\\"1\\\").trim(), // 启用搜索 #\\n            explore_enabled: getMyVar(\\\"explore_enabled\\\", \\\"0\\\").trim(), // 启用发现 #\\n\\n            title: getMyVar(\\\"title\\\", \\\"\\\").trim(), // 源名称\\n            author: getMyVar(\\\"author\\\", \\\"佚名\\\").trim(), // 源作者\\n            icon: getMyVar(\\\"icon\\\", \\\"\\\").trim(), // 源图标\\n            preRule: getMyVar(\\\"preRule\\\", \\\"\\\").trim(), // js预处理\\n\\n            search_url: getMyVar(\\\"search_url\\\", \\\"\\\").trim(), // 搜索链接\\n            search_group: getMyVar(\\\"search_group\\\", \\\"常用\\\").trim(), // 源分组 #\\n            searchFind: getMyVar(\\\"searchFind\\\", \\\"\\\").trim(), // 搜索规则\\n\\n            explore_X5: getMyVar(\\\"explore_X5\\\", \\\"0\\\").trim(), // 使用x5 #\\n            url: getMyVar(\\\"url\\\", \\\"\\\").trim(), // 发现链接\\n            find_rule: getMyVar(\\\"find_rule\\\", \\\"\\\").trim(), // 发现规则\\n\\n            // 发现链接替换\\n            class_name: getMyVar(\\\"class_name\\\", \\\"\\\").trim(),\\n            class_url: getMyVar(\\\"class_url\\\", \\\"\\\").trim(),\\n            area_name: getMyVar(\\\"area_name\\\", \\\"\\\").trim(),\\n            area_url: getMyVar(\\\"area_url\\\", \\\"\\\").trim(),\\n            year_name: getMyVar(\\\"year_name\\\", \\\"\\\").trim(),\\n            year_url: getMyVar(\\\"year_url\\\", \\\"\\\").trim(),\\n            sort_name: getMyVar(\\\"sort_name\\\", \\\"\\\").trim(),\\n            sort_url: getMyVar(\\\"sort_url\\\", \\\"\\\").trim(),\\n\\n            // x5设置\\n            x5_jsLoadingInject: getMyVar(\\\"x5_jsLoadingInject\\\", \\\"0\\\").trim(),\\n            x5_js: getMyVar(\\\"x5_js\\\", \\\"\\\").trim(),\\n            x5_blockRules: getMyVar(\\\"x5_blockRules\\\", \\\"\\\").trim(),\\n            x5_urlInterceptor: getMyVar(\\\"x5_urlInterceptor\\\", \\\"\\\").trim(),\\n            x5_pageHome: getMyVar(\\\"x5_pageHome\\\", \\\"\\\").trim(),\\n            x5_referer: getMyVar(\\\"x5_referer\\\", \\\"\\\").trim(),\\n            x5_imgLongClick: getMyVar(\\\"x5_imgLongClick\\\", \\\"0\\\").trim(),\\n            x5_showProgress: getMyVar(\\\"x5_showProgress\\\", \\\"0\\\").trim(),\\n            x5_floatVideo: getMyVar(\\\"x5_floatVideo\\\", \\\"0\\\").trim(),\\n            x5_autoPlay: getMyVar(\\\"x5_autoPlay\\\", \\\"0\\\").trim(),\\n            x5_ua: getMyVar(\\\"x5_ua\\\", \\\"\\\").trim(),\\n            x5_url: getMyVar(\\\"x5_url\\\", \\\"\\\").trim(),\\n            x5_desc: getMyVar(\\\"x5_desc\\\", \\\"\\\").trim(),\\n            x5_home: getMyVar(\\\"x5_home\\\", \\\"\\\").trim(),\\n            time: new Date().getTime(), // 保存时间 #\\n        };\\n        if (_.title != \\\"\\\" && _.title != \\\"聚搜\\\" && _.title != \\\"最后面\\\") {\\n            if ((_.search_url != \\\"\\\" && _.searchFind != \\\"\\\") || (_.url != \\\"\\\" && (_.explore_X5 == \\\"1\\\" || _.find_rule != \\\"\\\"))) {\\n                for (t in _) {\\n                    clearMyVar(t);\\n                    if (_[t] == \\\"\\\" || _[t] == \\\"0\\\" || _[t] == \\\"MOBILE_UA\\\") {\\n                        delete _[t];\\n                    }\\n                }\\n                jxlist = $.require(\\\"configs?rule=uckk云\\\").getJson();\\n                uids = jxlist.map(__ => md5(__.group + __.title));\\n                i = uids.indexOf(getMyVar('rule_uid', '-1'));\\n                if (i == -1) {\\n                    jxlist.push(_);\\n                } else {\\n                    jxlist.splice(i, 1, _);\\n                }\\n                clearMyVar('rule_tid');\\n                clearMyVar('rule_uid');\\n                jxlist = jxlist.filter((obj, index, arr) => {\\n                    return arr.findIndex(o => md5(obj.group + obj.title) === md5(o.group + o.title) && (obj.time > o.time || obj.time === o.time)) === index;\\n                });\\n                $.require(\\\"configs?rule=uckk云\\\").saveJson(jxlist);\\n                return back(true), 'toast://保存成功';\\n            } else {\\n                return 'toast://搜索规则/发现规则总得写一个吧';\\n            }\\n        } else if (_.title == \\\"\\\") {\\n            return 'toast://请填写源名称';\\n        } else {\\n            return 'toast://规则名不能是' + _.title;\\n        }\\n    },\\n\\n    getVariables() {\\n        return [\\\"group\\\", \\\"search_enabled\\\", \\\"explore_enabled\\\", \\\"title\\\", \\\"author\\\", \\\"icon\\\", \\\"preRule\\\", \\\"search_url\\\", \\\"search_group\\\", \\\"searchFind\\\", \\\"explore_X5\\\", \\\"url\\\", \\\"find_rule\\\", \\\"class_name\\\", \\\"class_url\\\", \\\"area_name\\\", \\\"area_url\\\", \\\"year_name\\\", \\\"year_url\\\", \\\"sort_name\\\", \\\"sort_url\\\", \\\"x5_jsLoadingInject\\\", \\\"x5_js\\\", \\\"x5_blockRules\\\", \\\"x5_urlInterceptor\\\", \\\"x5_pageHome\\\", \\\"x5_referer\\\", \\\"x5_imgLongClick\\\", \\\"x5_showProgress\\\", \\\"x5_floatVideo\\\", \\\"x5_autoPlay\\\", \\\"x5_ua\\\", \\\"x5_url\\\", \\\"x5_desc\\\", \\\"x5_home\\\", \\\"time\\\", \\\"rule_tid\\\", \\\"rule_uid\\\"];\\n    },\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"❶通用函数\",\"path\":\"lib\",\"rule\":\"const Color = (test, color) => {\\n    return '<font color=\\\"' + (color || '#FA7298') + '\\\">' + test + '</front>';\\n}\\nconst Strong = (test) => {\\n    return '<strong>' + test + '</strong>';\\n}\\nconst Rich = (test) => {\\n    return \\\"‘‘’’\\\" + String(test)\\n        .replace(/\\\\\\\\n|(<|\\\\s+)br\\\\s*\\\\/?\\\\s*>/gi, '\\\\n')\\n        .replace(/\\\\\\\\r/g, '\\\\r')\\n        .replace(/\\\\\\\\f/g, '\\\\f')\\n        .replace(/\\\\\\\\t/g, '\\\\t')\\n        .replace(/&(lt|gt|nbsp|amp|quot);/gi, ($0, $1) => ({\\n            'lt': '<',\\n            'gt': '>',\\n            'nbsp': ' ',\\n            'amp': '&',\\n            'quot': '\\\"'\\n        }[$1.toLowerCase()]))\\n        .replace(/<\\\\/?(em|span)[^>]*>/gi, '');\\n}\\nconst Size = size => {\\n    if (!size) return '无法计算';\\n    units = ['B', 'KB', 'MB', 'GB'];\\n    i = 0;\\n    while (size > 1023) {\\n        size /= 1024;\\n        i++;\\n    }\\n    size = i ? size.toFixed(2) : size;\\n    return `${size} ${units[i]}`;\\n}\\ntry {\\n    MY_PAGE;\\n} catch (err) {\\n    MY_PAGE = 1;\\n}\\nlet id = \\\"uckk云\\\";\\nlet page = MY_PAGE;\\nlet _PAGE = page == 1;\\nlet icons = {\\n    阿里: \\\"https://gw.alicdn.com/imgextra/i1/O1CN01rAr34V28oR0rupkAi_!!6000000007979-2-tps-240-240.png\\\",\\n    夸克: \\\"hiker://images/icon_kuake\\\",\\n    音频: \\\"hiker://images/icon_music3\\\",\\n    磁力: \\\"https://android-artworks.25pp.com/fs08/2023/08/23/10/110_e1533a024c7efec175bc5110e96736ac_con_130x130.png\\\",\\n    影视: \\\"hiker://images/icon_video2\\\",\\n    动漫: \\\"hiker://images/icon_pic3\\\",\\n    图文: \\\"hiker://images/icon_txt2\\\",\\n    其他: \\\"hiker://images/icon_unknown\\\"\\n}\\nlet groups = Object.keys(icons);\\nlet pageid = id + \\\"ypj-page\\\" + page;\\nlet keyword = String(getMyVar(\\\"keyword\\\", \\\"\\\")).trim();\\nlet _SOU = keyword != \\\"\\\" && !keyword.match(/quark.*\\\\/s\\\\/.+/) && keyword == String(getMyVar(\\\"keyword2\\\", \\\"\\\")).trim();\\nlet history = storage0.getItem(\\\"searchHistory\\\", []);\\n\\n\\nconst getRuleBaseUrl = (baseU) => {\\n    isFyAll = String(baseU).includes(\\\"fyAll\\\");\\n    FyAll_i = Number(getMyVar(\\\"FyAll_i\\\")) || 0;\\n    for (t of ['class', 'area', 'year', 'sort']) {\\n        eval(`${t}_i = Number(getMyVar(\\\"${t}_i\\\")) || 0;\\nrule.${t}_url = String(rule.${t}_url || \\\"\\\").trim().split(\\\"&\\\");\\nrule.${t}_name = String(rule.${t}_name || \\\"\\\").trim().split(\\\"&\\\");\\nrule.${t}_url = rule.${t}_url.filter((u, i) => rule.${t}_name[i] != \\\"\\\");\\nrule.${t}_name = rule.${t}_name.filter((Name) => Name != \\\"\\\");\\nrule.${t}_i = rule.${t}_name.length;`);\\n    }\\n    baseU = String(baseU)\\n        .replace(\\n            /fypage@([^\\\\?\\\\&\\\\;\\\\#\\\\\\\"\\\\'\\\\{]+)@?/g,\\n            ($0, $1) => {\\n                page2 = page;\\n                $1.split(\\\"@\\\").map(_ => {\\n                    eval(String('page2=page2' + _));\\n                });\\n                return page2;\\n            }\\n        )\\n        .replace(/fypage/g, page)\\n        .replace(\\n            /fy(class|area|year|sort)/g,\\n            ($0, $1) => rule[$1 + '_url'][eval($1 + '_i')] || \\\"\\\"\\n        )\\n        .replace(\\n            /fyAll/g,\\n            ($0, $1) => {\\n                FyAll_ii = FyAll_i;\\n                if (FyAll_ii > (rule.class_i - 1)) {\\n                    FyAll_ii -= rule.class_i;\\n                    if (FyAll_ii > (rule.area_i - 1)) {\\n                        FyAll_ii -= rule.area_i;\\n                        if (FyAll_ii > (rule.year_i - 1)) {\\n                            return rule.sort_url[FyAll_ii - rule.year_i];\\n                        } else {\\n                            return rule.year_url[FyAll_ii];\\n                        }\\n                    } else {\\n                        return rule.area_url[FyAll_ii];\\n                    }\\n                } else {\\n                    return rule.class_url[FyAll_ii];\\n                }\\n            }\\n        );\\n    return baseU;\\n}\\nconst getRuleGroup = (col_type, Sou) => {\\n    for (it of ['class', 'area', 'year', 'sort']) {\\n        eval(`index = {\\n    class: 0,\\n    area: rule.class_i,\\n    year: rule.class_i + rule.area_i,\\n    sort: rule.class_i + rule.area_i + rule.year_i,\\n}[it]\\nrule.${it}_name.map((name, i) => {\\n    if (isFyAll) {\\n        i = index + i;\\n        t = FyAll_i == i;\\n        k = 'FyAll_i';\\n    } else {\\n        t = ${it}_i == i;\\n        k = '${it}_i'\\n    }\\n    d.push({\\n        title: t ? Rich(Strong(Color(name))) : name,\\n        url: $('#noLoading#').lazyRule((k, i) => {\\n            putMyVar(k, i);\\n            refreshPage(false);\\n            return 'hiker://empty';\\n        }, k, i),\\n        col_type: \\\"${col_type||\\\"\\\"}\\\" || 'scroll_button'\\n    });\\n});\\nd.push({\\n    col_type: 'blank_block'\\n});`);\\n    }\\n    if (Sou) {\\n        d.push({\\n            title: '搜索',\\n            desc: '搜索关键词 / 链接$提取码',\\n            url: $.toString(() => {\\n                input = input.trim();\\n                if (input.match(/quark.cn.*\\\\/s\\\\/.+/)) {\\n                    return \\\"hiker://page/quarkList#noHistory##noRecordHistory#?realurl=\\\" + encodeURIComponent(input) + \\\"&rule=uckk云&sharePwd=\\\";\\n                } else if (input != \\\"\\\") {\\n                    putMyVar('keyword2', input);\\n                    refreshPage(false);\\n                }\\n                return 'hiker://empty';\\n            }),\\n            col_type: \\\"input\\\",\\n            extra: {\\n                id: id + \\\":search\\\",\\n                defaultValue: keyword,\\n                onChange: \\\"putMyVar('keyword',input)\\\"\\n            }\\n        });\\n    }\\n    d.push({\\n        url: \\\"toast://加载中...\\\",\\n        img: \\\"https://hikerfans.com/weisyr/img/Loading1.gif\\\",\\n        col_type: \\\"pic_1_center\\\",\\n        extra: {\\n            cls: \\\"loading_gif\\\"\\n        }\\n    });\\n    setPreResult(d);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"❺温馨提示\",\"path\":\"notice\",\"rule\":\"$.exports = function() {\\n    f = \\\"Gray\\\";\\n    t = false;\\n    up = getMyVar('Rule_noupdate', '');\\n    if (up != '1') {\\n        version = JSON.parse(request(\\\"hiker://home@uckk云\\\")).version;\\n        if (up == '') {\\n            [url, v, run] = $.require(\\\"lanzou?rule=uckk云\\\").list_one(\\\"https://wwr.lanzoui.com/b03qf28qb\\\", \\\"read\\\");\\n        } else {\\n            url = false;\\n            v = version + 1;\\n        }\\n        if (version < v) {\\n            f = \\\"red\\\";\\n            t = \\\"检测到新版更新，点击了解详情。\\\";\\n            T = \\\"更新内容\\\";\\n            if (up == '') {\\n                confirm({\\n                    title: '更新提示',\\n                    content: '检测到你的规则版本小于服务器版本，是否立即更新？',\\n                    confirm: $.toString((da) => {\\n                        f = $.require(\\\"lanzou?rule=uckk云\\\").one_url(da);\\n                        putMyVar('Rule_noupdate', '1');\\n                        return \\\"\\\\u6d77\\\\u9614\\\\u89c6\\\\u754c\\\\uffe5home_rule_url\\\\uffe5\\\" + getPath(f);\\n                    }, url)\\n                });\\n                putMyVar('Rule_noupdate', url);\\n            }\\n            url = $(\\\"hiker://empty#noHistory##noRecordHistory#\\\").rule((up, version) => {\\n                return $.require(\\\"lanzou?rule=uckk云\\\").one_info(up, \\\"uckk\\\", version);\\n            }, url || up, version);\\n        } else {\\n            putMyVar('Rule_noupdate', '1');\\n        }\\n    }\\n\\n\\n    if (!$.require(\\\"tool\\\").isLoginCookie(getItem(\\\"quarkCookie\\\", \\\"\\\"))) {\\n        clearItem(\\\"quarkCookie\\\");\\n        f = \\\"red\\\";\\n        T = \\\"登录账号\\\";\\n        t = \\\"未检测到登录信息\\\";\\n        url = $([\\\"输入Cookie\\\", \\\"网页登录\\\"]).select(() => {\\n            if (input === \\\"网页登录\\\") {\\n                return \\\"hiker://page/login\\\";\\n            } else {\\n                return $(\\\"\\\", \\\"请输入Cookie\\\").input(() => {\\n                    if ($.require(\\\"tool\\\").isLoginCookie(input)) {\\n                        setItem(\\\"quarkCookie\\\", input.replace(/\\\\s/g, \\\"\\\"));\\n                        refreshPage();\\n                        return \\\"toast://设置成功\\\";\\n                    } else {\\n                        return \\\"toast://Cookie格式错误\\\";\\n                    }\\n                });\\n            }\\n        })\\n    } else if (!t) {\\n        T = \\\"程序设置\\\";\\n        url = \\\"hiker://page/install#noHistory##noRecordHistory#\\\";\\n        T = \\\"捐赠/支持\\\";\\n        url = \\\"hiker://page/donate#noHistory##noRecordHistory#\\\";\\n        hour = new Date().getHours();\\n        if (hour < 5) {\\n            t = \\\"深夜，现在的夜，熬得只是还未改变的习惯\\\";\\n        } else if (hour < 11) {\\n            t = \\\"早安，清晨熹微的阳光， 是你在微笑吗\\\";\\n        } else if (hour < 14) {\\n            t = \\\"午好，伴随着熟悉的乐曲，聆听着动人的旋律\\\";\\n        } else if (hour < 19) {\\n            t = \\\"夕暮，似清风醉晚霞，不经意间盈笑回眸\\\";\\n        } else {\\n            t = \\\"夜晚，一个安静的角落，静静地聆听夜曲\\\";\\n        }\\n    }\\n    d.push({\\n        title: \\\"““””\\\" + t.fontcolor(f).small(),\\n        col_type: \\\"text_center_1\\\",\\n        url: url,\\n        extra: {\\n            pageTitle: T,\\n            lineVisible: false\\n        }\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"❽蓝奏更新\",\"path\":\"lanzou\",\"rule\":\"js:\\nhead = {\\n    headers: {\\n        \\\"upgrade-insecure-requests\\\": \\\"1\\\",\\n        \\\"User-Agent\\\": \\\"Mozilla/5.0 (Linux; Android 8.0.0; MI 5s Plus Build/OPR1.170623.032; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/71.0.3578.99 Mobile Safari/537.36\\\",\\n        \\\"Cookie\\\": \\\"down_ip=1\\\",\\n        \\\"accept\\\": \\\"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8\\\",\\n    },\\n    method: 'GET'\\n};\\none_url = function(url, pwd, run, noTp, Html) {\\n    try {\\n        head.headers.referer = url.split(\\\"?\\\")[0];\\n        isTp = !url.match(\\\"/tp/\\\");\\n        if (isTp && !noTp) {\\n            da = url.replace(/^(.*?\\\\.com)/, '$1/tp');\\n        } else {\\n            da = url;\\n        }\\n        html = String(Html || fetch(da, head));\\n        if (html == \\\"\\\" && isTp && !noTp) {\\n            return one_url(url, pwd, run, true);\\n        }\\n        try {\\n            path = html.match(/link = ['\\\"]([^\\\"']+)/i)[1];\\n            host = url.match(/^(.*?\\\\.com\\\\/)/)[1];\\n            return one_url(host + path, pwd, run);\\n        } catch (err0) {\\n            try {\\n                path = html.match(/'(\\\\?.+?)'/)[1];\\n                host = \\\"https://developer.lanzoug.com\\\";\\n            } catch (err1) {\\n                eval(html.match(/value\\\\;([\\\\s\\\\S]+?)\\\\$\\\\(/i)[1]);\\n                eval('body=' + html.match(/[\\\\s\\\\S]*data :([\\\\s\\\\S]*?\\\\}),\\\\s+/)[1]);\\n                u = String(url).replace(/\\\\.com.*/, \\\".com/ajaxm.php\\\");\\n                _ = JSON.parse(post(u, {\\n                    body: body,\\n                    headers: head.headers\\n                }));\\n                path = _.url;\\n                host = _.dom;\\n            }\\n        }\\n        u = host + \\\"/file/\\\" + path;\\n        k = JSON.parse(fetch(u, {\\n            redirect: false,\\n            onlyHeaders: true\\n        })).headers.location;\\n        k = Array.isArray(k) ? k[0] : k;\\n        if (run) return k;\\n        let f = \\\"hiker://files/cache/_fileSelect_rule.json\\\";\\n        downloadFile(k, f);\\n        return f;\\n    } catch (err2) {\\n        return false;\\n    }\\n};\\n$.exports = {\\n    list_one: function(url, pwd, run) {\\n        src = fetch(url, head);\\n        eval(src.match(/var pgs;([\\\\s\\\\S]*?pgs.+;)/)[1]);\\n        eval('body=' + src.match(/data :([\\\\s\\\\S]*?\\\\})/)[1]);\\n        url = url.replace(/\\\\.com.*/, \\\".com/filemoreajax.php\\\");\\n        list = JSON.parse(post(url, {\\n            body: body,\\n            headers: head.headers\\n        })).text;\\n        if (run) return list;\\n        __ = list[0];\\n        url = url.replace(/filemo.*/, 'tp/' + __.id);\\n        v = __.name_all.match(/\\\\[(.+)/)[1];\\n        [v, run] = v.split(\\\"]\\\");\\n        return [url, v, run];\\n    },\\n    one_url: one_url,\\n    one_info: function(url, pwd, version) {\\n        version = version || \\\"未知版本\\\";\\n        version = String(version).replace(/(\\\\d\\\\d)(\\\\d\\\\d)$/, \\\"-$1-$2\\\");\\n        item = fetch(url, head);\\n        t = pdfh(item, \\\".md&&Text\\\") || pdfh(item, \\\"title&&Text\\\");\\n        try {\\n            t = String(t).split(\\\"[\\\")[1].split(\\\"]\\\")[0];\\n        } catch (err) {}\\n        t = String(t).replace(/(\\\\d\\\\d)(\\\\d\\\\d)$/, \\\"-$1-$2\\\");\\n        d = [];\\n        d.push({\\n            desc: \\\"<b>““\\\" + version + \\\" => \\\" + t + \\\"””</b>\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: \\\"hiker://empty\\\",\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n        d.push({\\n            col_type: \\\"big_big_blank_block\\\"\\n        });\\n        d.push({\\n            title: pdfh(item, \\\".mdo&&Html\\\").replace(/(<\\\\/span>)?\\\\s*<span>/gi, \\\"<br>\\\"),\\n            url: 'hiker://empty',\\n            col_type: 'rich_text'\\n        });\\n        d.push({\\n            col_type: \\\"big_blank_block\\\"\\n        });\\n        d.push({\\n            title: \\\"<b>““确定更新””</b>\\\".big(),\\n            col_type: \\\"text_center_1\\\",\\n            url: $(\\\"hiker://empty#noHistory##noRecordHistory#\\\").lazyRule((url, pwd, item) => {\\n                if (getMyVar('Rule_noupdate') == '1') {\\n                    return back(true), \\\"hiker://empty\\\";\\n                }\\n                let {\\n                    one_url\\n                } = $.require(\\\"hiker://page/lanzou?rule=歌词适配\\\");\\n                let K = one_url(url, pwd, 1, 0, item);\\n                if (!K) {\\n                    K = one_url(url, pwd, 1);\\n                }\\n                if (!K) {\\n                    K = one_url(url.split(\\\"?\\\")[0], pwd, 1);\\n                }\\n                if (K) {\\n                    f = \\\"hiker://files/cache/_fileSelect_rule.json\\\";\\n                    downloadFile(K, f);\\n                    putMyVar('Rule_noupdate', '1');\\n                    return \\\"\\\\u6d77\\\\u9614\\\\u89c6\\\\u754c\\\\uffe5home_rule_url\\\\uffe5\\\" + getPath(f);\\n                } else {\\n                    return \\\"toast://获取下载链接失败\\\";\\n                }\\n            }, url, pwd, item),\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n        setResult(d);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"❻支持作者\",\"path\":\"donate\",\"rule\":\"js:\\nlet d = [];\\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/ThomasYou/haikuo/raw/master/IMG_20240112_081355.png\\\",\\n    pic_url: \\\"https://gitee.com/ThomasYou/haikuo/raw/master/IMG_20240112_081355.png\\\"\\n});\\nd.push({\\n    col_type: \\\"text_center_1\\\",\\n    title: \\\"““””\\\" + \\\"图片加载缓慢请稍等\\\".small().fontcolor(\\\"Gray\\\"),\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"❸规则列表\",\"path\":\"ruleList\",\"rule\":\"js:\\naddListener('onClose', $.toString(() => {\\n    arr = $.require('tool?rule=uckk云').getVariables();\\n    for (t of arr) {\\n        clearMyVar(t);\\n    }\\n}));\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\nd = [];\\nd.push({\\n    title: '新增规则',\\n    col_type: 'text_2',\\n    url: $('#noLoading#').lazyRule(() => {\\n        arr = $.require('tool?rule=uckk云').getVariables();\\n        for (t of arr) {\\n            clearMyVar(t);\\n        }\\n        clearMyVar(\\\"rule_uid\\\");\\n        return 'hiker://page/ruleEdit#noHistory##noRecordHistory#?pageTitle=规则编辑&rule=uckk云'\\n    })\\n});\\nd.push({\\n    title: '分享选中',\\n    col_type: 'text_2',\\n    url: $('#noLoading#').lazyRule(() => {\\n        zy = storage0.getMyVar(\\\"jxlist2\\\", {});\\n        zu = Object.keys(zy);\\n        if (zu.length == 0) {\\n            return \\\"toast://没有选中解析\\\";\\n        } else if (zu.length == 1) {\\n            json = [zy[zu[0]]];\\n            u = base64Encode(JSON.stringify(json));\\n            clearMyVar('jxlist2');\\n            refreshPage(false);\\n            return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥Text￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n        } else {\\n            json = zu.map(key => zy[key]);\\n            t = base64Encode(JSON.stringify(json));\\n            return $([\\\"剪贴板\\\", \\\"纯文本\\\"], 1, '选择分享格式').select((t) => {\\n                if (input == \\\"剪贴板\\\") {\\n                    u = sharePaste(t, '云剪贴板6');\\n                    t = \\\"Paste\\\";\\n                } else {\\n                    u = t;\\n                    t = \\\"Text\\\";\\n                }\\n                clearMyVar('jxlist2');\\n                refreshPage(false);\\n                return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥\\\" + t + \\\"￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n            }, t);\\n        }\\n    })\\n});\\n\\n\\n\\n\\n\\n\\n\\n\\nplatform = getMyVar('platform', '综合');\\n[\\\"综合\\\"].concat(groups).map(group => {\\n    if (group == platform)\\n        platform2 = Rich(Strong(Color(group)));\\n    else\\n        platform2 = group;\\n    d.push({\\n        title: platform2,\\n        url: $('#noLoading#').lazyRule((group) => {\\n            putMyVar('platform', group);\\n            refreshPage();\\n            return 'hiker://empty';\\n        }, group),\\n        col_type: 'scroll_button',\\n        extra: {\\n            longClick: [{\\n                    title: '删除' + group.replace('综合', '全部') + '规则',\\n                    js: $.toString((group) => {\\n                        $$ = $.require('configs?rule=uckk云');\\n                        if (group == \\\"综合\\\") {\\n                            deleteFile($$.rulePath);\\n                        } else {\\n                            rules = $$.getJson_1(\\\"group\\\", group);\\n                            $$.saveJson(rules);\\n                        }\\n                        refreshPage();\\n                        return \\\"hiker://empty\\\";\\n                    }, group)\\n                },\\n                {\\n                    title: '分享' + group.replace('综合', '全部') + '规则',\\n                    js: $.toString((group) => {\\n                        $$ = $.require('configs?rule=uckk云');\\n                        if (group == \\\"综合\\\") {\\n                            rules = $$.getJson();\\n                        } else {\\n                            rules = $$.getJson_1(\\\"group\\\", group, 1);\\n                        }\\n                        if (rules.length == 0) return \\\"toast://没有规则\\\";\\n                        t = base64Encode(JSON.stringify(rules));\\n                        return $([\\\"剪贴板\\\", \\\"纯文本\\\"], 1, '选择分享格式').select((t) => {\\n                            if (input == \\\"剪贴板\\\") {\\n                                u = sharePaste(t, '云剪贴板6');\\n                                t = \\\"Paste\\\";\\n                            } else {\\n                                u = t;\\n                                t = \\\"Text\\\";\\n                            }\\n                            clearMyVar('jxlist2');\\n                            refreshPage(false);\\n                            return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥\\\" + t + \\\"￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n                        }, t);\\n                    }, group)\\n                }\\n            ]\\n        }\\n    });\\n});\\nd.push({\\n    col_type: 'blank_block'\\n});\\nrules = $.require('configs?rule=uckk云').getGroupJson(false, \\\"group\\\", platform, \\\"综合\\\");\\n\\n\\n\\n\\n\\npid = Number(getMyVar('pid')) || 0;\\nnames = $.require('configs?rule=uckk云').getGroupNames(rules, \\\"search_group\\\");\\nif (pid > names.length - 1) {\\n    pid = 0;\\n}\\nnames.map((group, i) => {\\n    if (i == pid)\\n        platform2 = Rich(Strong(Color(group)));\\n    else\\n        platform2 = group;\\n    d.push({\\n        title: platform2,\\n        url: $('#noLoading#').lazyRule((i) => {\\n            putMyVar('pid', i);\\n            refreshPage(false);\\n            return 'hiker://empty';\\n        }, i),\\n        col_type: 'scroll_button',\\n        extra: {\\n            longClick: [{\\n                title: '分享' + group.replace('全全', '全部') + '规则',\\n                js: $.toString((platform, group) => {\\n                    $$ = $.require('configs?rule=uckk云');\\n                    rules = $$.getJson_1(\\\"group\\\", platform, 1);\\n                    if (group != \\\"全全\\\") {\\n                        rules = rules.filter(f => f.search_group == group);\\n                    }\\n                    if (rules.length == 0) return \\\"toast://没有规则\\\";\\n                    t = base64Encode(JSON.stringify(rules));\\n                    return $([\\\"剪贴板\\\", \\\"纯文本\\\"], 1, '选择分享格式').select((t) => {\\n                        if (input == \\\"剪贴板\\\") {\\n                            u = sharePaste(t, '云剪贴板6');\\n                            t = \\\"Paste\\\";\\n                        } else {\\n                            u = t;\\n                            t = \\\"Text\\\";\\n                        }\\n                        clearMyVar('jxlist2');\\n                        refreshPage(false);\\n                        return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥\\\" + t + \\\"￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n                    }, t);\\n                }, platform, group)\\n            }]\\n        }\\n    });\\n});\\nd.push({\\n    col_type: 'line'\\n});\\nplatform2 = names[pid];\\nrules = $.require('configs?rule=uckk云').getGroupJson(rules, \\\"search_group\\\", platform2, \\\"全全\\\").slice(1);\\n\\n\\n\\n\\n\\n\\nif (rules.length == 0) {\\n    d.push({\\n        title: Rich(Strong(Color(\\\"没有规则\\\"))),\\n        url: 'hiker://empty',\\n        col_type: 'text_center_1',\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n} else {\\n    jxlist2 = storage0.getMyVar(\\\"jxlist2\\\", {});\\n    rules.map((_, ii) => {\\n        m = md5(_.group + _.title);\\n        i = !jxlist2[m];\\n        d1 = _.explore_enabled == \\\"1\\\";\\n        d2 = 'by ' + _.author;\\n        d.push({\\n            title: Strong(i ? _.title : Color(_.title)),\\n            desc: d1 ? Color(d2, \\\"#2E5D8E\\\") : d2,\\n            url: $([\\\"分享\\\", \\\"编辑\\\", \\\"删除\\\", \\\"移动\\\"].concat([i ? \\\"选中规则\\\" : \\\"取消选中\\\", d1 ? \\\"禁用发现\\\" : \\\"启用发现\\\"]), 2, '选择扩展操作').select((m, _) => {\\n                switch (input) {\\n                    case '分享':\\n                        _ = base64Encode(JSON.stringify([_]));\\n                        return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥Text￥\\\" + _ + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n                        break;\\n                    case '编辑':\\n                        arr = $.require('tool?rule=uckk云').getVariables();\\n                        for (t of arr) {\\n                            clearMyVar(t);\\n                        }\\n                        arr = Object.keys(_);\\n                        for (t of arr) {\\n                            putMyVar(t, _[t] || \\\"\\\");\\n                        }\\n                        putMyVar('rule_uid', m);\\n                        putMyVar('search_enabled', _.search_enabled || \\\"0\\\");\\n                        putMyVar('explore_enabled', _.explore_enabled || \\\"0\\\");\\n                        return 'hiker://page/ruleEdit#noHistory##noRecordHistory#?pageTitle=规则编辑&rule=uckk云';\\n                        break;\\n                    case '删除':\\n                        return $(\\\"确定删除\\\" + _.group + \\\"规则“\\\" + _.title + '”吗？\\\\n此操作不可逆，请谨慎选择。').confirm((m) => {\\n                            $$ = $.require('configs?rule=uckk云');\\n                            rules = $$.getJson_2(m);\\n                            $$.saveJson(rules);\\n                            refreshPage(false);\\n                        }, m);\\n                        break;\\n                    case '移动':\\n                        zy = $.require('configs?rule=uckk云').getJson_2(m);\\n                        zu = zy.slice(1).map(_ => _.title);\\n                        return $(zu.concat(\\\"最后面\\\"), 2, '请选择移动位置').select((zy, zu, _) => {\\n                            i = zu.indexOf(input);\\n                            if (i == -1)\\n                                zy.push(_);\\n                            else\\n                                zy.splice(i + 1, 0, _);\\n                            $.require('configs?rule=uckk云').saveJson(zy);\\n                            refreshPage(false);\\n                        }, zy, zu, _);\\n                        break;\\n                    case '选中规则':\\n                        jxlist2 = storage0.getMyVar(\\\"jxlist2\\\", {});\\n                        jxlist2[m] = _;\\n                        storage0.putMyVar(\\\"jxlist2\\\", jxlist2);\\n                        refreshPage(false);\\n                        break;\\n                    case '取消选中':\\n                        jxlist2 = storage0.getMyVar(\\\"jxlist2\\\", {});\\n                        delete jxlist2[m];\\n                        storage0.putMyVar(\\\"jxlist2\\\", jxlist2);\\n                        refreshPage(false);\\n                        break;\\n                    case '启用发现':\\n                    case '禁用发现':\\n                        $.require('configs?rule=uckk云').getJson_2(m, \\\"explore_enabled\\\");\\n                        refreshPage(false);\\n                        break;\\n                }\\n            }, m, _),\\n            col_type: 'avatar',\\n            img: _.icon\\n        });\\n        d.push({\\n            title: _.group + '丨' + _.search_group + '丨' + (_.x5_url || (_.url ? _.url : _.search_url).split(\\\"/\\\").slice(0, 3).join(\\\"/\\\")),\\n            url: $('#noLoading#').lazyRule((m) => {\\n                $.require('configs?rule=uckk云').getJson_2(m, \\\"search_enabled\\\");\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, m),\\n            col_type: 'text_icon',\\n            img: 'https://hikerfans.com/tubiao/messy/' + (_.search_enabled == '1' ? 55 : 63) + '.svg',\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n        d.push({\\n            col_type: 'line'\\n        });\\n    });\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"❼程序首页\",\"path\":\"home\",\"rule\":\"js:\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\naddListener('onRefresh', $.toString(() => {\\n    putMyVar('keyword2', getMyVar('keyword'));\\n}));\\nd = [];\\nlet rules = $.require(\\\"configs?rule=uckk云\\\").getJson();\\n\\n\\n\\nsearch_rule = rules.filter(_ => _.search_enabled == \\\"1\\\" && _.search_url != \\\"\\\" && _.searchFind != \\\"\\\");\\nsearch_type = $.require(\\\"configs?rule=uckk云\\\").getGroupNames(search_rule, \\\"group\\\");\\nruleType = getMyVar(\\\"ruleType\\\", \\\"综合\\\");\\nsearch_rule = $.require(\\\"configs?rule=uckk云\\\").getGroupJson(search_rule, \\\"group\\\", ruleType, \\\"综合\\\");\\nsearch_group = $.require(\\\"configs?rule=uckk云\\\").getGroupNames(search_rule, \\\"search_group\\\");\\nruleGroup = Number(getMyVar(\\\"ruleGroup\\\")) || 0;\\nif (ruleGroup > search_group.length - 1) {\\n    ruleGroup = 0;\\n}\\nsearch_rule = $.require(\\\"configs?rule=uckk云\\\").getGroupJson(search_rule, \\\"search_group\\\", search_group[ruleGroup], \\\"全全\\\");\\nlet sid = Number(getMyVar(\\\"sid\\\")) || 0;\\nif (sid > search_rule.length - 1) {\\n    sid = 0;\\n}\\nif (sid) {\\n    data = [search_rule[sid]];\\n} else {\\n    data = search_rule.slice(1);\\n}\\n\\n\\n\\n\\nlet explore_rule = rules.filter(_ => _.explore_enabled == \\\"1\\\" && _.url != \\\"\\\" && (_.explore_X5 == \\\"1\\\" || _.find_rule != \\\"\\\"));\\nlet tid = Number(getMyVar(\\\"tid\\\")) || 0;\\nif (tid > explore_rule.length - 1) {\\n    tid = 0;\\n}\\nlet rule = _ = explore_rule[tid];\\nlet rule_x5 = _.explore_X5 == \\\"1\\\";\\nif (rule_x5) {\\n    if (!_.x5_url && (_.url ? _.url : _.search_url).match(/fy(All|class|area|sort|year|page)/)) {\\n        _.x5_url = (_.url ? _.url : _.search_url).split(\\\"/\\\").slice(0, 3).join(\\\"/\\\");\\n    }\\n} else {\\n    if (_PAGE) $.require('notice?rule=uckk云')();\\n    _.x5_desc = '1';\\n}\\nhome_baseUrl = getRuleBaseUrl(_.url);\\n\\n\\n\\n\\n\\n\\n\\n// top\\nif (_PAGE) {\\n    explore_rule.map((_, i) => {\\n        d.push({\\n            title: Strong(\\\"““\\\" + (tid == i ? _.title + \\\"””\\\" : \\\"””\\\" + _.title)),\\n            url: $('#noLoading#').lazyRule((i) => {\\n                putMyVar('keyword2', getMyVar('keyword'));\\n                putMyVar('tid', i);\\n                for (t of [\\\"class\\\", \\\"area\\\", \\\"year\\\", \\\"sort\\\", \\\"FyAll\\\"]) {\\n                    clearMyVar(t + \\\"_i\\\");\\n                }\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, i),\\n            col_type: 'scroll_button'\\n        });\\n    });\\n    d.push({\\n        col_type: \\\"x5_webview_single\\\",\\n        url: _.x5_desc == '1' || _.x5_url || _.url,\\n        desc: _.x5_desc || \\\"screen-133&&float\\\",\\n        extra: {\\n            canBack: true,\\n            ua: _.x5_ua ? (_.x5_ua == \\\"PC_UA\\\" ? PC_UA : _.x5_ua) : MOBILE_UA,\\n            referer: _.x5_referer,\\n            js: _.x5_js,\\n            jsLoadingInject: !!_.x5_jsLoadingInject,\\n            autoPlay: !!_.x5_autoPlay,\\n            floatVideo: !!_.x5_floatVideo,\\n            imgLongClick: !_.x5_imgLongClick,\\n            showProgress: !_.x5_showProgress,\\n            blockRules: eval(_.x5_blockRules) || [],\\n            urlInterceptor: $.toString((urlInterceptor_js, x5Url) => {\\n                if (input.includes(\\\"aliyundrive.com/\\\") || input.includes(\\\"aliyundrive.net/\\\") || input.includes(\\\"alipan.com/\\\")) {\\n                    return $.toString((url) => {\\n                        fba.open(JSON.stringify({\\n                            rule: '云盘君.简',\\n                            url: \\\"hiker://page/aliyun#noHistory##noRecordHistory#?rule=云盘君.简&page=fypage&realurl=\\\" + encodeURIComponent(url)\\n                        }));\\n                    }, input)\\n                } else if (input.includes(\\\"quark.cn\\\")) {\\n                    return $.toString((url) => {\\n                        fba.open(JSON.stringify({\\n                            title: \\\"夸克网盘\\\",\\n                            url: \\\"hiker://page/quarkList#noHistory##noRecordHistory#?rule=uckk云&realurl=\\\" + encodeURIComponent(url),\\n                        }))\\n                    }, input);\\n                }\\n                let x5_urlInterceptor = new Function(\\\"input\\\", \\\"x5Url\\\", urlInterceptor_js);\\n                return x5_urlInterceptor(input, x5Url);\\n            }, _.x5_urlInterceptor, \\\"hiker://page/ruleHome#noHistory##noRecordHistory#?rule=uckk云&page=fypage&ruleName=\\\" + _.title + \\\"&ruleGroup=\\\" + _.group + \\\"&baseUrl=\\\")\\n        }\\n    });\\n}\\n\\n\\n\\nif (rule_x5) { // x5\\n    if (_.x5_desc == '1') { // 自定义首页\\n        eval(_.preRule);\\n        eval(_.x5_home);\\n    }\\n} else { // 搜索/发现\\n    if (_PAGE) {\\n        d.push({\\n            col_type: 'line_blank'\\n        }, {\\n            col_type: 'line_blank'\\n        }, {\\n            title: Strong(\\\"我的收藏\\\"),\\n            url: \\\"hiker://collection?rule=\\\" + id,\\n            col_type: \\\"icon_small_3\\\",\\n            img: \\\"hiker://images/icon_download\\\"\\n        }, {\\n            title: Strong(\\\"历史记录\\\"),\\n            url: \\\"hiker://history?rule=\\\" + id,\\n            col_type: \\\"icon_small_3\\\",\\n            img: \\\"hiker://images/icon_his\\\"\\n        }, {\\n            title: Strong(\\\"规则管理\\\"),\\n            url: \\\"hiker://page/ruleList#noHistory##noRecordHistory#?pageTitle=规则管理&rule=\\\" + id,\\n            col_type: \\\"icon_small_3\\\",\\n            img: \\\"hiker://images/icon_xiutan\\\"\\n        }, {\\n            title: '搜索',\\n            desc: '搜索关键词 / 链接$提取码',\\n            url: $.toString(() => {\\n                input = input.trim();\\n                if (input.match(/quark.cn.*\\\\/s\\\\/.+/)) {\\n                    return \\\"hiker://page/quarkList#noHistory##noRecordHistory#?realurl=\\\" + encodeURIComponent(input) + \\\"&rule=uckk云&sharePwd=\\\";\\n                } else if (input != \\\"\\\") {\\n                    putMyVar('keyword2', input);\\n                    refreshPage(false);\\n                }\\n                return 'hiker://empty';\\n            }),\\n            col_type: \\\"input\\\",\\n            extra: {\\n                id: id + \\\":search\\\",\\n                defaultValue: keyword,\\n                onChange: \\\"putMyVar('keyword',input)\\\"\\n            }\\n        }, {\\n            title: Rich(Strong(Color(ruleType, \\\"#3399cc\\\"))),\\n            url: $([\\\"综合\\\"].concat(groups).map(name => {\\n                if (name == ruleType) {\\n                    name = Rich(Strong(Color(name)));\\n                } else if (search_type.indexOf(name) == -1) {\\n                    name = Rich(\\\"<S>\\\" + name + \\\"</S>\\\");\\n                }\\n                return name;\\n            }), 3, \\\"选择搜索类别\\\").select(() => {\\n                if (input.indexOf(\\\"<S>\\\") != -1) {\\n                    return \\\"toast://没有对应规则\\\";\\n                } else if (input.indexOf(\\\"<\\\") == -1) {\\n                    putMyVar('keyword2', getMyVar('keyword'));\\n                    putMyVar('ruleType', input);\\n                    clearMyVar(\\\"ruleGroup\\\");\\n                    clearMyVar(\\\"sid\\\");\\n                    refreshPage(false);\\n                }\\n                return 'hiker://empty';\\n            }),\\n            col_type: 'scroll_button'\\n        });\\n        search_group.map((name, i) => {\\n            d.push({\\n                title: ruleGroup == i ? Rich(Strong(Color(name))) : name,\\n                url: $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('keyword2', getMyVar('keyword'));\\n                    putMyVar('ruleGroup', i);\\n                    clearMyVar(\\\"sid\\\");\\n                    refreshPage();\\n                    return 'hiker://empty';\\n                }, i),\\n                col_type: 'scroll_button'\\n            });\\n        });\\n        d.push({\\n            col_type: 'blank_block'\\n        });\\n        search_rule.map((_, i) => {\\n            d.push({\\n                title: sid == i ? Rich(Strong(Color(_.title))) : _.title,\\n                url: $('#noLoading#').lazyRule((i) => {\\n                    putMyVar('keyword2', getMyVar('keyword'));\\n                    putMyVar('sid', i);\\n                    refreshPage();\\n                    return 'hiker://empty';\\n                }, i),\\n                col_type: 'scroll_button'\\n            });\\n        });\\n        d.push({\\n            col_type: 'line_blank'\\n        });\\n    }\\n\\n\\n\\n\\n\\n    if (_SOU) {\\n        if (data.length > 0) {\\n            d.push({\\n                title: \\\"加载第\\\" + page + \\\"页中，进度：1/\\\" + data.length,\\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"text_center_1\\\",\\n                desc: \\\"\\\",\\n                pic_url: \\\"\\\",\\n                extra: {\\n                    id: pageid\\n                }\\n            });\\n        } else if (_PAGE) {\\n            d.push({\\n                title: \\\"没有可用的搜索规则\\\",\\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"text_center_1\\\",\\n                desc: \\\"\\\",\\n                pic_url: \\\"\\\",\\n                extra: {\\n                    id: pageid\\n                }\\n            });\\n        }\\n    } else if (_PAGE || rule.url.match(\\\"fypage\\\")) {\\n        if (_PAGE) {\\n            if (rule.title != \\\"聚搜\\\") d.push({\\n                title: '‘‘’’<b>' + Color(rule.title, '#ff6601') + '</b>',\\n                url: $('#noLoading#').lazyRule((url) => {\\n                    for (t of [\\\"class\\\", \\\"area\\\", \\\"year\\\", \\\"sort\\\", \\\"FyAll\\\"]) {\\n                        clearMyVar(t + \\\"_i\\\");\\n                    }\\n                    return url;\\n                }, \\\"hiker://page/ruleHome?rule=uckk云&page=fypage&ruleName=\\\" + rule.title + \\\"&ruleGroup=\\\" + rule.group),\\n                col_type: 'text_center_1',\\n                img: rule.icon,\\n                extra: {\\n                    lineVisible: false,\\n                    home: 1\\n                }\\n            });\\n            getRuleGroup();\\n        }\\n        baseUrl = home_baseUrl;\\n        eval(String(rule.preRule));\\n        eval(String(rule.find_rule));\\n    }\\n}\\n_PAGE ? setPreResult(d) : setResult(d);\\ndeleteItemByCls('loading_gif');\\n\\n\\n\\n// 搜索\\nif (!rule_x5 && _SOU && data.length > 0) {\\n    let ii = history.indexOf(keyword);\\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(keyword);\\n    storage0.setItem(\\\"searchHistory\\\", history);\\n    let tasks = data.map(it => {\\n        return {\\n            func: function(rule) {\\n                try {\\n                    try {\\n                        MY_PAGE\\n                    } catch (err) {\\n                        MY_PAGE = 1\\n                    }\\n                    page = MY_PAGE;\\n                    baseUrl = rule.search_url\\n                        .replace(\\n                            /fypage@([^\\\\?\\\\&\\\\;\\\\#\\\\\\\"\\\\'\\\\{]+)@?/g,\\n                            ($0, $1) => {\\n                                page2 = page;\\n                                $1.split(\\\"@\\\").map(_ => {\\n                                    eval(String('page2=page2' + _));\\n                                });\\n                                return page2;\\n                            }\\n                        )\\n                        .replace(/fypage/g, page)\\n                        .replace(/\\\\*\\\\*/g, keyword);\\n                    if (page == 1 || rule.search_url.match(\\\"fypage\\\")) {\\n                        eval(rule.preRule);\\n                        let searchfind = new Function(\\\"rule\\\", \\\"baseUrl\\\", \\\"keyword\\\", \\\"page\\\", rule.searchFind);\\n                        let list = searchfind(rule, baseUrl, keyword, page);\\n                        if (!list) return [];\\n                        let descTips = \\\"““””\\\" + rule.title.fontcolor(\\\"#f13b66a\\\") + \\\"&nbsp;&nbsp;\\\";\\n                        let resList = [];\\n                        for (let it of list) {\\n                            resList.push({\\n                                title: it.title.includes(\\\"““””\\\") ? it.title : \\\"““””\\\" + it.title.replace(/<\\\\/em>/g, \\\"\\\").replace(new RegExp(keyword, \\\"g\\\"), \\\"<strong><span style=\\\\\\\"color: #1E90FF\\\\\\\">\\\" + keyword + \\\"</span></strong>\\\"),\\n                                desc: descTips + (it.desc || \\\"\\\"),\\n                                url: it.url,\\n                                img: it.img || it.pic_url,\\n                                col_type: it.col_type || \\\"text_1\\\",\\n                                extra: Object.assign({\\n                                    inheritTitle: false,\\n                                    noPic: true\\n                                }, it.extra || {})\\n                            });\\n                        }\\n                        return resList;\\n                    } else {\\n                        return [];\\n                    }\\n                } catch (e) {\\n                    log(_.title + \\\":\\\" + e.toString());\\n                    return [];\\n                }\\n            },\\n            param: it,\\n            id: \\\"uckk_rule@\\\" + it.title\\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}\"},{\"col_type\":\"movie_3\",\"name\":\"❹规则编辑\",\"path\":\"ruleEdit\",\"rule\":\"js:\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\n\\ngroup = getMyVar('group', '夸克');\\nsearch_enabled = getMyVar('search_enabled', '1') == '1';\\nexplore_enabled = getMyVar('explore_enabled', '0') == '1';\\n\\nrule_tid = getMyVar('rule_tid', '基本');\\nexplore_X5 = getMyVar('explore_X5', '0') == '1';\\ntime = Number(getMyVar(\\\"time\\\")) || new Date().getTime();\\n\\n\\n\\n\\n\\n\\n\\nd = [];\\nd.push({\\n    title: Strong(Color('<b>' + group + '资源</b>', '#ff6601')),\\n    url: $(groups.map(title => title == group ? Rich(Strong(Color(title))) : title), 2, '选择规则分组').select(() => {\\n        if (!input.match(/^‘‘’’/)) {\\n            putMyVar('group', input);\\n            refreshPage(false);\\n        }\\n        return 'hiker://empty';\\n    }),\\n    img: icons[group],\\n    col_type: 'icon_small_3'\\n});\\nd.push({\\n    title: Color('<b>启用搜索</b>', '#ff6601'),\\n    url: $('#noLoading#').lazyRule((search_enabled) => {\\n        putMyVar('search_enabled', search_enabled);\\n        refreshPage(false);\\n        return 'hiker://empty';\\n    }, search_enabled ? '0' : '1'),\\n    img: 'https://hikerfans.com/tubiao/messy/' + (search_enabled ? 55 : 63) + '.svg',\\n    col_type: 'icon_small_3'\\n});\\nd.push({\\n    title: Color('<b>启用发现</b>', '#ff6601'),\\n    url: $('#noLoading#').lazyRule((explore_enabled) => {\\n        putMyVar('explore_enabled', explore_enabled);\\n        refreshPage(false);\\n        return 'hiker://empty';\\n    }, explore_enabled ? '0' : '1'),\\n    img: 'https://hikerfans.com/tubiao/messy/' + (explore_enabled ? 55 : 63) + '.svg',\\n    col_type: 'icon_small_3'\\n});\\n\\n[\\\"基本\\\", \\\"搜索\\\", \\\"发现\\\", \\\"替换\\\", \\\"扩展\\\"].map(name => {\\n    i = rule_tid == name\\n    d.push({\\n        title: Rich(Strong(i ? Color(name) : name)),\\n        url: $('#noLoading#').lazyRule((tid, tii) => {\\n            if (tii) {\\n                putMyVar('rule_tid', tid);\\n                refreshPage(false);\\n            }\\n            return 'hiker://empty';\\n        }, name, !i),\\n        col_type: 'text_5'\\n    });\\n});\\ninput_push = (desc, id, value, json, height) => {\\n    d.push({\\n        desc: desc,\\n        title: \\\"</>\\\",\\n        url: $.toString((id) => {\\n            let group = $.require(\\\"configs?rule=uckk云\\\").getGroupNames(0, \\\"search_group\\\");\\n            if (!group.length) {\\n                return \\\"\\\";\\n            }\\n            return $(group, 3, \\\"选择规则分组\\\").select((id) => {\\n                let extra = findItem(id).extra;\\n                updateItem(id, {\\n                    extra: Object.assign(extra, {\\n                        defaultValue: input\\n                    })\\n                });\\n            }, id);\\n        }, id),\\n        col_type: 'input',\\n        extra: Object.assign({\\n            defaultValue: getMyVar(id, value),\\n            onChange: `putMyVar(\\\"${id}\\\", input)`,\\n            type: 'textarea',\\n            titleVisible: true,\\n            highlight: true,\\n            height: height || 5,\\n            id: id,\\n        }, json || {})\\n    });\\n}\\nswitch (rule_tid) {\\n    case '基本':\\n        [\\n            ['必填，源名称', 'title', ''],\\n            ['选填，源图标', 'icon', ''],\\n            ['选填，源作者', 'author', '佚名'],\\n            ['选填，JsLib', 'preRule', '', {\\n                height: 3\\n            }],\\n        ].map([a, b, c, e] => {\\n            input_push(a, b, c, e, 1);\\n        });\\n        break;\\n    case '搜索':\\n        [\\n            ['必填，搜索链接', 'search_url', ''],\\n            ['必填，搜索分组', 'search_group', '全全', {\\n                highlight: false,\\n            }],\\n            ['必填，列表规则\\\\n提供变量: baseUrl, keyword, page\\\\n\\\\n需要返回数组：return [];', 'searchFind', '', {\\n                height: 5\\n            }],\\n        ].map([a, b, c, e] => {\\n            input_push(a, b, c, e, 1);\\n        });\\n        break;\\n    case '发现':\\n        d.push({\\n            title: Strong('使用 x5_webview_single'),\\n            url: $('#noLoading#').lazyRule((explore_X5) => {\\n                putMyVar('explore_X5', explore_X5);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, explore_X5 ? '0' : '1'),\\n            col_type: 'text_icon',\\n            img: 'https://hikerfans.com/tubiao/messy/' + (explore_X5 ? 55 : 63) + '.svg'\\n        });\\n        [\\n            ['必填，源链接', 'url', '', {\\n                height: 1\\n            }],\\n            ['必填，列表规则\\\\n启用x5就不用写了\\\\n\\\\n继承数组d： d.push(json);', 'find_rule', ''],\\n        ].map([a, b, c, e] => {\\n            input_push(a, b, c, e);\\n        });\\n        break;\\n    case '替换':\\n        d.push({\\n            title: Strong('发现链接替换'),\\n            desc: '选填',\\n            url: 'hiker://empty',\\n            col_type: 'avatar',\\n            img: 'hiker://images/home_icon_edit'\\n        });\\n        [\\n            ['分类名称', 'class_name', ''],\\n            ['分类替换', 'class_url', ''],\\n            ['地区名称', 'area_name', ''],\\n            ['地区替换', 'area_url', ''],\\n            ['年代名称', 'year_name', ''],\\n            ['年代替换', 'year_url', ''],\\n            ['排序名称', 'sort_name', ''],\\n            ['排序替换', 'sort_url', ''],\\n        ].map([a, b, c, e] => {\\n            input_push(a, b, c, e, 1);\\n        });\\n        break;\\n    case '扩展':\\n        x5_jsLoadingInject = getMyVar('x5_jsLoadingInject', '0') == '1';\\n        x5_floatVideo = getMyVar('x5_floatVideo', '0') == '1';\\n        x5_autoPlay = getMyVar('x5_autoPlay', '0') == '1';\\n        x5_showProgress = getMyVar('x5_showProgress', '0') == '1';\\n        x5_imgLongClick = getMyVar('x5_imgLongClick', '0') == '1';\\n        x5_desc = getMyVar('x5_desc', '0') == '1';\\n\\n        d.push({\\n            title: Strong('注入js'),\\n            desc: '选填',\\n            url: 'hiker://empty',\\n            col_type: 'avatar',\\n            img: 'hiker://images/home_icon_edit'\\n        });\\n        d.push({\\n            title: '<b>网站加载中也执行</b>',\\n            url: $('#noLoading#').lazyRule((x) => {\\n                putMyVar('x5_jsLoadingInject', x);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, x5_jsLoadingInject ? '0' : '1'),\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_jsLoadingInject ? 55 : 63) + '.svg',\\n            col_type: 'text_icon'\\n        });\\n        input_push(\\\"\\\", \\\"x5_js\\\", \\\"\\\", {}, 3);\\n\\n        d.push({\\n            col_type: 'line_blank'\\n        });\\n        d.push({\\n            title: Strong('拦截资源'),\\n            desc: '选填',\\n            url: 'hiker://empty',\\n            col_type: 'avatar',\\n            img: 'hiker://images/home_icon_edit'\\n        });\\n        input_push(\\\"返回为数组，支持js，不需要return\\\\n不执行匹配的链接，让网页加载更快，规则为包含匹配，*代表任意字符（不是正则），如果想拦截不包含的可使用!!，如 ['!!test1!!$dom'] 表示链接不包含test1并且不包含网站域名那就拦截、!!$topdom不包含主域名就拦截\\\", \\\"x5_blockRules\\\", \\\"\\\");\\n        input_push(`提供变量 input，x5Url\\\\n该代码不是在网页中执行的，没有fy_bridge_app。\\\\n有返回就拦截链接，不加载网址，例：if(input.includes('/ad/')) return true\\\\n可以跳转到规则二级页面，例：\\\\nreturn $.toString((url, x5Url) => {\\n    fba.open(JSON.stringify({\\n        url: x5Url + encodeURIComponent(url)\\n    }));\\n}, input, x5Url)`, \\\"x5_urlInterceptor\\\", \\\"\\\", {}, 7);\\n        input_push(\\\"子页面规则，上面的规则可以通过x5Url跳转到这里。baseUrl是跳转的链接\\\", \\\"x5_pageHome\\\", \\\"\\\", {}, 3);\\n        d.push({\\n            col_type: 'line_blank'\\n        });\\n        d.push({\\n            title: Strong('x5设置'),\\n            desc: '一般不用管',\\n            url: 'hiker://empty',\\n            col_type: 'avatar',\\n            img: 'hiker://images/home_icon_edit'\\n        });\\n        input_push(\\\"Referer\\\", \\\"x5_referer\\\", \\\"\\\", {}, 1);\\n        input_push(\\\"UA，MOBILE_UA/PC_UA/自定义\\\", \\\"x5_ua\\\", \\\"\\\", {}, 1);\\n        d.push({\\n            title: '<b>长按图片不显示菜单</b>',\\n            url: $('#noLoading#').lazyRule((x) => {\\n                putMyVar('x5_imgLongClick', x);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, x5_imgLongClick ? '0' : '1'),\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_imgLongClick ? 55 : 63) + '.svg',\\n            col_type: 'text_icon'\\n        });\\n        d.push({\\n            title: '<b>不显示进度条</b>',\\n            url: $('#noLoading#').lazyRule((x) => {\\n                putMyVar('x5_showProgress', x);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, x5_showProgress ? '0' : '1'),\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_showProgress ? 55 : 63) + '.svg',\\n            col_type: 'text_icon'\\n        });\\n        d.push({\\n            title: '<b>悬浮嗅探播放</b>',\\n            url: $('#noLoading#').lazyRule((x) => {\\n                putMyVar('x5_floatVideo', x);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, x5_floatVideo ? '0' : '1'),\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_floatVideo ? 55 : 63) + '.svg',\\n            col_type: 'text_icon'\\n        });\\n        d.push({\\n            title: '<b>音视频自动播放</b>',\\n            url: $('#noLoading#').lazyRule((x) => {\\n                putMyVar('x5_autoPlay', x);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, x5_autoPlay ? '0' : '1'),\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_autoPlay ? 55 : 63) + '.svg',\\n            col_type: 'text_icon'\\n        });\\n        d.push({\\n            col_type: 'line_blank'\\n        });\\n        d.push({\\n            title: Strong('x5扩展'),\\n            desc: '选填',\\n            url: 'hiker://empty',\\n            col_type: 'avatar',\\n            img: 'hiker://images/home_icon_edit'\\n        });\\n        d.push({\\n            title: '<b>首页不显示搜索框</b>',\\n            url: $('#noLoading#').lazyRule((x) => {\\n                putMyVar('x5_desc', x);\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, x5_desc ? '0' : '1'),\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_desc ? 55 : 63) + '.svg',\\n            col_type: 'text_icon'\\n        });\\n        input_push(\\\"url，发现链接和x5链接冲突时填写\\\", \\\"x5_url\\\", \\\"\\\", {}, 1);\\n        input_push(\\\"home_js，不显示搜索框时执行。\\\\n继承数组d，内容只有规则分类。\\\\n在此基础上自定义首页吧。\\\", \\\"x5_home\\\", \\\"\\\");\\n        break;\\n}\\nd.push({\\n    col_type: 'line_blank'\\n});\\nd.push({\\n    title: Rich(Strong(Color('保存并退出'))),\\n    desc: '上次编辑：' + $.dateFormat(time, 'yyyy-MM-dd hh:mm:ss'),\\n    url: $('#noLoading#').lazyRule(() => {\\n        return $.require(\\\"tool?rule=uckk云\\\").setEdit();\\n    }),\\n    col_type: 'text_center_1',\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"❷规则文件\",\"path\":\"configs\",\"rule\":\"const rulePath = \\\"hiker://files/rules/Thomas/uckkRules.json\\\";\\nlet rules;\\n\\nfunction getJson() {\\n    if (Array.isArray(rules)) {\\n        return rules;\\n    }\\n    try {\\n        rules = JSON.parse(readFile(rulePath) || \\\"[]\\\");\\n    } catch (e) {\\n        rules = [];\\n    }\\n    if (rules.length == 0) deleteFile(rulePath);\\n    return rules;\\n}\\n\\nfunction saveJson(json) {\\n    saveFile(rulePath, JSON.stringify(json));\\n}\\n\\nfunction getJson_1(Key, Value, Type) {\\n    if (Type)\\n        return getJson().filter(f => f[Key] == Value);\\n    else\\n        return getJson().filter(f => f[Key] != Value);\\n}\\n\\nfunction getJson_2(M, Key) {\\n    if (Key)\\n        return saveJson(getJson().map(f => {\\n            if (md5(f.group + f.title) == M) {\\n                f[Key] = f[Key] == \\\"1\\\" ? \\\"0\\\" : \\\"1\\\";\\n            }\\n            return f;\\n        }));\\n    else\\n        return getJson().filter(v => md5(v.group + v.title) != M);\\n}\\n\\nfunction getGroupJson(Rules, Key, Value1, Value2) {\\n    return (Rules || getJson()).filter(f => f[Key] == Value1 || f[Key] == Value2 || Value1 == Value2);\\n}\\n\\nfunction getGroupNames(Rules, Key) {\\n    return Array.from(new Set((Rules || getJson()).map(f => f[Key]))).filter(v => v);\\n}\\n\\nif (!fileExist(rulePath)) {\\n    rules = [{\\n        group: \\\"综合\\\",\\n        search_enabled: \\\"1\\\",\\n        explore_enabled: \\\"1\\\",\\n\\n        title: \\\"聚搜\\\",\\n        author: \\\"Thomas喲\\\",\\n        icon: \\\"hiker://images/search\\\",\\n        preRule: \\\"\\\",\\n\\n        search_url: \\\"fypage\\\",\\n        search_group: \\\"全全\\\",\\n        searchFind: \\\"1\\\",\\n\\n        explore_X5: \\\"0\\\",\\n        url: \\\"hiker://empty\\\",\\n        find_rule: `d.push({\\n    title: '<b>历史搜索</b>'.fontcolor(\\\"#ff6601\\\"),\\n    pic_url: \\\"hiker://images/icon_find\\\",\\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});\\nif (history.length === 0) 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});\\nelse history.map((key, i) => {\\n    d.push({\\n        title: key,\\n        url: $(\\\"#noLoading#\\\").lazyRule((id, key) => {\\n            let extra = findItem(id + \\\":search\\\").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) => {\\n                    let history = storage0.getItem(\\\"searchHistory\\\", []);\\n                    let ii = history.indexOf(key);\\n                    history.splice(ii, 1);\\n                    storage0.setItem(\\\"searchHistory\\\", history);\\n                    deleteItem(id + \\\":key:\\\" + key);\\n                    if (history.length === 0) 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, key)\\n            }]\\n        }\\n    });\\n});`,\\n\\n        class_name: \\\"\\\",\\n        class_url: \\\"\\\",\\n        area_name: \\\"\\\",\\n        area_url: \\\"\\\",\\n        year_name: \\\"\\\",\\n        year_url: \\\"\\\",\\n        sort_name: \\\"\\\",\\n        sort_url: \\\"\\\",\\n        time: 0\\n    }];\\n    saveJson(rules);\\n}\\n$.exports = {\\n    getJson,\\n    saveJson,\\n    getJson_1,\\n    getJson_2,\\n    rulePath,\\n    getGroupNames,\\n    getGroupJson\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"❾跳转二级\",\"path\":\"ruleHome\",\"rule\":\"js:\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\nlet ruleGroup = getParam('ruleGroup', '综合');\\nlet ruleName = getParam('ruleName', '');\\nlet baseUrl = decodeURIComponent(getParam('baseUrl'));\\nlet rules = $.require(\\\"configs?rule=uckk云\\\").getGroupJson(false, \\\"group\\\", ruleGroup, \\\"综合\\\");\\nlet rule = _ = rules.find(f => f.title == ruleName);\\nif (rule != -1) {\\n    if (MY_PARAMS.home) { // 从首页跳转的\\n        d = [];\\n        baseUrl = getRuleBaseUrl(rule.url);\\n        if (_PAGE) {\\n            getRuleGroup(0, rule.search != \\\"\\\" && rule.searchFind != \\\"\\\");\\n        }\\n        eval(rule.preRule);\\n        if (_SOU && (_PAGE || rule.search_url.match(\\\"fypage\\\"))) {\\n            let ii = history.indexOf(keyword);\\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(keyword);\\n            storage0.setItem(\\\"searchHistory\\\", history);\\n\\n            let dd = d;\\n            baseUrl = rule.search_url\\n                .replace(\\n                    /fypage@([^\\\\?\\\\&\\\\;\\\\#\\\\\\\"\\\\'\\\\{]+)@?/g,\\n                    ($0, $1) => {\\n                        page2 = page;\\n                        $1.split(\\\"@\\\").map(_ => {\\n                            eval(String('page2=page2' + _));\\n                        });\\n                        return page2;\\n                    }\\n                )\\n                .replace(/fypage/g, page)\\n                .replace(/\\\\*\\\\*/g, keyword);\\n            searchfind = new Function(\\\"rule\\\", \\\"baseUrl\\\", \\\"keyword\\\", \\\"page\\\", rule.searchFind);\\n            list = searchfind(rule, baseUrl, keyword, page);\\n            d = dd.concat(list);\\n        } else if (!_SOU && (_PAGE || rule.url.includes(\\\"fypage\\\"))) {\\n            eval(rule.find_rule);\\n        }\\n        _PAGE ? setPreResult(d) : setResult(d);\\n        deleteItemByCls('loading_gif');\\n    } else { // 从x5跳转的\\n        eval(rule.preRule);\\n        eval(rule.x5_pageHome);\\n    }\\n} else {\\n    setResult([{\\n        title: Color('<h1 style=\\\"text-align:center;\\\">图书馆Pro</h1>', '#FEBD6F').big(),\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"rich_text\\\"\\n    }]);\\n}\"}],\"saved\":false,\"title\":\"uckk云\",\"version\":0,\"url\":\"hiker://page/ruleList#noHistory##noRecordHistory#?pageTitle=规则管理&rule=uckk云\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\naddListener('onClose', $.toString(() => {\\n    arr = $.require('tool?rule=uckk云').getVariables();\\n    for (t of arr) {\\n        clearMyVar(t);\\n    }\\n}));\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\nd = [];\\nd.push({\\n    title: '新增规则',\\n    col_type: 'text_2',\\n    url: $('#noLoading#').lazyRule(() => {\\n        arr = $.require('tool?rule=uckk云').getVariables();\\n        for (t of arr) {\\n            clearMyVar(t);\\n        }\\n        clearMyVar(\\\"rule_uid\\\");\\n        return 'hiker://page/ruleEdit#noHistory##noRecordHistory#?pageTitle=规则编辑&rule=uckk云'\\n    })\\n});\\nd.push({\\n    title: '分享选中',\\n    col_type: 'text_2',\\n    url: $('#noLoading#').lazyRule(() => {\\n        zy = storage0.getMyVar(\\\"jxlist2\\\", {});\\n        zu = Object.keys(zy);\\n        if (zu.length == 0) {\\n            return \\\"toast://没有选中解析\\\";\\n        } else if (zu.length == 1) {\\n            json = [zy[zu[0]]];\\n            u = base64Encode(JSON.stringify(json));\\n            clearMyVar('jxlist2');\\n            refreshPage(false);\\n            return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥Text￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n        } else {\\n            json = zu.map(key => zy[key]);\\n            t = base64Encode(JSON.stringify(json));\\n            return $([\\\"剪贴板\\\", \\\"纯文本\\\"], 1, '选择分享格式').select((t) => {\\n                if (input == \\\"剪贴板\\\") {\\n                    u = sharePaste(t, '云剪贴板6');\\n                    t = \\\"Paste\\\";\\n                } else {\\n                    u = t;\\n                    t = \\\"Text\\\";\\n                }\\n                clearMyVar('jxlist2');\\n                refreshPage(false);\\n                return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥\\\" + t + \\\"￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n            }, t);\\n        }\\n    })\\n});\\n\\n\\n\\n\\n\\n\\n\\n\\nplatform = getMyVar('platform', '综合');\\n[\\\"综合\\\"].concat(groups).map(group => {\\n    if (group == platform)\\n        platform2 = Rich(Strong(Color(group)));\\n    else\\n        platform2 = group;\\n    d.push({\\n        title: platform2,\\n        url: $('#noLoading#').lazyRule((group) => {\\n            putMyVar('platform', group);\\n            refreshPage();\\n            return 'hiker://empty';\\n        }, group),\\n        col_type: 'scroll_button',\\n        extra: {\\n            longClick: [{\\n                    title: '删除' + group.replace('综合', '全部') + '规则',\\n                    js: $.toString((group) => {\\n                        $$ = $.require('configs?rule=uckk云');\\n                        if (group == \\\"综合\\\") {\\n                            deleteFile($$.rulePath);\\n                        } else {\\n                            rules = $$.getJson_1(\\\"group\\\", group);\\n                            $$.saveJson(rules);\\n                        }\\n                        refreshPage();\\n                        return \\\"hiker://empty\\\";\\n                    }, group)\\n                },\\n                {\\n                    title: '分享' + group.replace('综合', '全部') + '规则',\\n                    js: $.toString((group) => {\\n                        $$ = $.require('configs?rule=uckk云');\\n                        if (group == \\\"综合\\\") {\\n                            rules = $$.getJson();\\n                        } else {\\n                            rules = $$.getJson_1(\\\"group\\\", group, 1);\\n                        }\\n                        if (rules.length == 0) return \\\"toast://没有规则\\\";\\n                        t = base64Encode(JSON.stringify(rules));\\n                        return $([\\\"剪贴板\\\", \\\"纯文本\\\"], 1, '选择分享格式').select((t) => {\\n                            if (input == \\\"剪贴板\\\") {\\n                                u = sharePaste(t, '云剪贴板6');\\n                                t = \\\"Paste\\\";\\n                            } else {\\n                                u = t;\\n                                t = \\\"Text\\\";\\n                            }\\n                            clearMyVar('jxlist2');\\n                            refreshPage(false);\\n                            return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥\\\" + t + \\\"￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n                        }, t);\\n                    }, group)\\n                }\\n            ]\\n        }\\n    });\\n});\\nd.push({\\n    col_type: 'blank_block'\\n});\\nrules = $.require('configs?rule=uckk云').getGroupJson(false, \\\"group\\\", platform, \\\"综合\\\");\\n\\n\\n\\n\\n\\npid = Number(getMyVar('pid')) || 0;\\nnames = $.require('configs?rule=uckk云').getGroupNames(rules, \\\"search_group\\\");\\nif (pid > names.length - 1) {\\n    pid = 0;\\n}\\nnames.map((group, i) => {\\n    if (i == pid)\\n        platform2 = Rich(Strong(Color(group)));\\n    else\\n        platform2 = group;\\n    d.push({\\n        title: platform2,\\n        url: $('#noLoading#').lazyRule((i) => {\\n            putMyVar('pid', i);\\n            refreshPage(false);\\n            return 'hiker://empty';\\n        }, i),\\n        col_type: 'scroll_button',\\n        extra: {\\n            longClick: [{\\n                title: '分享' + group.replace('全全', '全部') + '规则',\\n                js: $.toString((platform, group) => {\\n                    $$ = $.require('configs?rule=uckk云');\\n                    rules = $$.getJson_1(\\\"group\\\", platform, 1);\\n                    if (group != \\\"全全\\\") {\\n                        rules = rules.filter(f => f.search_group == group);\\n                    }\\n                    if (rules.length == 0) return \\\"toast://没有规则\\\";\\n                    t = base64Encode(JSON.stringify(rules));\\n                    return $([\\\"剪贴板\\\", \\\"纯文本\\\"], 1, '选择分享格式').select((t) => {\\n                        if (input == \\\"剪贴板\\\") {\\n                            u = sharePaste(t, '云剪贴板6');\\n                            t = \\\"Paste\\\";\\n                        } else {\\n                            u = t;\\n                            t = \\\"Text\\\";\\n                        }\\n                        clearMyVar('jxlist2');\\n                        refreshPage(false);\\n                        return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥\\\" + t + \\\"￥\\\" + u + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n                    }, t);\\n                }, platform, group)\\n            }]\\n        }\\n    });\\n});\\nd.push({\\n    col_type: 'line'\\n});\\nplatform2 = names[pid];\\nrules = $.require('configs?rule=uckk云').getGroupJson(rules, \\\"search_group\\\", platform2, \\\"全全\\\").slice(1);\\n\\n\\n\\n\\n\\n\\nif (rules.length == 0) {\\n    d.push({\\n        title: Rich(Strong(Color(\\\"没有规则\\\"))),\\n        url: 'hiker://empty',\\n        col_type: 'text_center_1',\\n        extra: {\\n            lineVisible: false\\n        }\\n    });\\n} else {\\n    jxlist2 = storage0.getMyVar(\\\"jxlist2\\\", {});\\n    rules.map((_, ii) => {\\n        m = md5(_.group + _.title);\\n        i = !jxlist2[m];\\n        d1 = _.explore_enabled == \\\"1\\\";\\n        d2 = 'by ' + _.author;\\n        d.push({\\n            title: Strong(i ? _.title : Color(_.title)),\\n            desc: d1 ? Color(d2, \\\"#2E5D8E\\\") : d2,\\n            url: $([\\\"分享\\\", \\\"编辑\\\", \\\"删除\\\", \\\"移动\\\"].concat([i ? \\\"选中规则\\\" : \\\"取消选中\\\", d1 ? \\\"禁用发现\\\" : \\\"启用发现\\\"]), 2, '选择扩展操作').select((m, _) => {\\n                switch (input) {\\n                    case '分享':\\n                        _ = base64Encode(JSON.stringify([_]));\\n                        return \\\"copy://uckk规则口令，打开海阔即可导入\\\\n￥Text￥\\\" + _ + '@import=js:$.require(\\\"tool?rule=uckk云\\\").setRule(input);';\\n                        break;\\n                    case '编辑':\\n                        arr = $.require('tool?rule=uckk云').getVariables();\\n                        for (t of arr) {\\n                            clearMyVar(t);\\n                        }\\n                        arr = Object.keys(_);\\n                        for (t of arr) {\\n                            putMyVar(t, _[t] || \\\"\\\");\\n                        }\\n                        putMyVar('rule_uid', m);\\n                        putMyVar('search_enabled', _.search_enabled || \\\"0\\\");\\n                        putMyVar('explore_enabled', _.explore_enabled || \\\"0\\\");\\n                        return 'hiker://page/ruleEdit#noHistory##noRecordHistory#?pageTitle=规则编辑&rule=uckk云';\\n                        break;\\n                    case '删除':\\n                        return $(\\\"确定删除\\\" + _.group + \\\"规则“\\\" + _.title + '”吗？\\\\n此操作不可逆，请谨慎选择。').confirm((m) => {\\n                            $$ = $.require('configs?rule=uckk云');\\n                            rules = $$.getJson_2(m);\\n                            $$.saveJson(rules);\\n                            refreshPage(false);\\n                        }, m);\\n                        break;\\n                    case '移动':\\n                        zy = $.require('configs?rule=uckk云').getJson_2(m);\\n                        zu = zy.slice(1).map(_ => _.title);\\n                        return $(zu.concat(\\\"最后面\\\"), 2, '请选择移动位置').select((zy, zu, _) => {\\n                            i = zu.indexOf(input);\\n                            if (i == -1)\\n                                zy.push(_);\\n                            else\\n                                zy.splice(i + 1, 0, _);\\n                            $.require('configs?rule=uckk云').saveJson(zy);\\n                            refreshPage(false);\\n                        }, zy, zu, _);\\n                        break;\\n                    case '选中规则':\\n                        jxlist2 = storage0.getMyVar(\\\"jxlist2\\\", {});\\n                        jxlist2[m] = _;\\n                        storage0.putMyVar(\\\"jxlist2\\\", jxlist2);\\n                        refreshPage(false);\\n                        break;\\n                    case '取消选中':\\n                        jxlist2 = storage0.getMyVar(\\\"jxlist2\\\", {});\\n                        delete jxlist2[m];\\n                        storage0.putMyVar(\\\"jxlist2\\\", jxlist2);\\n                        refreshPage(false);\\n                        break;\\n                    case '启用发现':\\n                    case '禁用发现':\\n                        $.require('configs?rule=uckk云').getJson_2(m, \\\"explore_enabled\\\");\\n                        refreshPage(false);\\n                        break;\\n                }\\n            }, m, _),\\n            col_type: 'avatar',\\n            img: _.icon\\n        });\\n        d.push({\\n            title: _.group + '丨' + _.search_group + '丨' + (_.x5_url || (_.url ? _.url : _.search_url).split(\\\"/\\\").slice(0, 3).join(\\\"/\\\")),\\n            url: $('#noLoading#').lazyRule((m) => {\\n                $.require('configs?rule=uckk云').getJson_2(m, \\\"search_enabled\\\");\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, m),\\n            col_type: 'text_icon',\\n            img: 'https://hikerfans.com/tubiao/messy/' + (_.search_enabled == '1' ? 55 : 63) + '.svg',\\n            extra: {\\n                lineVisible: false\\n            }\\n        });\\n        d.push({\\n            col_type: 'line'\\n        });\\n    });\\n}\\nsetResult(d);\",\"group\":\"①网盘\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Ⓛ列表API\\\",\\\"path\\\":\\\"QuarkShareApi\\\",\\\"rule\\\":\\\"js:\\\\n//@author LoyDgIk\\\\nlet httpRequest = $.require(\\\\\\\"httpRequest\\\\\\\");\\\\nconst baseUrl = \\\\\\\"https://pan.quark.cn\\\\\\\";\\\\n\\\\nfunction QuarkShareApi(shareId, sharePwd) {\\\\n    this.shareId = shareId;\\\\n    this.sharePwd = sharePwd;\\\\n    this.refreshCallBack = (() => void 0);\\\\n    //this.shareToken = shareToken || this.getShareToken();\\\\n}\\\\nObject.assign(QuarkShareApi.prototype, {\\\\n    setRefresh(refreshCallBack) {\\\\n        this.refreshCallBack = refreshCallBack;\\\\n        return this;\\\\n    },\\\\n    setToken(shareToken) {\\\\n        this.shareToken = shareToken;\\\\n        return this;\\\\n    },\\\\n    requestHttp(api) {\\\\n        return new httpRequest(baseUrl+api).success((body) => {\\\\n            if (body.status !== 200) {\\\\n                throw new Error(body.message);\\\\n            }\\\\n            return body;\\\\n        });\\\\n    },\\\\n    getToken() {\\\\n        return this.shareToken || this.getShareToken();\\\\n    },\\\\n\\\\n    getShareToken() {\\\\n        let result = this.requestHttp(\\\\\\\"/1/clouddrive/share/sharepage/token\\\\\\\").body({\\\\n            \\\\\\\"pwd_id\\\\\\\": this.shareId,\\\\n            \\\\\\\"passcode\\\\\\\": this.sharePwd,\\\\n        }).bodyToString(true).setStartRequestFunc(post).start(true);\\\\n        this.shareToken = result.data.stoken;\\\\n        this.refreshCallBack(result.data.stoken, this);\\\\n        return this.shareToken;\\\\n    },\\\\n    getListFile(fileId, page, orderBy) {\\\\n        let result = this.requestHttp(\\\\\\\"/1/clouddrive/share/sharepage/detail\\\\\\\").buildUrl({\\\\n            pwd_id: this.shareId || \\\\\\\"\\\\\\\",\\\\n            stoken: encodeURIComponent(this.getToken() || \\\\\\\"\\\\\\\"),\\\\n            pdir_fid: fileId || \\\\\\\"\\\\\\\",\\\\n            force: 0,\\\\n            _page: page,\\\\n            _size: 50,\\\\n            _fetch_banner: 1,\\\\n            _fetch_share: 1,\\\\n            _fetch_total: 1,\\\\n            _sort: \\\\\\\"file_type:asc,\\\\\\\" + orderBy\\\\n        }).errorWithRetry((err, res, http) => {\\\\n            if (JSON.parse(res.body).message.includes('stoken')) {\\\\n                http.mergeHeadAndBody({\\\\n                    buildUrl: {\\\\n                        stoken: encodeURIComponent(this.getShareToken()||\\\\\\\"\\\\\\\")\\\\n                    }\\\\n                });\\\\n                return true;\\\\n            }\\\\n        }).start(true);\\\\n        return result;\\\\n    }\\\\n});\\\\n$.exports = QuarkShareApi;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Ⓛ请求函数\\\",\\\"path\\\":\\\"httpRequest\\\",\\\"rule\\\":\\\"function httpRequest(url, options) {\\\\n    this.retryCount = 0;\\\\n    this.url = url;\\\\n    this.options = Object.assign({}, options, {\\\\n        withHeaders: true\\\\n    });\\\\n    this.errorCallback = (err, res) => {throw err};\\\\n    this.errorCallbackWithRetry = (err, res, tryRestart) => false;\\\\n    this.successCallback = (body, statusCode, headers) => body;\\\\n    this.errorTypeCallback = (err, res) => err;\\\\n    this.startRequest = fetch;\\\\n    this._bodyToString = false;\\\\n    this.buildParam = void(0);\\\\n}\\\\n\\\\nObject.assign(httpRequest.prototype, {\\\\n    bodyToString(flag) {\\\\n        this._bodyToString = !!flag;\\\\n        return this;\\\\n    },\\\\n    body(body) {\\\\n        this.options.body = body || void 0;\\\\n        return this;\\\\n    },\\\\n    buildUrl(buildParam) {\\\\n        this.buildParam = buildParam || {};\\\\n        return this;\\\\n    },\\\\n    setStartRequestFunc(func) {\\\\n        this.startRequest = func;\\\\n        return this;\\\\n    },\\\\n    headers(headers) {\\\\n        this.options.headers = headers || void 0;\\\\n        return this;\\\\n    },\\\\n    success(successCallback) {\\\\n        if (typeof successCallback !== \\\\\\\"function\\\\\\\") return this;\\\\n        this.successCallback = successCallback;\\\\n        return this;\\\\n    },\\\\n    error(errorCallback) {\\\\n        if (typeof errorCallback !== \\\\\\\"function\\\\\\\") return this;\\\\n        this.errorCallback = errorCallback;\\\\n        return this;\\\\n    },\\\\n    errorType(errorTypeCallback) {\\\\n        if (typeof errorTypeCallback !== \\\\\\\"function\\\\\\\") return this;\\\\n        this.errorTypeCallback = errorTypeCallback;\\\\n        return this;\\\\n    },\\\\n    errorWithRetry(retryCount, errorCallbackWithRetry) {\\\\n        if (typeof retryCount === \\\\\\\"function\\\\\\\" && typeof errorCallbackWithRetry === \\\\\\\"undefined\\\\\\\") {\\\\n            errorCallbackWithRetry = retryCount;\\\\n            retryCount = 1;\\\\n        }\\\\n        if (typeof errorCallbackWithRetry !== \\\\\\\"function\\\\\\\") {\\\\n            return this;\\\\n        }\\\\n        this.retryCount = Number(retryCount);\\\\n        this.errorCallbackWithRetry = errorCallbackWithRetry;\\\\n        return this;\\\\n    },\\\\n    start(toJson) {\\\\n        let options = Object.assign({}, this.options);\\\\n        if (typeof options.body === \\\\\\\"object\\\\\\\" && this._bodyToString) {\\\\n            options.body = JSON.stringify(options.body);\\\\n        }\\\\n        var res = JSON.parse(this.startRequest(this.buildParam?buildUrl(this.url, this.buildParam):this.url, options));\\\\n        try {\\\\n            if (res.statusCode >= 200 && res.statusCode <= 300) {\\\\n                let body = res.body;\\\\n                if (toJson) {\\\\n                    body = JSON.parse(body);\\\\n                }\\\\n                return this.successCallback(body, res);\\\\n            } else {\\\\n                throw new Error(String(res.statusCode));\\\\n            }\\\\n        } catch (err) {\\\\n            try {\\\\n                err = this.errorTypeCallback(err, res);\\\\n            } catch (e) {\\\\n\\\\n            }\\\\n            if (this.retryCount) {\\\\n                let tryResult = this.errorCallbackWithRetry(err, res, this);\\\\n                if (tryResult) {\\\\n                    this.retryCount--;\\\\n                    return this.start(toJson);\\\\n                } else {\\\\n                    this.retryCount = 0;\\\\n                    return this.errorCallback(err, res);\\\\n                }\\\\n            } else {\\\\n                return this.errorCallback(err, res);\\\\n            }\\\\n        }\\\\n    },\\\\n    setOptions(options) {\\\\n        this.options = Object.assign({}, options, {\\\\n            withHeaders: true\\\\n        });\\\\n        return this;\\\\n    },\\\\n    mergeHeadAndBody(options) {\\\\n        options = options || {};\\\\n        Object.assign(this.options.headers||{}, options.headers);\\\\n        if (typeof this.options.body === \\\\\\\"object\\\\\\\" && typeof options.body === \\\\\\\"object\\\\\\\") {\\\\n            Object.assign(this.options.body||{}, options.body);\\\\n        }\\\\n        if (typeof options.buildUrl === \\\\\\\"object\\\\\\\") {\\\\n            Object.assign(this.buildParam||{}, options.buildUrl);\\\\n        }\\\\n        return this;\\\\n    }\\\\n});\\\\n\\\\nObject.assign(httpRequest, {\\\\n    fetch(url, options) {\\\\n        return new httpRequest(url, options);\\\\n    },\\\\n    post(url, options) {\\\\n        return new httpRequest(url, options).setStartRequestFunc(post);\\\\n    },\\\\n    request(url, options) {\\\\n        return new httpRequest(url, options).setStartRequestFunc(request);\\\\n    },\\\\n    postRequest(url, options) {\\\\n        return new httpRequest(url, options).setStartRequestFunc(postRequest);\\\\n    },\\\\n    fetchCookie(url, options) {\\\\n        return new httpRequest(url, options).setStartRequestFunc(fetchCookie);\\\\n    }\\\\n});\\\\n$.exports = httpRequest;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Ⓛ列表页面\\\",\\\"path\\\":\\\"quarkList\\\",\\\"rule\\\":\\\"js:\\\\nlet d = [];\\\\n\\\\naddListener(\\\\\\\"onClose\\\\\\\", () => clearMyVar(\\\\\\\"playUrlCache\\\\\\\"));\\\\naddListener(\\\\\\\"onRefresh\\\\\\\", () => clearMyVar(\\\\\\\"playUrlCache\\\\\\\"));\\\\n\\\\nlet realurl = decodeURIComponent(getParam(\\\\\\\"realurl\\\\\\\", \\\\\\\"\\\\\\\")).split(\\\\\\\"?\\\\\\\")[0];\\\\nlet urlData = realurl.split(\\\\\\\"/\\\\\\\");\\\\n\\\\nlet shareId = MY_PARAMS.shareId || urlData[4].replace(\\\\\\\"#\\\\\\\", \\\\\\\"\\\\\\\");\\\\nlet sharePwd = getParam(\\\\\\\"sharePwd\\\\\\\", MY_PARAMS.sharePwd || \\\\\\\"\\\\\\\");\\\\nlet shareToken = getParam(\\\\\\\"shareToken\\\\\\\", MY_PARAMS.shareToken || \\\\\\\"\\\\\\\");\\\\n\\\\nlet fileId = MY_PARAMS.fileId;\\\\n\\\\nlet sort = {\\\\n    \\\\\\\"名称正序\\\\\\\": \\\\\\\"file_name:asc\\\\\\\",\\\\n    \\\\\\\"名称倒序\\\\\\\": \\\\\\\"file_name:desc\\\\\\\",\\\\n    \\\\\\\"时间正序\\\\\\\": \\\\\\\"updated_at:asc\\\\\\\",\\\\n    \\\\\\\"时间倒序\\\\\\\": \\\\\\\"updated_at:desc\\\\\\\"\\\\n};\\\\nlet styles = [\\\\\\\"text_1\\\\\\\", \\\\\\\"avatar\\\\\\\"];\\\\n\\\\nlet sortValue = sort[getItem(\\\\\\\"sortKey\\\\\\\", \\\\\\\"名称正序\\\\\\\")];\\\\nlet style = getItem(\\\\\\\"style\\\\\\\", styles[0]);\\\\nif (MY_PAGE == 1) {\\\\n    d.push({\\\\n        title: style,\\\\n        url: $(styles, 1, '请选择').select(() => {\\\\n            setItem('style', input);\\\\n            refreshPage();\\\\n        }),\\\\n        pic_url: \\\\\\\"https://hikerfans.com/img/ali_icon.svg\\\\\\\",\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    d.push({\\\\n        title: getItem(\\\\\\\"sortKey\\\\\\\", \\\\\\\"名称正序\\\\\\\"),\\\\n        url: $(Object.keys(sort), 1, '请选择').select(() => {\\\\n            setItem(\\\\\\\"sortKey\\\\\\\", input)\\\\n            refreshPage();\\\\n        }),\\\\n        pic_url: \\\\\\\"https://hikerfans.com/img/ali_sort.svg\\\\\\\",\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\"\\\\n    });\\\\n    d.push({\\\\n        title: getItem(\\\\\\\"quark_playMode\\\\\\\", \\\\\\\"转码\\\\\\\"),\\\\n        url: $([\\\\\\\"转码\\\\\\\", \\\\\\\"原画\\\\\\\"], 2, \\\\\\\"播放模式\\\\\\\").select(() => {\\\\n            setItem(\\\\\\\"quark_playMode\\\\\\\", input);\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://切换成功\\\\\\\";\\\\n        }),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n        pic_url: \\\\\\\"https://hikerfans.com/img/ali_play.svg\\\\\\\",\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"功能\\\\\\\",\\\\n        url: $([\\\\\\\"跳转夸克APP\\\\\\\", \\\\\\\"登录\\\\\\\", \\\\\\\"原画下载线程\\\\\\\"]).select((shareId) => {\\\\n            if (input === \\\\\\\"跳转夸克APP\\\\\\\") {\\\\n                return \\\\\\\"qklink://www.uc.cn/b20b84fd735a8dd3f7541129bacc4e9a?action=open_url&url=https://pan.quark.cn/s/\\\\\\\" + shareId;\\\\n            } else if (input === \\\\\\\"登录\\\\\\\") {\\\\n                return $([\\\\\\\"输入Cookie\\\\\\\", \\\\\\\"网页登录\\\\\\\"]).select(() => {\\\\n                    if (input === \\\\\\\"网页登录\\\\\\\") {\\\\n                        return \\\\\\\"hiker://page/login\\\\\\\";\\\\n                    } else {\\\\n                        return $(\\\\\\\"\\\\\\\", \\\\\\\"请输入Cookie\\\\\\\").input(() => {\\\\n                            if ($.require(\\\\\\\"tool\\\\\\\").isLoginCookie(input)) {\\\\n                                setItem(\\\\\\\"quarkCookie\\\\\\\", input.replace(/\\\\\\\\s/g, \\\\\\\"\\\\\\\"));\\\\n                                return \\\\\\\"toast://设置成功\\\\\\\";\\\\n                            } else {\\\\n                                return \\\\\\\"toast://Cookie格式错误\\\\\\\";\\\\n                            }\\\\n                        });\\\\n                    }\\\\n                })\\\\n            } else if (input === \\\\\\\"原画下载线程\\\\\\\") {\\\\n                return $(getItem(\\\\\\\"speedThread\\\\\\\", \\\\\\\"10\\\\\\\"), \\\\\\\"请输入3-32之间的整数\\\\\\\").input(() => {\\\\n                    let speedThread = parseInt(input);\\\\n                    if (speedThread < 3 || speedThread > 32) {\\\\n                        return \\\\\\\"toast://设置不合法\\\\\\\";\\\\n                    }\\\\n                    setItem(\\\\\\\"speedThread\\\\\\\", String(speedThread));\\\\n                    return \\\\\\\"toast://设置成功\\\\\\\";\\\\n                });\\\\n            }\\\\n        }, shareId),\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n        pic_url: \\\\\\\"https://hikerfans.com/img/ali_fileinto.svg\\\\\\\",\\\\n    });\\\\n    d.push({\\\\n        col_type: 'line_blank'\\\\n    });\\\\n}\\\\n\\\\n\\\\nlet QuarkShareApi = $.require(\\\\\\\"QuarkShareApi\\\\\\\");\\\\nlet quarkShareApi = new QuarkShareApi(shareId, sharePwd).setToken(shareToken).setRefresh((shareToken) => {\\\\n    MY_PARAMS.shareToken = shareToken;\\\\n    setPageParams(MY_PARAMS);\\\\n});\\\\n\\\\nfunction formatSize(size) {\\\\n    if (!size) {\\\\n        return '';\\\\n    }\\\\n    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\\\\n    let i = 0;\\\\n    while (size >= 1024) {\\\\n        size /= 1024;\\\\n        i++;\\\\n    }\\\\n    size = i ? Number(size.toFixed(2)) : size;\\\\n    return `${size} ${units[i]}`;\\\\n}\\\\n\\\\nlet subExts = [\\\\\\\"vtt\\\\\\\", \\\\\\\"srt\\\\\\\", \\\\\\\"ass\\\\\\\"];\\\\nlet titleHead = {\\\\n    video: \\\\\\\"🎬\\\\\\\",\\\\n    audio: \\\\\\\"🎵\\\\\\\",\\\\n    doc: \\\\\\\"📑\\\\\\\",\\\\n    image: \\\\\\\"🖼\\\\\\\",\\\\n    archive: \\\\\\\"📦\\\\\\\",\\\\n    \\\\\\\"default\\\\\\\": \\\\\\\"❓\\\\\\\"\\\\n};\\\\n\\\\nfunction getHead(type, ext) {\\\\n    let head = titleHead[type];\\\\n    /*if (subExts.includes(ext)) {\\\\n        head = \\\\\\\"🕸\\\\\\\";\\\\n    }*/\\\\n    return head || \\\\\\\"❓\\\\\\\";\\\\n}\\\\ntry {\\\\n    var res = quarkShareApi.getListFile(fileId, MY_PAGE, sortValue);\\\\n    //设置标题\\\\n    setPageTitle(res.data.share.title);\\\\n    var list = res.data.list;\\\\n    list.forEach(item => {\\\\n        //判断是否文件夹\\\\n        if (item.dir) {\\\\n            d.push({\\\\n                title: \\\\\\\"📂\\\\\\\" + item.file_name,\\\\n                desc: $.dateFormat(item.updated_at, 'yyyy-MM-dd') + '  ' + item.include_items + '项  ',\\\\n                pic_url: \\\\\\\"https://hikerfans.com/tubiao/messy/27.svg\\\\\\\",\\\\n                url: \\\\\\\"hiker://page/quarkList?page=fypage\\\\\\\",\\\\n                col_type: style,\\\\n                extra: {\\\\n                    shareId,\\\\n                    sharePwd,\\\\n                    shareToken: quarkShareApi.getToken(),\\\\n                    fileId: item.fid,\\\\n                    inheritTitle: false\\\\n                }\\\\n            });\\\\n        } else {\\\\n            d.push({\\\\n                title: getHead(item.obj_category) + item.file_name,\\\\n                desc: $.dateFormat(item.updated_at, 'yyyy-MM-dd') + '  ' + formatSize(item.size),\\\\n                pic_url: item.thumbnail,\\\\n                url: $().lazyRule((fid, fid_token, pwd_id, stoken, category) => {\\\\n                    let playUrlCache = storage0.getMyVar(\\\\\\\"playUrlCache\\\\\\\", {});\\\\n                    if (playUrlCache[fid]) {\\\\n                        return playUrlCache[fid];\\\\n                    } else {\\\\n                        let url = $.require(\\\\\\\"play\\\\\\\").getPlayUrl(fid, fid_token, pwd_id, stoken, category);\\\\n                        playUrlCache[fid] = url;\\\\n                        storage0.putMyVar(\\\\\\\"playUrlCache\\\\\\\", playUrlCache);\\\\n                        return url;\\\\n                    }\\\\n                }, item.fid, item.share_fid_token, shareId, quarkShareApi.getToken(), item.obj_category),\\\\n                col_type: style,\\\\n                extra: {\\\\n                    id: item.fid,\\\\n                    inheritTitle: false,\\\\n                    cls: 'playlist ' + item.obj_category\\\\n                }\\\\n            })\\\\n        }\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        });\\\\n    });\\\\n} catch (e) {\\\\n    d.push({\\\\n        title: e.message,\\\\n        url: 'hiker://empty',\\\\n        col_type: 'text_center_1',\\\\n        extra: {\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n    if (e.message.includes(\\\\\\\"提取码\\\\\\\")) {\\\\n        d.push({\\\\n            title: \\\\\\\"输入提取码\\\\\\\",\\\\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    }\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Ⓛ获取链接\\\",\\\"path\\\":\\\"play\\\",\\\"rule\\\":\\\"js:\\\\nconst cookie = getItem(\\\\\\\"quarkCookie\\\\\\\", \\\\\\\"\\\\\\\");\\\\nlet httpRequest = $.require(\\\\\\\"httpRequest\\\\\\\");\\\\n\\\\nfunction CookieManage(cookie) {\\\\n    this.cookie = {};\\\\n    this.add(cookie);\\\\n}\\\\nObject.assign(CookieManage.prototype, {\\\\n    add(cookie) {\\\\n        let cookies = [];\\\\n        if (typeof cookie === \\\\\\\"string\\\\\\\") {\\\\n            cookies = cookie.split(\\\\\\\";\\\\\\\");\\\\n        } else if (Array.isArray(cookie)) {\\\\n            cookies = cookie;\\\\n        }\\\\n        cookies.forEach(v => {\\\\n            v = v.split(\\\\\\\"=\\\\\\\");\\\\n            if(v.length<2) return;\\\\n            this.cookie[v[0].trim()] = v[1].trim();\\\\n        });\\\\n    },\\\\n    get() {\\\\n        return Object.entries(this.cookie).map(v => v[0] + \\\\\\\"=\\\\\\\" + v[1]).join(\\\\\\\";\\\\\\\");\\\\n    }\\\\n});\\\\nconst cookieManage = new CookieManage(cookie);\\\\n\\\\nfunction waitSleep(time) {\\\\n    java.lang.Thread.sleep(time || 600);\\\\n}\\\\n\\\\nfunction requestHttp(url) {\\\\n    return new httpRequest(url)\\\\n        .success((body, res) => {\\\\n            if (body.status !== 200) {\\\\n                throw new Error(body.message);\\\\n            }\\\\n            cookieManage.add(res.headers[\\\\\\\"set-cookie\\\\\\\"]);\\\\n            return body;\\\\n        })\\\\n        .errorType((err, res) => {\\\\n            return new Error(JSON.parse(res.body).message);\\\\n        })\\\\n        .bodyToString(true)\\\\n        .headers({\\\\n            cookie: cookieManage.get(),\\\\n            \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) quark-cloud-drive/2.5.20 Chrome/100.0.4896.160 Electron/18.3.5.4-b478491100 Safari/537.36 Channel/pckk_other_ch\\\\\\\",\\\\n            \\\\\\\"referer\\\\\\\": \\\\\\\"https://drive.quark.cn/\\\\\\\"\\\\n        });\\\\n}\\\\n\\\\nfunction getDriveInfo() {\\\\n    return requestHttp(\\\\\\\"https://drive.quark.cn/1/clouddrive/share/sharepage/dir?pr=ucpro&fr=pc&aver=1\\\\\\\").start(true);\\\\n}\\\\n\\\\nfunction createSaveTask(fid, fid_token, pwd_id, stoken) {\\\\n    let driveInfo = getDriveInfo();\\\\n    return requestHttp(\\\\\\\"https://drive.quark.cn/1/clouddrive/share/sharepage/save?pr=ucpro&fr=pc\\\\\\\").setStartRequestFunc(post).body({\\\\n        \\\\\\\"fid_list\\\\\\\": [\\\\n            fid\\\\n        ],\\\\n        \\\\\\\"fid_token_list\\\\\\\": [\\\\n            fid_token\\\\n        ],\\\\n        \\\\\\\"to_pdir_fid\\\\\\\": driveInfo.data.dir.fid,\\\\n        \\\\\\\"pwd_id\\\\\\\": pwd_id,\\\\n        \\\\\\\"stoken\\\\\\\": stoken,\\\\n        \\\\\\\"pdir_fid\\\\\\\": driveInfo.data.dir.pdir_fid\\\\n    }).start(true);\\\\n}\\\\n\\\\nfunction createDeleteTask(fid) {\\\\n    let driveInfo = getDriveInfo();\\\\n    return requestHttp(\\\\\\\"https://drive.quark.cn/1/clouddrive/file/delete?pr=ucpro&fr=pc\\\\\\\").setStartRequestFunc(post).body({\\\\n        \\\\\\\"action_type\\\\\\\": 2,\\\\n        \\\\\\\"filelist\\\\\\\": [\\\\n            fid\\\\n        ],\\\\n        \\\\\\\"exclude_fids\\\\\\\": []\\\\n    }).start(true);\\\\n}\\\\n\\\\nfunction task(task_id, retry_index) {\\\\n    return requestHttp(\\\\\\\"https://drive.quark.cn/1/clouddrive/task\\\\\\\").buildUrl({\\\\n        pr: \\\\\\\"ucpro\\\\\\\",\\\\n        fr: \\\\\\\"pc\\\\\\\",\\\\n        task_id: task_id,\\\\n        retry_index: retry_index\\\\n    }).start(true);\\\\n}\\\\n\\\\nfunction queryTask(task_id) {\\\\n    for (let i = 0; i < 6; i++) {\\\\n        try {\\\\n            let res = task(task_id, i + \\\\\\\"\\\\\\\");\\\\n            if (res.data.status === 2) {\\\\n                waitSleep(1000);\\\\n                return res.data.save_as.save_as_top_fids[0];\\\\n            }\\\\n            waitSleep(300);\\\\n        } catch (e) {}\\\\n    }\\\\n    return void(0);\\\\n}\\\\n\\\\nfunction queryTaskStatus(task_id) {\\\\n    for (let i = 0; i < 6; i++) {\\\\n        try {\\\\n            let res = task(task_id, i + \\\\\\\"\\\\\\\");\\\\n            if (res.data.status === 2) {\\\\n                waitSleep(1000);\\\\n                return true;\\\\n            }\\\\n            waitSleep(300);\\\\n        } catch (e) {}\\\\n    }\\\\n    return false;\\\\n}\\\\n\\\\nfunction getPreviewVideo(fid) {\\\\n    return requestHttp(\\\\\\\"https://drive.quark.cn/1/clouddrive/file/v2/play?pr=ucpro&fr=pc\\\\\\\").body({\\\\n        \\\\\\\"fid\\\\\\\": fid,\\\\n        \\\\\\\"resolutions\\\\\\\": \\\\\\\"normal,low,high,super,2k,4k\\\\\\\",\\\\n        \\\\\\\"supports\\\\\\\": \\\\\\\"fmp4,m3u8\\\\\\\"\\\\n    }).setStartRequestFunc(post).start(true);\\\\n}\\\\n\\\\nfunction getDownloadUrl(fid) {\\\\n    return requestHttp(\\\\\\\"https://drive.quark.cn/1/clouddrive/file/download?pr=ucpro&fr=pc\\\\\\\").body({\\\\n        \\\\\\\"fids\\\\\\\": [fid]\\\\n    }).setStartRequestFunc(post).start(true);\\\\n}\\\\n\\\\nfunction getPlayUrl(fid, fid_token, pwd_id, stoken, category) {\\\\n    try {\\\\n        if (!cookie) return \\\\\\\"toast://请登录账号\\\\\\\";\\\\n        if (category != \\\\\\\"video\\\\\\\") return \\\\\\\"toast://不支持\\\\\\\";\\\\n        let taskId = createSaveTask(fid, fid_token, pwd_id, stoken).data.task_id;\\\\n        let asfid = queryTask(taskId);\\\\n        if (!asfid) {\\\\n            return \\\\\\\"toast://获取失败\\\\\\\";\\\\n        }\\\\n        let playMode = getItem(\\\\\\\"quark_playMode\\\\\\\", \\\\\\\"转码\\\\\\\");\\\\n        if (playMode === \\\\\\\"转码\\\\\\\") {\\\\n            let videoRes = getPreviewVideo(asfid);\\\\n            let videoList = videoRes.data.video_list;\\\\n            let playList = {\\\\n                names: [],\\\\n                urls: [],\\\\n                headers: []\\\\n            };\\\\n            let playCookie = cookieManage.get();\\\\n            videoList.filter(v => v.accessable).forEach(v => {\\\\n                playList.names.push(v.resolution);\\\\n                playList.urls.push(v.video_info.url + \\\\\\\"#isVideo=true#\\\\\\\");\\\\n                playList.headers.push({\\\\n                    Referer: \\\\\\\"http://pan.quark.cn/\\\\\\\",\\\\n                    cookie: playCookie,\\\\n                    \\\\\\\"User-Agent\\\\\\\": \\\\\\\"com.stub.StubApp/1.3.0 (Linux;Android 14) AndroidXMedia3/1.1.1\\\\\\\"\\\\n                });\\\\n            });\\\\n            createDeleteTask(asfid);\\\\n            return JSON.stringify(playList);\\\\n        } else {\\\\n            let playUrl = getDownloadUrl(asfid).data[0].download_url;\\\\n            let playCookie = cookieManage.get();\\\\n            let playList = {\\\\n                names: [\\\\\\\"原画\\\\\\\"],\\\\n                urls: [playUrl + \\\\\\\"#isVideo=true##fastPlayMode##threads=\\\\\\\"+getItem(\\\\\\\"speedThread\\\\\\\", \\\\\\\"10\\\\\\\")+\\\\\\\"#\\\\\\\"],\\\\n                headers: [{\\\\n                    Referer: \\\\\\\"http://pan.quark.cn/\\\\\\\",\\\\n                    cookie: playCookie,\\\\n                    \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) quark-cloud-drive/2.5.20 Chrome/100.0.4896.160 Electron/18.3.5.4-b478491100 Safari/537.36 Channel/pckk_other_ch\\\\\\\"\\\\n                }]\\\\n            }\\\\n            createDeleteTask(asfid);\\\\n            return JSON.stringify(playList);\\\\n        }\\\\n    } catch (e) {\\\\n        if (e.message.includes(\\\\\\\"require login\\\\\\\")) {\\\\n            toast(\\\\\\\"未登录或登录过期，请重新登录\\\\\\\");\\\\n            return \\\\\\\"hiker://page/login\\\\\\\";\\\\n        }\\\\n        return \\\\\\\"toast://\\\\\\\" + e.toString();\\\\n    }\\\\n}\\\\n\\\\n$.exports = {\\\\n    getPlayUrl\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Ⓛ登录账号\\\",\\\"path\\\":\\\"login\\\",\\\"rule\\\":\\\"js:\\\\nlet d = [];\\\\naddListener(\\\\\\\"onClose\\\\\\\", () => {\\\\n    let cookie = getVar(\\\\\\\"quarkCookie\\\\\\\", \\\\\\\"\\\\\\\");\\\\n    if (cookie) {\\\\n        setItem(\\\\\\\"quarkCookie\\\\\\\", cookie);\\\\n        toast(\\\\\\\"Cookie获取成功\\\\\\\");\\\\n        refreshPage();\\\\n    }\\\\n    clearVar(\\\\\\\"quarkCookie\\\\\\\");\\\\n});\\\\nd.push({\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    url: \\\\\\\"https://pan.quark.cn/\\\\\\\",\\\\n    desc: \\\\\\\"float&&100%\\\\\\\",\\\\n    extra: {\\\\n        js: $.toString((ApiRootUrl) => {\\\\n            let timeInter = setInterval(() => {\\\\n                let Cookie = fba.getCookie(ApiRootUrl);\\\\n                if (Cookie.includes(\\\\\\\"_UP_F7E_8D_=\\\\\\\") && Cookie.includes(\\\\\\\"__uid=\\\\\\\")&&Cookie.includes(\\\\\\\"__puus=\\\\\\\")) {\\\\n                    fba.putVar(\\\\\\\"quarkCookie\\\\\\\", Cookie)\\\\n                    clearInterval(timeInter);\\\\n                    fba.log(Cookie);\\\\n                    fba.back(false);\\\\n                }\\\\n            }, 600);\\\\n        }, \\\\\\\"https://pan.quark.cn\\\\\\\"),\\\\n        ua: PC_UA,\\\\n        jsLoadingInject: false\\\\n    }\\\\n});\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"Ⓛ登录检测\\\",\\\"path\\\":\\\"tool\\\",\\\"rule\\\":\\\"js:\\\\n$.exports = {\\\\n    isLoginCookie(cookie) {\\\\n        return !!(cookie && cookie.includes(\\\\\\\"_UP_F7E_8D_=\\\\\\\") && cookie.includes(\\\\\\\"__uid=\\\\\\\") && cookie.includes(\\\\\\\"__puus=\\\\\\\"));\\\\n    },\\\\n\\\\n\\\\n\\\\n\\\\n    setRule(input) {\\\\n        try {\\\\n            // 格式化\\\\n            [logT, type, text] = String(input).split(\\\\\\\"￥\\\\\\\");\\\\n            switch (String(type)) {\\\\n                case 'Paste':\\\\n                    text = parsePaste(text);\\\\n                    break;\\\\n                case 'Lanzou':\\\\n                    [url, pwd] = text.split(\\\\\\\"##\\\\\\\");\\\\n                    durl = $.require('lanzou?rule=uckk云').one_url(url, pwd, 1);\\\\n                    text = String(fetch(durl));\\\\n                    if ((sp = text.split(\\\\\\\"￥\\\\\\\")).length == 3) {\\\\n                        text = sp[2].split(\\\\\\\"@\\\\\\\")[0].trim();\\\\n                    }\\\\n                    break;\\\\n            }\\\\n            arr1 = JSON.parse(base64Decode(text));\\\\n\\\\n\\\\n            // 合并，去重\\\\n            arr2 = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getJson();\\\\n            arr3 = arr1.concat(arr2).filter((obj, index, arr) => {\\\\n                return arr.findIndex(o => obj.group === o.group && obj.title === o.title && (obj.time > o.time || obj.time == o.time)) === index;\\\\n            });\\\\n            $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").saveJson(arr3);\\\\n\\\\n\\\\n            // 计算余量\\\\n            x = arr3.length - arr2.length;\\\\n            f = arr1.length - x\\\\n            refreshPage();\\\\n            toast(\\\\\\\"导入成功，新增：\\\\\\\" + x + \\\\\\\" 覆盖：\\\\\\\" + f);\\\\n        } catch (e) {\\\\n            log(e.toString());\\\\n            toast(\\\\\\\"导入失败\\\\\\\");\\\\n        }\\\\n    },\\\\n\\\\n\\\\n\\\\n\\\\n    setEdit() {\\\\n        _ = {\\\\n            group: getMyVar(\\\\\\\"group\\\\\\\", \\\\\\\"夸克\\\\\\\").trim(), // 规则 类别\\\\n            search_enabled: getMyVar(\\\\\\\"search_enabled\\\\\\\", \\\\\\\"1\\\\\\\").trim(), // 启用搜索 #\\\\n            explore_enabled: getMyVar(\\\\\\\"explore_enabled\\\\\\\", \\\\\\\"0\\\\\\\").trim(), // 启用发现 #\\\\n\\\\n            title: getMyVar(\\\\\\\"title\\\\\\\", \\\\\\\"\\\\\\\").trim(), // 源名称\\\\n            author: getMyVar(\\\\\\\"author\\\\\\\", \\\\\\\"佚名\\\\\\\").trim(), // 源作者\\\\n            icon: getMyVar(\\\\\\\"icon\\\\\\\", \\\\\\\"\\\\\\\").trim(), // 源图标\\\\n            preRule: getMyVar(\\\\\\\"preRule\\\\\\\", \\\\\\\"\\\\\\\").trim(), // js预处理\\\\n\\\\n            search_url: getMyVar(\\\\\\\"search_url\\\\\\\", \\\\\\\"\\\\\\\").trim(), // 搜索链接\\\\n            search_group: getMyVar(\\\\\\\"search_group\\\\\\\", \\\\\\\"常用\\\\\\\").trim(), // 源分组 #\\\\n            searchFind: getMyVar(\\\\\\\"searchFind\\\\\\\", \\\\\\\"\\\\\\\").trim(), // 搜索规则\\\\n\\\\n            explore_X5: getMyVar(\\\\\\\"explore_X5\\\\\\\", \\\\\\\"0\\\\\\\").trim(), // 使用x5 #\\\\n            url: getMyVar(\\\\\\\"url\\\\\\\", \\\\\\\"\\\\\\\").trim(), // 发现链接\\\\n            find_rule: getMyVar(\\\\\\\"find_rule\\\\\\\", \\\\\\\"\\\\\\\").trim(), // 发现规则\\\\n\\\\n            // 发现链接替换\\\\n            class_name: getMyVar(\\\\\\\"class_name\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            class_url: getMyVar(\\\\\\\"class_url\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            area_name: getMyVar(\\\\\\\"area_name\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            area_url: getMyVar(\\\\\\\"area_url\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            year_name: getMyVar(\\\\\\\"year_name\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            year_url: getMyVar(\\\\\\\"year_url\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            sort_name: getMyVar(\\\\\\\"sort_name\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            sort_url: getMyVar(\\\\\\\"sort_url\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n\\\\n            // x5设置\\\\n            x5_jsLoadingInject: getMyVar(\\\\\\\"x5_jsLoadingInject\\\\\\\", \\\\\\\"0\\\\\\\").trim(),\\\\n            x5_js: getMyVar(\\\\\\\"x5_js\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_blockRules: getMyVar(\\\\\\\"x5_blockRules\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_urlInterceptor: getMyVar(\\\\\\\"x5_urlInterceptor\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_pageHome: getMyVar(\\\\\\\"x5_pageHome\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_referer: getMyVar(\\\\\\\"x5_referer\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_imgLongClick: getMyVar(\\\\\\\"x5_imgLongClick\\\\\\\", \\\\\\\"0\\\\\\\").trim(),\\\\n            x5_showProgress: getMyVar(\\\\\\\"x5_showProgress\\\\\\\", \\\\\\\"0\\\\\\\").trim(),\\\\n            x5_floatVideo: getMyVar(\\\\\\\"x5_floatVideo\\\\\\\", \\\\\\\"0\\\\\\\").trim(),\\\\n            x5_autoPlay: getMyVar(\\\\\\\"x5_autoPlay\\\\\\\", \\\\\\\"0\\\\\\\").trim(),\\\\n            x5_ua: getMyVar(\\\\\\\"x5_ua\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_url: getMyVar(\\\\\\\"x5_url\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_desc: getMyVar(\\\\\\\"x5_desc\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            x5_home: getMyVar(\\\\\\\"x5_home\\\\\\\", \\\\\\\"\\\\\\\").trim(),\\\\n            time: new Date().getTime(), // 保存时间 #\\\\n        };\\\\n        if (_.title != \\\\\\\"\\\\\\\" && _.title != \\\\\\\"聚搜\\\\\\\" && _.title != \\\\\\\"最后面\\\\\\\") {\\\\n            if ((_.search_url != \\\\\\\"\\\\\\\" && _.searchFind != \\\\\\\"\\\\\\\") || (_.url != \\\\\\\"\\\\\\\" && (_.explore_X5 == \\\\\\\"1\\\\\\\" || _.find_rule != \\\\\\\"\\\\\\\"))) {\\\\n                for (t in _) {\\\\n                    clearMyVar(t);\\\\n                    if (_[t] == \\\\\\\"\\\\\\\" || _[t] == \\\\\\\"0\\\\\\\" || _[t] == \\\\\\\"MOBILE_UA\\\\\\\") {\\\\n                        delete _[t];\\\\n                    }\\\\n                }\\\\n                jxlist = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getJson();\\\\n                uids = jxlist.map(__ => md5(__.group + __.title));\\\\n                i = uids.indexOf(getMyVar('rule_uid', '-1'));\\\\n                if (i == -1) {\\\\n                    jxlist.push(_);\\\\n                } else {\\\\n                    jxlist.splice(i, 1, _);\\\\n                }\\\\n                clearMyVar('rule_tid');\\\\n                clearMyVar('rule_uid');\\\\n                jxlist = jxlist.filter((obj, index, arr) => {\\\\n                    return arr.findIndex(o => md5(obj.group + obj.title) === md5(o.group + o.title) && (obj.time > o.time || obj.time === o.time)) === index;\\\\n                });\\\\n                $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").saveJson(jxlist);\\\\n                return back(true), 'toast://保存成功';\\\\n            } else {\\\\n                return 'toast://搜索规则/发现规则总得写一个吧';\\\\n            }\\\\n        } else if (_.title == \\\\\\\"\\\\\\\") {\\\\n            return 'toast://请填写源名称';\\\\n        } else {\\\\n            return 'toast://规则名不能是' + _.title;\\\\n        }\\\\n    },\\\\n\\\\n    getVariables() {\\\\n        return [\\\\\\\"group\\\\\\\", \\\\\\\"search_enabled\\\\\\\", \\\\\\\"explore_enabled\\\\\\\", \\\\\\\"title\\\\\\\", \\\\\\\"author\\\\\\\", \\\\\\\"icon\\\\\\\", \\\\\\\"preRule\\\\\\\", \\\\\\\"search_url\\\\\\\", \\\\\\\"search_group\\\\\\\", \\\\\\\"searchFind\\\\\\\", \\\\\\\"explore_X5\\\\\\\", \\\\\\\"url\\\\\\\", \\\\\\\"find_rule\\\\\\\", \\\\\\\"class_name\\\\\\\", \\\\\\\"class_url\\\\\\\", \\\\\\\"area_name\\\\\\\", \\\\\\\"area_url\\\\\\\", \\\\\\\"year_name\\\\\\\", \\\\\\\"year_url\\\\\\\", \\\\\\\"sort_name\\\\\\\", \\\\\\\"sort_url\\\\\\\", \\\\\\\"x5_jsLoadingInject\\\\\\\", \\\\\\\"x5_js\\\\\\\", \\\\\\\"x5_blockRules\\\\\\\", \\\\\\\"x5_urlInterceptor\\\\\\\", \\\\\\\"x5_pageHome\\\\\\\", \\\\\\\"x5_referer\\\\\\\", \\\\\\\"x5_imgLongClick\\\\\\\", \\\\\\\"x5_showProgress\\\\\\\", \\\\\\\"x5_floatVideo\\\\\\\", \\\\\\\"x5_autoPlay\\\\\\\", \\\\\\\"x5_ua\\\\\\\", \\\\\\\"x5_url\\\\\\\", \\\\\\\"x5_desc\\\\\\\", \\\\\\\"x5_home\\\\\\\", \\\\\\\"time\\\\\\\", \\\\\\\"rule_tid\\\\\\\", \\\\\\\"rule_uid\\\\\\\"];\\\\n    },\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❶通用函数\\\",\\\"path\\\":\\\"lib\\\",\\\"rule\\\":\\\"const Color = (test, color) => {\\\\n    return '<font color=\\\\\\\"' + (color || '#FA7298') + '\\\\\\\">' + test + '</front>';\\\\n}\\\\nconst Strong = (test) => {\\\\n    return '<strong>' + test + '</strong>';\\\\n}\\\\nconst Rich = (test) => {\\\\n    return \\\\\\\"‘‘’’\\\\\\\" + String(test)\\\\n        .replace(/\\\\\\\\\\\\\\\\n|(<|\\\\\\\\s+)br\\\\\\\\s*\\\\\\\\/?\\\\\\\\s*>/gi, '\\\\\\\\n')\\\\n        .replace(/\\\\\\\\\\\\\\\\r/g, '\\\\\\\\r')\\\\n        .replace(/\\\\\\\\\\\\\\\\f/g, '\\\\\\\\f')\\\\n        .replace(/\\\\\\\\\\\\\\\\t/g, '\\\\\\\\t')\\\\n        .replace(/&(lt|gt|nbsp|amp|quot);/gi, ($0, $1) => ({\\\\n            'lt': '<',\\\\n            'gt': '>',\\\\n            'nbsp': ' ',\\\\n            'amp': '&',\\\\n            'quot': '\\\\\\\"'\\\\n        }[$1.toLowerCase()]))\\\\n        .replace(/<\\\\\\\\/?(em|span)[^>]*>/gi, '');\\\\n}\\\\nconst Size = size => {\\\\n    if (!size) return '无法计算';\\\\n    units = ['B', 'KB', 'MB', 'GB'];\\\\n    i = 0;\\\\n    while (size > 1023) {\\\\n        size /= 1024;\\\\n        i++;\\\\n    }\\\\n    size = i ? size.toFixed(2) : size;\\\\n    return `${size} ${units[i]}`;\\\\n}\\\\ntry {\\\\n    MY_PAGE;\\\\n} catch (err) {\\\\n    MY_PAGE = 1;\\\\n}\\\\nlet id = \\\\\\\"uckk云\\\\\\\";\\\\nlet page = MY_PAGE;\\\\nlet _PAGE = page == 1;\\\\nlet icons = {\\\\n    阿里: \\\\\\\"https://gw.alicdn.com/imgextra/i1/O1CN01rAr34V28oR0rupkAi_!!6000000007979-2-tps-240-240.png\\\\\\\",\\\\n    夸克: \\\\\\\"hiker://images/icon_kuake\\\\\\\",\\\\n    音频: \\\\\\\"hiker://images/icon_music3\\\\\\\",\\\\n    磁力: \\\\\\\"https://android-artworks.25pp.com/fs08/2023/08/23/10/110_e1533a024c7efec175bc5110e96736ac_con_130x130.png\\\\\\\",\\\\n    影视: \\\\\\\"hiker://images/icon_video2\\\\\\\",\\\\n    动漫: \\\\\\\"hiker://images/icon_pic3\\\\\\\",\\\\n    图文: \\\\\\\"hiker://images/icon_txt2\\\\\\\",\\\\n    其他: \\\\\\\"hiker://images/icon_unknown\\\\\\\"\\\\n}\\\\nlet groups = Object.keys(icons);\\\\nlet pageid = id + \\\\\\\"ypj-page\\\\\\\" + page;\\\\nlet keyword = String(getMyVar(\\\\\\\"keyword\\\\\\\", \\\\\\\"\\\\\\\")).trim();\\\\nlet _SOU = keyword != \\\\\\\"\\\\\\\" && !keyword.match(/quark.*\\\\\\\\/s\\\\\\\\/.+/) && keyword == String(getMyVar(\\\\\\\"keyword2\\\\\\\", \\\\\\\"\\\\\\\")).trim();\\\\nlet history = storage0.getItem(\\\\\\\"searchHistory\\\\\\\", []);\\\\n\\\\n\\\\nconst getRuleBaseUrl = (baseU) => {\\\\n    isFyAll = String(baseU).includes(\\\\\\\"fyAll\\\\\\\");\\\\n    FyAll_i = Number(getMyVar(\\\\\\\"FyAll_i\\\\\\\")) || 0;\\\\n    for (t of ['class', 'area', 'year', 'sort']) {\\\\n        eval(`${t}_i = Number(getMyVar(\\\\\\\"${t}_i\\\\\\\")) || 0;\\\\nrule.${t}_url = String(rule.${t}_url || \\\\\\\"\\\\\\\").trim().split(\\\\\\\"&\\\\\\\");\\\\nrule.${t}_name = String(rule.${t}_name || \\\\\\\"\\\\\\\").trim().split(\\\\\\\"&\\\\\\\");\\\\nrule.${t}_url = rule.${t}_url.filter((u, i) => rule.${t}_name[i] != \\\\\\\"\\\\\\\");\\\\nrule.${t}_name = rule.${t}_name.filter((Name) => Name != \\\\\\\"\\\\\\\");\\\\nrule.${t}_i = rule.${t}_name.length;`);\\\\n    }\\\\n    baseU = String(baseU)\\\\n        .replace(\\\\n            /fypage@([^\\\\\\\\?\\\\\\\\&\\\\\\\\;\\\\\\\\#\\\\\\\\\\\\\\\"\\\\\\\\'\\\\\\\\{]+)@?/g,\\\\n            ($0, $1) => {\\\\n                page2 = page;\\\\n                $1.split(\\\\\\\"@\\\\\\\").map(_ => {\\\\n                    eval(String('page2=page2' + _));\\\\n                });\\\\n                return page2;\\\\n            }\\\\n        )\\\\n        .replace(/fypage/g, page)\\\\n        .replace(\\\\n            /fy(class|area|year|sort)/g,\\\\n            ($0, $1) => rule[$1 + '_url'][eval($1 + '_i')] || \\\\\\\"\\\\\\\"\\\\n        )\\\\n        .replace(\\\\n            /fyAll/g,\\\\n            ($0, $1) => {\\\\n                FyAll_ii = FyAll_i;\\\\n                if (FyAll_ii > (rule.class_i - 1)) {\\\\n                    FyAll_ii -= rule.class_i;\\\\n                    if (FyAll_ii > (rule.area_i - 1)) {\\\\n                        FyAll_ii -= rule.area_i;\\\\n                        if (FyAll_ii > (rule.year_i - 1)) {\\\\n                            return rule.sort_url[FyAll_ii - rule.year_i];\\\\n                        } else {\\\\n                            return rule.year_url[FyAll_ii];\\\\n                        }\\\\n                    } else {\\\\n                        return rule.area_url[FyAll_ii];\\\\n                    }\\\\n                } else {\\\\n                    return rule.class_url[FyAll_ii];\\\\n                }\\\\n            }\\\\n        );\\\\n    return baseU;\\\\n}\\\\nconst getRuleGroup = (col_type, Sou) => {\\\\n    for (it of ['class', 'area', 'year', 'sort']) {\\\\n        eval(`index = {\\\\n    class: 0,\\\\n    area: rule.class_i,\\\\n    year: rule.class_i + rule.area_i,\\\\n    sort: rule.class_i + rule.area_i + rule.year_i,\\\\n}[it]\\\\nrule.${it}_name.map((name, i) => {\\\\n    if (isFyAll) {\\\\n        i = index + i;\\\\n        t = FyAll_i == i;\\\\n        k = 'FyAll_i';\\\\n    } else {\\\\n        t = ${it}_i == i;\\\\n        k = '${it}_i'\\\\n    }\\\\n    d.push({\\\\n        title: t ? Rich(Strong(Color(name))) : name,\\\\n        url: $('#noLoading#').lazyRule((k, i) => {\\\\n            putMyVar(k, i);\\\\n            refreshPage(false);\\\\n            return 'hiker://empty';\\\\n        }, k, i),\\\\n        col_type: \\\\\\\"${col_type||\\\\\\\"\\\\\\\"}\\\\\\\" || 'scroll_button'\\\\n    });\\\\n});\\\\nd.push({\\\\n    col_type: 'blank_block'\\\\n});`);\\\\n    }\\\\n    if (Sou) {\\\\n        d.push({\\\\n            title: '搜索',\\\\n            desc: '搜索关键词 / 链接$提取码',\\\\n            url: $.toString(() => {\\\\n                input = input.trim();\\\\n                if (input.match(/quark.cn.*\\\\\\\\/s\\\\\\\\/.+/)) {\\\\n                    return \\\\\\\"hiker://page/quarkList#noHistory##noRecordHistory#?realurl=\\\\\\\" + encodeURIComponent(input) + \\\\\\\"&rule=uckk云&sharePwd=\\\\\\\";\\\\n                } else if (input != \\\\\\\"\\\\\\\") {\\\\n                    putMyVar('keyword2', input);\\\\n                    refreshPage(false);\\\\n                }\\\\n                return 'hiker://empty';\\\\n            }),\\\\n            col_type: \\\\\\\"input\\\\\\\",\\\\n            extra: {\\\\n                id: id + \\\\\\\":search\\\\\\\",\\\\n                defaultValue: keyword,\\\\n                onChange: \\\\\\\"putMyVar('keyword',input)\\\\\\\"\\\\n            }\\\\n        });\\\\n    }\\\\n    d.push({\\\\n        url: \\\\\\\"toast://加载中...\\\\\\\",\\\\n        img: \\\\\\\"https://hikerfans.com/weisyr/img/Loading1.gif\\\\\\\",\\\\n        col_type: \\\\\\\"pic_1_center\\\\\\\",\\\\n        extra: {\\\\n            cls: \\\\\\\"loading_gif\\\\\\\"\\\\n        }\\\\n    });\\\\n    setPreResult(d);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❺温馨提示\\\",\\\"path\\\":\\\"notice\\\",\\\"rule\\\":\\\"$.exports = function() {\\\\n    f = \\\\\\\"Gray\\\\\\\";\\\\n    t = false;\\\\n    up = getMyVar('Rule_noupdate', '');\\\\n    if (up != '1') {\\\\n        version = JSON.parse(request(\\\\\\\"hiker://home@uckk云\\\\\\\")).version;\\\\n        if (up == '') {\\\\n            [url, v, run] = $.require(\\\\\\\"lanzou?rule=uckk云\\\\\\\").list_one(\\\\\\\"https://wwr.lanzoui.com/b03qf28qb\\\\\\\", \\\\\\\"read\\\\\\\");\\\\n        } else {\\\\n            url = false;\\\\n            v = version + 1;\\\\n        }\\\\n        if (version < v) {\\\\n            f = \\\\\\\"red\\\\\\\";\\\\n            t = \\\\\\\"检测到新版更新，点击了解详情。\\\\\\\";\\\\n            T = \\\\\\\"更新内容\\\\\\\";\\\\n            if (up == '') {\\\\n                confirm({\\\\n                    title: '更新提示',\\\\n                    content: '检测到你的规则版本小于服务器版本，是否立即更新？',\\\\n                    confirm: $.toString((da) => {\\\\n                        f = $.require(\\\\\\\"lanzou?rule=uckk云\\\\\\\").one_url(da);\\\\n                        putMyVar('Rule_noupdate', '1');\\\\n                        return \\\\\\\"\\\\\\\\u6d77\\\\\\\\u9614\\\\\\\\u89c6\\\\\\\\u754c\\\\\\\\uffe5home_rule_url\\\\\\\\uffe5\\\\\\\" + getPath(f);\\\\n                    }, url)\\\\n                });\\\\n                putMyVar('Rule_noupdate', url);\\\\n            }\\\\n            url = $(\\\\\\\"hiker://empty#noHistory##noRecordHistory#\\\\\\\").rule((up, version) => {\\\\n                return $.require(\\\\\\\"lanzou?rule=uckk云\\\\\\\").one_info(up, \\\\\\\"uckk\\\\\\\", version);\\\\n            }, url || up, version);\\\\n        } else {\\\\n            putMyVar('Rule_noupdate', '1');\\\\n        }\\\\n    }\\\\n\\\\n\\\\n    if (!$.require(\\\\\\\"tool\\\\\\\").isLoginCookie(getItem(\\\\\\\"quarkCookie\\\\\\\", \\\\\\\"\\\\\\\"))) {\\\\n        clearItem(\\\\\\\"quarkCookie\\\\\\\");\\\\n        f = \\\\\\\"red\\\\\\\";\\\\n        T = \\\\\\\"登录账号\\\\\\\";\\\\n        t = \\\\\\\"未检测到登录信息\\\\\\\";\\\\n        url = $([\\\\\\\"输入Cookie\\\\\\\", \\\\\\\"网页登录\\\\\\\"]).select(() => {\\\\n            if (input === \\\\\\\"网页登录\\\\\\\") {\\\\n                return \\\\\\\"hiker://page/login\\\\\\\";\\\\n            } else {\\\\n                return $(\\\\\\\"\\\\\\\", \\\\\\\"请输入Cookie\\\\\\\").input(() => {\\\\n                    if ($.require(\\\\\\\"tool\\\\\\\").isLoginCookie(input)) {\\\\n                        setItem(\\\\\\\"quarkCookie\\\\\\\", input.replace(/\\\\\\\\s/g, \\\\\\\"\\\\\\\"));\\\\n                        refreshPage();\\\\n                        return \\\\\\\"toast://设置成功\\\\\\\";\\\\n                    } else {\\\\n                        return \\\\\\\"toast://Cookie格式错误\\\\\\\";\\\\n                    }\\\\n                });\\\\n            }\\\\n        })\\\\n    } else if (!t) {\\\\n        T = \\\\\\\"程序设置\\\\\\\";\\\\n        url = \\\\\\\"hiker://page/install#noHistory##noRecordHistory#\\\\\\\";\\\\n        T = \\\\\\\"捐赠/支持\\\\\\\";\\\\n        url = \\\\\\\"hiker://page/donate#noHistory##noRecordHistory#\\\\\\\";\\\\n        hour = new Date().getHours();\\\\n        if (hour < 5) {\\\\n            t = \\\\\\\"深夜，现在的夜，熬得只是还未改变的习惯\\\\\\\";\\\\n        } else if (hour < 11) {\\\\n            t = \\\\\\\"早安，清晨熹微的阳光， 是你在微笑吗\\\\\\\";\\\\n        } else if (hour < 14) {\\\\n            t = \\\\\\\"午好，伴随着熟悉的乐曲，聆听着动人的旋律\\\\\\\";\\\\n        } else if (hour < 19) {\\\\n            t = \\\\\\\"夕暮，似清风醉晚霞，不经意间盈笑回眸\\\\\\\";\\\\n        } else {\\\\n            t = \\\\\\\"夜晚，一个安静的角落，静静地聆听夜曲\\\\\\\";\\\\n        }\\\\n    }\\\\n    d.push({\\\\n        title: \\\\\\\"““””\\\\\\\" + t.fontcolor(f).small(),\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: url,\\\\n        extra: {\\\\n            pageTitle: T,\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❽蓝奏更新\\\",\\\"path\\\":\\\"lanzou\\\",\\\"rule\\\":\\\"js:\\\\nhead = {\\\\n    headers: {\\\\n        \\\\\\\"upgrade-insecure-requests\\\\\\\": \\\\\\\"1\\\\\\\",\\\\n        \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Linux; Android 8.0.0; MI 5s Plus Build/OPR1.170623.032; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/71.0.3578.99 Mobile Safari/537.36\\\\\\\",\\\\n        \\\\\\\"Cookie\\\\\\\": \\\\\\\"down_ip=1\\\\\\\",\\\\n        \\\\\\\"accept\\\\\\\": \\\\\\\"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8\\\\\\\",\\\\n    },\\\\n    method: 'GET'\\\\n};\\\\none_url = function(url, pwd, run, noTp, Html) {\\\\n    try {\\\\n        head.headers.referer = url.split(\\\\\\\"?\\\\\\\")[0];\\\\n        isTp = !url.match(\\\\\\\"/tp/\\\\\\\");\\\\n        if (isTp && !noTp) {\\\\n            da = url.replace(/^(.*?\\\\\\\\.com)/, '$1/tp');\\\\n        } else {\\\\n            da = url;\\\\n        }\\\\n        html = String(Html || fetch(da, head));\\\\n        if (html == \\\\\\\"\\\\\\\" && isTp && !noTp) {\\\\n            return one_url(url, pwd, run, true);\\\\n        }\\\\n        try {\\\\n            path = html.match(/link = ['\\\\\\\"]([^\\\\\\\"']+)/i)[1];\\\\n            host = url.match(/^(.*?\\\\\\\\.com\\\\\\\\/)/)[1];\\\\n            return one_url(host + path, pwd, run);\\\\n        } catch (err0) {\\\\n            try {\\\\n                path = html.match(/'(\\\\\\\\?.+?)'/)[1];\\\\n                host = \\\\\\\"https://developer.lanzoug.com\\\\\\\";\\\\n            } catch (err1) {\\\\n                eval(html.match(/value\\\\\\\\;([\\\\\\\\s\\\\\\\\S]+?)\\\\\\\\$\\\\\\\\(/i)[1]);\\\\n                eval('body=' + html.match(/[\\\\\\\\s\\\\\\\\S]*data :([\\\\\\\\s\\\\\\\\S]*?\\\\\\\\}),\\\\\\\\s+/)[1]);\\\\n                u = String(url).replace(/\\\\\\\\.com.*/, \\\\\\\".com/ajaxm.php\\\\\\\");\\\\n                _ = JSON.parse(post(u, {\\\\n                    body: body,\\\\n                    headers: head.headers\\\\n                }));\\\\n                path = _.url;\\\\n                host = _.dom;\\\\n            }\\\\n        }\\\\n        u = host + \\\\\\\"/file/\\\\\\\" + path;\\\\n        k = JSON.parse(fetch(u, {\\\\n            redirect: false,\\\\n            onlyHeaders: true\\\\n        })).headers.location;\\\\n        k = Array.isArray(k) ? k[0] : k;\\\\n        if (run) return k;\\\\n        let f = \\\\\\\"hiker://files/cache/_fileSelect_rule.json\\\\\\\";\\\\n        downloadFile(k, f);\\\\n        return f;\\\\n    } catch (err2) {\\\\n        return false;\\\\n    }\\\\n};\\\\n$.exports = {\\\\n    list_one: function(url, pwd, run) {\\\\n        src = fetch(url, head);\\\\n        eval(src.match(/var pgs;([\\\\\\\\s\\\\\\\\S]*?pgs.+;)/)[1]);\\\\n        eval('body=' + src.match(/data :([\\\\\\\\s\\\\\\\\S]*?\\\\\\\\})/)[1]);\\\\n        url = url.replace(/\\\\\\\\.com.*/, \\\\\\\".com/filemoreajax.php\\\\\\\");\\\\n        list = JSON.parse(post(url, {\\\\n            body: body,\\\\n            headers: head.headers\\\\n        })).text;\\\\n        if (run) return list;\\\\n        __ = list[0];\\\\n        url = url.replace(/filemo.*/, 'tp/' + __.id);\\\\n        v = __.name_all.match(/\\\\\\\\[(.+)/)[1];\\\\n        [v, run] = v.split(\\\\\\\"]\\\\\\\");\\\\n        return [url, v, run];\\\\n    },\\\\n    one_url: one_url,\\\\n    one_info: function(url, pwd, version) {\\\\n        version = version || \\\\\\\"未知版本\\\\\\\";\\\\n        version = String(version).replace(/(\\\\\\\\d\\\\\\\\d)(\\\\\\\\d\\\\\\\\d)$/, \\\\\\\"-$1-$2\\\\\\\");\\\\n        item = fetch(url, head);\\\\n        t = pdfh(item, \\\\\\\".md&&Text\\\\\\\") || pdfh(item, \\\\\\\"title&&Text\\\\\\\");\\\\n        try {\\\\n            t = String(t).split(\\\\\\\"[\\\\\\\")[1].split(\\\\\\\"]\\\\\\\")[0];\\\\n        } catch (err) {}\\\\n        t = String(t).replace(/(\\\\\\\\d\\\\\\\\d)(\\\\\\\\d\\\\\\\\d)$/, \\\\\\\"-$1-$2\\\\\\\");\\\\n        d = [];\\\\n        d.push({\\\\n            desc: \\\\\\\"<b>““\\\\\\\" + version + \\\\\\\" => \\\\\\\" + t + \\\\\\\"””</b>\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        });\\\\n        d.push({\\\\n            col_type: \\\\\\\"big_big_blank_block\\\\\\\"\\\\n        });\\\\n        d.push({\\\\n            title: pdfh(item, \\\\\\\".mdo&&Html\\\\\\\").replace(/(<\\\\\\\\/span>)?\\\\\\\\s*<span>/gi, \\\\\\\"<br>\\\\\\\"),\\\\n            url: 'hiker://empty',\\\\n            col_type: 'rich_text'\\\\n        });\\\\n        d.push({\\\\n            col_type: \\\\\\\"big_blank_block\\\\\\\"\\\\n        });\\\\n        d.push({\\\\n            title: \\\\\\\"<b>““确定更新””</b>\\\\\\\".big(),\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            url: $(\\\\\\\"hiker://empty#noHistory##noRecordHistory#\\\\\\\").lazyRule((url, pwd, item) => {\\\\n                if (getMyVar('Rule_noupdate') == '1') {\\\\n                    return back(true), \\\\\\\"hiker://empty\\\\\\\";\\\\n                }\\\\n                let {\\\\n                    one_url\\\\n                } = $.require(\\\\\\\"hiker://page/lanzou?rule=歌词适配\\\\\\\");\\\\n                let K = one_url(url, pwd, 1, 0, item);\\\\n                if (!K) {\\\\n                    K = one_url(url, pwd, 1);\\\\n                }\\\\n                if (!K) {\\\\n                    K = one_url(url.split(\\\\\\\"?\\\\\\\")[0], pwd, 1);\\\\n                }\\\\n                if (K) {\\\\n                    f = \\\\\\\"hiker://files/cache/_fileSelect_rule.json\\\\\\\";\\\\n                    downloadFile(K, f);\\\\n                    putMyVar('Rule_noupdate', '1');\\\\n                    return \\\\\\\"\\\\\\\\u6d77\\\\\\\\u9614\\\\\\\\u89c6\\\\\\\\u754c\\\\\\\\uffe5home_rule_url\\\\\\\\uffe5\\\\\\\" + getPath(f);\\\\n                } else {\\\\n                    return \\\\\\\"toast://获取下载链接失败\\\\\\\";\\\\n                }\\\\n            }, url, pwd, item),\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        });\\\\n        setResult(d);\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❻支持作者\\\",\\\"path\\\":\\\"donate\\\",\\\"rule\\\":\\\"js:\\\\nlet d = [];\\\\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/ThomasYou/haikuo/raw/master/IMG_20240112_081355.png\\\\\\\",\\\\n    pic_url: \\\\\\\"https://gitee.com/ThomasYou/haikuo/raw/master/IMG_20240112_081355.png\\\\\\\"\\\\n});\\\\nd.push({\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    title: \\\\\\\"““””\\\\\\\" + \\\\\\\"图片加载缓慢请稍等\\\\\\\".small().fontcolor(\\\\\\\"Gray\\\\\\\"),\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❸规则列表\\\",\\\"path\\\":\\\"ruleList\\\",\\\"rule\\\":\\\"js:\\\\naddListener('onClose', $.toString(() => {\\\\n    arr = $.require('tool?rule=uckk云').getVariables();\\\\n    for (t of arr) {\\\\n        clearMyVar(t);\\\\n    }\\\\n}));\\\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\\\nd = [];\\\\nd.push({\\\\n    title: '新增规则',\\\\n    col_type: 'text_2',\\\\n    url: $('#noLoading#').lazyRule(() => {\\\\n        arr = $.require('tool?rule=uckk云').getVariables();\\\\n        for (t of arr) {\\\\n            clearMyVar(t);\\\\n        }\\\\n        clearMyVar(\\\\\\\"rule_uid\\\\\\\");\\\\n        return 'hiker://page/ruleEdit#noHistory##noRecordHistory#?pageTitle=规则编辑&rule=uckk云'\\\\n    })\\\\n});\\\\nd.push({\\\\n    title: '分享选中',\\\\n    col_type: 'text_2',\\\\n    url: $('#noLoading#').lazyRule(() => {\\\\n        zy = storage0.getMyVar(\\\\\\\"jxlist2\\\\\\\", {});\\\\n        zu = Object.keys(zy);\\\\n        if (zu.length == 0) {\\\\n            return \\\\\\\"toast://没有选中解析\\\\\\\";\\\\n        } else if (zu.length == 1) {\\\\n            json = [zy[zu[0]]];\\\\n            u = base64Encode(JSON.stringify(json));\\\\n            clearMyVar('jxlist2');\\\\n            refreshPage(false);\\\\n            return \\\\\\\"copy://uckk规则口令，打开海阔即可导入\\\\\\\\n￥Text￥\\\\\\\" + u + '@import=js:$.require(\\\\\\\"tool?rule=uckk云\\\\\\\").setRule(input);';\\\\n        } else {\\\\n            json = zu.map(key => zy[key]);\\\\n            t = base64Encode(JSON.stringify(json));\\\\n            return $([\\\\\\\"剪贴板\\\\\\\", \\\\\\\"纯文本\\\\\\\"], 1, '选择分享格式').select((t) => {\\\\n                if (input == \\\\\\\"剪贴板\\\\\\\") {\\\\n                    u = sharePaste(t, '云剪贴板6');\\\\n                    t = \\\\\\\"Paste\\\\\\\";\\\\n                } else {\\\\n                    u = t;\\\\n                    t = \\\\\\\"Text\\\\\\\";\\\\n                }\\\\n                clearMyVar('jxlist2');\\\\n                refreshPage(false);\\\\n                return \\\\\\\"copy://uckk规则口令，打开海阔即可导入\\\\\\\\n￥\\\\\\\" + t + \\\\\\\"￥\\\\\\\" + u + '@import=js:$.require(\\\\\\\"tool?rule=uckk云\\\\\\\").setRule(input);';\\\\n            }, t);\\\\n        }\\\\n    })\\\\n});\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\nplatform = getMyVar('platform', '综合');\\\\n[\\\\\\\"综合\\\\\\\"].concat(groups).map(group => {\\\\n    if (group == platform)\\\\n        platform2 = Rich(Strong(Color(group)));\\\\n    else\\\\n        platform2 = group;\\\\n    d.push({\\\\n        title: platform2,\\\\n        url: $('#noLoading#').lazyRule((group) => {\\\\n            putMyVar('platform', group);\\\\n            refreshPage();\\\\n            return 'hiker://empty';\\\\n        }, group),\\\\n        col_type: 'scroll_button',\\\\n        extra: {\\\\n            longClick: [{\\\\n                    title: '删除' + group.replace('综合', '全部') + '规则',\\\\n                    js: $.toString((group) => {\\\\n                        $$ = $.require('configs?rule=uckk云');\\\\n                        if (group == \\\\\\\"综合\\\\\\\") {\\\\n                            deleteFile($$.rulePath);\\\\n                        } else {\\\\n                            rules = $$.getJson_1(\\\\\\\"group\\\\\\\", group);\\\\n                            $$.saveJson(rules);\\\\n                        }\\\\n                        refreshPage();\\\\n                        return \\\\\\\"hiker://empty\\\\\\\";\\\\n                    }, group)\\\\n                },\\\\n                {\\\\n                    title: '分享' + group.replace('综合', '全部') + '规则',\\\\n                    js: $.toString((group) => {\\\\n                        $$ = $.require('configs?rule=uckk云');\\\\n                        if (group == \\\\\\\"综合\\\\\\\") {\\\\n                            rules = $$.getJson();\\\\n                        } else {\\\\n                            rules = $$.getJson_1(\\\\\\\"group\\\\\\\", group, 1);\\\\n                        }\\\\n                        if (rules.length == 0) return \\\\\\\"toast://没有规则\\\\\\\";\\\\n                        t = base64Encode(JSON.stringify(rules));\\\\n                        return $([\\\\\\\"剪贴板\\\\\\\", \\\\\\\"纯文本\\\\\\\"], 1, '选择分享格式').select((t) => {\\\\n                            if (input == \\\\\\\"剪贴板\\\\\\\") {\\\\n                                u = sharePaste(t, '云剪贴板6');\\\\n                                t = \\\\\\\"Paste\\\\\\\";\\\\n                            } else {\\\\n                                u = t;\\\\n                                t = \\\\\\\"Text\\\\\\\";\\\\n                            }\\\\n                            clearMyVar('jxlist2');\\\\n                            refreshPage(false);\\\\n                            return \\\\\\\"copy://uckk规则口令，打开海阔即可导入\\\\\\\\n￥\\\\\\\" + t + \\\\\\\"￥\\\\\\\" + u + '@import=js:$.require(\\\\\\\"tool?rule=uckk云\\\\\\\").setRule(input);';\\\\n                        }, t);\\\\n                    }, group)\\\\n                }\\\\n            ]\\\\n        }\\\\n    });\\\\n});\\\\nd.push({\\\\n    col_type: 'blank_block'\\\\n});\\\\nrules = $.require('configs?rule=uckk云').getGroupJson(false, \\\\\\\"group\\\\\\\", platform, \\\\\\\"综合\\\\\\\");\\\\n\\\\n\\\\n\\\\n\\\\n\\\\npid = Number(getMyVar('pid')) || 0;\\\\nnames = $.require('configs?rule=uckk云').getGroupNames(rules, \\\\\\\"search_group\\\\\\\");\\\\nif (pid > names.length - 1) {\\\\n    pid = 0;\\\\n}\\\\nnames.map((group, i) => {\\\\n    if (i == pid)\\\\n        platform2 = Rich(Strong(Color(group)));\\\\n    else\\\\n        platform2 = group;\\\\n    d.push({\\\\n        title: platform2,\\\\n        url: $('#noLoading#').lazyRule((i) => {\\\\n            putMyVar('pid', i);\\\\n            refreshPage(false);\\\\n            return 'hiker://empty';\\\\n        }, i),\\\\n        col_type: 'scroll_button',\\\\n        extra: {\\\\n            longClick: [{\\\\n                title: '分享' + group.replace('全全', '全部') + '规则',\\\\n                js: $.toString((platform, group) => {\\\\n                    $$ = $.require('configs?rule=uckk云');\\\\n                    rules = $$.getJson_1(\\\\\\\"group\\\\\\\", platform, 1);\\\\n                    if (group != \\\\\\\"全全\\\\\\\") {\\\\n                        rules = rules.filter(f => f.search_group == group);\\\\n                    }\\\\n                    if (rules.length == 0) return \\\\\\\"toast://没有规则\\\\\\\";\\\\n                    t = base64Encode(JSON.stringify(rules));\\\\n                    return $([\\\\\\\"剪贴板\\\\\\\", \\\\\\\"纯文本\\\\\\\"], 1, '选择分享格式').select((t) => {\\\\n                        if (input == \\\\\\\"剪贴板\\\\\\\") {\\\\n                            u = sharePaste(t, '云剪贴板6');\\\\n                            t = \\\\\\\"Paste\\\\\\\";\\\\n                        } else {\\\\n                            u = t;\\\\n                            t = \\\\\\\"Text\\\\\\\";\\\\n                        }\\\\n                        clearMyVar('jxlist2');\\\\n                        refreshPage(false);\\\\n                        return \\\\\\\"copy://uckk规则口令，打开海阔即可导入\\\\\\\\n￥\\\\\\\" + t + \\\\\\\"￥\\\\\\\" + u + '@import=js:$.require(\\\\\\\"tool?rule=uckk云\\\\\\\").setRule(input);';\\\\n                    }, t);\\\\n                }, platform, group)\\\\n            }]\\\\n        }\\\\n    });\\\\n});\\\\nd.push({\\\\n    col_type: 'line'\\\\n});\\\\nplatform2 = names[pid];\\\\nrules = $.require('configs?rule=uckk云').getGroupJson(rules, \\\\\\\"search_group\\\\\\\", platform2, \\\\\\\"全全\\\\\\\").slice(1);\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\nif (rules.length == 0) {\\\\n    d.push({\\\\n        title: Rich(Strong(Color(\\\\\\\"没有规则\\\\\\\"))),\\\\n        url: 'hiker://empty',\\\\n        col_type: 'text_center_1',\\\\n        extra: {\\\\n            lineVisible: false\\\\n        }\\\\n    });\\\\n} else {\\\\n    jxlist2 = storage0.getMyVar(\\\\\\\"jxlist2\\\\\\\", {});\\\\n    rules.map((_, ii) => {\\\\n        m = md5(_.group + _.title);\\\\n        i = !jxlist2[m];\\\\n        d1 = _.explore_enabled == \\\\\\\"1\\\\\\\";\\\\n        d2 = 'by ' + _.author;\\\\n        d.push({\\\\n            title: Strong(i ? _.title : Color(_.title)),\\\\n            desc: d1 ? Color(d2, \\\\\\\"#2E5D8E\\\\\\\") : d2,\\\\n            url: $([\\\\\\\"分享\\\\\\\", \\\\\\\"编辑\\\\\\\", \\\\\\\"删除\\\\\\\", \\\\\\\"移动\\\\\\\"].concat([i ? \\\\\\\"选中规则\\\\\\\" : \\\\\\\"取消选中\\\\\\\", d1 ? \\\\\\\"禁用发现\\\\\\\" : \\\\\\\"启用发现\\\\\\\"]), 2, '选择扩展操作').select((m, _) => {\\\\n                switch (input) {\\\\n                    case '分享':\\\\n                        _ = base64Encode(JSON.stringify([_]));\\\\n                        return \\\\\\\"copy://uckk规则口令，打开海阔即可导入\\\\\\\\n￥Text￥\\\\\\\" + _ + '@import=js:$.require(\\\\\\\"tool?rule=uckk云\\\\\\\").setRule(input);';\\\\n                        break;\\\\n                    case '编辑':\\\\n                        arr = $.require('tool?rule=uckk云').getVariables();\\\\n                        for (t of arr) {\\\\n                            clearMyVar(t);\\\\n                        }\\\\n                        arr = Object.keys(_);\\\\n                        for (t of arr) {\\\\n                            putMyVar(t, _[t] || \\\\\\\"\\\\\\\");\\\\n                        }\\\\n                        putMyVar('rule_uid', m);\\\\n                        putMyVar('search_enabled', _.search_enabled || \\\\\\\"0\\\\\\\");\\\\n                        putMyVar('explore_enabled', _.explore_enabled || \\\\\\\"0\\\\\\\");\\\\n                        return 'hiker://page/ruleEdit#noHistory##noRecordHistory#?pageTitle=规则编辑&rule=uckk云';\\\\n                        break;\\\\n                    case '删除':\\\\n                        return $(\\\\\\\"确定删除\\\\\\\" + _.group + \\\\\\\"规则“\\\\\\\" + _.title + '”吗？\\\\\\\\n此操作不可逆，请谨慎选择。').confirm((m) => {\\\\n                            $$ = $.require('configs?rule=uckk云');\\\\n                            rules = $$.getJson_2(m);\\\\n                            $$.saveJson(rules);\\\\n                            refreshPage(false);\\\\n                        }, m);\\\\n                        break;\\\\n                    case '移动':\\\\n                        zy = $.require('configs?rule=uckk云').getJson_2(m);\\\\n                        zu = zy.slice(1).map(_ => _.title);\\\\n                        return $(zu.concat(\\\\\\\"最后面\\\\\\\"), 2, '请选择移动位置').select((zy, zu, _) => {\\\\n                            i = zu.indexOf(input);\\\\n                            if (i == -1)\\\\n                                zy.push(_);\\\\n                            else\\\\n                                zy.splice(i + 1, 0, _);\\\\n                            $.require('configs?rule=uckk云').saveJson(zy);\\\\n                            refreshPage(false);\\\\n                        }, zy, zu, _);\\\\n                        break;\\\\n                    case '选中规则':\\\\n                        jxlist2 = storage0.getMyVar(\\\\\\\"jxlist2\\\\\\\", {});\\\\n                        jxlist2[m] = _;\\\\n                        storage0.putMyVar(\\\\\\\"jxlist2\\\\\\\", jxlist2);\\\\n                        refreshPage(false);\\\\n                        break;\\\\n                    case '取消选中':\\\\n                        jxlist2 = storage0.getMyVar(\\\\\\\"jxlist2\\\\\\\", {});\\\\n                        delete jxlist2[m];\\\\n                        storage0.putMyVar(\\\\\\\"jxlist2\\\\\\\", jxlist2);\\\\n                        refreshPage(false);\\\\n                        break;\\\\n                    case '启用发现':\\\\n                    case '禁用发现':\\\\n                        $.require('configs?rule=uckk云').getJson_2(m, \\\\\\\"explore_enabled\\\\\\\");\\\\n                        refreshPage(false);\\\\n                        break;\\\\n                }\\\\n            }, m, _),\\\\n            col_type: 'avatar',\\\\n            img: _.icon\\\\n        });\\\\n        d.push({\\\\n            title: _.group + '丨' + _.search_group + '丨' + (_.x5_url || (_.url ? _.url : _.search_url).split(\\\\\\\"/\\\\\\\").slice(0, 3).join(\\\\\\\"/\\\\\\\")),\\\\n            url: $('#noLoading#').lazyRule((m) => {\\\\n                $.require('configs?rule=uckk云').getJson_2(m, \\\\\\\"search_enabled\\\\\\\");\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, m),\\\\n            col_type: 'text_icon',\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (_.search_enabled == '1' ? 55 : 63) + '.svg',\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        });\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        });\\\\n    });\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❼程序首页\\\",\\\"path\\\":\\\"home\\\",\\\"rule\\\":\\\"js:\\\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\\\naddListener('onRefresh', $.toString(() => {\\\\n    putMyVar('keyword2', getMyVar('keyword'));\\\\n}));\\\\nd = [];\\\\nlet rules = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getJson();\\\\n\\\\n\\\\n\\\\nsearch_rule = rules.filter(_ => _.search_enabled == \\\\\\\"1\\\\\\\" && _.search_url != \\\\\\\"\\\\\\\" && _.searchFind != \\\\\\\"\\\\\\\");\\\\nsearch_type = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getGroupNames(search_rule, \\\\\\\"group\\\\\\\");\\\\nruleType = getMyVar(\\\\\\\"ruleType\\\\\\\", \\\\\\\"综合\\\\\\\");\\\\nsearch_rule = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getGroupJson(search_rule, \\\\\\\"group\\\\\\\", ruleType, \\\\\\\"综合\\\\\\\");\\\\nsearch_group = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getGroupNames(search_rule, \\\\\\\"search_group\\\\\\\");\\\\nruleGroup = Number(getMyVar(\\\\\\\"ruleGroup\\\\\\\")) || 0;\\\\nif (ruleGroup > search_group.length - 1) {\\\\n    ruleGroup = 0;\\\\n}\\\\nsearch_rule = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getGroupJson(search_rule, \\\\\\\"search_group\\\\\\\", search_group[ruleGroup], \\\\\\\"全全\\\\\\\");\\\\nlet sid = Number(getMyVar(\\\\\\\"sid\\\\\\\")) || 0;\\\\nif (sid > search_rule.length - 1) {\\\\n    sid = 0;\\\\n}\\\\nif (sid) {\\\\n    data = [search_rule[sid]];\\\\n} else {\\\\n    data = search_rule.slice(1);\\\\n}\\\\n\\\\n\\\\n\\\\n\\\\nlet explore_rule = rules.filter(_ => _.explore_enabled == \\\\\\\"1\\\\\\\" && _.url != \\\\\\\"\\\\\\\" && (_.explore_X5 == \\\\\\\"1\\\\\\\" || _.find_rule != \\\\\\\"\\\\\\\"));\\\\nlet tid = Number(getMyVar(\\\\\\\"tid\\\\\\\")) || 0;\\\\nif (tid > explore_rule.length - 1) {\\\\n    tid = 0;\\\\n}\\\\nlet rule = _ = explore_rule[tid];\\\\nlet rule_x5 = _.explore_X5 == \\\\\\\"1\\\\\\\";\\\\nif (rule_x5) {\\\\n    if (!_.x5_url && (_.url ? _.url : _.search_url).match(/fy(All|class|area|sort|year|page)/)) {\\\\n        _.x5_url = (_.url ? _.url : _.search_url).split(\\\\\\\"/\\\\\\\").slice(0, 3).join(\\\\\\\"/\\\\\\\");\\\\n    }\\\\n} else {\\\\n    if (_PAGE) $.require('notice?rule=uckk云')();\\\\n    _.x5_desc = '1';\\\\n}\\\\nhome_baseUrl = getRuleBaseUrl(_.url);\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n// top\\\\nif (_PAGE) {\\\\n    explore_rule.map((_, i) => {\\\\n        d.push({\\\\n            title: Strong(\\\\\\\"““\\\\\\\" + (tid == i ? _.title + \\\\\\\"””\\\\\\\" : \\\\\\\"””\\\\\\\" + _.title)),\\\\n            url: $('#noLoading#').lazyRule((i) => {\\\\n                putMyVar('keyword2', getMyVar('keyword'));\\\\n                putMyVar('tid', i);\\\\n                for (t of [\\\\\\\"class\\\\\\\", \\\\\\\"area\\\\\\\", \\\\\\\"year\\\\\\\", \\\\\\\"sort\\\\\\\", \\\\\\\"FyAll\\\\\\\"]) {\\\\n                    clearMyVar(t + \\\\\\\"_i\\\\\\\");\\\\n                }\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            }, i),\\\\n            col_type: 'scroll_button'\\\\n        });\\\\n    });\\\\n    d.push({\\\\n        col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n        url: _.x5_desc == '1' || _.x5_url || _.url,\\\\n        desc: _.x5_desc || \\\\\\\"screen-133&&float\\\\\\\",\\\\n        extra: {\\\\n            canBack: true,\\\\n            ua: _.x5_ua ? (_.x5_ua == \\\\\\\"PC_UA\\\\\\\" ? PC_UA : _.x5_ua) : MOBILE_UA,\\\\n            referer: _.x5_referer,\\\\n            js: _.x5_js,\\\\n            jsLoadingInject: !!_.x5_jsLoadingInject,\\\\n            autoPlay: !!_.x5_autoPlay,\\\\n            floatVideo: !!_.x5_floatVideo,\\\\n            imgLongClick: !_.x5_imgLongClick,\\\\n            showProgress: !_.x5_showProgress,\\\\n            blockRules: eval(_.x5_blockRules) || [],\\\\n            urlInterceptor: $.toString((urlInterceptor_js, x5Url) => {\\\\n                if (input.includes(\\\\\\\"aliyundrive.com/\\\\\\\") || input.includes(\\\\\\\"aliyundrive.net/\\\\\\\") || input.includes(\\\\\\\"alipan.com/\\\\\\\")) {\\\\n                    return $.toString((url) => {\\\\n                        fba.open(JSON.stringify({\\\\n                            rule: '云盘君.简',\\\\n                            url: \\\\\\\"hiker://page/aliyun#noHistory##noRecordHistory#?rule=云盘君.简&page=fypage&realurl=\\\\\\\" + encodeURIComponent(url)\\\\n                        }));\\\\n                    }, input)\\\\n                } else if (input.includes(\\\\\\\"quark.cn\\\\\\\")) {\\\\n                    return $.toString((url) => {\\\\n                        fba.open(JSON.stringify({\\\\n                            title: \\\\\\\"夸克网盘\\\\\\\",\\\\n                            url: \\\\\\\"hiker://page/quarkList#noHistory##noRecordHistory#?rule=uckk云&realurl=\\\\\\\" + encodeURIComponent(url),\\\\n                        }))\\\\n                    }, input);\\\\n                }\\\\n                let x5_urlInterceptor = new Function(\\\\\\\"input\\\\\\\", \\\\\\\"x5Url\\\\\\\", urlInterceptor_js);\\\\n                return x5_urlInterceptor(input, x5Url);\\\\n            }, _.x5_urlInterceptor, \\\\\\\"hiker://page/ruleHome#noHistory##noRecordHistory#?rule=uckk云&page=fypage&ruleName=\\\\\\\" + _.title + \\\\\\\"&ruleGroup=\\\\\\\" + _.group + \\\\\\\"&baseUrl=\\\\\\\")\\\\n        }\\\\n    });\\\\n}\\\\n\\\\n\\\\n\\\\nif (rule_x5) { // x5\\\\n    if (_.x5_desc == '1') { // 自定义首页\\\\n        eval(_.preRule);\\\\n        eval(_.x5_home);\\\\n    }\\\\n} else { // 搜索/发现\\\\n    if (_PAGE) {\\\\n        d.push({\\\\n            col_type: 'line_blank'\\\\n        }, {\\\\n            col_type: 'line_blank'\\\\n        }, {\\\\n            title: Strong(\\\\\\\"我的收藏\\\\\\\"),\\\\n            url: \\\\\\\"hiker://collection?rule=\\\\\\\" + id,\\\\n            col_type: \\\\\\\"icon_small_3\\\\\\\",\\\\n            img: \\\\\\\"hiker://images/icon_download\\\\\\\"\\\\n        }, {\\\\n            title: Strong(\\\\\\\"历史记录\\\\\\\"),\\\\n            url: \\\\\\\"hiker://history?rule=\\\\\\\" + id,\\\\n            col_type: \\\\\\\"icon_small_3\\\\\\\",\\\\n            img: \\\\\\\"hiker://images/icon_his\\\\\\\"\\\\n        }, {\\\\n            title: Strong(\\\\\\\"规则管理\\\\\\\"),\\\\n            url: \\\\\\\"hiker://page/ruleList#noHistory##noRecordHistory#?pageTitle=规则管理&rule=\\\\\\\" + id,\\\\n            col_type: \\\\\\\"icon_small_3\\\\\\\",\\\\n            img: \\\\\\\"hiker://images/icon_xiutan\\\\\\\"\\\\n        }, {\\\\n            title: '搜索',\\\\n            desc: '搜索关键词 / 链接$提取码',\\\\n            url: $.toString(() => {\\\\n                input = input.trim();\\\\n                if (input.match(/quark.cn.*\\\\\\\\/s\\\\\\\\/.+/)) {\\\\n                    return \\\\\\\"hiker://page/quarkList#noHistory##noRecordHistory#?realurl=\\\\\\\" + encodeURIComponent(input) + \\\\\\\"&rule=uckk云&sharePwd=\\\\\\\";\\\\n                } else if (input != \\\\\\\"\\\\\\\") {\\\\n                    putMyVar('keyword2', input);\\\\n                    refreshPage(false);\\\\n                }\\\\n                return 'hiker://empty';\\\\n            }),\\\\n            col_type: \\\\\\\"input\\\\\\\",\\\\n            extra: {\\\\n                id: id + \\\\\\\":search\\\\\\\",\\\\n                defaultValue: keyword,\\\\n                onChange: \\\\\\\"putMyVar('keyword',input)\\\\\\\"\\\\n            }\\\\n        }, {\\\\n            title: Rich(Strong(Color(ruleType, \\\\\\\"#3399cc\\\\\\\"))),\\\\n            url: $([\\\\\\\"综合\\\\\\\"].concat(groups).map(name => {\\\\n                if (name == ruleType) {\\\\n                    name = Rich(Strong(Color(name)));\\\\n                } else if (search_type.indexOf(name) == -1) {\\\\n                    name = Rich(\\\\\\\"<S>\\\\\\\" + name + \\\\\\\"</S>\\\\\\\");\\\\n                }\\\\n                return name;\\\\n            }), 3, \\\\\\\"选择搜索类别\\\\\\\").select(() => {\\\\n                if (input.indexOf(\\\\\\\"<S>\\\\\\\") != -1) {\\\\n                    return \\\\\\\"toast://没有对应规则\\\\\\\";\\\\n                } else if (input.indexOf(\\\\\\\"<\\\\\\\") == -1) {\\\\n                    putMyVar('keyword2', getMyVar('keyword'));\\\\n                    putMyVar('ruleType', input);\\\\n                    clearMyVar(\\\\\\\"ruleGroup\\\\\\\");\\\\n                    clearMyVar(\\\\\\\"sid\\\\\\\");\\\\n                    refreshPage(false);\\\\n                }\\\\n                return 'hiker://empty';\\\\n            }),\\\\n            col_type: 'scroll_button'\\\\n        });\\\\n        search_group.map((name, i) => {\\\\n            d.push({\\\\n                title: ruleGroup == i ? Rich(Strong(Color(name))) : name,\\\\n                url: $('#noLoading#').lazyRule((i) => {\\\\n                    putMyVar('keyword2', getMyVar('keyword'));\\\\n                    putMyVar('ruleGroup', i);\\\\n                    clearMyVar(\\\\\\\"sid\\\\\\\");\\\\n                    refreshPage();\\\\n                    return 'hiker://empty';\\\\n                }, i),\\\\n                col_type: 'scroll_button'\\\\n            });\\\\n        });\\\\n        d.push({\\\\n            col_type: 'blank_block'\\\\n        });\\\\n        search_rule.map((_, i) => {\\\\n            d.push({\\\\n                title: sid == i ? Rich(Strong(Color(_.title))) : _.title,\\\\n                url: $('#noLoading#').lazyRule((i) => {\\\\n                    putMyVar('keyword2', getMyVar('keyword'));\\\\n                    putMyVar('sid', i);\\\\n                    refreshPage();\\\\n                    return 'hiker://empty';\\\\n                }, i),\\\\n                col_type: 'scroll_button'\\\\n            });\\\\n        });\\\\n        d.push({\\\\n            col_type: 'line_blank'\\\\n        });\\\\n    }\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n    if (_SOU) {\\\\n        if (data.length > 0) {\\\\n            d.push({\\\\n                title: \\\\\\\"加载第\\\\\\\" + page + \\\\\\\"页中，进度：1/\\\\\\\" + data.length,\\\\n                url: \\\\\\\"hiker://empty\\\\\\\",\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n                desc: \\\\\\\"\\\\\\\",\\\\n                pic_url: \\\\\\\"\\\\\\\",\\\\n                extra: {\\\\n                    id: pageid\\\\n                }\\\\n            });\\\\n        } else if (_PAGE) {\\\\n            d.push({\\\\n                title: \\\\\\\"没有可用的搜索规则\\\\\\\",\\\\n                url: \\\\\\\"hiker://empty\\\\\\\",\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n                desc: \\\\\\\"\\\\\\\",\\\\n                pic_url: \\\\\\\"\\\\\\\",\\\\n                extra: {\\\\n                    id: pageid\\\\n                }\\\\n            });\\\\n        }\\\\n    } else if (_PAGE || rule.url.match(\\\\\\\"fypage\\\\\\\")) {\\\\n        if (_PAGE) {\\\\n            if (rule.title != \\\\\\\"聚搜\\\\\\\") d.push({\\\\n                title: '‘‘’’<b>' + Color(rule.title, '#ff6601') + '</b>',\\\\n                url: $('#noLoading#').lazyRule((url) => {\\\\n                    for (t of [\\\\\\\"class\\\\\\\", \\\\\\\"area\\\\\\\", \\\\\\\"year\\\\\\\", \\\\\\\"sort\\\\\\\", \\\\\\\"FyAll\\\\\\\"]) {\\\\n                        clearMyVar(t + \\\\\\\"_i\\\\\\\");\\\\n                    }\\\\n                    return url;\\\\n                }, \\\\\\\"hiker://page/ruleHome?rule=uckk云&page=fypage&ruleName=\\\\\\\" + rule.title + \\\\\\\"&ruleGroup=\\\\\\\" + rule.group),\\\\n                col_type: 'text_center_1',\\\\n                img: rule.icon,\\\\n                extra: {\\\\n                    lineVisible: false,\\\\n                    home: 1\\\\n                }\\\\n            });\\\\n            getRuleGroup();\\\\n        }\\\\n        baseUrl = home_baseUrl;\\\\n        eval(String(rule.preRule));\\\\n        eval(String(rule.find_rule));\\\\n    }\\\\n}\\\\n_PAGE ? setPreResult(d) : setResult(d);\\\\ndeleteItemByCls('loading_gif');\\\\n\\\\n\\\\n\\\\n// 搜索\\\\nif (!rule_x5 && _SOU && data.length > 0) {\\\\n    let ii = history.indexOf(keyword);\\\\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(keyword);\\\\n    storage0.setItem(\\\\\\\"searchHistory\\\\\\\", history);\\\\n    let tasks = data.map(it => {\\\\n        return {\\\\n            func: function(rule) {\\\\n                try {\\\\n                    try {\\\\n                        MY_PAGE\\\\n                    } catch (err) {\\\\n                        MY_PAGE = 1\\\\n                    }\\\\n                    page = MY_PAGE;\\\\n                    baseUrl = rule.search_url\\\\n                        .replace(\\\\n                            /fypage@([^\\\\\\\\?\\\\\\\\&\\\\\\\\;\\\\\\\\#\\\\\\\\\\\\\\\"\\\\\\\\'\\\\\\\\{]+)@?/g,\\\\n                            ($0, $1) => {\\\\n                                page2 = page;\\\\n                                $1.split(\\\\\\\"@\\\\\\\").map(_ => {\\\\n                                    eval(String('page2=page2' + _));\\\\n                                });\\\\n                                return page2;\\\\n                            }\\\\n                        )\\\\n                        .replace(/fypage/g, page)\\\\n                        .replace(/\\\\\\\\*\\\\\\\\*/g, keyword);\\\\n                    if (page == 1 || rule.search_url.match(\\\\\\\"fypage\\\\\\\")) {\\\\n                        eval(rule.preRule);\\\\n                        let searchfind = new Function(\\\\\\\"rule\\\\\\\", \\\\\\\"baseUrl\\\\\\\", \\\\\\\"keyword\\\\\\\", \\\\\\\"page\\\\\\\", rule.searchFind);\\\\n                        let list = searchfind(rule, baseUrl, keyword, page);\\\\n                        if (!list) return [];\\\\n                        let descTips = \\\\\\\"““””\\\\\\\" + rule.title.fontcolor(\\\\\\\"#f13b66a\\\\\\\") + \\\\\\\"&nbsp;&nbsp;\\\\\\\";\\\\n                        let resList = [];\\\\n                        for (let it of list) {\\\\n                            resList.push({\\\\n                                title: it.title.includes(\\\\\\\"““””\\\\\\\") ? it.title : \\\\\\\"““””\\\\\\\" + it.title.replace(/<\\\\\\\\/em>/g, \\\\\\\"\\\\\\\").replace(new RegExp(keyword, \\\\\\\"g\\\\\\\"), \\\\\\\"<strong><span style=\\\\\\\\\\\\\\\"color: #1E90FF\\\\\\\\\\\\\\\">\\\\\\\" + keyword + \\\\\\\"</span></strong>\\\\\\\"),\\\\n                                desc: descTips + (it.desc || \\\\\\\"\\\\\\\"),\\\\n                                url: it.url,\\\\n                                img: it.img || it.pic_url,\\\\n                                col_type: it.col_type || \\\\\\\"text_1\\\\\\\",\\\\n                                extra: Object.assign({\\\\n                                    inheritTitle: false,\\\\n                                    noPic: true\\\\n                                }, it.extra || {})\\\\n                            });\\\\n                        }\\\\n                        return resList;\\\\n                    } else {\\\\n                        return [];\\\\n                    }\\\\n                } catch (e) {\\\\n                    log(_.title + \\\\\\\":\\\\\\\" + e.toString());\\\\n                    return [];\\\\n                }\\\\n            },\\\\n            param: it,\\\\n            id: \\\\\\\"uckk_rule@\\\\\\\" + it.title\\\\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}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❹规则编辑\\\",\\\"path\\\":\\\"ruleEdit\\\",\\\"rule\\\":\\\"js:\\\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\\\n\\\\ngroup = getMyVar('group', '夸克');\\\\nsearch_enabled = getMyVar('search_enabled', '1') == '1';\\\\nexplore_enabled = getMyVar('explore_enabled', '0') == '1';\\\\n\\\\nrule_tid = getMyVar('rule_tid', '基本');\\\\nexplore_X5 = getMyVar('explore_X5', '0') == '1';\\\\ntime = Number(getMyVar(\\\\\\\"time\\\\\\\")) || new Date().getTime();\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\nd = [];\\\\nd.push({\\\\n    title: Strong(Color('<b>' + group + '资源</b>', '#ff6601')),\\\\n    url: $(groups.map(title => title == group ? Rich(Strong(Color(title))) : title), 2, '选择规则分组').select(() => {\\\\n        if (!input.match(/^‘‘’’/)) {\\\\n            putMyVar('group', input);\\\\n            refreshPage(false);\\\\n        }\\\\n        return 'hiker://empty';\\\\n    }),\\\\n    img: icons[group],\\\\n    col_type: 'icon_small_3'\\\\n});\\\\nd.push({\\\\n    title: Color('<b>启用搜索</b>', '#ff6601'),\\\\n    url: $('#noLoading#').lazyRule((search_enabled) => {\\\\n        putMyVar('search_enabled', search_enabled);\\\\n        refreshPage(false);\\\\n        return 'hiker://empty';\\\\n    }, search_enabled ? '0' : '1'),\\\\n    img: 'https://hikerfans.com/tubiao/messy/' + (search_enabled ? 55 : 63) + '.svg',\\\\n    col_type: 'icon_small_3'\\\\n});\\\\nd.push({\\\\n    title: Color('<b>启用发现</b>', '#ff6601'),\\\\n    url: $('#noLoading#').lazyRule((explore_enabled) => {\\\\n        putMyVar('explore_enabled', explore_enabled);\\\\n        refreshPage(false);\\\\n        return 'hiker://empty';\\\\n    }, explore_enabled ? '0' : '1'),\\\\n    img: 'https://hikerfans.com/tubiao/messy/' + (explore_enabled ? 55 : 63) + '.svg',\\\\n    col_type: 'icon_small_3'\\\\n});\\\\n\\\\n[\\\\\\\"基本\\\\\\\", \\\\\\\"搜索\\\\\\\", \\\\\\\"发现\\\\\\\", \\\\\\\"替换\\\\\\\", \\\\\\\"扩展\\\\\\\"].map(name => {\\\\n    i = rule_tid == name\\\\n    d.push({\\\\n        title: Rich(Strong(i ? Color(name) : name)),\\\\n        url: $('#noLoading#').lazyRule((tid, tii) => {\\\\n            if (tii) {\\\\n                putMyVar('rule_tid', tid);\\\\n                refreshPage(false);\\\\n            }\\\\n            return 'hiker://empty';\\\\n        }, name, !i),\\\\n        col_type: 'text_5'\\\\n    });\\\\n});\\\\ninput_push = (desc, id, value, json, height) => {\\\\n    d.push({\\\\n        desc: desc,\\\\n        title: \\\\\\\"</>\\\\\\\",\\\\n        url: $.toString((id) => {\\\\n            let group = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getGroupNames(0, \\\\\\\"search_group\\\\\\\");\\\\n            if (!group.length) {\\\\n                return \\\\\\\"\\\\\\\";\\\\n            }\\\\n            return $(group, 3, \\\\\\\"选择规则分组\\\\\\\").select((id) => {\\\\n                let extra = findItem(id).extra;\\\\n                updateItem(id, {\\\\n                    extra: Object.assign(extra, {\\\\n                        defaultValue: input\\\\n                    })\\\\n                });\\\\n            }, id);\\\\n        }, id),\\\\n        col_type: 'input',\\\\n        extra: Object.assign({\\\\n            defaultValue: getMyVar(id, value),\\\\n            onChange: `putMyVar(\\\\\\\"${id}\\\\\\\", input)`,\\\\n            type: 'textarea',\\\\n            titleVisible: true,\\\\n            highlight: true,\\\\n            height: height || 5,\\\\n            id: id,\\\\n        }, json || {})\\\\n    });\\\\n}\\\\nswitch (rule_tid) {\\\\n    case '基本':\\\\n        [\\\\n            ['必填，源名称', 'title', ''],\\\\n            ['选填，源图标', 'icon', ''],\\\\n            ['选填，源作者', 'author', '佚名'],\\\\n            ['选填，JsLib', 'preRule', '', {\\\\n                height: 3\\\\n            }],\\\\n        ].map([a, b, c, e] => {\\\\n            input_push(a, b, c, e, 1);\\\\n        });\\\\n        break;\\\\n    case '搜索':\\\\n        [\\\\n            ['必填，搜索链接', 'search_url', ''],\\\\n            ['必填，搜索分组', 'search_group', '全全', {\\\\n                highlight: false,\\\\n            }],\\\\n            ['必填，列表规则\\\\\\\\n提供变量: baseUrl, keyword, page\\\\\\\\n\\\\\\\\n需要返回数组：return [];', 'searchFind', '', {\\\\n                height: 5\\\\n            }],\\\\n        ].map([a, b, c, e] => {\\\\n            input_push(a, b, c, e, 1);\\\\n        });\\\\n        break;\\\\n    case '发现':\\\\n        d.push({\\\\n            title: Strong('使用 x5_webview_single'),\\\\n            url: $('#noLoading#').lazyRule((explore_X5) => {\\\\n                putMyVar('explore_X5', explore_X5);\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, explore_X5 ? '0' : '1'),\\\\n            col_type: 'text_icon',\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (explore_X5 ? 55 : 63) + '.svg'\\\\n        });\\\\n        [\\\\n            ['必填，源链接', 'url', '', {\\\\n                height: 1\\\\n            }],\\\\n            ['必填，列表规则\\\\\\\\n启用x5就不用写了\\\\\\\\n\\\\\\\\n继承数组d： d.push(json);', 'find_rule', ''],\\\\n        ].map([a, b, c, e] => {\\\\n            input_push(a, b, c, e);\\\\n        });\\\\n        break;\\\\n    case '替换':\\\\n        d.push({\\\\n            title: Strong('发现链接替换'),\\\\n            desc: '选填',\\\\n            url: 'hiker://empty',\\\\n            col_type: 'avatar',\\\\n            img: 'hiker://images/home_icon_edit'\\\\n        });\\\\n        [\\\\n            ['分类名称', 'class_name', ''],\\\\n            ['分类替换', 'class_url', ''],\\\\n            ['地区名称', 'area_name', ''],\\\\n            ['地区替换', 'area_url', ''],\\\\n            ['年代名称', 'year_name', ''],\\\\n            ['年代替换', 'year_url', ''],\\\\n            ['排序名称', 'sort_name', ''],\\\\n            ['排序替换', 'sort_url', ''],\\\\n        ].map([a, b, c, e] => {\\\\n            input_push(a, b, c, e, 1);\\\\n        });\\\\n        break;\\\\n    case '扩展':\\\\n        x5_jsLoadingInject = getMyVar('x5_jsLoadingInject', '0') == '1';\\\\n        x5_floatVideo = getMyVar('x5_floatVideo', '0') == '1';\\\\n        x5_autoPlay = getMyVar('x5_autoPlay', '0') == '1';\\\\n        x5_showProgress = getMyVar('x5_showProgress', '0') == '1';\\\\n        x5_imgLongClick = getMyVar('x5_imgLongClick', '0') == '1';\\\\n        x5_desc = getMyVar('x5_desc', '0') == '1';\\\\n\\\\n        d.push({\\\\n            title: Strong('注入js'),\\\\n            desc: '选填',\\\\n            url: 'hiker://empty',\\\\n            col_type: 'avatar',\\\\n            img: 'hiker://images/home_icon_edit'\\\\n        });\\\\n        d.push({\\\\n            title: '<b>网站加载中也执行</b>',\\\\n            url: $('#noLoading#').lazyRule((x) => {\\\\n                putMyVar('x5_jsLoadingInject', x);\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, x5_jsLoadingInject ? '0' : '1'),\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_jsLoadingInject ? 55 : 63) + '.svg',\\\\n            col_type: 'text_icon'\\\\n        });\\\\n        input_push(\\\\\\\"\\\\\\\", \\\\\\\"x5_js\\\\\\\", \\\\\\\"\\\\\\\", {}, 3);\\\\n\\\\n        d.push({\\\\n            col_type: 'line_blank'\\\\n        });\\\\n        d.push({\\\\n            title: Strong('拦截资源'),\\\\n            desc: '选填',\\\\n            url: 'hiker://empty',\\\\n            col_type: 'avatar',\\\\n            img: 'hiker://images/home_icon_edit'\\\\n        });\\\\n        input_push(\\\\\\\"返回为数组，支持js，不需要return\\\\\\\\n不执行匹配的链接，让网页加载更快，规则为包含匹配，*代表任意字符（不是正则），如果想拦截不包含的可使用!!，如 ['!!test1!!$dom'] 表示链接不包含test1并且不包含网站域名那就拦截、!!$topdom不包含主域名就拦截\\\\\\\", \\\\\\\"x5_blockRules\\\\\\\", \\\\\\\"\\\\\\\");\\\\n        input_push(`提供变量 input，x5Url\\\\\\\\n该代码不是在网页中执行的，没有fy_bridge_app。\\\\\\\\n有返回就拦截链接，不加载网址，例：if(input.includes('/ad/')) return true\\\\\\\\n可以跳转到规则二级页面，例：\\\\\\\\nreturn $.toString((url, x5Url) => {\\\\n    fba.open(JSON.stringify({\\\\n        url: x5Url + encodeURIComponent(url)\\\\n    }));\\\\n}, input, x5Url)`, \\\\\\\"x5_urlInterceptor\\\\\\\", \\\\\\\"\\\\\\\", {}, 7);\\\\n        input_push(\\\\\\\"子页面规则，上面的规则可以通过x5Url跳转到这里。baseUrl是跳转的链接\\\\\\\", \\\\\\\"x5_pageHome\\\\\\\", \\\\\\\"\\\\\\\", {}, 3);\\\\n        d.push({\\\\n            col_type: 'line_blank'\\\\n        });\\\\n        d.push({\\\\n            title: Strong('x5设置'),\\\\n            desc: '一般不用管',\\\\n            url: 'hiker://empty',\\\\n            col_type: 'avatar',\\\\n            img: 'hiker://images/home_icon_edit'\\\\n        });\\\\n        input_push(\\\\\\\"Referer\\\\\\\", \\\\\\\"x5_referer\\\\\\\", \\\\\\\"\\\\\\\", {}, 1);\\\\n        input_push(\\\\\\\"UA，MOBILE_UA/PC_UA/自定义\\\\\\\", \\\\\\\"x5_ua\\\\\\\", \\\\\\\"\\\\\\\", {}, 1);\\\\n        d.push({\\\\n            title: '<b>长按图片不显示菜单</b>',\\\\n            url: $('#noLoading#').lazyRule((x) => {\\\\n                putMyVar('x5_imgLongClick', x);\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, x5_imgLongClick ? '0' : '1'),\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_imgLongClick ? 55 : 63) + '.svg',\\\\n            col_type: 'text_icon'\\\\n        });\\\\n        d.push({\\\\n            title: '<b>不显示进度条</b>',\\\\n            url: $('#noLoading#').lazyRule((x) => {\\\\n                putMyVar('x5_showProgress', x);\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, x5_showProgress ? '0' : '1'),\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_showProgress ? 55 : 63) + '.svg',\\\\n            col_type: 'text_icon'\\\\n        });\\\\n        d.push({\\\\n            title: '<b>悬浮嗅探播放</b>',\\\\n            url: $('#noLoading#').lazyRule((x) => {\\\\n                putMyVar('x5_floatVideo', x);\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, x5_floatVideo ? '0' : '1'),\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_floatVideo ? 55 : 63) + '.svg',\\\\n            col_type: 'text_icon'\\\\n        });\\\\n        d.push({\\\\n            title: '<b>音视频自动播放</b>',\\\\n            url: $('#noLoading#').lazyRule((x) => {\\\\n                putMyVar('x5_autoPlay', x);\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, x5_autoPlay ? '0' : '1'),\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_autoPlay ? 55 : 63) + '.svg',\\\\n            col_type: 'text_icon'\\\\n        });\\\\n        d.push({\\\\n            col_type: 'line_blank'\\\\n        });\\\\n        d.push({\\\\n            title: Strong('x5扩展'),\\\\n            desc: '选填',\\\\n            url: 'hiker://empty',\\\\n            col_type: 'avatar',\\\\n            img: 'hiker://images/home_icon_edit'\\\\n        });\\\\n        d.push({\\\\n            title: '<b>首页不显示搜索框</b>',\\\\n            url: $('#noLoading#').lazyRule((x) => {\\\\n                putMyVar('x5_desc', x);\\\\n                refreshPage(false);\\\\n                return 'hiker://empty';\\\\n            }, x5_desc ? '0' : '1'),\\\\n            img: 'https://hikerfans.com/tubiao/messy/' + (x5_desc ? 55 : 63) + '.svg',\\\\n            col_type: 'text_icon'\\\\n        });\\\\n        input_push(\\\\\\\"url，发现链接和x5链接冲突时填写\\\\\\\", \\\\\\\"x5_url\\\\\\\", \\\\\\\"\\\\\\\", {}, 1);\\\\n        input_push(\\\\\\\"home_js，不显示搜索框时执行。\\\\\\\\n继承数组d，内容只有规则分类。\\\\\\\\n在此基础上自定义首页吧。\\\\\\\", \\\\\\\"x5_home\\\\\\\", \\\\\\\"\\\\\\\");\\\\n        break;\\\\n}\\\\nd.push({\\\\n    col_type: 'line_blank'\\\\n});\\\\nd.push({\\\\n    title: Rich(Strong(Color('保存并退出'))),\\\\n    desc: '上次编辑：' + $.dateFormat(time, 'yyyy-MM-dd hh:mm:ss'),\\\\n    url: $('#noLoading#').lazyRule(() => {\\\\n        return $.require(\\\\\\\"tool?rule=uckk云\\\\\\\").setEdit();\\\\n    }),\\\\n    col_type: 'text_center_1',\\\\n    extra: {\\\\n        lineVisible: false\\\\n    }\\\\n});\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❷规则文件\\\",\\\"path\\\":\\\"configs\\\",\\\"rule\\\":\\\"const rulePath = \\\\\\\"hiker://files/rules/Thomas/uckkRules.json\\\\\\\";\\\\nlet rules;\\\\n\\\\nfunction getJson() {\\\\n    if (Array.isArray(rules)) {\\\\n        return rules;\\\\n    }\\\\n    try {\\\\n        rules = JSON.parse(readFile(rulePath) || \\\\\\\"[]\\\\\\\");\\\\n    } catch (e) {\\\\n        rules = [];\\\\n    }\\\\n    if (rules.length == 0) deleteFile(rulePath);\\\\n    return rules;\\\\n}\\\\n\\\\nfunction saveJson(json) {\\\\n    saveFile(rulePath, JSON.stringify(json));\\\\n}\\\\n\\\\nfunction getJson_1(Key, Value, Type) {\\\\n    if (Type)\\\\n        return getJson().filter(f => f[Key] == Value);\\\\n    else\\\\n        return getJson().filter(f => f[Key] != Value);\\\\n}\\\\n\\\\nfunction getJson_2(M, Key) {\\\\n    if (Key)\\\\n        return saveJson(getJson().map(f => {\\\\n            if (md5(f.group + f.title) == M) {\\\\n                f[Key] = f[Key] == \\\\\\\"1\\\\\\\" ? \\\\\\\"0\\\\\\\" : \\\\\\\"1\\\\\\\";\\\\n            }\\\\n            return f;\\\\n        }));\\\\n    else\\\\n        return getJson().filter(v => md5(v.group + v.title) != M);\\\\n}\\\\n\\\\nfunction getGroupJson(Rules, Key, Value1, Value2) {\\\\n    return (Rules || getJson()).filter(f => f[Key] == Value1 || f[Key] == Value2 || Value1 == Value2);\\\\n}\\\\n\\\\nfunction getGroupNames(Rules, Key) {\\\\n    return Array.from(new Set((Rules || getJson()).map(f => f[Key]))).filter(v => v);\\\\n}\\\\n\\\\nif (!fileExist(rulePath)) {\\\\n    rules = [{\\\\n        group: \\\\\\\"综合\\\\\\\",\\\\n        search_enabled: \\\\\\\"1\\\\\\\",\\\\n        explore_enabled: \\\\\\\"1\\\\\\\",\\\\n\\\\n        title: \\\\\\\"聚搜\\\\\\\",\\\\n        author: \\\\\\\"Thomas喲\\\\\\\",\\\\n        icon: \\\\\\\"hiker://images/search\\\\\\\",\\\\n        preRule: \\\\\\\"\\\\\\\",\\\\n\\\\n        search_url: \\\\\\\"fypage\\\\\\\",\\\\n        search_group: \\\\\\\"全全\\\\\\\",\\\\n        searchFind: \\\\\\\"1\\\\\\\",\\\\n\\\\n        explore_X5: \\\\\\\"0\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        find_rule: `d.push({\\\\n    title: '<b>历史搜索</b>'.fontcolor(\\\\\\\"#ff6601\\\\\\\"),\\\\n    pic_url: \\\\\\\"hiker://images/icon_find\\\\\\\",\\\\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});\\\\nif (history.length === 0) 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});\\\\nelse history.map((key, i) => {\\\\n    d.push({\\\\n        title: key,\\\\n        url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((id, key) => {\\\\n            let extra = findItem(id + \\\\\\\":search\\\\\\\").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) => {\\\\n                    let history = storage0.getItem(\\\\\\\"searchHistory\\\\\\\", []);\\\\n                    let ii = history.indexOf(key);\\\\n                    history.splice(ii, 1);\\\\n                    storage0.setItem(\\\\\\\"searchHistory\\\\\\\", history);\\\\n                    deleteItem(id + \\\\\\\":key:\\\\\\\" + key);\\\\n                    if (history.length === 0) 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, key)\\\\n            }]\\\\n        }\\\\n    });\\\\n});`,\\\\n\\\\n        class_name: \\\\\\\"\\\\\\\",\\\\n        class_url: \\\\\\\"\\\\\\\",\\\\n        area_name: \\\\\\\"\\\\\\\",\\\\n        area_url: \\\\\\\"\\\\\\\",\\\\n        year_name: \\\\\\\"\\\\\\\",\\\\n        year_url: \\\\\\\"\\\\\\\",\\\\n        sort_name: \\\\\\\"\\\\\\\",\\\\n        sort_url: \\\\\\\"\\\\\\\",\\\\n        time: 0\\\\n    }];\\\\n    saveJson(rules);\\\\n}\\\\n$.exports = {\\\\n    getJson,\\\\n    saveJson,\\\\n    getJson_1,\\\\n    getJson_2,\\\\n    rulePath,\\\\n    getGroupNames,\\\\n    getGroupJson\\\\n};\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"❾跳转二级\\\",\\\"path\\\":\\\"ruleHome\\\",\\\"rule\\\":\\\"js:\\\\neval(JSON.parse(fetch('hiker://page/lib?rule=uckk云', {})).rule);\\\\nlet ruleGroup = getParam('ruleGroup', '综合');\\\\nlet ruleName = getParam('ruleName', '');\\\\nlet baseUrl = decodeURIComponent(getParam('baseUrl'));\\\\nlet rules = $.require(\\\\\\\"configs?rule=uckk云\\\\\\\").getGroupJson(false, \\\\\\\"group\\\\\\\", ruleGroup, \\\\\\\"综合\\\\\\\");\\\\nlet rule = _ = rules.find(f => f.title == ruleName);\\\\nif (rule != -1) {\\\\n    if (MY_PARAMS.home) { // 从首页跳转的\\\\n        d = [];\\\\n        baseUrl = getRuleBaseUrl(rule.url);\\\\n        if (_PAGE) {\\\\n            getRuleGroup(0, rule.search != \\\\\\\"\\\\\\\" && rule.searchFind != \\\\\\\"\\\\\\\");\\\\n        }\\\\n        eval(rule.preRule);\\\\n        if (_SOU && (_PAGE || rule.search_url.match(\\\\\\\"fypage\\\\\\\"))) {\\\\n            let ii = history.indexOf(keyword);\\\\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(keyword);\\\\n            storage0.setItem(\\\\\\\"searchHistory\\\\\\\", history);\\\\n\\\\n            let dd = d;\\\\n            baseUrl = rule.search_url\\\\n                .replace(\\\\n                    /fypage@([^\\\\\\\\?\\\\\\\\&\\\\\\\\;\\\\\\\\#\\\\\\\\\\\\\\\"\\\\\\\\'\\\\\\\\{]+)@?/g,\\\\n                    ($0, $1) => {\\\\n                        page2 = page;\\\\n                        $1.split(\\\\\\\"@\\\\\\\").map(_ => {\\\\n                            eval(String('page2=page2' + _));\\\\n                        });\\\\n                        return page2;\\\\n                    }\\\\n                )\\\\n                .replace(/fypage/g, page)\\\\n                .replace(/\\\\\\\\*\\\\\\\\*/g, keyword);\\\\n            searchfind = new Function(\\\\\\\"rule\\\\\\\", \\\\\\\"baseUrl\\\\\\\", \\\\\\\"keyword\\\\\\\", \\\\\\\"page\\\\\\\", rule.searchFind);\\\\n            list = searchfind(rule, baseUrl, keyword, page);\\\\n            d = dd.concat(list);\\\\n        } else if (!_SOU && (_PAGE || rule.url.includes(\\\\\\\"fypage\\\\\\\"))) {\\\\n            eval(rule.find_rule);\\\\n        }\\\\n        _PAGE ? setPreResult(d) : setResult(d);\\\\n        deleteItemByCls('loading_gif');\\\\n    } else { // 从x5跳转的\\\\n        eval(rule.preRule);\\\\n        eval(rule.x5_pageHome);\\\\n    }\\\\n} else {\\\\n    setResult([{\\\\n        title: Color('<h1 style=\\\\\\\"text-align:center;\\\\\\\">图书馆Pro</h1>', '#FEBD6F').big(),\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    }]);\\\\n}\\\"}]\",\"proxy\":\"\"}","picUrl":"hiker://images/icon_xiutan","title":"规则管理"}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!