API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：搜索结果

xiaomianao666
Jul 22nd, 2024
195
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 132.14 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥搜索结果@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"依赖\",\"path\":\"data\",\"rule\":\"js:\\n$.exports.decrypt = function() {\\n    const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n    const key = CryptoUtil.Data.parseUTF8('f5d965df75336270');\\n    const iv = CryptoUtil.Data.parseUTF8('97b60394abc2fbe1');\\n    const textData = CryptoUtil.Data.parseInputStream(input).toBase64(_base64.NO_WRAP);\\n    const decrypted = CryptoUtil.AES.decrypt(textData, key, {\\n        iv: iv,\\n        mode: \\\"AES/CBC/NoPadding\\\"\\n    }).toBase64(_base64.NO_WRAP);\\n    const decrypted0 = CryptoUtil.Data.parseBase64(decrypted, _base64.NO_WRAP);\\n    return decrypted0.toInputStream();\\n}\\n\\nfunction Decrypt(data) {\\n    eval(getCryptoJS());\\n    const _0x40982e = CryptoJS.enc.Hex.parse(data),\\n        key = CryptoJS.enc.Utf8.parse('cc88ddc9357ff461e08f047aedee692b'),\\n        iv = CryptoJS.enc.Utf8.parse('e89225cfbbimgkcu'),\\n        _0x439cae = CryptoJS.enc.Base64.stringify(_0x40982e),\\n        _0x385d37 = CryptoJS.AES.decrypt(_0x439cae, key, {\\n            'iv': iv,\\n            'mode': CryptoJS.mode.CFB,\\n            'padding': CryptoJS.pad.NoPadding\\n        });\\n    const _0x27056b = _0x385d37.toString(CryptoJS.enc.Utf8);\\n    return JSON.parse(_0x27056b.toString());\\n}\\n\\nfunction decryptsign(dd) {\\n    const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n    const Data = \\\"client=pwa&data=\\\" + dd.data + \\\"&timestamp=\\\" + dd.timestamp + \\\"cc88ddc9357ff461e08f047aedee692b\\\";\\n    const utt8Data = CryptoUtil.Data.parseUTF8(Data);\\n    const sha256 = utt8Data.toDigest().sha256();\\n    const sign = md5(sha256);\\n    return sign;\\n}\\n\\nfunction encrypt(_0x3ae9ac) {\\n    eval(getCryptoJS());\\n    const key = CryptoJS.enc.Utf8.parse('cc88ddc9357ff461e08f047aedee692b');\\n    const iv = CryptoJS.enc.Utf8.parse('e89225cfbbimgkcu');\\n    _0x3ae9ac = \\\"object\\\" == typeof _0x3ae9ac ? JSON.stringify(_0x3ae9ac) : _0x3ae9ac;\\n    let _0x7927ae = CryptoJS.enc.Utf8.parse(_0x3ae9ac),\\n        _0x2e2910 = CryptoJS.AES.encrypt(_0x7927ae, key, {\\n            'iv': iv,\\n            'mode': CryptoJS.mode.CFB,\\n            'padding': CryptoJS.pad.NoPadding\\n        });\\n    const data = _0x2e2910.ciphertext.toString().toUpperCase(),\\n        _0x49cb52 = new Date().getTime() / 1000,\\n        timestamp = parseInt(_0x49cb52.toString()),\\n        sign = decryptsign({\\n            'client': \\\"pwa\\\",\\n            'data': data,\\n            'timestamp': timestamp\\n        });\\n    return {\\n        'client': \\\"pwa\\\",\\n        'sign': sign,\\n        'timestamp': timestamp,\\n        'data': data\\n    };\\n}\\n\\nfunction strong(d, c) {\\n    return '‘‘’’<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\n}\\n\\nfunction strongR(d, c) {\\n    return '<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\n}\\n\\nfunction Category(list, mode, d) {\\n    for (var i in list) {\\n        var List = list[i];\\n        var title = List.title;\\n        var Title = (getMyVar('color', '-1') == i) ? strong(title, 'FF6699') : title;\\n        d.push({\\n            title: Title,\\n            url: $(List.type).lazyRule((i, mode, List) => {\\n                if (mode == 0) {\\n                    putMyVar('type', input);\\n                } else if (mode == 1) {\\n                    putMyVar('typeS', input);\\n                } else if (mode == 2) {\\n                    putMyVar('typeSS', input);\\n                }\\n                putMyVar('color', i);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, i, mode, List),\\n            col_type: 'flex_button'\\n        });\\n    }\\n    d.push({\\n        col_type: 'blank_block',\\n    });\\n    return d;\\n}\\n\\nfunction category(list, d) {\\n    if (getItem('switch', 'off') == 'on') {\\n        for (var i in list) {\\n            var List = list[i];\\n            var title = List.name;\\n            var Title = (getMyVar('Color', '-1') == i) ? strong(title, 'FF6699') : title;\\n            if (List.id == '6' || List.id == '2') {\\n\\n            } else if (List.id == '4' || List.id == '7') {\\n                d.push({\\n                    title: Title,\\n                    url: $(List.id).lazyRule((i, List) => {\\n                        putMyVar('id', input);\\n                        putMyVar('Color', i);\\n                        refreshPage();\\n                        return 'hiker://page/type1?fypage';\\n                    }, i, List),\\n                    col_type: 'scroll_button'\\n                });\\n            } else {\\n                d.push({\\n                    title: Title,\\n                    url: $(List.id).lazyRule((i, List) => {\\n                        putMyVar('id', input);\\n                        putMyVar('Color', i);\\n                        refreshPage();\\n                        return 'hiker://page/type2?fypage';\\n                    }, i, List),\\n                    col_type: 'scroll_button'\\n                });\\n            }\\n        }\\n    }\\n    /*d.push({\\n        title: '🔒',\\n        url: $('').lazyRule(() => {\\n            putMyVar('on-off', 'off')\\n            refreshPage();\\n            return 'hiker://empty';\\n        }),\\n        col_type: 'flex_button'\\n    });*/\\n    d.push({\\n        title: (getItem('switch', 'off') == 'off') ? '📁' : '📂',\\n        url: $('').lazyRule(() => {\\n            if (getItem('switch', 'off') == 'off') {\\n                setItem('switch', 'on');\\n            } else {\\n                setItem('switch', 'off');\\n            }\\n            refreshPage();\\n            return 'hiker://empty';\\n        }),\\n        col_type: 'flex_button'\\n    });\\n    d.push({\\n        title: '🔍',\\n        url: 'hiker://page/search',\\n        col_type: 'flex_button'\\n    });\\n    return d;\\n}\\n\\n$.exports.Category = Category;\\n$.exports.category = category;\\n$.exports.strongR = strongR;\\n$.exports.strong = strong;\\n$.exports.encrypt = encrypt;\\n$.exports.Decrypt = Decrypt;\"},{\"col_type\":\"movie_3\",\"name\":\"①页面-类型一\",\"path\":\"type1\",\"rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar Page = getMyVar('page', '0');\\n//var id = MY_PARAMS.id;\\n//var col_type = MY_PARAMS.col_type;\\nvar id = getMyVar('id');\\nif (id == '7') {\\n    id = '22';\\n} else if (id == '4') {\\n    id = '33';\\n}\\nvar rr = {\\n    \\\"code\\\": \\\"getElementItembyId\\\",\\n    \\\"id\\\": id,\\n    \\\"limit\\\": 12,\\n    \\\"mod\\\": \\\"element\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"page\\\": (Page == 0) ? page : Page,\\n    \\\"timestamp\\\": 1.704546667806E12,\\n    \\\"version\\\": \\\"4.5.0\\\"\\n}\\nclearMyVar('page');\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\nlog(encryptdata)\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\n\\nvar list = r.data.list;\\nfor (var i in list) {\\n    var playurl = list[i].playUrl;\\n    var title = list[i].title;\\n    var nickName = list[i].nickName;\\n    var uuid = list[i].uuid;\\n    var desc = '\\\\t🆙' + list[i].created_at + '\\\\t🔥' + list[i].play_count + '\\\\t🏷️' + nickName + '\\\\t⏱️' + list[i].durationStr;\\n    var imageurl = list[i].thumbImg;\\n    d.push({\\n        title: title,\\n        desc: desc,\\n        img: imageurl + image,\\n        col_type: (storage0.getItem('Col1', '') == '') ? 'pic_1_card' : storage0.getItem('Col1', ''),\\n        url: playurl.replace('10play', 'long'),\\n        extra: {\\n            longClick: eval(JSON.parse(request('hiker://page/longClick1')).rule)\\n        }\\n    });\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"②页面-用户-全部页\",\"path\":\"userlist\",\"rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar mod = MY_PARAMS.mod;\\nvar code = MY_PARAMS.code;\\nvar col_type = MY_PARAMS.col_type;\\nvar rr = {\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"version\\\": \\\"4.5.0\\\",\\n    \\\"mod\\\": mod,\\n    \\\"code\\\": code,\\n    \\\"page\\\": page,\\n    \\\"limit\\\": 21,\\n    \\\"uuid\\\": getMyVar('uuid', ''),\\n    \\\"timestamp\\\": 1.704546667806E12\\n}\\n\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nif (mod == \\\"club\\\") {\\n    var list = r.data.item;\\n} else if (mod == \\\"user\\\") {\\n    var list = r.data;\\n}\\nfor (var i in list) {\\n    var playurl = list[i].playUrl;\\n    var title = list[i].title;\\n    var desc = '\\\\t🔥' + list[i].play_count;\\n    var imageurl = list[i].thumbImg;\\n    var nickName = list[i].nickName;\\n    var uuid = list[i].uuid;\\neval(JSON.parse(request('hiker://page/longClick')).rule)\\n    d.push({\\n        title: title,\\n        desc: desc,\\n        img: imageurl + image,\\n        col_type: (storage0.getItem('Col_media', '') == '') ? col_type : storage0.getItem('Col_media', ''),\\n        url: playurl.replace('10play', 'long'),\\n        extra: {\\n            longClick: longClick1\\n        }\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"②页面-用户-预览页\",\"path\":\"user\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle('UP主页');\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\nvar col_type = MY_PARAMS.col_type;\\n\\n//用户数据+帖子板块\\nvar rr = {\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"version\\\": \\\"4.5.0\\\",\\n    \\\"mod\\\": \\\"user\\\",\\n    \\\"code\\\": \\\"other\\\",\\n    \\\"uuid\\\": getMyVar('uuid', ''),\\n    \\\"timestamp\\\": 1.704546667806E12\\n}\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar list = r.data;\\n\\nvar club_video_count = list.club_video_count;\\nvar videosCount = list.videosCount;\\nvar likesCount = list.likesCount;\\n\\nif (list != '' && list != null && MY_PAGE == 1) {\\n    d.push({\\n        col_type: 'movie_1_vertical_pic_blur',\\n        title: '👩🏿‍🦲' + list.nickname,\\n        desc: list.fans + '粉丝\\\\t\\\\t' + list.followed + '关注\\\\t\\\\t' + list.fabulous + '被赞\\\\n' + '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t' + list.news_num + '帖子\\\\n' + '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t点击👆🏿前往',\\n        img: list.thumb + image,\\n        url: 'hiker://page/news?fypage',\\n        extra: {\\n            mod: \\\"news\\\",\\n            code: \\\"target_news\\\",\\n            col_type: \\\"text_1\\\",\\n            pageTitle: '帖子'\\n        }\\n    });\\n    d.push({\\n        col_type: 'big_blank_block',\\n        url: 'hiker://empty'\\n    });\\n}\\n\\n//他人主页子板块\\nvar Typelist = [\\n{title: '粉丝团专属', count: club_video_count , col_type:  'text_icon', mod: 'club',code: 'videos'},\\n{title: 'Ta的作品', count: videosCount , col_type:  'text_icon', mod: 'user', code: 'videos'},\\n{title: 'Ta的喜欢', count: likesCount , col_type:  'text_icon', mod: 'user', code: 'likes'}\\n];\\nfor (var i in Typelist) {\\n    var rr = {\\n        \\\"oauth_type\\\": \\\"pwa\\\",\\n        \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n        \\\"version\\\": \\\"4.5.0\\\",\\n        \\\"mod\\\": Typelist[i].mod,\\n        \\\"code\\\": Typelist[i].code,\\n        \\\"page\\\": 1,\\n        \\\"limit\\\": 3,\\n        \\\"uuid\\\": getMyVar('uuid', ''),\\n        \\\"timestamp\\\": 1.704546667806E12\\n    }\\n    var encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n    var timestamp = encryptdata.timestamp.toString();\\n    var data = encryptdata.data;\\n    var sign = encryptdata.sign;\\n    var Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n        body: {\\n            \\\"client\\\": \\\"pwa\\\",\\n            \\\"timestamp\\\": timestamp,\\n            \\\"data\\\": data,\\n            \\\"sign\\\": sign\\n        }\\n    })\\n    var h = Data;\\n    var data = JSON.parse(h).data;\\n    var r = $.require(\\\"data\\\").Decrypt(data);\\n    if (Typelist[i].mod == \\\"club\\\") {\\n        var list = r.data.item;\\n    } else if (Typelist[i].mod == \\\"user\\\") {\\n        var list = r.data;\\n    }\\n    if (list != '' && list != null && MY_PAGE == 1) {\\n        d.push({\\n            col_type: Typelist[i].col_type,\\n            title: $.require(\\\"data\\\").strongR(Typelist[i].title + Typelist[i].count + '部', 'FF6699'),\\n            img: 'hiker://images/icon_right5',\\n            url: 'hiker://page/userlist?fypage',\\n            extra: {\\n                mod: Typelist[i].mod,\\n                code: Typelist[i].code,\\n                pageTitle: Typelist[i].title\\n            }\\n        });\\n        for (var j in list) {\\n            var playurl = list[j].playUrl;\\n            var title = list[j].title;\\n            var desc = '\\\\t🔥' + list[j].play_count;\\n            var imageurl = list[j].thumbImg;\\n            d.push({\\n                title: title,\\n                desc: desc,\\n                img: imageurl + image,\\n                col_type: col_type,\\n                url: playurl.replace('10play', 'long')\\n            });\\n        }\\n        d.push({\\n            col_type: 'big_blank_block',\\n            url: 'hiker://empty'\\n        });\\n    }\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"②页面-用户-帖子列表\",\"path\":\"news\",\"rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar mod = MY_PARAMS.mod;\\nvar code = MY_PARAMS.code;\\nvar col_type = MY_PARAMS.col_type;\\nvar rr = {\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"version\\\": \\\"4.5.0\\\",\\n    \\\"mod\\\": mod,\\n    \\\"code\\\": code,\\n    \\\"page\\\": page,\\n    \\\"limit\\\": 15,\\n    \\\"target_uuid\\\": getMyVar('uuid', ''),\\n    \\\"timestamp\\\": 1.704546667806E12\\n}\\n\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar list = r.data;\\nfor (var i in list) {\\n    var id = list[i].id;\\n    var title = list[i].content;\\n    var desc = list[i].created_at + '发布\\\\t\\\\t' + list[i].view_num + '浏览\\\\t\\\\t' + list[i].like_num + '点赞';\\n    d.push({\\n        title: title,\\n        desc: desc,\\n        col_type: col_type,\\n        url: 'hiker://page/newsdetail',\\n        extra: {\\n            news_id: id,\\n            mod: \\\"news\\\",\\n            code: \\\"detail_v1\\\",\\n            pageTitle: \\\"帖子详情\\\"\\n        }\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"②页面-用户-帖子详情\",\"path\":\"newsdetail\",\"rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar mod = MY_PARAMS.mod;\\nvar code = MY_PARAMS.code;\\nvar news_id = MY_PARAMS.news_id;\\nvar rr = {\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"version\\\": \\\"4.5.0\\\",\\n    \\\"mod\\\": mod,\\n    \\\"code\\\": code,\\n    \\\"news_id\\\": news_id,\\n    \\\"timestamp\\\": 1.704546667806E12\\n}\\n\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar detail = r.data.detail;\\nvar comment_list = r.data.comment_list;\\nvar title = detail.title;\\nvar created_at = detail.created_at;\\nvar content = detail.content;\\nvar medialist = detail.medias;\\nvar comment_num = detail.comment_num;\\nvar nickName = detail.nickname;\\nvar uuid = detail.uuid;\\neval(JSON.parse(request('hiker://page/longClick')).rule)\\n//标题\\nd.push({\\n    title: '发布于:' + created_at + '\\\\t✍🏽️' + title,\\n    url: 'hiker://empty',\\n    col_type: 'rich_text',\\n});\\n\\n//正文\\nd.push({\\n    title: content,\\n    url: 'hiker://empty',\\n    col_type: 'rich_text',\\n});\\n\\n//视频\\nfor (var i in medialist) {\\n    var imageurl = medialist[i].media_url;\\n    if (imageurl.includes('m3u8')) {\\n        d.push({\\n            title: '视频▶️' + i,\\n            url: imageurl,\\n            col_type: 'text_3',\\n        });\\n    }\\n}\\n\\n//图片\\nfor (var i in medialist) {\\n    var imageurl = medialist[i].media_url;\\n    if (!imageurl.includes('m3u8')) {\\n        d.push({\\n            img: imageurl + image,\\n            url: imageurl + image,\\n            col_type: (storage0.getItem('Col_text', '') == '') ? 'pic_1_full' : storage0.getItem('Col_text', ''),\\n            extra: {\\n                longClick: longClick2\\n            }\\n        });\\n    }\\n}\\n\\n//评论区\\nd.push({\\n    title: '全部评论\\\\t(' + comment_num + ')',\\n    url: 'hiker://empty',\\n    col_type: 'text_1',\\n});\\nfor (var i in comment_list) {\\n    var nickname = comment_list[i].nickname;\\n    var sexType = comment_list[i].sexType;\\n    var sex = (sexType == '0') ? '\\\\t👩🏽\\\\t' : '\\\\t👨🏽\\\\t';\\n    var cityname = comment_list[i].cityname;\\n    var created_at = comment_list[i].created_at;\\n    var comment = comment_list[i].comment;\\n    var thumb = comment_list[i].thumb;\\n    d.push({\\n        title: nickname + sex,\\n        desc: cityname + '·\\\\t' + created_at,\\n        img: thumb + image,\\n        url: 'hiker://empty',\\n        col_type: 'avatar'\\n    });\\n    d.push({\\n        title: comment,\\n        url: 'hiker://empty',\\n        col_type: 'text_1'\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"①页面-类型二\",\"path\":\"type2\",\"rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar Page = getMyVar('page', '0');\\nvar id = getMyVar('id');\\nvar rr = {\\n    \\\"code\\\": \\\"getConstructById\\\",\\n    \\\"id\\\": id,\\n    \\\"limit\\\": 12,\\n    \\\"mod\\\": \\\"element\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"page\\\": (Page == 0) ? page : Page,\\n    \\\"timestamp\\\": 1.704546667806E12,\\n    \\\"version\\\": \\\"4.5.0\\\"\\n}\\nclearMyVar('page');\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar List = r.data;\\nfor (var i in List) {\\n    var title = List[i].title;\\n    var id = List[i].id;\\n    var list = List[i].list;\\n    if (!title.includes('banner')) {\\n        d.push({\\n            col_type: 'text_icon',\\n            title: $.require(\\\"data\\\").strongR(title, 'FF6699'),\\n            img: 'hiker://images/icon_right5',\\n            url: 'hiker://page/playlist?fypage',\\n            extra: {\\n                id: id,\\n                pageTitle: title\\n            }\\n        });\\n        for (var i in list) {\\n            var title = list[i].title;\\n            var playUrl = list[i].playUrl;\\n            var nickName = list[i].nickName;\\n            var uuid = list[i].uuid;\\n            var desc = '🔥' + list[i].play_count + '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t⏱️' + list[i].durationStr;\\n            var imageurl = list[i].thumbImg;\\n            d.push({\\n                title: title,\\n                desc: desc,\\n                img: imageurl + image,\\n                col_type: (storage0.getItem('Col2', '') == '') ? 'movie_2' : storage0.getItem('Col2', ''),\\n                url: playUrl.replace('10play', 'long'),\\n                extra: {\\n                    longClick: eval(JSON.parse(request('hiker://page/longClick2')).rule)\\n                }\\n            });\\n        }\\n        d.push({\\n            col_type: 'big_blank_block',\\n            url: 'hiker://empty'\\n        });\\n    }\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"①页面-类型二_二级\",\"path\":\"playlist\",\"rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar Page = getMyVar('page', '0');\\nvar id = MY_PARAMS.id;\\nvar typelist = [{\\n    title: '最新',\\n    type: 'new'\\n}, {\\n    title: '最热',\\n    type: 'hot'\\n}];\\n\\nif (MY_PAGE == 1) {\\n    $.require(\\\"data\\\").Category(typelist,0,d);\\n}\\nvar rr = {\\n    \\\"code\\\": \\\"getElementItembyId\\\",\\n    \\\"id\\\": id,\\n    \\\"limit\\\": 12,\\n    \\\"mod\\\": \\\"element\\\",\\n    \\\"type\\\": getMyVar('type', 'new'),\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"page\\\": (Page == 0) ? page : Page,\\n    \\\"timestamp\\\": 1.704546667806E12,\\n    \\\"version\\\": \\\"4.5.0\\\"\\n}\\nclearMyVar('page');\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\n\\nvar list = r.data.list;\\nfor (var i in list) {\\n    var playurl = list[i].playUrl;\\n    var title = list[i].title;\\n    var nickName = list[i].nickName;\\n    var uuid = list[i].uuid;\\n    var desc = '\\\\t🔥' + list[i].play_count + '\\\\t⏱️' + list[i].durationStr;\\n    var imageurl = list[i].thumbImg; eval(JSON.parse(request('hiker://page/longClick')).rule)\\n    d.push({\\n        title: title,\\n        desc: desc,\\n        img: imageurl + image,\\n        col_type: (storage0.getItem('Col_media', '') == '') ? 'movie_2' : storage0.getItem('Col_media', ''),\\n        url: playurl.replace('10play', 'long'),\\n        extra: { \\n            longClick: longClick1\\n        }\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"⑨全部页_longClick\",\"path\":\"longClick\",\"rule\":\"//col_type媒体显示样式\\nvar longClick1 = [{\\n    title: '样式',\\n    js: $.toString(() => {\\n        var Type = [\\\"movie_1\\\", \\\"movie_2\\\", \\\"movie_3\\\", \\\"movie_1_left_pic\\\", \\\"movie_1_vertical_pic\\\", \\\"movie_1_vertical_pic_blur\\\", \\\"pic_1\\\", \\\"pic_2\\\", \\\"pic_3\\\", \\\"pic_1_full\\\", \\\"pic_1_center\\\", \\\"pic_1_card\\\", \\\"pic_2_card\\\", \\\"pic_3_square\\\", \\\"card_pic_1\\\", \\\"card_pic_2\\\", \\\"card_pic_3\\\", \\\"card_pic_3_center\\\", \\\"long_text\\\", \\\"rich_text\\\", \\\"scroll_button\\\", \\\"flex_button\\\"];\\n        var Type1 = [];\\n        for (var i in Type) {\\n            var col = storage0.getItem('type', '');\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n            if (Type[i] == Col) {\\n                Type[i] = '👉🏽' + Type[i];\\n            } else {\\n                Type[i] = Type[i];\\n            }\\n            Type1[i] = Type[i];\\n        }\\n        showSelectOptions({\\n            title: \\\"选择类型\\\",\\n            col: 2,\\n            options: Type1,\\n            js: $.toString(() => {\\n                storage0.setItem('type', input);\\n                var col = storage0.getItem('type', '');\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n                storage0.setItem('Col_media', Col);\\n                refreshPage();\\n            })\\n        });\\n        return \\\"hiker://empty\\\"\\n    })},{\\n    title: '搜索',\\n    js: $.toString(() => {\\n        return 'hiker://page/search';\\n    }),\\n},{\\n    title: '首页',\\n    js: $.toString(() => {\\n        refreshPage();\\n        return 'hiker://empty';\\n    }),\\n}, {\\n    title: '第' + MY_PAGE + '页',\\n    js: $.toString(() => {\\n        return 'hiker://empty';\\n    }),\\n}, {\\n    title: '跳转',\\n    js: $.toString(() => {\\n        return $('').input(() => {\\n            input = input;\\n            putMyVar('page', input);\\n            refreshPage();\\n        });\\n    }),\\n}, {\\n    title: nickName,\\n    js: $.toString((uuid) => {\\n        putMyVar('uuid', uuid);\\n        return 'hiker://page/user#immersiveTheme#';\\n    }, uuid),\\n}]\\nstorage0.getItem('longClick1', longClick1);\\n\\n//col_type文本显示样式\\nvar longClick2 = [{\\n    title: '样式',\\n    js: $.toString(() => {\\n        var Type = [\\\"movie_1\\\", \\\"movie_2\\\", \\\"movie_3\\\", \\\"movie_1_left_pic\\\", \\\"movie_1_vertical_pic\\\", \\\"movie_1_vertical_pic_blur\\\", \\\"pic_1\\\", \\\"pic_2\\\", \\\"pic_3\\\", \\\"pic_1_full\\\", \\\"pic_1_center\\\", \\\"pic_1_card\\\", \\\"pic_2_card\\\", \\\"pic_3_square\\\", \\\"card_pic_1\\\", \\\"card_pic_2\\\", \\\"card_pic_3\\\", \\\"card_pic_3_center\\\", \\\"long_text\\\", \\\"rich_text\\\", \\\"scroll_button\\\", \\\"flex_button\\\"];\\n        var Type1 = [];\\n        for (var i in Type) {\\n            var col = storage0.getItem('type', '');\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n            if (Type[i] == Col) {\\n                Type[i] = '👉🏽' + Type[i];\\n            } else {\\n                Type[i] = Type[i];\\n            }\\n            Type1[i] = Type[i];\\n        }\\n        showSelectOptions({\\n            title: \\\"选择类型\\\",\\n            col: 2,\\n            options: Type1,\\n            js: $.toString(() => {\\n                storage0.setItem('type', input);\\n                var col = storage0.getItem('type', '');\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n                storage0.setItem('Col_text', Col);\\n                refreshPage();\\n            })\\n        });\\n        return \\\"hiker://empty\\\"\\n    })\\n},{\\n    title: nickName,\\n    js: $.toString((uuid) => {\\n        putMyVar('uuid', uuid);\\n        return 'hiker://page/user#immersiveTheme#';\\n    }, uuid),\\n}]\\nstorage0.setItem('longClick2', longClick2);\\n\"},{\"col_type\":\"movie_3\",\"name\":\"⑨类型二_longClick\",\"path\":\"longClick2\",\"rule\":\"//col_type显示样式\\n[{\\n    title: '样式',\\n    js: $.toString(() => {\\n        var Type = [\\\"movie_1\\\", \\\"movie_2\\\", \\\"movie_3\\\", \\\"movie_1_left_pic\\\", \\\"movie_1_vertical_pic\\\", \\\"movie_1_vertical_pic_blur\\\", \\\"pic_1\\\", \\\"pic_2\\\", \\\"pic_3\\\", \\\"pic_1_full\\\", \\\"pic_1_center\\\", \\\"pic_1_card\\\", \\\"pic_2_card\\\", \\\"pic_3_square\\\", \\\"card_pic_1\\\", \\\"card_pic_2\\\", \\\"card_pic_3\\\", \\\"card_pic_3_center\\\", \\\"long_text\\\", \\\"rich_text\\\", \\\"scroll_button\\\", \\\"flex_button\\\"];\\n        var Type1 = [];\\n        for (var i in Type) {\\n            var col = storage0.getItem('type', '');\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n            if (Type[i] == Col) {\\n                Type[i] = '👉🏽' + Type[i];\\n            } else {\\n                Type[i] = Type[i];\\n            }\\n            Type1[i] = Type[i];\\n        }\\n        showSelectOptions({\\n            title: \\\"选择类型\\\",\\n            col: 2,\\n            options: Type1,\\n            js: $.toString(() => {\\n                storage0.setItem('type', input);\\n                var col = storage0.getItem('type', '');\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n                storage0.setItem('Col2', Col);\\n                refreshPage();\\n            })\\n        });\\n        return \\\"hiker://empty\\\"\\n    }),\\n}, {\\n    title: '搜索',\\n    js: $.toString(() => {\\n        return 'hiker://page/search';\\n    }),\\n},{\\n    title: '首页',\\n    js: $.toString(() => {\\n        refreshPage();\\n        return 'hiker://empty';\\n    }),\\n}, {\\n    title: '第' + MY_PAGE + '页',\\n    js: $.toString(() => {\\n        return 'hiker://empty';\\n    }),\\n}, {\\n    title: '跳转',\\n    js: $.toString(() => {\\n        return $('').input(() => {\\n            input = input;\\n            putMyVar('page', input);\\n            refreshPage();\\n        });\\n    }),\\n}, {\\n    title: nickName,\\n    js: $.toString((uuid) => {\\n        putMyVar('uuid', uuid);\\n        return 'hiker://page/user#immersiveTheme#';\\n    }, uuid),\\n}]\"},{\"col_type\":\"movie_3\",\"name\":\"⑨类型一_longClick\",\"path\":\"longClick1\",\"rule\":\"//col_type显示样式\\n[{\\n    title: '样式',\\n    js: $.toString(() => {\\n        var Type = [\\\"movie_1\\\", \\\"movie_2\\\", \\\"movie_3\\\", \\\"movie_1_left_pic\\\", \\\"movie_1_vertical_pic\\\", \\\"movie_1_vertical_pic_blur\\\", \\\"pic_1\\\", \\\"pic_2\\\", \\\"pic_3\\\", \\\"pic_1_full\\\", \\\"pic_1_center\\\", \\\"pic_1_card\\\", \\\"pic_2_card\\\", \\\"pic_3_square\\\", \\\"card_pic_1\\\", \\\"card_pic_2\\\", \\\"card_pic_3\\\", \\\"card_pic_3_center\\\", \\\"long_text\\\", \\\"rich_text\\\", \\\"scroll_button\\\", \\\"flex_button\\\"];\\n        var Type1 = [];\\n        for (var i in Type) {\\n            var col = storage0.getItem('type', '');\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n            if (Type[i] == Col) {\\n                Type[i] = '👉🏽' + Type[i];\\n            } else {\\n                Type[i] = Type[i];\\n            }\\n            Type1[i] = Type[i];\\n        }\\n        showSelectOptions({\\n            title: \\\"选择类型\\\",\\n            col: 2,\\n            options: Type1,\\n            js: $.toString(() => {\\n                storage0.setItem('type', input);\\n                var col = storage0.getItem('type', '');\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\n                storage0.setItem('Col1', Col);\\n                refreshPage();\\n            })\\n        });\\n        return \\\"hiker://empty\\\"\\n    }),\\n}, {\\n    title: '搜索',\\n    js: $.toString(() => {\\n        return 'hiker://page/search';\\n    }),\\n},{\\n    title: '首页',\\n    js: $.toString(() => {\\n        refreshPage();\\n        return 'hiker://empty';\\n    }),\\n}, {\\n    title: '第' + MY_PAGE + '页',\\n    js: $.toString(() => {\\n        return 'hiker://empty';\\n    }),\\n}, {\\n    title: '跳转',\\n    js: $.toString(() => {\\n        return $('').input(() => {\\n            input = input;\\n            putMyVar('page', input);\\n            refreshPage();\\n        });\\n    }),\\n}, {\\n    title: nickName,\\n    js: $.toString((uuid) => {\\n        putMyVar('uuid', uuid);\\n        return 'hiker://page/user#immersiveTheme#';\\n    }, uuid),\\n}]\"},{\"col_type\":\"movie_3\",\"name\":\"③页面-搜索\",\"path\":\"search\",\"rule\":\"js:\\nvar d = [];\\nsetPageTitle('搜索页');\\nvar rr = {\\n    \\\"code\\\": \\\"searchIndex\\\",\\n    \\\"mod\\\": \\\"index\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"timestamp\\\": 1.704546667806E12,\\n    \\\"version\\\": \\\"4.5.0\\\"\\n}\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar list = r.data.hotSearch;\\nvar list1 = r.data.hotTopic;\\nvar list2 = r.data.category[0].mvlist;\\nvar title2 = r.data.category[0].name;\\nvar desc2 = r.data.category[0].desc;\\n\\nd.push({\\n    title: '搜索',\\n    url: $.toString(() => {\\n        putVar('keyword', input);\\n        return 'hiker://page/search_result?fypage';\\n    }),\\n    col_type: 'input',\\n    extra: {\\n        defaultValue: getVar('keyword', ''),\\n        pageTitle: '搜索结果'\\n    }\\n});\\nd.push({\\n    col_type: 'big_blank_block',\\n    url: 'hiker://empty'\\n});\\n\\nd.push({\\n    title: $.require(\\\"data\\\").strongR('热搜榜', 'FF6699'),\\n    col_type: 'text_icon',\\n    url: 'hiker://empty'\\n});\\nfor (var i in list) {\\n    var title = list[i];\\n    d.push({\\n        title: title,\\n        col_type: 'flex_button',\\n        url: \\\"copy://\\\" + title\\n    });\\n}\\nd.push({\\n    col_type: 'big_blank_block',\\n    url: 'hiker://empty'\\n});\\n\\nd.push({\\n    title: $.require(\\\"data\\\").strongR('91热点', 'FF6699'),\\n    img: 'hiker://images/icon_right5',\\n    col_type: 'text_icon',\\n    url: 'hiker://page/search_hotTopics'\\n});\\nfor (var i in list1) {\\n    var title = list1[i].title;\\n    var id = list1[i].value;\\n    var num = Number(i) + 1;\\n    d.push({\\n        title: num + '.\\\\t' + title,\\n        col_type: 'text_1',\\n        url: 'hiker://page/search_hotTopics_detail',\\n        extra: {\\n            id: id,\\n            pageTitle: '详情'\\n      }\\n    });\\n}\\nd.push({\\n    col_type: 'big_blank_block',\\n    url: 'hiker://empty'\\n});\\n\\nd.push({\\n    title: desc2 + title2,\\n    col_type: 'text_icon',\\n    url: 'hiker://empty'\\n});\\nfor (var i in list2) {\\n    var title = list2[i].title;\\n    var playUrl = list2[i].playUrl;\\n    var nickName = list2[i].nickName;\\n    var uuid = list2[i].uuid;\\n    var desc = '🔥' + list2[i].play_count + '\\\\t' + list2[i].durationStr;\\n    var imageurl = list2[i].thumbImg;\\n    d.push({\\n        title: title,\\n        desc: desc,\\n        img: imageurl + image,\\n        col_type: 'movie_3',\\n        url: playUrl.replace('10play', 'long'),\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"③页面-搜索_结果\",\"path\":\"search_result\",\"rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar Page = getMyVar('page', '0');\\nvar typeSlist = [{\\n    title: '短视频',\\n    type: '1'\\n}, {\\n    title: '合集',\\n    type: '5'\\n}, {\\n    title: '帖子',\\n    type: '3'\\n}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"data\\\").Category(typeSlist,1,d);\\n}\\nvar rr = {\\n    \\\"code\\\": \\\"search\\\",\\n    \\\"type\\\": getMyVar('typeS', '1'),\\n    \\\"key\\\": getVar('keyword', ''),\\n    \\\"mod\\\": \\\"index\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"page\\\": (Page == 0) ? page : Page,\\n    \\\"timestamp\\\": 1.704546667806E12,\\n    \\\"version\\\": \\\"4.5.0\\\"\\n}\\nclearMyVar('page');\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar list = r.data;\\nif (r.status == 0) {\\n    toast(r.msg);\\n    back();\\n} else if (list == '') {\\n    d.push({\\n        title: '没有更多内容!',\\n        url: 'toast://🏀你干嘛~',\\n        col_type: 'text_1'\\n    });\\n\\n} else if(getMyVar('typeS', '1')==1){\\n    for (var i in list) {\\n        var playurl = list[i].playUrl;\\n        var title = list[i].title;\\n        var nickName = list[i].nickName;\\n        var uuid = list[i].uuid;\\n        var desc = '\\\\t🔥' + list[i].play_count + '\\\\t⏱️' + list[i].durationStr;\\n        var imageurl = list[i].thumbImg;\\n        eval(JSON.parse(request('hiker://page/longClick')).rule)\\n        d.push({\\n            title: title,\\n            desc: desc,\\n            img: imageurl + image,\\n            col_type: (storage0.getItem('Col_media', '') == '') ? 'movie_2' : storage0.getItem('Col_media', ''),\\n            url: playurl.replace('10play', 'long'),\\n            extra: {\\n                longClick: longClick1\\n            }\\n        });\\n    }\\n} else if(getMyVar('typeS', '3')==3){\\nfor (var i in list) {\\n    var id = list[i].id;\\n    var title = list[i].content;\\n    var desc = list[i].created_at + '发布\\\\t\\\\t' + list[i].view_num + '浏览\\\\t\\\\t' + list[i].like_num + '点赞';\\n    d.push({\\n        title: title,\\n        desc: desc,\\n        col_type: 'text_1',\\n        url: 'hiker://page/newsdetail',\\n        extra: {\\n            news_id: id,\\n            mod: \\\"news\\\",\\n            code: \\\"detail_v1\\\",\\n            pageTitle: \\\"帖子详情\\\"\\n        }\\n    });\\n}\\n} else{\\n      toast('增加功能的机会来了！');\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"③页面-搜索_91热点\",\"path\":\"search_hotTopics\",\"rule\":\"js:\\nvar d = [];\\nvar rr = {\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"version\\\": \\\"4.5.0\\\",\\n    \\\"mod\\\": \\\"category\\\",\\n    \\\"code\\\": \\\"hotTopics\\\",\\n    \\\"timestamp\\\": 1.704546667806E12\\n}\\n\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar list = r.data.list;\\nfor (var i in list) {\\n    var id = list[i].value;\\n    var title = list[i].title;\\n    var img = list[i].img_url;\\n    var desc = list[i].updated_at + '🔥\\\\t\\\\t'+[i].hot_num  + '🏷️\\\\t\\\\t'+ list[i].tags_name;\\n    d.push({\\n        title: title,\\n        desc: '0',\\n        img: img + image,\\n        col_type: 'card_pic_1',\\n        url: 'hiker://page/search_hotTopics_detail',\\n        extra: {\\n            id: id,\\n            pageTitle: \\\"详情\\\"\\n        }\\n    });\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"③页面-搜索_91热点_二级\",\"path\":\"search_hotTopics_detail\",\"rule\":\"js:\\nvar d = [];\\nvar id = MY_PARAMS.id;\\nvar rr = {\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"id\\\": id,\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"version\\\": \\\"4.5.0\\\",\\n    \\\"mod\\\": \\\"index\\\",\\n    \\\"code\\\": \\\"detail_v1\\\",\\n    \\\"timestamp\\\": 1.704546667806E12\\n}\\n\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar data = r.data;\\nvar title = data.title;\\nvar playUrl = data.playUrl;\\nvar previewUrl = data.previewUrl;\\nvar playurl = (playUrl!='')?playUrl:previewUrl;\\nvar thumbImg = data.thumbImg;\\nvar tags = data.tags;\\nvar created_at = data.created_at;\\nvar play_count = data.play_count;\\nvar like = data.like;var like = data.like;\\nvar comment = data.comment;\\nvar durationStr = data.durationStr;\\nvar nickName = data.nickName;\\nvar uuid = data.uuid;\\nvar medialist = data.recommend; //精彩视频\\nvar comment_list = data.commentList; //评论\\n\\nd.push({\\n        title: title,\\n        desc: '0',\\n        img: thumbImg + image,\\n        url: playurl.replace('10play', 'long'),\\n        col_type: 'card_pic_1'\\n});\\nd.push({\\n        title: '‘‘’’<small>' +'发布时间:'+created_at+'\\\\t\\\\tUP主:'+nickName+'\\\\n🏷️'+tags+'\\\\t\\\\t时长'+durationStr+'\\\\n🔥'+play_count+'\\\\t\\\\t❤️'+like+'\\\\t\\\\t✍🏽️'+comment+'</small>',\\n        url: 'hiker://empty',\\n        col_type: 'text_center_1'\\n});\\nd.push({\\n            col_type: 'big_blank_block',\\n            url: 'hiker://empty'\\n        });\\nvar typeSSlist = [{\\n    title: '精彩视频',\\n    type: '1'\\n}, {\\n    title: '评论'+comment,\\n    type: '0'\\n}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"data\\\").Category(typeSSlist,2,d);\\n}\\nif(getMyVar('typeSS', '1')==0){\\nd.push({\\n        title: '全部评论\\\\t('+comment+')',\\n        url: 'hiker://empty',\\n        col_type: 'text_1'\\n});\\nfor (var i in comment_list) {\\n    var nickname = comment_list[i].nickName;\\n    var sexType = comment_list[i].sexType;\\n    var sex = (sexType == '0') ? '\\\\t👩🏽\\\\t' : '\\\\t👨🏽\\\\t';\\n    var created_at = comment_list[i].created_at;\\n    var comment = comment_list[i].comment;\\n    var thumb = comment_list[i].thumb;\\n    d.push({\\n        title: nickname + sex,\\n        desc: created_at,\\n        img: thumb + image,\\n        url: 'hiker://empty',\\n        col_type: 'avatar'\\n    });\\n    d.push({\\n        title: comment,\\n        url: 'hiker://empty',\\n        col_type: 'text_1'\\n    });\\n}\\n} else {\\nfor (var i in medialist) {\\n    var id = medialist[i].id;\\n    var title = medialist[i].title;\\n    var img = medialist[i].thumbImg;\\n    //var playUrl = medialist[i].playUrl;\\n    d.push({\\n        title: title,\\n        img: img + image,\\n        col_type: 'movie_2',\\n        url: 'hiker://page/search_hotTopics_detail',\\n        extra: {\\n            id: id,\\n            pageTitle: \\\"详情\\\"\\n        }\\n    });\\n}\\n}\\nsetResult(d);\"}],\"params\":\"{\\\"defaultValue\\\":\\\"\\\",\\\"pageTitle\\\":\\\"搜索结果\\\"}\",\"saved\":false,\"title\":\"摸鱼日报\",\"version\":0,\"url\":\"hiker://page/search_result?fypage\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar d = [];\\nvar page = MY_PAGE;\\nvar Page = getMyVar('page', '0');\\nvar typeSlist = [{\\n    title: '短视频',\\n    type: '1'\\n}, {\\n    title: '合集',\\n    type: '5'\\n}, {\\n    title: '帖子',\\n    type: '3'\\n}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"data\\\").Category(typeSlist,1,d);\\n}\\nvar rr = {\\n    \\\"code\\\": \\\"search\\\",\\n    \\\"type\\\": getMyVar('typeS', '1'),\\n    \\\"key\\\": getVar('keyword', ''),\\n    \\\"mod\\\": \\\"index\\\",\\n    \\\"oauth_id\\\": \\\"gynUGtLvSDhkKAsg1704513789286\\\",\\n    \\\"oauth_type\\\": \\\"pwa\\\",\\n    \\\"page\\\": (Page == 0) ? page : Page,\\n    \\\"timestamp\\\": 1.704546667806E12,\\n    \\\"version\\\": \\\"4.5.0\\\"\\n}\\nclearMyVar('page');\\nvar encryptdata = $.require(\\\"data\\\").encrypt(rr);\\n\\nvar timestamp = encryptdata.timestamp.toString();\\nvar data = encryptdata.data;\\nvar sign = encryptdata.sign;\\n\\nvar Data = post(\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\", {\\n    body: {\\n        \\\"client\\\": \\\"pwa\\\",\\n        \\\"timestamp\\\": timestamp,\\n        \\\"data\\\": data,\\n        \\\"sign\\\": sign\\n    }\\n})\\nvar h = Data;\\n\\nlet image = $().image(() => $.require(\\\"data?rule=\\\" + MY_TITLE).decrypt());\\n\\nvar data = JSON.parse(h).data;\\nvar r = $.require(\\\"data\\\").Decrypt(data);\\nvar list = r.data;\\nif (r.status == 0) {\\n    toast(r.msg);\\n    back();\\n} else if (list == '') {\\n    d.push({\\n        title: '没有更多内容!',\\n        url: 'toast://🏀你干嘛~',\\n        col_type: 'text_1'\\n    });\\n\\n} else if(getMyVar('typeS', '1')==1){\\n    for (var i in list) {\\n        var playurl = list[i].playUrl;\\n        var title = list[i].title;\\n        var nickName = list[i].nickName;\\n        var uuid = list[i].uuid;\\n        var desc = '\\\\t🔥' + list[i].play_count + '\\\\t⏱️' + list[i].durationStr;\\n        var imageurl = list[i].thumbImg;\\n        eval(JSON.parse(request('hiker://page/longClick')).rule)\\n        d.push({\\n            title: title,\\n            desc: desc,\\n            img: imageurl + image,\\n            col_type: (storage0.getItem('Col_media', '') == '') ? 'movie_2' : storage0.getItem('Col_media', ''),\\n            url: playurl.replace('10play', 'long'),\\n            extra: {\\n                longClick: longClick1\\n            }\\n        });\\n    }\\n} else if(getMyVar('typeS', '3')==3){\\nfor (var i in list) {\\n    var id = list[i].id;\\n    var title = list[i].content;\\n    var desc = list[i].created_at + '发布\\\\t\\\\t' + list[i].view_num + '浏览\\\\t\\\\t' + list[i].like_num + '点赞';\\n    d.push({\\n        title: title,\\n        desc: desc,\\n        col_type: 'text_1',\\n        url: 'hiker://page/newsdetail',\\n        extra: {\\n            news_id: id,\\n            mod: \\\"news\\\",\\n            code: \\\"detail_v1\\\",\\n            pageTitle: \\\"帖子详情\\\"\\n        }\\n    });\\n}\\n} else{\\n      toast('增加功能的机会来了！');\\n}\\nsetResult(d);\",\"group\":\"③深夜\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"依赖\\\",\\\"path\\\":\\\"data\\\",\\\"rule\\\":\\\"js:\\\\n$.exports.decrypt = function() {\\\\n    const CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n    const key = CryptoUtil.Data.parseUTF8('f5d965df75336270');\\\\n    const iv = CryptoUtil.Data.parseUTF8('97b60394abc2fbe1');\\\\n    const textData = CryptoUtil.Data.parseInputStream(input).toBase64(_base64.NO_WRAP);\\\\n    const decrypted = CryptoUtil.AES.decrypt(textData, key, {\\\\n        iv: iv,\\\\n        mode: \\\\\\\"AES/CBC/NoPadding\\\\\\\"\\\\n    }).toBase64(_base64.NO_WRAP);\\\\n    const decrypted0 = CryptoUtil.Data.parseBase64(decrypted, _base64.NO_WRAP);\\\\n    return decrypted0.toInputStream();\\\\n}\\\\n\\\\nfunction Decrypt(data) {\\\\n    eval(getCryptoJS());\\\\n    const _0x40982e = CryptoJS.enc.Hex.parse(data),\\\\n        key = CryptoJS.enc.Utf8.parse('cc88ddc9357ff461e08f047aedee692b'),\\\\n        iv = CryptoJS.enc.Utf8.parse('e89225cfbbimgkcu'),\\\\n        _0x439cae = CryptoJS.enc.Base64.stringify(_0x40982e),\\\\n        _0x385d37 = CryptoJS.AES.decrypt(_0x439cae, key, {\\\\n            'iv': iv,\\\\n            'mode': CryptoJS.mode.CFB,\\\\n            'padding': CryptoJS.pad.NoPadding\\\\n        });\\\\n    const _0x27056b = _0x385d37.toString(CryptoJS.enc.Utf8);\\\\n    return JSON.parse(_0x27056b.toString());\\\\n}\\\\n\\\\nfunction decryptsign(dd) {\\\\n    const CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n    const Data = \\\\\\\"client=pwa&data=\\\\\\\" + dd.data + \\\\\\\"&timestamp=\\\\\\\" + dd.timestamp + \\\\\\\"cc88ddc9357ff461e08f047aedee692b\\\\\\\";\\\\n    const utt8Data = CryptoUtil.Data.parseUTF8(Data);\\\\n    const sha256 = utt8Data.toDigest().sha256();\\\\n    const sign = md5(sha256);\\\\n    return sign;\\\\n}\\\\n\\\\nfunction encrypt(_0x3ae9ac) {\\\\n    eval(getCryptoJS());\\\\n    const key = CryptoJS.enc.Utf8.parse('cc88ddc9357ff461e08f047aedee692b');\\\\n    const iv = CryptoJS.enc.Utf8.parse('e89225cfbbimgkcu');\\\\n    _0x3ae9ac = \\\\\\\"object\\\\\\\" == typeof _0x3ae9ac ? JSON.stringify(_0x3ae9ac) : _0x3ae9ac;\\\\n    let _0x7927ae = CryptoJS.enc.Utf8.parse(_0x3ae9ac),\\\\n        _0x2e2910 = CryptoJS.AES.encrypt(_0x7927ae, key, {\\\\n            'iv': iv,\\\\n            'mode': CryptoJS.mode.CFB,\\\\n            'padding': CryptoJS.pad.NoPadding\\\\n        });\\\\n    const data = _0x2e2910.ciphertext.toString().toUpperCase(),\\\\n        _0x49cb52 = new Date().getTime() / 1000,\\\\n        timestamp = parseInt(_0x49cb52.toString()),\\\\n        sign = decryptsign({\\\\n            'client': \\\\\\\"pwa\\\\\\\",\\\\n            'data': data,\\\\n            'timestamp': timestamp\\\\n        });\\\\n    return {\\\\n        'client': \\\\\\\"pwa\\\\\\\",\\\\n        'sign': sign,\\\\n        'timestamp': timestamp,\\\\n        'data': data\\\\n    };\\\\n}\\\\n\\\\nfunction strong(d, c) {\\\\n    return '‘‘’’<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\\\n}\\\\n\\\\nfunction strongR(d, c) {\\\\n    return '<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\\\n}\\\\n\\\\nfunction Category(list, mode, d) {\\\\n    for (var i in list) {\\\\n        var List = list[i];\\\\n        var title = List.title;\\\\n        var Title = (getMyVar('color', '-1') == i) ? strong(title, 'FF6699') : title;\\\\n        d.push({\\\\n            title: Title,\\\\n            url: $(List.type).lazyRule((i, mode, List) => {\\\\n                if (mode == 0) {\\\\n                    putMyVar('type', input);\\\\n                } else if (mode == 1) {\\\\n                    putMyVar('typeS', input);\\\\n                } else if (mode == 2) {\\\\n                    putMyVar('typeSS', input);\\\\n                }\\\\n                putMyVar('color', i);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            }, i, mode, List),\\\\n            col_type: 'flex_button'\\\\n        });\\\\n    }\\\\n    d.push({\\\\n        col_type: 'blank_block',\\\\n    });\\\\n    return d;\\\\n}\\\\n\\\\nfunction category(list, d) {\\\\n    if (getItem('switch', 'off') == 'on') {\\\\n        for (var i in list) {\\\\n            var List = list[i];\\\\n            var title = List.name;\\\\n            var Title = (getMyVar('Color', '-1') == i) ? strong(title, 'FF6699') : title;\\\\n            if (List.id == '6' || List.id == '2') {\\\\n\\\\n            } else if (List.id == '4' || List.id == '7') {\\\\n                d.push({\\\\n                    title: Title,\\\\n                    url: $(List.id).lazyRule((i, List) => {\\\\n                        putMyVar('id', input);\\\\n                        putMyVar('Color', i);\\\\n                        refreshPage();\\\\n                        return 'hiker://page/type1?fypage';\\\\n                    }, i, List),\\\\n                    col_type: 'scroll_button'\\\\n                });\\\\n            } else {\\\\n                d.push({\\\\n                    title: Title,\\\\n                    url: $(List.id).lazyRule((i, List) => {\\\\n                        putMyVar('id', input);\\\\n                        putMyVar('Color', i);\\\\n                        refreshPage();\\\\n                        return 'hiker://page/type2?fypage';\\\\n                    }, i, List),\\\\n                    col_type: 'scroll_button'\\\\n                });\\\\n            }\\\\n        }\\\\n    }\\\\n    /*d.push({\\\\n        title: '🔒',\\\\n        url: $('').lazyRule(() => {\\\\n            putMyVar('on-off', 'off')\\\\n            refreshPage();\\\\n            return 'hiker://empty';\\\\n        }),\\\\n        col_type: 'flex_button'\\\\n    });*/\\\\n    d.push({\\\\n        title: (getItem('switch', 'off') == 'off') ? '📁' : '📂',\\\\n        url: $('').lazyRule(() => {\\\\n            if (getItem('switch', 'off') == 'off') {\\\\n                setItem('switch', 'on');\\\\n            } else {\\\\n                setItem('switch', 'off');\\\\n            }\\\\n            refreshPage();\\\\n            return 'hiker://empty';\\\\n        }),\\\\n        col_type: 'flex_button'\\\\n    });\\\\n    d.push({\\\\n        title: '🔍',\\\\n        url: 'hiker://page/search',\\\\n        col_type: 'flex_button'\\\\n    });\\\\n    return d;\\\\n}\\\\n\\\\n$.exports.Category = Category;\\\\n$.exports.category = category;\\\\n$.exports.strongR = strongR;\\\\n$.exports.strong = strong;\\\\n$.exports.encrypt = encrypt;\\\\n$.exports.Decrypt = Decrypt;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"①页面-类型一\\\",\\\"path\\\":\\\"type1\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar page = MY_PAGE;\\\\nvar Page = getMyVar('page', '0');\\\\n//var id = MY_PARAMS.id;\\\\n//var col_type = MY_PARAMS.col_type;\\\\nvar id = getMyVar('id');\\\\nif (id == '7') {\\\\n    id = '22';\\\\n} else if (id == '4') {\\\\n    id = '33';\\\\n}\\\\nvar rr = {\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"getElementItembyId\\\\\\\",\\\\n    \\\\\\\"id\\\\\\\": id,\\\\n    \\\\\\\"limit\\\\\\\": 12,\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"element\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"page\\\\\\\": (Page == 0) ? page : Page,\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12,\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\"\\\\n}\\\\nclearMyVar('page');\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\nlog(encryptdata)\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\n\\\\nvar list = r.data.list;\\\\nfor (var i in list) {\\\\n    var playurl = list[i].playUrl;\\\\n    var title = list[i].title;\\\\n    var nickName = list[i].nickName;\\\\n    var uuid = list[i].uuid;\\\\n    var desc = '\\\\\\\\t🆙' + list[i].created_at + '\\\\\\\\t🔥' + list[i].play_count + '\\\\\\\\t🏷️' + nickName + '\\\\\\\\t⏱️' + list[i].durationStr;\\\\n    var imageurl = list[i].thumbImg;\\\\n    d.push({\\\\n        title: title,\\\\n        desc: desc,\\\\n        img: imageurl + image,\\\\n        col_type: (storage0.getItem('Col1', '') == '') ? 'pic_1_card' : storage0.getItem('Col1', ''),\\\\n        url: playurl.replace('10play', 'long'),\\\\n        extra: {\\\\n            longClick: eval(JSON.parse(request('hiker://page/longClick1')).rule)\\\\n        }\\\\n    });\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"②页面-用户-全部页\\\",\\\"path\\\":\\\"userlist\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar page = MY_PAGE;\\\\nvar mod = MY_PARAMS.mod;\\\\nvar code = MY_PARAMS.code;\\\\nvar col_type = MY_PARAMS.col_type;\\\\nvar rr = {\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\",\\\\n    \\\\\\\"mod\\\\\\\": mod,\\\\n    \\\\\\\"code\\\\\\\": code,\\\\n    \\\\\\\"page\\\\\\\": page,\\\\n    \\\\\\\"limit\\\\\\\": 21,\\\\n    \\\\\\\"uuid\\\\\\\": getMyVar('uuid', ''),\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12\\\\n}\\\\n\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nif (mod == \\\\\\\"club\\\\\\\") {\\\\n    var list = r.data.item;\\\\n} else if (mod == \\\\\\\"user\\\\\\\") {\\\\n    var list = r.data;\\\\n}\\\\nfor (var i in list) {\\\\n    var playurl = list[i].playUrl;\\\\n    var title = list[i].title;\\\\n    var desc = '\\\\\\\\t🔥' + list[i].play_count;\\\\n    var imageurl = list[i].thumbImg;\\\\n    var nickName = list[i].nickName;\\\\n    var uuid = list[i].uuid;\\\\neval(JSON.parse(request('hiker://page/longClick')).rule)\\\\n    d.push({\\\\n        title: title,\\\\n        desc: desc,\\\\n        img: imageurl + image,\\\\n        col_type: (storage0.getItem('Col_media', '') == '') ? col_type : storage0.getItem('Col_media', ''),\\\\n        url: playurl.replace('10play', 'long'),\\\\n        extra: {\\\\n            longClick: longClick1\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"②页面-用户-预览页\\\",\\\"path\\\":\\\"user\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nsetPageTitle('UP主页');\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\nvar col_type = MY_PARAMS.col_type;\\\\n\\\\n//用户数据+帖子板块\\\\nvar rr = {\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\",\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"user\\\\\\\",\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"other\\\\\\\",\\\\n    \\\\\\\"uuid\\\\\\\": getMyVar('uuid', ''),\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12\\\\n}\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar list = r.data;\\\\n\\\\nvar club_video_count = list.club_video_count;\\\\nvar videosCount = list.videosCount;\\\\nvar likesCount = list.likesCount;\\\\n\\\\nif (list != '' && list != null && MY_PAGE == 1) {\\\\n    d.push({\\\\n        col_type: 'movie_1_vertical_pic_blur',\\\\n        title: '👩🏿‍🦲' + list.nickname,\\\\n        desc: list.fans + '粉丝\\\\\\\\t\\\\\\\\t' + list.followed + '关注\\\\\\\\t\\\\\\\\t' + list.fabulous + '被赞\\\\\\\\n' + '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t' + list.news_num + '帖子\\\\\\\\n' + '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t点击👆🏿前往',\\\\n        img: list.thumb + image,\\\\n        url: 'hiker://page/news?fypage',\\\\n        extra: {\\\\n            mod: \\\\\\\"news\\\\\\\",\\\\n            code: \\\\\\\"target_news\\\\\\\",\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n            pageTitle: '帖子'\\\\n        }\\\\n    });\\\\n    d.push({\\\\n        col_type: 'big_blank_block',\\\\n        url: 'hiker://empty'\\\\n    });\\\\n}\\\\n\\\\n//他人主页子板块\\\\nvar Typelist = [\\\\n{title: '粉丝团专属', count: club_video_count , col_type:  'text_icon', mod: 'club',code: 'videos'},\\\\n{title: 'Ta的作品', count: videosCount , col_type:  'text_icon', mod: 'user', code: 'videos'},\\\\n{title: 'Ta的喜欢', count: likesCount , col_type:  'text_icon', mod: 'user', code: 'likes'}\\\\n];\\\\nfor (var i in Typelist) {\\\\n    var rr = {\\\\n        \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n        \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\",\\\\n        \\\\\\\"mod\\\\\\\": Typelist[i].mod,\\\\n        \\\\\\\"code\\\\\\\": Typelist[i].code,\\\\n        \\\\\\\"page\\\\\\\": 1,\\\\n        \\\\\\\"limit\\\\\\\": 3,\\\\n        \\\\\\\"uuid\\\\\\\": getMyVar('uuid', ''),\\\\n        \\\\\\\"timestamp\\\\\\\": 1.704546667806E12\\\\n    }\\\\n    var encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n    var timestamp = encryptdata.timestamp.toString();\\\\n    var data = encryptdata.data;\\\\n    var sign = encryptdata.sign;\\\\n    var Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n        body: {\\\\n            \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n            \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n            \\\\\\\"data\\\\\\\": data,\\\\n            \\\\\\\"sign\\\\\\\": sign\\\\n        }\\\\n    })\\\\n    var h = Data;\\\\n    var data = JSON.parse(h).data;\\\\n    var r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\n    if (Typelist[i].mod == \\\\\\\"club\\\\\\\") {\\\\n        var list = r.data.item;\\\\n    } else if (Typelist[i].mod == \\\\\\\"user\\\\\\\") {\\\\n        var list = r.data;\\\\n    }\\\\n    if (list != '' && list != null && MY_PAGE == 1) {\\\\n        d.push({\\\\n            col_type: Typelist[i].col_type,\\\\n            title: $.require(\\\\\\\"data\\\\\\\").strongR(Typelist[i].title + Typelist[i].count + '部', 'FF6699'),\\\\n            img: 'hiker://images/icon_right5',\\\\n            url: 'hiker://page/userlist?fypage',\\\\n            extra: {\\\\n                mod: Typelist[i].mod,\\\\n                code: Typelist[i].code,\\\\n                pageTitle: Typelist[i].title\\\\n            }\\\\n        });\\\\n        for (var j in list) {\\\\n            var playurl = list[j].playUrl;\\\\n            var title = list[j].title;\\\\n            var desc = '\\\\\\\\t🔥' + list[j].play_count;\\\\n            var imageurl = list[j].thumbImg;\\\\n            d.push({\\\\n                title: title,\\\\n                desc: desc,\\\\n                img: imageurl + image,\\\\n                col_type: col_type,\\\\n                url: playurl.replace('10play', 'long')\\\\n            });\\\\n        }\\\\n        d.push({\\\\n            col_type: 'big_blank_block',\\\\n            url: 'hiker://empty'\\\\n        });\\\\n    }\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"②页面-用户-帖子列表\\\",\\\"path\\\":\\\"news\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar page = MY_PAGE;\\\\nvar mod = MY_PARAMS.mod;\\\\nvar code = MY_PARAMS.code;\\\\nvar col_type = MY_PARAMS.col_type;\\\\nvar rr = {\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\",\\\\n    \\\\\\\"mod\\\\\\\": mod,\\\\n    \\\\\\\"code\\\\\\\": code,\\\\n    \\\\\\\"page\\\\\\\": page,\\\\n    \\\\\\\"limit\\\\\\\": 15,\\\\n    \\\\\\\"target_uuid\\\\\\\": getMyVar('uuid', ''),\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12\\\\n}\\\\n\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar list = r.data;\\\\nfor (var i in list) {\\\\n    var id = list[i].id;\\\\n    var title = list[i].content;\\\\n    var desc = list[i].created_at + '发布\\\\\\\\t\\\\\\\\t' + list[i].view_num + '浏览\\\\\\\\t\\\\\\\\t' + list[i].like_num + '点赞';\\\\n    d.push({\\\\n        title: title,\\\\n        desc: desc,\\\\n        col_type: col_type,\\\\n        url: 'hiker://page/newsdetail',\\\\n        extra: {\\\\n            news_id: id,\\\\n            mod: \\\\\\\"news\\\\\\\",\\\\n            code: \\\\\\\"detail_v1\\\\\\\",\\\\n            pageTitle: \\\\\\\"帖子详情\\\\\\\"\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"②页面-用户-帖子详情\\\",\\\"path\\\":\\\"newsdetail\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar page = MY_PAGE;\\\\nvar mod = MY_PARAMS.mod;\\\\nvar code = MY_PARAMS.code;\\\\nvar news_id = MY_PARAMS.news_id;\\\\nvar rr = {\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\",\\\\n    \\\\\\\"mod\\\\\\\": mod,\\\\n    \\\\\\\"code\\\\\\\": code,\\\\n    \\\\\\\"news_id\\\\\\\": news_id,\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12\\\\n}\\\\n\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar detail = r.data.detail;\\\\nvar comment_list = r.data.comment_list;\\\\nvar title = detail.title;\\\\nvar created_at = detail.created_at;\\\\nvar content = detail.content;\\\\nvar medialist = detail.medias;\\\\nvar comment_num = detail.comment_num;\\\\nvar nickName = detail.nickname;\\\\nvar uuid = detail.uuid;\\\\neval(JSON.parse(request('hiker://page/longClick')).rule)\\\\n//标题\\\\nd.push({\\\\n    title: '发布于:' + created_at + '\\\\\\\\t✍🏽️' + title,\\\\n    url: 'hiker://empty',\\\\n    col_type: 'rich_text',\\\\n});\\\\n\\\\n//正文\\\\nd.push({\\\\n    title: content,\\\\n    url: 'hiker://empty',\\\\n    col_type: 'rich_text',\\\\n});\\\\n\\\\n//视频\\\\nfor (var i in medialist) {\\\\n    var imageurl = medialist[i].media_url;\\\\n    if (imageurl.includes('m3u8')) {\\\\n        d.push({\\\\n            title: '视频▶️' + i,\\\\n            url: imageurl,\\\\n            col_type: 'text_3',\\\\n        });\\\\n    }\\\\n}\\\\n\\\\n//图片\\\\nfor (var i in medialist) {\\\\n    var imageurl = medialist[i].media_url;\\\\n    if (!imageurl.includes('m3u8')) {\\\\n        d.push({\\\\n            img: imageurl + image,\\\\n            url: imageurl + image,\\\\n            col_type: (storage0.getItem('Col_text', '') == '') ? 'pic_1_full' : storage0.getItem('Col_text', ''),\\\\n            extra: {\\\\n                longClick: longClick2\\\\n            }\\\\n        });\\\\n    }\\\\n}\\\\n\\\\n//评论区\\\\nd.push({\\\\n    title: '全部评论\\\\\\\\t(' + comment_num + ')',\\\\n    url: 'hiker://empty',\\\\n    col_type: 'text_1',\\\\n});\\\\nfor (var i in comment_list) {\\\\n    var nickname = comment_list[i].nickname;\\\\n    var sexType = comment_list[i].sexType;\\\\n    var sex = (sexType == '0') ? '\\\\\\\\t👩🏽\\\\\\\\t' : '\\\\\\\\t👨🏽\\\\\\\\t';\\\\n    var cityname = comment_list[i].cityname;\\\\n    var created_at = comment_list[i].created_at;\\\\n    var comment = comment_list[i].comment;\\\\n    var thumb = comment_list[i].thumb;\\\\n    d.push({\\\\n        title: nickname + sex,\\\\n        desc: cityname + '·\\\\\\\\t' + created_at,\\\\n        img: thumb + image,\\\\n        url: 'hiker://empty',\\\\n        col_type: 'avatar'\\\\n    });\\\\n    d.push({\\\\n        title: comment,\\\\n        url: 'hiker://empty',\\\\n        col_type: 'text_1'\\\\n    });\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"①页面-类型二\\\",\\\"path\\\":\\\"type2\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar page = MY_PAGE;\\\\nvar Page = getMyVar('page', '0');\\\\nvar id = getMyVar('id');\\\\nvar rr = {\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"getConstructById\\\\\\\",\\\\n    \\\\\\\"id\\\\\\\": id,\\\\n    \\\\\\\"limit\\\\\\\": 12,\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"element\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"page\\\\\\\": (Page == 0) ? page : Page,\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12,\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\"\\\\n}\\\\nclearMyVar('page');\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar List = r.data;\\\\nfor (var i in List) {\\\\n    var title = List[i].title;\\\\n    var id = List[i].id;\\\\n    var list = List[i].list;\\\\n    if (!title.includes('banner')) {\\\\n        d.push({\\\\n            col_type: 'text_icon',\\\\n            title: $.require(\\\\\\\"data\\\\\\\").strongR(title, 'FF6699'),\\\\n            img: 'hiker://images/icon_right5',\\\\n            url: 'hiker://page/playlist?fypage',\\\\n            extra: {\\\\n                id: id,\\\\n                pageTitle: title\\\\n            }\\\\n        });\\\\n        for (var i in list) {\\\\n            var title = list[i].title;\\\\n            var playUrl = list[i].playUrl;\\\\n            var nickName = list[i].nickName;\\\\n            var uuid = list[i].uuid;\\\\n            var desc = '🔥' + list[i].play_count + '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t⏱️' + list[i].durationStr;\\\\n            var imageurl = list[i].thumbImg;\\\\n            d.push({\\\\n                title: title,\\\\n                desc: desc,\\\\n                img: imageurl + image,\\\\n                col_type: (storage0.getItem('Col2', '') == '') ? 'movie_2' : storage0.getItem('Col2', ''),\\\\n                url: playUrl.replace('10play', 'long'),\\\\n                extra: {\\\\n                    longClick: eval(JSON.parse(request('hiker://page/longClick2')).rule)\\\\n                }\\\\n            });\\\\n        }\\\\n        d.push({\\\\n            col_type: 'big_blank_block',\\\\n            url: 'hiker://empty'\\\\n        });\\\\n    }\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"①页面-类型二_二级\\\",\\\"path\\\":\\\"playlist\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar page = MY_PAGE;\\\\nvar Page = getMyVar('page', '0');\\\\nvar id = MY_PARAMS.id;\\\\nvar typelist = [{\\\\n    title: '最新',\\\\n    type: 'new'\\\\n}, {\\\\n    title: '最热',\\\\n    type: 'hot'\\\\n}];\\\\n\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"data\\\\\\\").Category(typelist,0,d);\\\\n}\\\\nvar rr = {\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"getElementItembyId\\\\\\\",\\\\n    \\\\\\\"id\\\\\\\": id,\\\\n    \\\\\\\"limit\\\\\\\": 12,\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"element\\\\\\\",\\\\n    \\\\\\\"type\\\\\\\": getMyVar('type', 'new'),\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"page\\\\\\\": (Page == 0) ? page : Page,\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12,\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\"\\\\n}\\\\nclearMyVar('page');\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\n\\\\nvar list = r.data.list;\\\\nfor (var i in list) {\\\\n    var playurl = list[i].playUrl;\\\\n    var title = list[i].title;\\\\n    var nickName = list[i].nickName;\\\\n    var uuid = list[i].uuid;\\\\n    var desc = '\\\\\\\\t🔥' + list[i].play_count + '\\\\\\\\t⏱️' + list[i].durationStr;\\\\n    var imageurl = list[i].thumbImg; eval(JSON.parse(request('hiker://page/longClick')).rule)\\\\n    d.push({\\\\n        title: title,\\\\n        desc: desc,\\\\n        img: imageurl + image,\\\\n        col_type: (storage0.getItem('Col_media', '') == '') ? 'movie_2' : storage0.getItem('Col_media', ''),\\\\n        url: playurl.replace('10play', 'long'),\\\\n        extra: { \\\\n            longClick: longClick1\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"⑨全部页_longClick\\\",\\\"path\\\":\\\"longClick\\\",\\\"rule\\\":\\\"//col_type媒体显示样式\\\\nvar longClick1 = [{\\\\n    title: '样式',\\\\n    js: $.toString(() => {\\\\n        var Type = [\\\\\\\"movie_1\\\\\\\", \\\\\\\"movie_2\\\\\\\", \\\\\\\"movie_3\\\\\\\", \\\\\\\"movie_1_left_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic_blur\\\\\\\", \\\\\\\"pic_1\\\\\\\", \\\\\\\"pic_2\\\\\\\", \\\\\\\"pic_3\\\\\\\", \\\\\\\"pic_1_full\\\\\\\", \\\\\\\"pic_1_center\\\\\\\", \\\\\\\"pic_1_card\\\\\\\", \\\\\\\"pic_2_card\\\\\\\", \\\\\\\"pic_3_square\\\\\\\", \\\\\\\"card_pic_1\\\\\\\", \\\\\\\"card_pic_2\\\\\\\", \\\\\\\"card_pic_3\\\\\\\", \\\\\\\"card_pic_3_center\\\\\\\", \\\\\\\"long_text\\\\\\\", \\\\\\\"rich_text\\\\\\\", \\\\\\\"scroll_button\\\\\\\", \\\\\\\"flex_button\\\\\\\"];\\\\n        var Type1 = [];\\\\n        for (var i in Type) {\\\\n            var col = storage0.getItem('type', '');\\\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n            if (Type[i] == Col) {\\\\n                Type[i] = '👉🏽' + Type[i];\\\\n            } else {\\\\n                Type[i] = Type[i];\\\\n            }\\\\n            Type1[i] = Type[i];\\\\n        }\\\\n        showSelectOptions({\\\\n            title: \\\\\\\"选择类型\\\\\\\",\\\\n            col: 2,\\\\n            options: Type1,\\\\n            js: $.toString(() => {\\\\n                storage0.setItem('type', input);\\\\n                var col = storage0.getItem('type', '');\\\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n                storage0.setItem('Col_media', Col);\\\\n                refreshPage();\\\\n            })\\\\n        });\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    })},{\\\\n    title: '搜索',\\\\n    js: $.toString(() => {\\\\n        return 'hiker://page/search';\\\\n    }),\\\\n},{\\\\n    title: '首页',\\\\n    js: $.toString(() => {\\\\n        refreshPage();\\\\n        return 'hiker://empty';\\\\n    }),\\\\n}, {\\\\n    title: '第' + MY_PAGE + '页',\\\\n    js: $.toString(() => {\\\\n        return 'hiker://empty';\\\\n    }),\\\\n}, {\\\\n    title: '跳转',\\\\n    js: $.toString(() => {\\\\n        return $('').input(() => {\\\\n            input = input;\\\\n            putMyVar('page', input);\\\\n            refreshPage();\\\\n        });\\\\n    }),\\\\n}, {\\\\n    title: nickName,\\\\n    js: $.toString((uuid) => {\\\\n        putMyVar('uuid', uuid);\\\\n        return 'hiker://page/user#immersiveTheme#';\\\\n    }, uuid),\\\\n}]\\\\nstorage0.getItem('longClick1', longClick1);\\\\n\\\\n//col_type文本显示样式\\\\nvar longClick2 = [{\\\\n    title: '样式',\\\\n    js: $.toString(() => {\\\\n        var Type = [\\\\\\\"movie_1\\\\\\\", \\\\\\\"movie_2\\\\\\\", \\\\\\\"movie_3\\\\\\\", \\\\\\\"movie_1_left_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic_blur\\\\\\\", \\\\\\\"pic_1\\\\\\\", \\\\\\\"pic_2\\\\\\\", \\\\\\\"pic_3\\\\\\\", \\\\\\\"pic_1_full\\\\\\\", \\\\\\\"pic_1_center\\\\\\\", \\\\\\\"pic_1_card\\\\\\\", \\\\\\\"pic_2_card\\\\\\\", \\\\\\\"pic_3_square\\\\\\\", \\\\\\\"card_pic_1\\\\\\\", \\\\\\\"card_pic_2\\\\\\\", \\\\\\\"card_pic_3\\\\\\\", \\\\\\\"card_pic_3_center\\\\\\\", \\\\\\\"long_text\\\\\\\", \\\\\\\"rich_text\\\\\\\", \\\\\\\"scroll_button\\\\\\\", \\\\\\\"flex_button\\\\\\\"];\\\\n        var Type1 = [];\\\\n        for (var i in Type) {\\\\n            var col = storage0.getItem('type', '');\\\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n            if (Type[i] == Col) {\\\\n                Type[i] = '👉🏽' + Type[i];\\\\n            } else {\\\\n                Type[i] = Type[i];\\\\n            }\\\\n            Type1[i] = Type[i];\\\\n        }\\\\n        showSelectOptions({\\\\n            title: \\\\\\\"选择类型\\\\\\\",\\\\n            col: 2,\\\\n            options: Type1,\\\\n            js: $.toString(() => {\\\\n                storage0.setItem('type', input);\\\\n                var col = storage0.getItem('type', '');\\\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n                storage0.setItem('Col_text', Col);\\\\n                refreshPage();\\\\n            })\\\\n        });\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    })\\\\n},{\\\\n    title: nickName,\\\\n    js: $.toString((uuid) => {\\\\n        putMyVar('uuid', uuid);\\\\n        return 'hiker://page/user#immersiveTheme#';\\\\n    }, uuid),\\\\n}]\\\\nstorage0.setItem('longClick2', longClick2);\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"⑨类型二_longClick\\\",\\\"path\\\":\\\"longClick2\\\",\\\"rule\\\":\\\"//col_type显示样式\\\\n[{\\\\n    title: '样式',\\\\n    js: $.toString(() => {\\\\n        var Type = [\\\\\\\"movie_1\\\\\\\", \\\\\\\"movie_2\\\\\\\", \\\\\\\"movie_3\\\\\\\", \\\\\\\"movie_1_left_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic_blur\\\\\\\", \\\\\\\"pic_1\\\\\\\", \\\\\\\"pic_2\\\\\\\", \\\\\\\"pic_3\\\\\\\", \\\\\\\"pic_1_full\\\\\\\", \\\\\\\"pic_1_center\\\\\\\", \\\\\\\"pic_1_card\\\\\\\", \\\\\\\"pic_2_card\\\\\\\", \\\\\\\"pic_3_square\\\\\\\", \\\\\\\"card_pic_1\\\\\\\", \\\\\\\"card_pic_2\\\\\\\", \\\\\\\"card_pic_3\\\\\\\", \\\\\\\"card_pic_3_center\\\\\\\", \\\\\\\"long_text\\\\\\\", \\\\\\\"rich_text\\\\\\\", \\\\\\\"scroll_button\\\\\\\", \\\\\\\"flex_button\\\\\\\"];\\\\n        var Type1 = [];\\\\n        for (var i in Type) {\\\\n            var col = storage0.getItem('type', '');\\\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n            if (Type[i] == Col) {\\\\n                Type[i] = '👉🏽' + Type[i];\\\\n            } else {\\\\n                Type[i] = Type[i];\\\\n            }\\\\n            Type1[i] = Type[i];\\\\n        }\\\\n        showSelectOptions({\\\\n            title: \\\\\\\"选择类型\\\\\\\",\\\\n            col: 2,\\\\n            options: Type1,\\\\n            js: $.toString(() => {\\\\n                storage0.setItem('type', input);\\\\n                var col = storage0.getItem('type', '');\\\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n                storage0.setItem('Col2', Col);\\\\n                refreshPage();\\\\n            })\\\\n        });\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }),\\\\n}, {\\\\n    title: '搜索',\\\\n    js: $.toString(() => {\\\\n        return 'hiker://page/search';\\\\n    }),\\\\n},{\\\\n    title: '首页',\\\\n    js: $.toString(() => {\\\\n        refreshPage();\\\\n        return 'hiker://empty';\\\\n    }),\\\\n}, {\\\\n    title: '第' + MY_PAGE + '页',\\\\n    js: $.toString(() => {\\\\n        return 'hiker://empty';\\\\n    }),\\\\n}, {\\\\n    title: '跳转',\\\\n    js: $.toString(() => {\\\\n        return $('').input(() => {\\\\n            input = input;\\\\n            putMyVar('page', input);\\\\n            refreshPage();\\\\n        });\\\\n    }),\\\\n}, {\\\\n    title: nickName,\\\\n    js: $.toString((uuid) => {\\\\n        putMyVar('uuid', uuid);\\\\n        return 'hiker://page/user#immersiveTheme#';\\\\n    }, uuid),\\\\n}]\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"⑨类型一_longClick\\\",\\\"path\\\":\\\"longClick1\\\",\\\"rule\\\":\\\"//col_type显示样式\\\\n[{\\\\n    title: '样式',\\\\n    js: $.toString(() => {\\\\n        var Type = [\\\\\\\"movie_1\\\\\\\", \\\\\\\"movie_2\\\\\\\", \\\\\\\"movie_3\\\\\\\", \\\\\\\"movie_1_left_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic\\\\\\\", \\\\\\\"movie_1_vertical_pic_blur\\\\\\\", \\\\\\\"pic_1\\\\\\\", \\\\\\\"pic_2\\\\\\\", \\\\\\\"pic_3\\\\\\\", \\\\\\\"pic_1_full\\\\\\\", \\\\\\\"pic_1_center\\\\\\\", \\\\\\\"pic_1_card\\\\\\\", \\\\\\\"pic_2_card\\\\\\\", \\\\\\\"pic_3_square\\\\\\\", \\\\\\\"card_pic_1\\\\\\\", \\\\\\\"card_pic_2\\\\\\\", \\\\\\\"card_pic_3\\\\\\\", \\\\\\\"card_pic_3_center\\\\\\\", \\\\\\\"long_text\\\\\\\", \\\\\\\"rich_text\\\\\\\", \\\\\\\"scroll_button\\\\\\\", \\\\\\\"flex_button\\\\\\\"];\\\\n        var Type1 = [];\\\\n        for (var i in Type) {\\\\n            var col = storage0.getItem('type', '');\\\\n            var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n            if (Type[i] == Col) {\\\\n                Type[i] = '👉🏽' + Type[i];\\\\n            } else {\\\\n                Type[i] = Type[i];\\\\n            }\\\\n            Type1[i] = Type[i];\\\\n        }\\\\n        showSelectOptions({\\\\n            title: \\\\\\\"选择类型\\\\\\\",\\\\n            col: 2,\\\\n            options: Type1,\\\\n            js: $.toString(() => {\\\\n                storage0.setItem('type', input);\\\\n                var col = storage0.getItem('type', '');\\\\n                var Col = (col.includes('👉🏽')) ? col.split('👉🏽')[1] : col;\\\\n                storage0.setItem('Col1', Col);\\\\n                refreshPage();\\\\n            })\\\\n        });\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }),\\\\n}, {\\\\n    title: '搜索',\\\\n    js: $.toString(() => {\\\\n        return 'hiker://page/search';\\\\n    }),\\\\n},{\\\\n    title: '首页',\\\\n    js: $.toString(() => {\\\\n        refreshPage();\\\\n        return 'hiker://empty';\\\\n    }),\\\\n}, {\\\\n    title: '第' + MY_PAGE + '页',\\\\n    js: $.toString(() => {\\\\n        return 'hiker://empty';\\\\n    }),\\\\n}, {\\\\n    title: '跳转',\\\\n    js: $.toString(() => {\\\\n        return $('').input(() => {\\\\n            input = input;\\\\n            putMyVar('page', input);\\\\n            refreshPage();\\\\n        });\\\\n    }),\\\\n}, {\\\\n    title: nickName,\\\\n    js: $.toString((uuid) => {\\\\n        putMyVar('uuid', uuid);\\\\n        return 'hiker://page/user#immersiveTheme#';\\\\n    }, uuid),\\\\n}]\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"③页面-搜索\\\",\\\"path\\\":\\\"search\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nsetPageTitle('搜索页');\\\\nvar rr = {\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"searchIndex\\\\\\\",\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"index\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12,\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\"\\\\n}\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar list = r.data.hotSearch;\\\\nvar list1 = r.data.hotTopic;\\\\nvar list2 = r.data.category[0].mvlist;\\\\nvar title2 = r.data.category[0].name;\\\\nvar desc2 = r.data.category[0].desc;\\\\n\\\\nd.push({\\\\n    title: '搜索',\\\\n    url: $.toString(() => {\\\\n        putVar('keyword', input);\\\\n        return 'hiker://page/search_result?fypage';\\\\n    }),\\\\n    col_type: 'input',\\\\n    extra: {\\\\n        defaultValue: getVar('keyword', ''),\\\\n        pageTitle: '搜索结果'\\\\n    }\\\\n});\\\\nd.push({\\\\n    col_type: 'big_blank_block',\\\\n    url: 'hiker://empty'\\\\n});\\\\n\\\\nd.push({\\\\n    title: $.require(\\\\\\\"data\\\\\\\").strongR('热搜榜', 'FF6699'),\\\\n    col_type: 'text_icon',\\\\n    url: 'hiker://empty'\\\\n});\\\\nfor (var i in list) {\\\\n    var title = list[i];\\\\n    d.push({\\\\n        title: title,\\\\n        col_type: 'flex_button',\\\\n        url: \\\\\\\"copy://\\\\\\\" + title\\\\n    });\\\\n}\\\\nd.push({\\\\n    col_type: 'big_blank_block',\\\\n    url: 'hiker://empty'\\\\n});\\\\n\\\\nd.push({\\\\n    title: $.require(\\\\\\\"data\\\\\\\").strongR('91热点', 'FF6699'),\\\\n    img: 'hiker://images/icon_right5',\\\\n    col_type: 'text_icon',\\\\n    url: 'hiker://page/search_hotTopics'\\\\n});\\\\nfor (var i in list1) {\\\\n    var title = list1[i].title;\\\\n    var id = list1[i].value;\\\\n    var num = Number(i) + 1;\\\\n    d.push({\\\\n        title: num + '.\\\\\\\\t' + title,\\\\n        col_type: 'text_1',\\\\n        url: 'hiker://page/search_hotTopics_detail',\\\\n        extra: {\\\\n            id: id,\\\\n            pageTitle: '详情'\\\\n      }\\\\n    });\\\\n}\\\\nd.push({\\\\n    col_type: 'big_blank_block',\\\\n    url: 'hiker://empty'\\\\n});\\\\n\\\\nd.push({\\\\n    title: desc2 + title2,\\\\n    col_type: 'text_icon',\\\\n    url: 'hiker://empty'\\\\n});\\\\nfor (var i in list2) {\\\\n    var title = list2[i].title;\\\\n    var playUrl = list2[i].playUrl;\\\\n    var nickName = list2[i].nickName;\\\\n    var uuid = list2[i].uuid;\\\\n    var desc = '🔥' + list2[i].play_count + '\\\\\\\\t' + list2[i].durationStr;\\\\n    var imageurl = list2[i].thumbImg;\\\\n    d.push({\\\\n        title: title,\\\\n        desc: desc,\\\\n        img: imageurl + image,\\\\n        col_type: 'movie_3',\\\\n        url: playUrl.replace('10play', 'long'),\\\\n    });\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"③页面-搜索_结果\\\",\\\"path\\\":\\\"search_result\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar page = MY_PAGE;\\\\nvar Page = getMyVar('page', '0');\\\\nvar typeSlist = [{\\\\n    title: '短视频',\\\\n    type: '1'\\\\n}, {\\\\n    title: '合集',\\\\n    type: '5'\\\\n}, {\\\\n    title: '帖子',\\\\n    type: '3'\\\\n}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"data\\\\\\\").Category(typeSlist,1,d);\\\\n}\\\\nvar rr = {\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"search\\\\\\\",\\\\n    \\\\\\\"type\\\\\\\": getMyVar('typeS', '1'),\\\\n    \\\\\\\"key\\\\\\\": getVar('keyword', ''),\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"index\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"page\\\\\\\": (Page == 0) ? page : Page,\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12,\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\"\\\\n}\\\\nclearMyVar('page');\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar list = r.data;\\\\nif (r.status == 0) {\\\\n    toast(r.msg);\\\\n    back();\\\\n} else if (list == '') {\\\\n    d.push({\\\\n        title: '没有更多内容!',\\\\n        url: 'toast://🏀你干嘛~',\\\\n        col_type: 'text_1'\\\\n    });\\\\n\\\\n} else if(getMyVar('typeS', '1')==1){\\\\n    for (var i in list) {\\\\n        var playurl = list[i].playUrl;\\\\n        var title = list[i].title;\\\\n        var nickName = list[i].nickName;\\\\n        var uuid = list[i].uuid;\\\\n        var desc = '\\\\\\\\t🔥' + list[i].play_count + '\\\\\\\\t⏱️' + list[i].durationStr;\\\\n        var imageurl = list[i].thumbImg;\\\\n        eval(JSON.parse(request('hiker://page/longClick')).rule)\\\\n        d.push({\\\\n            title: title,\\\\n            desc: desc,\\\\n            img: imageurl + image,\\\\n            col_type: (storage0.getItem('Col_media', '') == '') ? 'movie_2' : storage0.getItem('Col_media', ''),\\\\n            url: playurl.replace('10play', 'long'),\\\\n            extra: {\\\\n                longClick: longClick1\\\\n            }\\\\n        });\\\\n    }\\\\n} else if(getMyVar('typeS', '3')==3){\\\\nfor (var i in list) {\\\\n    var id = list[i].id;\\\\n    var title = list[i].content;\\\\n    var desc = list[i].created_at + '发布\\\\\\\\t\\\\\\\\t' + list[i].view_num + '浏览\\\\\\\\t\\\\\\\\t' + list[i].like_num + '点赞';\\\\n    d.push({\\\\n        title: title,\\\\n        desc: desc,\\\\n        col_type: 'text_1',\\\\n        url: 'hiker://page/newsdetail',\\\\n        extra: {\\\\n            news_id: id,\\\\n            mod: \\\\\\\"news\\\\\\\",\\\\n            code: \\\\\\\"detail_v1\\\\\\\",\\\\n            pageTitle: \\\\\\\"帖子详情\\\\\\\"\\\\n        }\\\\n    });\\\\n}\\\\n} else{\\\\n      toast('增加功能的机会来了！');\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"③页面-搜索_91热点\\\",\\\"path\\\":\\\"search_hotTopics\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar rr = {\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\",\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"category\\\\\\\",\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"hotTopics\\\\\\\",\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12\\\\n}\\\\n\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar list = r.data.list;\\\\nfor (var i in list) {\\\\n    var id = list[i].value;\\\\n    var title = list[i].title;\\\\n    var img = list[i].img_url;\\\\n    var desc = list[i].updated_at + '🔥\\\\\\\\t\\\\\\\\t'+[i].hot_num  + '🏷️\\\\\\\\t\\\\\\\\t'+ list[i].tags_name;\\\\n    d.push({\\\\n        title: title,\\\\n        desc: '0',\\\\n        img: img + image,\\\\n        col_type: 'card_pic_1',\\\\n        url: 'hiker://page/search_hotTopics_detail',\\\\n        extra: {\\\\n            id: id,\\\\n            pageTitle: \\\\\\\"详情\\\\\\\"\\\\n        }\\\\n    });\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"③页面-搜索_91热点_二级\\\",\\\"path\\\":\\\"search_hotTopics_detail\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar id = MY_PARAMS.id;\\\\nvar rr = {\\\\n    \\\\\\\"oauth_type\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n    \\\\\\\"id\\\\\\\": id,\\\\n    \\\\\\\"oauth_id\\\\\\\": \\\\\\\"gynUGtLvSDhkKAsg1704513789286\\\\\\\",\\\\n    \\\\\\\"version\\\\\\\": \\\\\\\"4.5.0\\\\\\\",\\\\n    \\\\\\\"mod\\\\\\\": \\\\\\\"index\\\\\\\",\\\\n    \\\\\\\"code\\\\\\\": \\\\\\\"detail_v1\\\\\\\",\\\\n    \\\\\\\"timestamp\\\\\\\": 1.704546667806E12\\\\n}\\\\n\\\\nvar encryptdata = $.require(\\\\\\\"data\\\\\\\").encrypt(rr);\\\\n\\\\nvar timestamp = encryptdata.timestamp.toString();\\\\nvar data = encryptdata.data;\\\\nvar sign = encryptdata.sign;\\\\n\\\\nvar Data = post(\\\\\\\"https://zwsfxv.bmafdxt.com/pwa.php\\\\\\\", {\\\\n    body: {\\\\n        \\\\\\\"client\\\\\\\": \\\\\\\"pwa\\\\\\\",\\\\n        \\\\\\\"timestamp\\\\\\\": timestamp,\\\\n        \\\\\\\"data\\\\\\\": data,\\\\n        \\\\\\\"sign\\\\\\\": sign\\\\n    }\\\\n})\\\\nvar h = Data;\\\\n\\\\nlet image = $().image(() => $.require(\\\\\\\"data?rule=\\\\\\\" + MY_TITLE).decrypt());\\\\n\\\\nvar data = JSON.parse(h).data;\\\\nvar r = $.require(\\\\\\\"data\\\\\\\").Decrypt(data);\\\\nvar data = r.data;\\\\nvar title = data.title;\\\\nvar playUrl = data.playUrl;\\\\nvar previewUrl = data.previewUrl;\\\\nvar playurl = (playUrl!='')?playUrl:previewUrl;\\\\nvar thumbImg = data.thumbImg;\\\\nvar tags = data.tags;\\\\nvar created_at = data.created_at;\\\\nvar play_count = data.play_count;\\\\nvar like = data.like;var like = data.like;\\\\nvar comment = data.comment;\\\\nvar durationStr = data.durationStr;\\\\nvar nickName = data.nickName;\\\\nvar uuid = data.uuid;\\\\nvar medialist = data.recommend; //精彩视频\\\\nvar comment_list = data.commentList; //评论\\\\n\\\\nd.push({\\\\n        title: title,\\\\n        desc: '0',\\\\n        img: thumbImg + image,\\\\n        url: playurl.replace('10play', 'long'),\\\\n        col_type: 'card_pic_1'\\\\n});\\\\nd.push({\\\\n        title: '‘‘’’<small>' +'发布时间:'+created_at+'\\\\\\\\t\\\\\\\\tUP主:'+nickName+'\\\\\\\\n🏷️'+tags+'\\\\\\\\t\\\\\\\\t时长'+durationStr+'\\\\\\\\n🔥'+play_count+'\\\\\\\\t\\\\\\\\t❤️'+like+'\\\\\\\\t\\\\\\\\t✍🏽️'+comment+'</small>',\\\\n        url: 'hiker://empty',\\\\n        col_type: 'text_center_1'\\\\n});\\\\nd.push({\\\\n            col_type: 'big_blank_block',\\\\n            url: 'hiker://empty'\\\\n        });\\\\nvar typeSSlist = [{\\\\n    title: '精彩视频',\\\\n    type: '1'\\\\n}, {\\\\n    title: '评论'+comment,\\\\n    type: '0'\\\\n}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"data\\\\\\\").Category(typeSSlist,2,d);\\\\n}\\\\nif(getMyVar('typeSS', '1')==0){\\\\nd.push({\\\\n        title: '全部评论\\\\\\\\t('+comment+')',\\\\n        url: 'hiker://empty',\\\\n        col_type: 'text_1'\\\\n});\\\\nfor (var i in comment_list) {\\\\n    var nickname = comment_list[i].nickName;\\\\n    var sexType = comment_list[i].sexType;\\\\n    var sex = (sexType == '0') ? '\\\\\\\\t👩🏽\\\\\\\\t' : '\\\\\\\\t👨🏽\\\\\\\\t';\\\\n    var created_at = comment_list[i].created_at;\\\\n    var comment = comment_list[i].comment;\\\\n    var thumb = comment_list[i].thumb;\\\\n    d.push({\\\\n        title: nickname + sex,\\\\n        desc: created_at,\\\\n        img: thumb + image,\\\\n        url: 'hiker://empty',\\\\n        col_type: 'avatar'\\\\n    });\\\\n    d.push({\\\\n        title: comment,\\\\n        url: 'hiker://empty',\\\\n        col_type: 'text_1'\\\\n    });\\\\n}\\\\n} else {\\\\nfor (var i in medialist) {\\\\n    var id = medialist[i].id;\\\\n    var title = medialist[i].title;\\\\n    var img = medialist[i].thumbImg;\\\\n    //var playUrl = medialist[i].playUrl;\\\\n    d.push({\\\\n        title: title,\\\\n        img: img + image,\\\\n        col_type: 'movie_2',\\\\n        url: 'hiker://page/search_hotTopics_detail',\\\\n        extra: {\\\\n            id: id,\\\\n            pageTitle: \\\\\\\"详情\\\\\\\"\\\\n        }\\\\n    });\\\\n}\\\\n}\\\\nsetResult(d);\\\"}]\",\"proxy\":\"\"}","title":"搜索结果"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!