邀您一起看：PONDEMIX (雪国おまる)｜作品-帮助了一位无处可去的淫荡又纯洁女孩~她通过要求SEX来回报‼️①

xiaomianao666

Apr 18th, 2025

958

Never

Add comment

Not a member of Pastebin yet? Sign Up, it unlocks many cool features!

JavaScript 84.38 KB | None | 0 0

raw download clone embed print report

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥PONDEMIX (雪国おまる)｜作品-帮助了一位无处可去的淫荡又纯洁女孩~她通过要求SEX来回报‼️①@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"函数\",\"path\":\"hanshu\",\"rule\":\"const apiview = {\\n    color: (test) => {\\n        return '<font color=\\\"#FA7298\\\">' + test + '</front>';\\n    },\\n    strong: (test) => {\\n        return '<strong>' + test + '</strong>';\\n    },\\n    small: (test) => {\\n        return '<small>' + test + '</small>';\\n    },\\n    center: (test) => {\\n        return '<p style=\\\"text-align: center;\\\">' + test + '</p>'\\n    },\\n    big: (test) => {\\n        return '<big>' + test + '</big>';\\n    },\\n    gray: (test) => {\\n        return \\\"<font color='gray'>\\\" + test + \\\"</font>\\\";\\n    },\\n    rich: (test) => {\\n        return \\\"‘‘’’\\\" + test;\\n    },\\n    addressTag: (url, text) => {\\n        return \\\"<a href='\\\" + url + \\\"'>\\\" + text + \\\"</a>\\\"\\n    },\\n    empty: \\\"hiker://empty\\\",\\n    layout: [],\\n    noLoad: \\\"#noLoading#\\\",\\n    timestamp: () => Math.floor(new Date().getTime() / 1000),\\n    t10: () => apiview.timestamp().toString(),\\n    t13: () => apiview.t10() + '000',\\n    host: getItem(\\\"api\\\"),\\n    getDatesArray: (endDate) => {\\n        // 将结束日期字符串转换为Date对象\\n        let endDateObj = new Date(endDate);\\n\\n        // 获取当前日期\\n        let currentDate = new Date();\\n\\n        // 初始化日期数组\\n        let datesArray = [];\\n\\n        // 循环从当前日期到结束日期\\n        while (currentDate >= endDateObj) {\\n            // 将日期转换为YYYY-MM-DD格式的字符串并添加到数组\\n            datesArray.push(currentDate.toISOString().split('T')[0]);\\n\\n            // 减去一天\\n            currentDate.setDate(currentDate.getDate() - 1);\\n        }\\n        /*\\n            // 反转数组以按降序排列日期\\n            datesArray.reverse();\\n        */\\n        return datesArray;\\n    },\\n    getYearMonthArray: (endDate) => {\\n        let endDateObj = new Date(endDate);\\n        let currentDate = new Date();\\n        let yearMonthArray = [];\\n\\n        // 确保当前日期不小于结束日期\\n        if (currentDate < endDateObj) {\\n            return yearMonthArray; // 如果当前日期小于结束日期，直接返回空数组\\n        }\\n\\n        // 循环从当前日期到结束日期\\n        while (currentDate >= endDateObj) {\\n            // 获取当前日期的年和月，并格式化为\\\"YYYY-MM\\\"字符串\\n            let year = currentDate.getFullYear();\\n            let month = (currentDate.getMonth() + 1).toString().padStart(2, '0'); // 月份从0开始，所以加1，并且确保是两位数\\n            let yearMonth = `${year}-${month}`; // 正确使用模板字符串\\n\\n            // 将年月字符串添加到数组\\n            yearMonthArray.push(yearMonth);\\n\\n            // 减去一个月\\n            currentDate.setMonth(currentDate.getMonth() - 1);\\n        }\\n\\n        return yearMonthArray;\\n    },\\n    CryptoJS: null, // 用于存储 CryptoJS 对象\\n    initCryptoJS: () => {\\n        if (!apiview.CryptoJS) {\\n            eval(getCryptoJS()); // 执行一次 eval，确保 `CryptoJS` 变量被定义\\n            apiview.CryptoJS = CryptoJS; // 将 `CryptoJS` 缓存到 `apiview.CryptoJS`\\n        }\\n    },\\n    Encrypt: (word) => {\\n        apiview.initCryptoJS(); // 确保 CryptoJS 已加载\\n        let key = apiview.CryptoJS.enc.Utf8.parse(\\\"l*bv%Ziq000Biaog\\\");\\n        let iv = apiview.CryptoJS.enc.Utf8.parse(\\\"8597506002939249\\\");\\n        let encrypt = apiview.CryptoJS.AES.encrypt(word, key, {\\n            iv: iv,\\n            mode: apiview.CryptoJS.mode.CBC,\\n            padding: apiview.CryptoJS.pad.Pkcs7,\\n        });\\n        return encrypt.toString(); // 默认返回 Base64 编码的字符串\\n    },\\n    Decrypt: (word) => {\\n        apiview.initCryptoJS(); // 确保 CryptoJS 已加载\\n        let key = apiview.CryptoJS.enc.Utf8.parse(\\\"l*bv%Ziq000Biaog\\\");\\n        let iv = apiview.CryptoJS.enc.Utf8.parse(\\\"8597506002939249\\\");\\n        let decrypt = apiview.CryptoJS.AES.decrypt(word, key, {\\n            iv: iv,\\n            mode: apiview.CryptoJS.mode.CBC,\\n            padding: apiview.CryptoJS.pad.Pkcs7,\\n        });\\n        return decrypt.toString(apiview.CryptoJS.enc.Utf8); // 解密结果转换为文本格式\\n    },\\n    Decrypt1: (input) => {\\n        return $(input).image(() => {\\n            const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n            let key = CryptoUtil.Data.parseUTF8(\\\"saIZXc4yMvq0Iz56\\\");\\n            let iv = CryptoUtil.Data.parseUTF8(\\\"kbJYtBJUECT0oyjo\\\");\\n            let textData = CryptoUtil.Data.parseInputStream(input);\\n            let encrypted = CryptoUtil.AES.decrypt(textData, key, {\\n                mode: \\\"AES/CBC/PKCS7Padding\\\",\\n                iv: iv\\n            });\\n            return encrypted.toInputStream();\\n        })\\n    },\\n    gettoken: () => {\\n        var html = fetch(apiview.host+'/v2.5/refresh/token', {\\n            headers: {\\n                'Content-Type': 'application/x-www-form-urlencoded',\\n                'uuid': 'c9ad221f-b445-39d2-85f5-a693c24115e3',\\n                'timestamp': apiview.t10(),\\n                'ip': '0.0.0.0',\\n                'user-key': '760355cc88218f0c1514f56764362066',\\n                'platform': '1',\\n                'sign': md5(md5('0.0.0.0.1.'+apiview.t10()+'.760355cc88218f0c1514f56764362066.c9ad221f-b445-39d2-85f5-a693c24115e3')+'m4n2hjPeYWkD6tFpqKF^3HO^h24P@idT'),\\n                'app-version': '2.2.9',\\n                'Content-Length': '0',\\n                'Host': apiview.host.split('//')[1],\\n                'Connection': 'Keep-Alive',\\n                //'Accept-Encoding': 'gzip',\\n                'User-Agent': 'okhttp/4.3.1',\\n            },\\n            method: 'POST'\\n        }); //log(html)\\n        var html1 = apiview.Decrypt(html); //log(html1)\\n        //var logged_at = JSON.parse(html1).data.user.logged_at.split(' ')[0]; log(logged_at)\\n        var token = JSON.parse(html1).data.user.token; log(token)\\n        //setItem(\\\"logged_at\\\",logged_at)\\n        setItem(\\\"token\\\",token)\\n    },\\n    gethtml: (url,body) => {\\n        var html = fetch(url, {\\n            headers: {\\n                'uuid': 'c9ad221f-b445-39d2-85f5-a693c24115e3',\\n                'timestamp': apiview.t10(),\\n                'ip': '0.0.0.0',\\n                'user-key': '760355cc88218f0c1514f56764362066',\\n                'platform': '1',\\n                'sign': md5(md5('0.0.0.0.1.'+apiview.t10()+'.760355cc88218f0c1514f56764362066.c9ad221f-b445-39d2-85f5-a693c24115e3')+'m4n2hjPeYWkD6tFpqKF^3HO^h24P@idT'),\\n                'app-version': '2.2.9',\\n                'token': getItem(\\\"token\\\"),\\n                'Content-Type': 'application/x-www-form-urlencoded',\\n                'Content-Length': '0',\\n                'Host': apiview.host.split('//')[1],\\n                'Connection': 'Keep-Alive',\\n                //'Accept-Encoding': 'gzip',\\n                'User-Agent': 'okhttp/4.3.1',\\n            },\\n            body: body,            \\n            method: 'POST',\\n            rejectCoding: true\\n        }); //log(html)\\n        var html1 = apiview.Decrypt(html); //log(html1)\\n        return html1\\n    },\\n    tuwenyiji: (d,data) => {\\n        data.forEach(item => {\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n            d.push({\\n                title: item.published_at.split(' ')[0],\\n                img: img,\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\n                col_type: 'movie_2',\\n                extra: {\\n                    model_id: item.model_id,\\n                    id: item.id,\\n                    img: img\\n                }\\n            })\\n        })\\n    },\\n    yueduyiji: (d,data) => {\\n        data.forEach(item => {\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n            d.push({\\n                title: item.title + '\\\\n' + item.author,\\n                desc: item.description,\\n                img: img,\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\n                col_type: 'movie_1_left_pic',\\n                extra: {\\n                    model_id: item.model_id,\\n                    id: item.id,\\n                    img: img\\n                }\\n            })\\n        })\\n    },\\n    yingshiyiji: (d,data) => {\\n        data.forEach(item => {\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n            d.push({\\n                title: item.title,\\n                desc: item.description,\\n                img: img,\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\n                col_type: 'movie_1_left_pic',\\n                extra: {\\n                    model_id: item.model_id,\\n                    id: item.id,\\n                    img: img\\n                }\\n            })\\n        })\\n    },\\n    diantaiyiji: (d,data) => {\\n        data.forEach(item => {\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n            d.push({\\n                title: item.title,\\n                desc: '0',\\n                img: img,\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\n                col_type: 'card_pic_1',\\n                extra: {\\n                    model_id: item.model_id,\\n                    id: item.id,\\n                    img: img\\n                }\\n            })\\n        })\\n    },\\n    xiezhenmanhuayiji: (d,data) => {\\n        data.forEach(item => {\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n            d.push({\\n                title: item.title,\\n                desc: '0',\\n                img: img,\\n                url: $('hiker://empty' + item.id).rule(() => {\\n                    var apiview = $.require(\\\"hanshu\\\")\\n                    var url = apiview.host+'/v2.5/series/chapters'\\n                    var body = apiview.Encrypt('series_id=' + MY_URL.replace('hiker://empty', ''))\\n                    var data = JSON.parse(apiview.gethtml(url, body)).data; //log(data)\\n                    var d = [];\\n                    data.chapters.forEach(item => {\\n                        var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n                        d.push({\\n                            title: item.title,\\n                            desc: item.description,\\n                            img: img,\\n                            url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\n                            col_type: 'movie_1_left_pic',\\n                            extra: {\\n                                model_id: 2,\\n                                id: item.id,\\n                                img: img\\n                            }\\n                        })\\n                    })\\n                    setResult(d)\\n                }),\\n                col_type: 'card_pic_1'\\n            })\\n        })\\n    },\\n    tuwen: (d,data) => {\\n        var imgs = data.content.replace(/(<figure[\\\\S\\\\s]*?<\\\\/figure>)/g, \\\"@$1@\\\");\\n        imgs.split(\\\"@\\\").forEach(it => {\\n            if (it.includes(\\\"figure\\\")) {\\n                let img = apiview.Decrypt1('https://jmtp.gpgreii.com' + pdfh(it, \\\"img&&src\\\"))\\n                d.push({\\n                    //desc: '0',\\n                    img: img,\\n                    url: img,\\n                    col_type: 'pic_1_full'\\n                });\\n            } else if (it.trim()) {\\n                d.push({\\n                    title: it,\\n                    url: 'hiker://empty',\\n                    col_type: 'rich_text'\\n                });\\n            }\\n        })\\n    },\\n    biaoqian: (d,data) => {\\n        data.tags.forEach(item => {\\n            d.push({\\n                title: item,\\n                url: $(item + '#noLoading#').lazyRule(() => {\\n                    //putMyVar('search', input)\\n                    //refreshPage()\\n                    return 'hiker://empty'\\n                }),\\n                col_type: 'flex_button'\\n            })\\n        })\\n    },\\n    yulantu: (d,data) => {\\n        data.multiple_pic.forEach(item => {\\n            let img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item)\\n            d.push({\\n                img: img,\\n                url: img,\\n                col_type: 'card_pic_3'\\n            })\\n        })\\n    },\\n    pinglun: (d, data) => {\\n        data.forEach(data => {\\n            if (data.author) {\\n                if (data.avatar == '') {\\n                    var avatar = 'https://img.vinua.cn/images/InnDk.th.png'\\n                } else {\\n                    var avatar = apiview.Decrypt1('https://jmtp.gpgreii.com' + data.avatar)\\n                }\\n                d.push({\\n                    title: data.author,\\n                    desc: data.created_at,\\n                    img: avatar,\\n                    url: 'hiker://empty',\\n                    col_type: 'avatar'\\n                })\\n                if (data.replies.length != '0') {\\n                    var title = data.text + apiview.addressTag('hiker://page/pinlun', '\\\\t\\\\t\\\\t查看全部')\\n                } else {\\n                    var title = data.text\\n                }\\n                d.push({\\n                    title: apiview.gray(title),\\n                    col_type: 'rich_text',\\n                    extra: {\\n                        title: data.author,\\n                        desc: data.created_at,\\n                        desc1: data.text,\\n                        img: avatar,\\n                        item: data.replies,\\n                        pageTitle: data.author\\n                    }\\n                })\\n            }\\n        })\\n    }\\n}\\n\\n$.exports = apiview;\\n\"},{\"col_type\":\"movie_3\",\"name\":\"点播\",\"path\":\"cla1\",\"rule\":\"var endDate = \\\"2021-09-01\\\";\\nvar he = apiview.getYearMonthArray(endDate); //log(he) \\nvar subs = he //log(subs) \\nif(MY_PAGE == '1'){\\nhe.forEach((x,i)=>{\\n    var ctitle = x\\n    var sub = subs[i]\\n    d.push({\\n        title: getMyVar('ctitle', he[0]) == ctitle ? '““””'+ctitle.fontcolor('#'+getRangeColors()):ctitle,\\n        url: $('#noLoading##noHistory#').lazyRule((ctitle,sub) => {\\n                putMyVar(\\\"ctitle\\\", ctitle);\\n                putMyVar(\\\"sub\\\",sub);\\n                refreshPage();\\n                return 'hiker://empty'\\n            }, ctitle,sub),\\n        col_type: \\\"scroll_button\\\"\\n    })\\n})\\n}\\nvar he = getMyVar(\\\"ctitle\\\",he[0])\\nvar sub = getMyVar(\\\"sub\\\",subs[0]); //log(sub)\\n\\nvar url = apiview.host+'/v2.5/article/discovery'\\nvar body = apiview.Encrypt('model_id=6&published_at='+sub+'&page='+MY_PAGE+'&size=20&sort=published_at')\\nvar data = JSON.parse(apiview.gethtml(url,body)).data;\\ndata.forEach(item => {\\n    var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n    d.push({\\n        title: item.title,\\n        desc: '',\\n        img: img,\\n        url: `hiker://page/erji1?page=fypage#noHistory#`,\\n        col_type: 'pic_1_card',\\n        extra: {\\n            model_id: item.model_id,\\n            id: item.id,\\n            img: img\\n        }\\n    })\\n})\"},{\"col_type\":\"movie_3\",\"name\":\"点播二级\",\"path\":\"erji1\",\"rule\":\"js:\\nvar apiview = $.require(\\\"hanshu\\\")\\nvar model_id = MY_PARAMS.model_id; //log(typeof model_id)\\nvar id = MY_PARAMS.id; //log(id)\\nvar img = MY_PARAMS.img\\nvar d = [];\\nif(MY_PAGE == '1'){\\nd.push({\\n    desc: '0',\\n    img: img,\\n    url: img,\\n    col_type: 'card_pic_1'\\n})\\nif(getMyVar('a') == '1'){\\nvar title1 = '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t影片介绍\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t'\\nvar title2 = '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t‘‘用户评价’’\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t'\\n}else{\\nvar title1 = '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t‘‘影片介绍’’\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t'\\nvar title2 = '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t用户评价\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t'\\n}\\nd.push({\\n    title: title1,\\n    url: $('#noLoading#').lazyRule(()=>{\\n        clearMyVar('a')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'flex_button',\\n    //extra: {'backgroundColor': '#E0F8FF'}\\n})\\nd.push({\\n    title: title2,\\n    url: $('#noLoading#').lazyRule(()=>{\\n        putMyVar('a','1')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'flex_button',\\n    //extra: {'backgroundColor': '#E0F8FF'}\\n})\\n}\\nif(getMyVar('a') == '1'){\\nvar url = apiview.host+'/v2.5/comment/list'\\nvar body = apiview.Encrypt('article_id='+id+'&page='+MY_PAGE+'&size=20&sorting='+getMyVar('a1','likes'))\\nvar data = JSON.parse(apiview.gethtml(url, body)).data; //log(data)\\nif(MY_PAGE == '1'){\\nif(getMyVar('a1','likes') == 'likes'){\\nvar text = '当前排序：按热度'\\n}\\nif(getMyVar('a1') == 'created_at'){\\nvar text = '当前排序：按时间'\\n}\\n//log(getMyVar('a1','likes'))\\nvar paixu = $('#noLoading#').b64().lazyRule(() => {\\n    if(getMyVar('a1','likes') == 'likes'){\\n        putMyVar('a1','created_at')\\n        toast('按时间')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }\\n    if(getMyVar('a1') == 'created_at'){\\n        putMyVar('a1','likes')\\n        toast('按热度')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }\\n})\\nd.push({\\n    title: apiview.big(apiview.strong('评论列表'))+'\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t'+apiview.addressTag(paixu,text),\\n    col_type: 'rich_text',\\n})\\n}\\napiview.pinglun(d,data)\\n}else{\\nif(MY_PAGE == '1'){\\nvar url = apiview.host+'/v2.5/article/detail'\\nvar body = apiview.Encrypt('id='+id)\\nvar data = JSON.parse(apiview.gethtml(url,body)).data; //log(data)\\nd.push({\\n    title: '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t预览\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t',\\n    url: $(data.video_file+'#noLoading#').lazyRule((data)=>{\\n        return 'https://akmaivideo.cdchuangao.com'+input\\n    },data),\\n    col_type: 'text_2',\\n    //extra: {'backgroundColor': '#E0F8FF'}\\n})\\nd.push({\\n    title: '\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t原片\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t',\\n    url: $(data.video_file+'#noLoading#').lazyRule((data)=>{\\n        if(/sample/.test(input)){\\n            var url = input.replace(/[^a-zA-Z0-9](sample)/,'')\\n            return 'https://akmaivideo.cdchuangao.com'+url\\n        }\\n        if(!/无/.test(data.number)){\\n            var url = input.replace(/\\\\/([^\\\\/]+)\\\\./,'/'+data.number+'.')\\n            return 'https://akmaivideo.cdchuangao.com'+url\\n        }\\n    },data),\\n    col_type: 'text_2',\\n    //extra: {'backgroundColor': '#E0F8FF'}\\n})\\nd.push({\\n    title: apiview.big(apiview.strong(data.title))+'<br><br>'+'番号：'+apiview.gray(data.number)+'\\\\t\\\\t\\\\t'+'演员：'+apiview.gray(data.actor)+'<br>'+apiview.gray(data.published_at.split(' ')[0])+'\\\\t\\\\t\\\\t'+apiview.gray(data.length)+'\\\\t\\\\t\\\\t'+apiview.gray(data.size)+'\\\\t\\\\t\\\\t'+apiview.gray(data.quality),\\n    url: 'hiker://empty',\\n    col_type: 'rich_text'\\n})\\napiview.biaoqian(d,data)\\napiview.yulantu(d,data)\\n//log(data.content)\\napiview.tuwen(d,data)\\n\\n}\\n}\\n\\nsetResult(d)\\n\"},{\"col_type\":\"movie_3\",\"name\":\"评论详情\",\"path\":\"pinlun\",\"rule\":\"js:\\nvar apiview = $.require(\\\"hanshu\\\")\\nvar d = [];\\nd.push({\\n    title: MY_PARAMS.title,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'avatar'\\n})\\nd.push({\\n    title: apiview.gray(MY_PARAMS.desc1),\\n    col_type: 'rich_text',\\n})\\nd.push({\\n    title: apiview.big(apiview.strong('相关回复共'+MY_PARAMS.item.length+'条')),\\n    col_type: 'rich_text',\\n})\\nMY_PARAMS.item.reverse().forEach(data => {\\n    if (data.avatar == '') {\\n        var avatar = 'https://img.vinua.cn/images/InnDk.th.png'\\n    } else {\\n        var avatar = apiview.Decrypt1('https://jmtp.gpgreii.com' + data.avatar)\\n    }\\n    d.push({\\n        title: data.author,\\n        desc: data.created_at,\\n        img: avatar,\\n        url: 'hiker://empty',\\n        col_type: 'avatar'\\n    })\\n    d.push({\\n        title: apiview.addressTag('hiker://empty','@'+data.tag_author+'\\\\t\\\\t\\\\t')+apiview.gray(data.text),\\n        col_type: 'rich_text',\\n    })\\n})\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"home\",\"rule\":\"if(MY_PAGE == '1'){\\nvar endDate = \\\"2019-11-08\\\";\\nvar datesArray = apiview.getDatesArray(endDate);\\nvar url = apiview.host+'/v2.5/article/day'\\nvar published_at = getMyVar(\\\"published_at\\\") == '' ? datesArray[0] : getMyVar(\\\"published_at\\\"); //log(published_at)\\nvar body = apiview.Encrypt('published_at='+published_at)\\nvar data = JSON.parse(apiview.gethtml(url,body)).data;\\ndata.info.forEach(item => {\\n    var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\n    if(item.model_id == '6'){\\n    var url = `hiker://page/erji1?page=fypage#noHistory#`\\n    }else{\\n    var url = `hiker://page/erji?page=fypage#noHistory##gameTheme#`\\n    }\\n    d.push({\\n        title: `${apiview.strong(item.title)}<br>${apiview.gray(item.author)}<br>${apiview.gray(item.description.replace(/\\\\n/g,'<br>'))}`,\\n        col_type: 'rich_text'\\n    })\\n    d.push({\\n        img: img,\\n        url: url,\\n        col_type: 'pic_1_full',\\n        extra: {\\n            model_id: item.model_id,\\n            id: item.id,\\n            img: img\\n        }\\n    })\\n    d.push({\\n        col_type: 'line_blank'\\n    })\\n})\\nd.push({\\n    title: '““切换””',\\n    url: $().lazyRule((published_at,datesArray) => {\\n        showSelectOptions({\\n            title: '当前：'+published_at,\\n            options: datesArray,\\n            js: $.toString(() => {\\n                putMyVar(\\\"published_at\\\",input);\\n                refreshPage();\\n                return \\\"toast://\\\" + input\\n            })\\n        });\\n        return \\\"hiker://empty\\\"\\n    },published_at,datesArray),\\n    col_type: \\\"text_center_1\\\"\\n})\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"二级\",\"path\":\"erji\",\"rule\":\"js:\\nvar apiview = $.require(\\\"hanshu\\\")\\nvar model_id = MY_PARAMS.model_id; //log(typeof model_id)\\nvar id = MY_PARAMS.id; //log(id)\\nvar img = MY_PARAMS.img\\nvar d = [];\\n\\nif(MY_PAGE == '1'){\\nvar url = apiview.host+'/v2.5/article/detail'\\nvar body = apiview.Encrypt('id='+id)\\nvar data = JSON.parse(apiview.gethtml(url,body)).data; //log(data)\\nswitch (model_id) {\\n    case 1:\\n        d.push({\\n            img: img,\\n            url: img,\\n            col_type: 'pic_1_full'\\n        })\\n        d.push({\\n            title: `${apiview.strong(apiview.center(data.title))}${apiview.gray(data.description)}${apiview.gray(apiview.center(data.author))}`,\\n            col_type: 'rich_text'\\n        })\\n        break;\\n    case 2:\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 3:\\n        d.push({\\n            img: img,\\n            url: img,\\n            col_type: 'pic_1_full'\\n        })\\n        d.push({\\n            title: '““视频””',\\n            url: 'https://akmaivideo.cdchuangao.com' + data.video_file,\\n            col_type: 'text_center_1'\\n        })\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 4:\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 5:\\n        d.push({\\n            img: img,\\n            url: img,\\n            col_type: 'pic_1_full'\\n        })\\n        d.push({\\n            title: '““电台””',\\n            url: 'https://akmaivideo.cdchuangao.com' + data.video,\\n            col_type: 'text_center_1'\\n        })\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 6:\\n\\n        break;\\n}\\nif(getMyVar('a1','created_at') == 'created_at'){\\nvar text = '当前排序：按时间'\\n}\\nif(getMyVar('a1') == 'likes'){\\nvar text = '当前排序：按热度'\\n}\\n//log(getMyVar('a1','created_at'))\\nvar paixu = $('#noLoading#').b64().lazyRule(() => {\\n    if(getMyVar('a1','created_at') == 'created_at'){\\n        putMyVar('a1','likes')\\n        toast('按热度')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }\\n    if(getMyVar('a1') == 'likes'){\\n        putMyVar('a1','created_at')\\n        toast('按时间')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }\\n})\\nd.push({\\n    title: apiview.big(apiview.strong('相关回复共'+data.reply_counts+'条'))+'\\\\t\\\\t\\\\t\\\\t\\\\t'+apiview.addressTag(paixu,text),\\n    col_type: 'rich_text',\\n})\\n}\\nvar url = apiview.host+'/v2.5/comment/list'\\nvar body = apiview.Encrypt('article_id='+id+'&page='+MY_PAGE+'&size=20&sorting='+getMyVar('a1','created_at'))\\nvar data = JSON.parse(apiview.gethtml(url, body)).data; //log(data)\\napiview.pinglun(d,data)\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"发现\",\"path\":\"cla\",\"rule\":\"var endDate = \\\"2021-09-01\\\";\\nvar he1 = ['图文','阅读','影视','电台','写真','漫画']; //log(he1) \\nvar subs1 = ['1','2','3','5','0','0']; //log(subs1) \\nvar subs2 = apiview.getYearMonthArray(endDate); //log(subs2)\\nif(MY_PAGE == '1'){\\nhe1.forEach((x,i)=>{\\n    var ctitle1 = x\\n    var sub1 = subs1[i]\\n    d.push({\\n        title: getMyVar('ctitle1', he1[0]) == ctitle1 ? '““””'+ctitle1.fontcolor('#'+getRangeColors()):ctitle1,\\n        url: $('#noLoading##noHistory#').lazyRule((ctitle1,sub1) => {\\n                putMyVar(\\\"ctitle1\\\", ctitle1);\\n                putMyVar(\\\"sub1\\\",sub1);                \\n                refreshPage();\\n                return 'hiker://empty'\\n            }, ctitle1,sub1),\\n        col_type: \\\"scroll_button\\\"\\n    })\\n})\\n}\\nvar he1 = getMyVar(\\\"ctitle1\\\",he1[0]); //log(he1)\\nvar sub1 = getMyVar(\\\"sub1\\\",subs1[0]); //log(sub1)\\nvar sub2 = subs2[MY_PAGE-1]; //log(sub2)\\n\\nif(he1 == '写真'){\\nvar url = apiview.host+'/v2.5/series/album/list'\\nvar body = apiview.Encrypt('type='+sub1+'&page='+MY_PAGE+'&size=31&sort=published_at')\\n}else if(he1 == '漫画'){\\nvar url = apiview.host+'/v2.5/series/manga/list'\\nvar body = apiview.Encrypt('type='+sub1+'&page='+MY_PAGE+'&size=31&sort=published_at')\\n}else{\\nvar url = apiview.host+'/v2.5/article/discovery'\\nvar body = apiview.Encrypt('model_id='+sub1+'&published_at='+sub2+'&page=1&size=31')\\n}\\nvar data = JSON.parse(apiview.gethtml(url,body)).data;\\n\\nswitch (sub1) {\\n    case '0':\\n        apiview.xiezhenmanhuayiji(d,data)\\n        break;\\n    case '1':\\n        apiview.tuwenyiji(d, data)\\n        break;\\n    case '2':\\n        apiview.yueduyiji(d, data)\\n        break;\\n    case '3':\\n        apiview.yingshiyiji(d, data)\\n        break;\\n    case '5':\\n        apiview.diantaiyiji(d, data)\\n        break;\\n}\"}],\"params\":\"{\\\"id\\\":27707,\\\"img\\\":\\\"https://jmtp.gpgreii.com/storage/thumb/27707/67a21167b407c.jpg@js=$.hiker.MY_TITLE = \\\\\\\"一个APP\\\\\\\";(\\\\n() => {\\\\n    const CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n    let key = CryptoUtil.Data.parseUTF8(\\\\\\\"saIZXc4yMvq0Iz56\\\\\\\");\\\\n    let iv = CryptoUtil.Data.parseUTF8(\\\\\\\"kbJYtBJUECT0oyjo\\\\\\\");\\\\n    let textData = CryptoUtil.Data.parseInputStream(input);\\\\n    let encrypted = CryptoUtil.AES.decrypt(textData, key, {mode: \\\\\\\"AES/CBC/PKCS7Padding\\\\\\\", iv: iv});\\\\n    return encrypted.toInputStream();\\\\n}\\\\n)()\\\",\\\"model_id\\\":2}\",\"saved\":false,\"title\":\"一个APP\",\"version\":0,\"url\":\"hiker://page/erji?page=fypage#noHistory##gameTheme#\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar apiview = $.require(\\\"hanshu\\\")\\nvar model_id = MY_PARAMS.model_id; //log(typeof model_id)\\nvar id = MY_PARAMS.id; //log(id)\\nvar img = MY_PARAMS.img\\nvar d = [];\\n\\nif(MY_PAGE == '1'){\\nvar url = apiview.host+'/v2.5/article/detail'\\nvar body = apiview.Encrypt('id='+id)\\nvar data = JSON.parse(apiview.gethtml(url,body)).data; //log(data)\\nswitch (model_id) {\\n    case 1:\\n        d.push({\\n            img: img,\\n            url: img,\\n            col_type: 'pic_1_full'\\n        })\\n        d.push({\\n            title: `${apiview.strong(apiview.center(data.title))}${apiview.gray(data.description)}${apiview.gray(apiview.center(data.author))}`,\\n            col_type: 'rich_text'\\n        })\\n        break;\\n    case 2:\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 3:\\n        d.push({\\n            img: img,\\n            url: img,\\n            col_type: 'pic_1_full'\\n        })\\n        d.push({\\n            title: '““视频””',\\n            url: 'https://akmaivideo.cdchuangao.com' + data.video_file,\\n            col_type: 'text_center_1'\\n        })\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 4:\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 5:\\n        d.push({\\n            img: img,\\n            url: img,\\n            col_type: 'pic_1_full'\\n        })\\n        d.push({\\n            title: '““电台””',\\n            url: 'https://akmaivideo.cdchuangao.com' + data.video,\\n            col_type: 'text_center_1'\\n        })\\n        d.push({\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\n            col_type: 'rich_text'\\n        })\\n        apiview.tuwen(d,data)\\n        break;\\n    case 6:\\n\\n        break;\\n}\\nif(getMyVar('a1','created_at') == 'created_at'){\\nvar text = '当前排序：按时间'\\n}\\nif(getMyVar('a1') == 'likes'){\\nvar text = '当前排序：按热度'\\n}\\n//log(getMyVar('a1','created_at'))\\nvar paixu = $('#noLoading#').b64().lazyRule(() => {\\n    if(getMyVar('a1','created_at') == 'created_at'){\\n        putMyVar('a1','likes')\\n        toast('按热度')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }\\n    if(getMyVar('a1') == 'likes'){\\n        putMyVar('a1','created_at')\\n        toast('按时间')\\n        refreshPage()\\n        return 'hiker://empty'\\n    }\\n})\\nd.push({\\n    title: apiview.big(apiview.strong('相关回复共'+data.reply_counts+'条'))+'\\\\t\\\\t\\\\t\\\\t\\\\t'+apiview.addressTag(paixu,text),\\n    col_type: 'rich_text',\\n})\\n}\\nvar url = apiview.host+'/v2.5/comment/list'\\nvar body = apiview.Encrypt('article_id='+id+'&page='+MY_PAGE+'&size=20&sorting='+getMyVar('a1','created_at'))\\nvar data = JSON.parse(apiview.gethtml(url, body)).data; //log(data)\\napiview.pinglun(d,data)\\n\\nsetResult(d)\",\"group\":\"#\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"函数\\\",\\\"path\\\":\\\"hanshu\\\",\\\"rule\\\":\\\"const apiview = {\\\\n    color: (test) => {\\\\n        return '<font color=\\\\\\\"#FA7298\\\\\\\">' + test + '</front>';\\\\n    },\\\\n    strong: (test) => {\\\\n        return '<strong>' + test + '</strong>';\\\\n    },\\\\n    small: (test) => {\\\\n        return '<small>' + test + '</small>';\\\\n    },\\\\n    center: (test) => {\\\\n        return '<p style=\\\\\\\"text-align: center;\\\\\\\">' + test + '</p>'\\\\n    },\\\\n    big: (test) => {\\\\n        return '<big>' + test + '</big>';\\\\n    },\\\\n    gray: (test) => {\\\\n        return \\\\\\\"<font color='gray'>\\\\\\\" + test + \\\\\\\"</font>\\\\\\\";\\\\n    },\\\\n    rich: (test) => {\\\\n        return \\\\\\\"‘‘’’\\\\\\\" + test;\\\\n    },\\\\n    addressTag: (url, text) => {\\\\n        return \\\\\\\"<a href='\\\\\\\" + url + \\\\\\\"'>\\\\\\\" + text + \\\\\\\"</a>\\\\\\\"\\\\n    },\\\\n    empty: \\\\\\\"hiker://empty\\\\\\\",\\\\n    layout: [],\\\\n    noLoad: \\\\\\\"#noLoading#\\\\\\\",\\\\n    timestamp: () => Math.floor(new Date().getTime() / 1000),\\\\n    t10: () => apiview.timestamp().toString(),\\\\n    t13: () => apiview.t10() + '000',\\\\n    host: getItem(\\\\\\\"api\\\\\\\"),\\\\n    getDatesArray: (endDate) => {\\\\n        // 将结束日期字符串转换为Date对象\\\\n        let endDateObj = new Date(endDate);\\\\n\\\\n        // 获取当前日期\\\\n        let currentDate = new Date();\\\\n\\\\n        // 初始化日期数组\\\\n        let datesArray = [];\\\\n\\\\n        // 循环从当前日期到结束日期\\\\n        while (currentDate >= endDateObj) {\\\\n            // 将日期转换为YYYY-MM-DD格式的字符串并添加到数组\\\\n            datesArray.push(currentDate.toISOString().split('T')[0]);\\\\n\\\\n            // 减去一天\\\\n            currentDate.setDate(currentDate.getDate() - 1);\\\\n        }\\\\n        /*\\\\n            // 反转数组以按降序排列日期\\\\n            datesArray.reverse();\\\\n        */\\\\n        return datesArray;\\\\n    },\\\\n    getYearMonthArray: (endDate) => {\\\\n        let endDateObj = new Date(endDate);\\\\n        let currentDate = new Date();\\\\n        let yearMonthArray = [];\\\\n\\\\n        // 确保当前日期不小于结束日期\\\\n        if (currentDate < endDateObj) {\\\\n            return yearMonthArray; // 如果当前日期小于结束日期，直接返回空数组\\\\n        }\\\\n\\\\n        // 循环从当前日期到结束日期\\\\n        while (currentDate >= endDateObj) {\\\\n            // 获取当前日期的年和月，并格式化为\\\\\\\"YYYY-MM\\\\\\\"字符串\\\\n            let year = currentDate.getFullYear();\\\\n            let month = (currentDate.getMonth() + 1).toString().padStart(2, '0'); // 月份从0开始，所以加1，并且确保是两位数\\\\n            let yearMonth = `${year}-${month}`; // 正确使用模板字符串\\\\n\\\\n            // 将年月字符串添加到数组\\\\n            yearMonthArray.push(yearMonth);\\\\n\\\\n            // 减去一个月\\\\n            currentDate.setMonth(currentDate.getMonth() - 1);\\\\n        }\\\\n\\\\n        return yearMonthArray;\\\\n    },\\\\n    CryptoJS: null, // 用于存储 CryptoJS 对象\\\\n    initCryptoJS: () => {\\\\n        if (!apiview.CryptoJS) {\\\\n            eval(getCryptoJS()); // 执行一次 eval，确保 `CryptoJS` 变量被定义\\\\n            apiview.CryptoJS = CryptoJS; // 将 `CryptoJS` 缓存到 `apiview.CryptoJS`\\\\n        }\\\\n    },\\\\n    Encrypt: (word) => {\\\\n        apiview.initCryptoJS(); // 确保 CryptoJS 已加载\\\\n        let key = apiview.CryptoJS.enc.Utf8.parse(\\\\\\\"l*bv%Ziq000Biaog\\\\\\\");\\\\n        let iv = apiview.CryptoJS.enc.Utf8.parse(\\\\\\\"8597506002939249\\\\\\\");\\\\n        let encrypt = apiview.CryptoJS.AES.encrypt(word, key, {\\\\n            iv: iv,\\\\n            mode: apiview.CryptoJS.mode.CBC,\\\\n            padding: apiview.CryptoJS.pad.Pkcs7,\\\\n        });\\\\n        return encrypt.toString(); // 默认返回 Base64 编码的字符串\\\\n    },\\\\n    Decrypt: (word) => {\\\\n        apiview.initCryptoJS(); // 确保 CryptoJS 已加载\\\\n        let key = apiview.CryptoJS.enc.Utf8.parse(\\\\\\\"l*bv%Ziq000Biaog\\\\\\\");\\\\n        let iv = apiview.CryptoJS.enc.Utf8.parse(\\\\\\\"8597506002939249\\\\\\\");\\\\n        let decrypt = apiview.CryptoJS.AES.decrypt(word, key, {\\\\n            iv: iv,\\\\n            mode: apiview.CryptoJS.mode.CBC,\\\\n            padding: apiview.CryptoJS.pad.Pkcs7,\\\\n        });\\\\n        return decrypt.toString(apiview.CryptoJS.enc.Utf8); // 解密结果转换为文本格式\\\\n    },\\\\n    Decrypt1: (input) => {\\\\n        return $(input).image(() => {\\\\n            const CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n            let key = CryptoUtil.Data.parseUTF8(\\\\\\\"saIZXc4yMvq0Iz56\\\\\\\");\\\\n            let iv = CryptoUtil.Data.parseUTF8(\\\\\\\"kbJYtBJUECT0oyjo\\\\\\\");\\\\n            let textData = CryptoUtil.Data.parseInputStream(input);\\\\n            let encrypted = CryptoUtil.AES.decrypt(textData, key, {\\\\n                mode: \\\\\\\"AES/CBC/PKCS7Padding\\\\\\\",\\\\n                iv: iv\\\\n            });\\\\n            return encrypted.toInputStream();\\\\n        })\\\\n    },\\\\n    gettoken: () => {\\\\n        var html = fetch(apiview.host+'/v2.5/refresh/token', {\\\\n            headers: {\\\\n                'Content-Type': 'application/x-www-form-urlencoded',\\\\n                'uuid': 'c9ad221f-b445-39d2-85f5-a693c24115e3',\\\\n                'timestamp': apiview.t10(),\\\\n                'ip': '0.0.0.0',\\\\n                'user-key': '760355cc88218f0c1514f56764362066',\\\\n                'platform': '1',\\\\n                'sign': md5(md5('0.0.0.0.1.'+apiview.t10()+'.760355cc88218f0c1514f56764362066.c9ad221f-b445-39d2-85f5-a693c24115e3')+'m4n2hjPeYWkD6tFpqKF^3HO^h24P@idT'),\\\\n                'app-version': '2.2.9',\\\\n                'Content-Length': '0',\\\\n                'Host': apiview.host.split('//')[1],\\\\n                'Connection': 'Keep-Alive',\\\\n                //'Accept-Encoding': 'gzip',\\\\n                'User-Agent': 'okhttp/4.3.1',\\\\n            },\\\\n            method: 'POST'\\\\n        }); //log(html)\\\\n        var html1 = apiview.Decrypt(html); //log(html1)\\\\n        //var logged_at = JSON.parse(html1).data.user.logged_at.split(' ')[0]; log(logged_at)\\\\n        var token = JSON.parse(html1).data.user.token; log(token)\\\\n        //setItem(\\\\\\\"logged_at\\\\\\\",logged_at)\\\\n        setItem(\\\\\\\"token\\\\\\\",token)\\\\n    },\\\\n    gethtml: (url,body) => {\\\\n        var html = fetch(url, {\\\\n            headers: {\\\\n                'uuid': 'c9ad221f-b445-39d2-85f5-a693c24115e3',\\\\n                'timestamp': apiview.t10(),\\\\n                'ip': '0.0.0.0',\\\\n                'user-key': '760355cc88218f0c1514f56764362066',\\\\n                'platform': '1',\\\\n                'sign': md5(md5('0.0.0.0.1.'+apiview.t10()+'.760355cc88218f0c1514f56764362066.c9ad221f-b445-39d2-85f5-a693c24115e3')+'m4n2hjPeYWkD6tFpqKF^3HO^h24P@idT'),\\\\n                'app-version': '2.2.9',\\\\n                'token': getItem(\\\\\\\"token\\\\\\\"),\\\\n                'Content-Type': 'application/x-www-form-urlencoded',\\\\n                'Content-Length': '0',\\\\n                'Host': apiview.host.split('//')[1],\\\\n                'Connection': 'Keep-Alive',\\\\n                //'Accept-Encoding': 'gzip',\\\\n                'User-Agent': 'okhttp/4.3.1',\\\\n            },\\\\n            body: body,            \\\\n            method: 'POST',\\\\n            rejectCoding: true\\\\n        }); //log(html)\\\\n        var html1 = apiview.Decrypt(html); //log(html1)\\\\n        return html1\\\\n    },\\\\n    tuwenyiji: (d,data) => {\\\\n        data.forEach(item => {\\\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n            d.push({\\\\n                title: item.published_at.split(' ')[0],\\\\n                img: img,\\\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\\\n                col_type: 'movie_2',\\\\n                extra: {\\\\n                    model_id: item.model_id,\\\\n                    id: item.id,\\\\n                    img: img\\\\n                }\\\\n            })\\\\n        })\\\\n    },\\\\n    yueduyiji: (d,data) => {\\\\n        data.forEach(item => {\\\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n            d.push({\\\\n                title: item.title + '\\\\\\\\n' + item.author,\\\\n                desc: item.description,\\\\n                img: img,\\\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\\\n                col_type: 'movie_1_left_pic',\\\\n                extra: {\\\\n                    model_id: item.model_id,\\\\n                    id: item.id,\\\\n                    img: img\\\\n                }\\\\n            })\\\\n        })\\\\n    },\\\\n    yingshiyiji: (d,data) => {\\\\n        data.forEach(item => {\\\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n            d.push({\\\\n                title: item.title,\\\\n                desc: item.description,\\\\n                img: img,\\\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\\\n                col_type: 'movie_1_left_pic',\\\\n                extra: {\\\\n                    model_id: item.model_id,\\\\n                    id: item.id,\\\\n                    img: img\\\\n                }\\\\n            })\\\\n        })\\\\n    },\\\\n    diantaiyiji: (d,data) => {\\\\n        data.forEach(item => {\\\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n            d.push({\\\\n                title: item.title,\\\\n                desc: '0',\\\\n                img: img,\\\\n                url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\\\n                col_type: 'card_pic_1',\\\\n                extra: {\\\\n                    model_id: item.model_id,\\\\n                    id: item.id,\\\\n                    img: img\\\\n                }\\\\n            })\\\\n        })\\\\n    },\\\\n    xiezhenmanhuayiji: (d,data) => {\\\\n        data.forEach(item => {\\\\n            var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n            d.push({\\\\n                title: item.title,\\\\n                desc: '0',\\\\n                img: img,\\\\n                url: $('hiker://empty' + item.id).rule(() => {\\\\n                    var apiview = $.require(\\\\\\\"hanshu\\\\\\\")\\\\n                    var url = apiview.host+'/v2.5/series/chapters'\\\\n                    var body = apiview.Encrypt('series_id=' + MY_URL.replace('hiker://empty', ''))\\\\n                    var data = JSON.parse(apiview.gethtml(url, body)).data; //log(data)\\\\n                    var d = [];\\\\n                    data.chapters.forEach(item => {\\\\n                        var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n                        d.push({\\\\n                            title: item.title,\\\\n                            desc: item.description,\\\\n                            img: img,\\\\n                            url: `hiker://page/erji?page=fypage#noHistory##gameTheme#`,\\\\n                            col_type: 'movie_1_left_pic',\\\\n                            extra: {\\\\n                                model_id: 2,\\\\n                                id: item.id,\\\\n                                img: img\\\\n                            }\\\\n                        })\\\\n                    })\\\\n                    setResult(d)\\\\n                }),\\\\n                col_type: 'card_pic_1'\\\\n            })\\\\n        })\\\\n    },\\\\n    tuwen: (d,data) => {\\\\n        var imgs = data.content.replace(/(<figure[\\\\\\\\S\\\\\\\\s]*?<\\\\\\\\/figure>)/g, \\\\\\\"@$1@\\\\\\\");\\\\n        imgs.split(\\\\\\\"@\\\\\\\").forEach(it => {\\\\n            if (it.includes(\\\\\\\"figure\\\\\\\")) {\\\\n                let img = apiview.Decrypt1('https://jmtp.gpgreii.com' + pdfh(it, \\\\\\\"img&&src\\\\\\\"))\\\\n                d.push({\\\\n                    //desc: '0',\\\\n                    img: img,\\\\n                    url: img,\\\\n                    col_type: 'pic_1_full'\\\\n                });\\\\n            } else if (it.trim()) {\\\\n                d.push({\\\\n                    title: it,\\\\n                    url: 'hiker://empty',\\\\n                    col_type: 'rich_text'\\\\n                });\\\\n            }\\\\n        })\\\\n    },\\\\n    biaoqian: (d,data) => {\\\\n        data.tags.forEach(item => {\\\\n            d.push({\\\\n                title: item,\\\\n                url: $(item + '#noLoading#').lazyRule(() => {\\\\n                    //putMyVar('search', input)\\\\n                    //refreshPage()\\\\n                    return 'hiker://empty'\\\\n                }),\\\\n                col_type: 'flex_button'\\\\n            })\\\\n        })\\\\n    },\\\\n    yulantu: (d,data) => {\\\\n        data.multiple_pic.forEach(item => {\\\\n            let img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item)\\\\n            d.push({\\\\n                img: img,\\\\n                url: img,\\\\n                col_type: 'card_pic_3'\\\\n            })\\\\n        })\\\\n    },\\\\n    pinglun: (d, data) => {\\\\n        data.forEach(data => {\\\\n            if (data.author) {\\\\n                if (data.avatar == '') {\\\\n                    var avatar = 'https://img.vinua.cn/images/InnDk.th.png'\\\\n                } else {\\\\n                    var avatar = apiview.Decrypt1('https://jmtp.gpgreii.com' + data.avatar)\\\\n                }\\\\n                d.push({\\\\n                    title: data.author,\\\\n                    desc: data.created_at,\\\\n                    img: avatar,\\\\n                    url: 'hiker://empty',\\\\n                    col_type: 'avatar'\\\\n                })\\\\n                if (data.replies.length != '0') {\\\\n                    var title = data.text + apiview.addressTag('hiker://page/pinlun', '\\\\\\\\t\\\\\\\\t\\\\\\\\t查看全部')\\\\n                } else {\\\\n                    var title = data.text\\\\n                }\\\\n                d.push({\\\\n                    title: apiview.gray(title),\\\\n                    col_type: 'rich_text',\\\\n                    extra: {\\\\n                        title: data.author,\\\\n                        desc: data.created_at,\\\\n                        desc1: data.text,\\\\n                        img: avatar,\\\\n                        item: data.replies,\\\\n                        pageTitle: data.author\\\\n                    }\\\\n                })\\\\n            }\\\\n        })\\\\n    }\\\\n}\\\\n\\\\n$.exports = apiview;\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"点播\\\",\\\"path\\\":\\\"cla1\\\",\\\"rule\\\":\\\"var endDate = \\\\\\\"2021-09-01\\\\\\\";\\\\nvar he = apiview.getYearMonthArray(endDate); //log(he) \\\\nvar subs = he //log(subs) \\\\nif(MY_PAGE == '1'){\\\\nhe.forEach((x,i)=>{\\\\n    var ctitle = x\\\\n    var sub = subs[i]\\\\n    d.push({\\\\n        title: getMyVar('ctitle', he[0]) == ctitle ? '““””'+ctitle.fontcolor('#'+getRangeColors()):ctitle,\\\\n        url: $('#noLoading##noHistory#').lazyRule((ctitle,sub) => {\\\\n                putMyVar(\\\\\\\"ctitle\\\\\\\", ctitle);\\\\n                putMyVar(\\\\\\\"sub\\\\\\\",sub);\\\\n                refreshPage();\\\\n                return 'hiker://empty'\\\\n            }, ctitle,sub),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    })\\\\n})\\\\n}\\\\nvar he = getMyVar(\\\\\\\"ctitle\\\\\\\",he[0])\\\\nvar sub = getMyVar(\\\\\\\"sub\\\\\\\",subs[0]); //log(sub)\\\\n\\\\nvar url = apiview.host+'/v2.5/article/discovery'\\\\nvar body = apiview.Encrypt('model_id=6&published_at='+sub+'&page='+MY_PAGE+'&size=20&sort=published_at')\\\\nvar data = JSON.parse(apiview.gethtml(url,body)).data;\\\\ndata.forEach(item => {\\\\n    var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n    d.push({\\\\n        title: item.title,\\\\n        desc: '',\\\\n        img: img,\\\\n        url: `hiker://page/erji1?page=fypage#noHistory#`,\\\\n        col_type: 'pic_1_card',\\\\n        extra: {\\\\n            model_id: item.model_id,\\\\n            id: item.id,\\\\n            img: img\\\\n        }\\\\n    })\\\\n})\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"点播二级\\\",\\\"path\\\":\\\"erji1\\\",\\\"rule\\\":\\\"js:\\\\nvar apiview = $.require(\\\\\\\"hanshu\\\\\\\")\\\\nvar model_id = MY_PARAMS.model_id; //log(typeof model_id)\\\\nvar id = MY_PARAMS.id; //log(id)\\\\nvar img = MY_PARAMS.img\\\\nvar d = [];\\\\nif(MY_PAGE == '1'){\\\\nd.push({\\\\n    desc: '0',\\\\n    img: img,\\\\n    url: img,\\\\n    col_type: 'card_pic_1'\\\\n})\\\\nif(getMyVar('a') == '1'){\\\\nvar title1 = '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t影片介绍\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t'\\\\nvar title2 = '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t‘‘用户评价’’\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t'\\\\n}else{\\\\nvar title1 = '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t‘‘影片介绍’’\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t'\\\\nvar title2 = '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t用户评价\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t'\\\\n}\\\\nd.push({\\\\n    title: title1,\\\\n    url: $('#noLoading#').lazyRule(()=>{\\\\n        clearMyVar('a')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }),\\\\n    col_type: 'flex_button',\\\\n    //extra: {'backgroundColor': '#E0F8FF'}\\\\n})\\\\nd.push({\\\\n    title: title2,\\\\n    url: $('#noLoading#').lazyRule(()=>{\\\\n        putMyVar('a','1')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }),\\\\n    col_type: 'flex_button',\\\\n    //extra: {'backgroundColor': '#E0F8FF'}\\\\n})\\\\n}\\\\nif(getMyVar('a') == '1'){\\\\nvar url = apiview.host+'/v2.5/comment/list'\\\\nvar body = apiview.Encrypt('article_id='+id+'&page='+MY_PAGE+'&size=20&sorting='+getMyVar('a1','likes'))\\\\nvar data = JSON.parse(apiview.gethtml(url, body)).data; //log(data)\\\\nif(MY_PAGE == '1'){\\\\nif(getMyVar('a1','likes') == 'likes'){\\\\nvar text = '当前排序：按热度'\\\\n}\\\\nif(getMyVar('a1') == 'created_at'){\\\\nvar text = '当前排序：按时间'\\\\n}\\\\n//log(getMyVar('a1','likes'))\\\\nvar paixu = $('#noLoading#').b64().lazyRule(() => {\\\\n    if(getMyVar('a1','likes') == 'likes'){\\\\n        putMyVar('a1','created_at')\\\\n        toast('按时间')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }\\\\n    if(getMyVar('a1') == 'created_at'){\\\\n        putMyVar('a1','likes')\\\\n        toast('按热度')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }\\\\n})\\\\nd.push({\\\\n    title: apiview.big(apiview.strong('评论列表'))+'\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t'+apiview.addressTag(paixu,text),\\\\n    col_type: 'rich_text',\\\\n})\\\\n}\\\\napiview.pinglun(d,data)\\\\n}else{\\\\nif(MY_PAGE == '1'){\\\\nvar url = apiview.host+'/v2.5/article/detail'\\\\nvar body = apiview.Encrypt('id='+id)\\\\nvar data = JSON.parse(apiview.gethtml(url,body)).data; //log(data)\\\\nd.push({\\\\n    title: '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t预览\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t',\\\\n    url: $(data.video_file+'#noLoading#').lazyRule((data)=>{\\\\n        return 'https://akmaivideo.cdchuangao.com'+input\\\\n    },data),\\\\n    col_type: 'text_2',\\\\n    //extra: {'backgroundColor': '#E0F8FF'}\\\\n})\\\\nd.push({\\\\n    title: '\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t原片\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t',\\\\n    url: $(data.video_file+'#noLoading#').lazyRule((data)=>{\\\\n        if(/sample/.test(input)){\\\\n            var url = input.replace(/[^a-zA-Z0-9](sample)/,'')\\\\n            return 'https://akmaivideo.cdchuangao.com'+url\\\\n        }\\\\n        if(!/无/.test(data.number)){\\\\n            var url = input.replace(/\\\\\\\\/([^\\\\\\\\/]+)\\\\\\\\./,'/'+data.number+'.')\\\\n            return 'https://akmaivideo.cdchuangao.com'+url\\\\n        }\\\\n    },data),\\\\n    col_type: 'text_2',\\\\n    //extra: {'backgroundColor': '#E0F8FF'}\\\\n})\\\\nd.push({\\\\n    title: apiview.big(apiview.strong(data.title))+'<br><br>'+'番号：'+apiview.gray(data.number)+'\\\\\\\\t\\\\\\\\t\\\\\\\\t'+'演员：'+apiview.gray(data.actor)+'<br>'+apiview.gray(data.published_at.split(' ')[0])+'\\\\\\\\t\\\\\\\\t\\\\\\\\t'+apiview.gray(data.length)+'\\\\\\\\t\\\\\\\\t\\\\\\\\t'+apiview.gray(data.size)+'\\\\\\\\t\\\\\\\\t\\\\\\\\t'+apiview.gray(data.quality),\\\\n    url: 'hiker://empty',\\\\n    col_type: 'rich_text'\\\\n})\\\\napiview.biaoqian(d,data)\\\\napiview.yulantu(d,data)\\\\n//log(data.content)\\\\napiview.tuwen(d,data)\\\\n\\\\n}\\\\n}\\\\n\\\\nsetResult(d)\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"评论详情\\\",\\\"path\\\":\\\"pinlun\\\",\\\"rule\\\":\\\"js:\\\\nvar apiview = $.require(\\\\\\\"hanshu\\\\\\\")\\\\nvar d = [];\\\\nd.push({\\\\n    title: MY_PARAMS.title,\\\\n    desc: MY_PARAMS.desc,\\\\n    img: MY_PARAMS.img,\\\\n    url: 'hiker://empty',\\\\n    col_type: 'avatar'\\\\n})\\\\nd.push({\\\\n    title: apiview.gray(MY_PARAMS.desc1),\\\\n    col_type: 'rich_text',\\\\n})\\\\nd.push({\\\\n    title: apiview.big(apiview.strong('相关回复共'+MY_PARAMS.item.length+'条')),\\\\n    col_type: 'rich_text',\\\\n})\\\\nMY_PARAMS.item.reverse().forEach(data => {\\\\n    if (data.avatar == '') {\\\\n        var avatar = 'https://img.vinua.cn/images/InnDk.th.png'\\\\n    } else {\\\\n        var avatar = apiview.Decrypt1('https://jmtp.gpgreii.com' + data.avatar)\\\\n    }\\\\n    d.push({\\\\n        title: data.author,\\\\n        desc: data.created_at,\\\\n        img: avatar,\\\\n        url: 'hiker://empty',\\\\n        col_type: 'avatar'\\\\n    })\\\\n    d.push({\\\\n        title: apiview.addressTag('hiker://empty','@'+data.tag_author+'\\\\\\\\t\\\\\\\\t\\\\\\\\t')+apiview.gray(data.text),\\\\n        col_type: 'rich_text',\\\\n    })\\\\n})\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"首页\\\",\\\"path\\\":\\\"home\\\",\\\"rule\\\":\\\"if(MY_PAGE == '1'){\\\\nvar endDate = \\\\\\\"2019-11-08\\\\\\\";\\\\nvar datesArray = apiview.getDatesArray(endDate);\\\\nvar url = apiview.host+'/v2.5/article/day'\\\\nvar published_at = getMyVar(\\\\\\\"published_at\\\\\\\") == '' ? datesArray[0] : getMyVar(\\\\\\\"published_at\\\\\\\"); //log(published_at)\\\\nvar body = apiview.Encrypt('published_at='+published_at)\\\\nvar data = JSON.parse(apiview.gethtml(url,body)).data;\\\\ndata.info.forEach(item => {\\\\n    var img = apiview.Decrypt1('https://jmtp.gpgreii.com' + item.thumb)\\\\n    if(item.model_id == '6'){\\\\n    var url = `hiker://page/erji1?page=fypage#noHistory#`\\\\n    }else{\\\\n    var url = `hiker://page/erji?page=fypage#noHistory##gameTheme#`\\\\n    }\\\\n    d.push({\\\\n        title: `${apiview.strong(item.title)}<br>${apiview.gray(item.author)}<br>${apiview.gray(item.description.replace(/\\\\\\\\n/g,'<br>'))}`,\\\\n        col_type: 'rich_text'\\\\n    })\\\\n    d.push({\\\\n        img: img,\\\\n        url: url,\\\\n        col_type: 'pic_1_full',\\\\n        extra: {\\\\n            model_id: item.model_id,\\\\n            id: item.id,\\\\n            img: img\\\\n        }\\\\n    })\\\\n    d.push({\\\\n        col_type: 'line_blank'\\\\n    })\\\\n})\\\\nd.push({\\\\n    title: '““切换””',\\\\n    url: $().lazyRule((published_at,datesArray) => {\\\\n        showSelectOptions({\\\\n            title: '当前：'+published_at,\\\\n            options: datesArray,\\\\n            js: $.toString(() => {\\\\n                putMyVar(\\\\\\\"published_at\\\\\\\",input);\\\\n                refreshPage();\\\\n                return \\\\\\\"toast://\\\\\\\" + input\\\\n            })\\\\n        });\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    },published_at,datesArray),\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n})\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级\\\",\\\"path\\\":\\\"erji\\\",\\\"rule\\\":\\\"js:\\\\nvar apiview = $.require(\\\\\\\"hanshu\\\\\\\")\\\\nvar model_id = MY_PARAMS.model_id; //log(typeof model_id)\\\\nvar id = MY_PARAMS.id; //log(id)\\\\nvar img = MY_PARAMS.img\\\\nvar d = [];\\\\n\\\\nif(MY_PAGE == '1'){\\\\nvar url = apiview.host+'/v2.5/article/detail'\\\\nvar body = apiview.Encrypt('id='+id)\\\\nvar data = JSON.parse(apiview.gethtml(url,body)).data; //log(data)\\\\nswitch (model_id) {\\\\n    case 1:\\\\n        d.push({\\\\n            img: img,\\\\n            url: img,\\\\n            col_type: 'pic_1_full'\\\\n        })\\\\n        d.push({\\\\n            title: `${apiview.strong(apiview.center(data.title))}${apiview.gray(data.description)}${apiview.gray(apiview.center(data.author))}`,\\\\n            col_type: 'rich_text'\\\\n        })\\\\n        break;\\\\n    case 2:\\\\n        d.push({\\\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\\\n            col_type: 'rich_text'\\\\n        })\\\\n        apiview.tuwen(d,data)\\\\n        break;\\\\n    case 3:\\\\n        d.push({\\\\n            img: img,\\\\n            url: img,\\\\n            col_type: 'pic_1_full'\\\\n        })\\\\n        d.push({\\\\n            title: '““视频””',\\\\n            url: 'https://akmaivideo.cdchuangao.com' + data.video_file,\\\\n            col_type: 'text_center_1'\\\\n        })\\\\n        d.push({\\\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\\\n            col_type: 'rich_text'\\\\n        })\\\\n        apiview.tuwen(d,data)\\\\n        break;\\\\n    case 4:\\\\n        d.push({\\\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\\\n            col_type: 'rich_text'\\\\n        })\\\\n        apiview.tuwen(d,data)\\\\n        break;\\\\n    case 5:\\\\n        d.push({\\\\n            img: img,\\\\n            url: img,\\\\n            col_type: 'pic_1_full'\\\\n        })\\\\n        d.push({\\\\n            title: '““电台””',\\\\n            url: 'https://akmaivideo.cdchuangao.com' + data.video,\\\\n            col_type: 'text_center_1'\\\\n        })\\\\n        d.push({\\\\n            title: `<h1>${apiview.strong(data.title)}</h1>${apiview.gray(data.author)}`,\\\\n            col_type: 'rich_text'\\\\n        })\\\\n        apiview.tuwen(d,data)\\\\n        break;\\\\n    case 6:\\\\n\\\\n        break;\\\\n}\\\\nif(getMyVar('a1','created_at') == 'created_at'){\\\\nvar text = '当前排序：按时间'\\\\n}\\\\nif(getMyVar('a1') == 'likes'){\\\\nvar text = '当前排序：按热度'\\\\n}\\\\n//log(getMyVar('a1','created_at'))\\\\nvar paixu = $('#noLoading#').b64().lazyRule(() => {\\\\n    if(getMyVar('a1','created_at') == 'created_at'){\\\\n        putMyVar('a1','likes')\\\\n        toast('按热度')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }\\\\n    if(getMyVar('a1') == 'likes'){\\\\n        putMyVar('a1','created_at')\\\\n        toast('按时间')\\\\n        refreshPage()\\\\n        return 'hiker://empty'\\\\n    }\\\\n})\\\\nd.push({\\\\n    title: apiview.big(apiview.strong('相关回复共'+data.reply_counts+'条'))+'\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t'+apiview.addressTag(paixu,text),\\\\n    col_type: 'rich_text',\\\\n})\\\\n}\\\\nvar url = apiview.host+'/v2.5/comment/list'\\\\nvar body = apiview.Encrypt('article_id='+id+'&page='+MY_PAGE+'&size=20&sorting='+getMyVar('a1','created_at'))\\\\nvar data = JSON.parse(apiview.gethtml(url, body)).data; //log(data)\\\\napiview.pinglun(d,data)\\\\n\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"发现\\\",\\\"path\\\":\\\"cla\\\",\\\"rule\\\":\\\"var endDate = \\\\\\\"2021-09-01\\\\\\\";\\\\nvar he1 = ['图文','阅读','影视','电台','写真','漫画']; //log(he1) \\\\nvar subs1 = ['1','2','3','5','0','0']; //log(subs1) \\\\nvar subs2 = apiview.getYearMonthArray(endDate); //log(subs2)\\\\nif(MY_PAGE == '1'){\\\\nhe1.forEach((x,i)=>{\\\\n    var ctitle1 = x\\\\n    var sub1 = subs1[i]\\\\n    d.push({\\\\n        title: getMyVar('ctitle1', he1[0]) == ctitle1 ? '““””'+ctitle1.fontcolor('#'+getRangeColors()):ctitle1,\\\\n        url: $('#noLoading##noHistory#').lazyRule((ctitle1,sub1) => {\\\\n                putMyVar(\\\\\\\"ctitle1\\\\\\\", ctitle1);\\\\n                putMyVar(\\\\\\\"sub1\\\\\\\",sub1);                \\\\n                refreshPage();\\\\n                return 'hiker://empty'\\\\n            }, ctitle1,sub1),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    })\\\\n})\\\\n}\\\\nvar he1 = getMyVar(\\\\\\\"ctitle1\\\\\\\",he1[0]); //log(he1)\\\\nvar sub1 = getMyVar(\\\\\\\"sub1\\\\\\\",subs1[0]); //log(sub1)\\\\nvar sub2 = subs2[MY_PAGE-1]; //log(sub2)\\\\n\\\\nif(he1 == '写真'){\\\\nvar url = apiview.host+'/v2.5/series/album/list'\\\\nvar body = apiview.Encrypt('type='+sub1+'&page='+MY_PAGE+'&size=31&sort=published_at')\\\\n}else if(he1 == '漫画'){\\\\nvar url = apiview.host+'/v2.5/series/manga/list'\\\\nvar body = apiview.Encrypt('type='+sub1+'&page='+MY_PAGE+'&size=31&sort=published_at')\\\\n}else{\\\\nvar url = apiview.host+'/v2.5/article/discovery'\\\\nvar body = apiview.Encrypt('model_id='+sub1+'&published_at='+sub2+'&page=1&size=31')\\\\n}\\\\nvar data = JSON.parse(apiview.gethtml(url,body)).data;\\\\n\\\\nswitch (sub1) {\\\\n    case '0':\\\\n        apiview.xiezhenmanhuayiji(d,data)\\\\n        break;\\\\n    case '1':\\\\n        apiview.tuwenyiji(d, data)\\\\n        break;\\\\n    case '2':\\\\n        apiview.yueduyiji(d, data)\\\\n        break;\\\\n    case '3':\\\\n        apiview.yingshiyiji(d, data)\\\\n        break;\\\\n    case '5':\\\\n        apiview.diantaiyiji(d, data)\\\\n        break;\\\\n}\\\"}]\"}","picUrl":"https://jmtp.gpgreii.com/storage/thumb/27707/67a21167b407c.jpg@js=$.hiker.MY_TITLE = \"一个APP\";(\n() => {\n    const CryptoUtil = $.require(\"hiker://assets/crypto-java.js\");\n    let key = CryptoUtil.Data.parseUTF8(\"saIZXc4yMvq0Iz56\");\n    let iv = CryptoUtil.Data.parseUTF8(\"kbJYtBJUECT0oyjo\");\n    let textData = CryptoUtil.Data.parseInputStream(input);\n    let encrypted = CryptoUtil.AES.decrypt(textData, key, {mode: \"AES/CBC/PKCS7Padding\", iv: iv});\n    return encrypted.toInputStream();\n}\n)()","title":"PONDEMIX (雪国おまる)｜作品-帮助了一位无处可去的淫荡又纯洁女孩~她通过要求SEX来回报‼️①"}

Add Comment

Please, Sign In to add comment