API tools faq
paste
xiaomianao666

小程序：樱花动漫

xiaomianao666
Jun 30th, 2023
320
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 103.62 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@樱花动漫@{"last_chapter_rule":"","title":"樱花动漫","author":"zetalpha","url":"hiker://empty##http://yhdm81.com/##fypage","version":0,"col_type":"movie_3","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar d = []\n\nvar edition = 'new' //new 新版 old 旧版\n\nif (edition == 'old') { eval(JSON.parse(request('hiker://page/old')).rule)\n}\n\nMY_URL = MY_URL.split('##')[1]\n\n\nvar titles = ['首页', '筛选', '排行', '搜索']\n\nvar tindex = storage0.getMyVar('tindex', 0)\n\ntitles = titles.map((x, i) => {\n    var title = i == tindex ? `““””<b><font color=\"#1E90FF\">${x}</font></b>` : x\n    return title\n})\n\nif (MY_PAGE == 1) {\n    d.push({\n        title: titles[0],\n        img: 'https://lanmeiguojiang.com/tubiao/more/47.png@Referer=',\n        col_type: 'icon_small_4',\n        url: $('').lazyRule(() => {\n            putVar(MY_RULE.url, config.首页)\n            storage0.putMyVar('tindex', 0)\n            refreshPage()\n            return 'hiker://empty'\n        }),\n        extra: {\n            longClick: [{\n                title: '强制更新',\n                js: $.toString(() => {\n                    deleteFile(config.ui)\n                    refreshPage()\n                    return 'toast://完成'\n                })\n            }]\n        }\n    })\n\n    d.push({\n        title: titles[1],\n        img: 'https://lanmeiguojiang.com/tubiao/more/104.png@Referer=',\n        col_type: 'icon_small_4',\n        url: $('').lazyRule(() => {\n            storage0.putMyVar('tindex', 1)\n            refreshPage()\n            return 'hiker://empty'\n        })\n    })\n\n    d.push({\n        title: titles[2],\n        img: 'https://lanmeiguojiang.com/tubiao/more/74.png@Referer=',\n        col_type: 'icon_small_4',\n        url: $('').lazyRule(() => {\n            storage0.putMyVar('tindex', 2)\n            refreshPage()\n            return 'hiker://empty'\n        })\n    })\n\n    d.push({\n        title: titles[3],\n        img: 'https://lanmeiguojiang.com/tubiao/more/7.png@Referer=',\n        col_type: 'icon_small_4',\n        url: $('').lazyRule(() => {\n            storage0.putMyVar('tindex', 3)\n            refreshPage()\n            return 'hiker://empty'\n        })\n    })\n}\n\n//扩展函数\neval(JSON.parse(request('hiker://page/extend')).rule)\n\n\n//随机颜色\nvar getRangeColors = function() {       \n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);     \n}\n\n\nlet true_url = getVar(MY_RULE.url, MY_URL)\n//const page = MY_PAGE\n\n//log(true_url)\n\n\n//list 列表 item每项\nvar selects = {\n    item: 'item',\n    list: \"pdfa(html, 'body&&.mb')\",\n    img: \"pd(item, 'img&&data-original')\",\n    title: \"pdfh(item, 'a&&title')\",\n    desc: \"pdfh(item, '.bz&&Text')\",\n    url: \"pd(item, 'a&&href')\",\n    col_type: 'movie_3_marquee'\n}\n\neval(JSON.parse(request('hiker://page/ui')).rule)\n\nconst page = MY_PAGE\n\nswitch (parseInt(tindex)) {\n    case 0:\n        eval(JSON.parse(request('hiker://page/main')).rule)\n        break;\n    case 1:\n        eval(JSON.parse(request('hiker://page/sift')).rule)\n        break;\n    case 2:\n        eval(JSON.parse(request('hiker://page/rank')).rule)\n        break;\n    case 3:\n        eval(JSON.parse(request('hiker://page/search')).rule)\n        break;\n}\n\n\nsetResult(d);","search_url":"http://yhdm81.com/search.php?searchword=**;post;UTF-8;","group":"2️⃣动漫","searchFind":"js:\nvar d = []\n//扩展函数\neval(JSON.parse(request('hiker://page/extend')).rule)\nvar html = getResCode()\n\nvar s = pdfh(html, 'body&&.wrap>script&&Html')\nvar q=''\n\neval(s)\nif(q==''){\n    d.push({\n        title: '搜索等待:需等待5秒刷新',\n        col_type: \"text_1\",\n        desc: \"\",\n        url: \"\",\n        extra: {\n            id: 'test_1'\n        }\n    });\n\n    setResult(d);\n\n\n    for (let i = 4; i >= 0; i--) {\n        java.lang.Thread.sleep(1000)\n        let obj = findItem('test_1');\n        log(obj.title)\n        updateItem('test_1', {\n            title: obj.title.replace(/(\\d)/, () => {\n                return i\n            })\n        });\n    }\n    updateItem('test_1', {\n        title: '请下拉刷新'\n    })\n}\n\n\nvar p = {\n    top: \"10\",\n    q: q,\n    other_kkk217: _other_kkk217,\n    dect: f_dect\n}\n\nvar u = urlParse(MY_URL)\nvar host = u.Protocol + `://${u.Host}`\n\nvar json = fetch(`${my_search}?${Object.ToParams(p)}`)\n\nvar j = JSON.parse(json)\n\nif(json.includes('error_1')){\n    d.push({\n        title:j[0].error_1\n    })\n    j=[]\n}\n\n\n\n\n\n\nfor (let i of j) {\n\n    var lianzai = i.lianzaijs ? '连载至' + i.lianzaijs + '集' : i.beizhu;\n    var star = i.star != '' ? '主演：' + i.star : '无'\n    var img = i.thumb\n\n    d.push({\n        title: i.title,\n        url: (i.url.includes('http') ? i.url : host + i.url) + '#immersiveTheme#',\n        //img: (img.endsWith('0') ? img + '/' : img) + '@Referer='+config.首页,\n        img:img+'@Referer=',\n        desc: lianzai,\n        content: star\n\n    })\n}\n\n\nsetResult(d)","detail_col_type":"movie_1","detail_find_rule":"js:\n\nrequire(config.ui)\nvar d = []\n\nMY_URL = MY_URL.replace('#immersiveTheme#', '')\nvar html = getResCode()\n\nvar title = MY_PARAMS.title!=undefined?MY_PARAMS.title:pdfh(html, ' .name--span--span&&Text')\n\n\nsetPageTitle(title)\n\n//var title = xpath(html, \"//dt[@class='name']/text()[1]\")\n\n\n\n\nvar s = pdfh(html, 'body&&script[src*=d.gqyy8.com]&&src')\n\nvar so = request(s)\n//log(so)\n\nfunction getCap(str, re) {\n    var data = [];\n    str.replace(re, function(match, capture) {\n        data.push(capture == undefined ? '' : capture);\n    });\n    return data\n}\n\nfunction swapArr(arr, index1, index2) {\n    arr[index1] = arr.splice(index2, 1, arr[index1])[0];\n    return arr;\n}\n\nvar arr = getCap(so, /lianzaijs_?(\\w{0,})_ed/gm)\n\n\n//log(arr)\n\nvar type = {\n    cctv:\"主线\",\n    1: \"永久\",\n    2: \"最大\",\n    zd: \"最大\",\n    yj: \"永久\",\n    hn: \"牛牛\",\n    gs: \"光波\",\n    sn: \"新朗\",\n    wl: \"涡轮\",\n    lz: \"良子\",\n    fs: \"F速\",\n    bd: \"百度\",\n    uk: \"酷U\",\n    wj: \"无天\",\n    bj: \"八戒\",\n    tk: \"天空\",\n    ss: \"速速\",\n    kb: \"酷播\",\n    sd: \"闪电\",\n    xk: \"看看\",\n    tp: \"淘淘\",\n    jy: \"精英\",\n    ff: \"飞飞\"\n}\n\nvar playlist = []\nvar tabs = []\nvar lists = []\n\n\n\nfor (let it of arr) {\n    \n    if (it != '') {\n        tabs.push(type[it])\n        playlist.push(`playarr_${it}`)\n    } else {\n        tabs.push('主线')\n        playlist.push('playarr')\n    }\n}\n\neval(so)\n\nvar lazy = ''\n\nif (request('hiker://home@配置助手') != 'null') {\n\n    lazy = $('').lazyRule(() => {\n        return $.require(\"hiker://page/mulParse?rule=配置助手\").mulParse(input);\n    })\n\n    lazydm = $('').lazyRule(() => {\n        //网站链接\n        var link1 = input.split(';')[0]\n        //源站链接\n        var link2 = input.split(';')[1]\n        /*var h = request(link1)\n        var s = pdfh(h, 'head&&script,-2&&Html')\n        eval(s)\n        //log(s)\n        var l = decodeURIComponent(_s2_dplayer_2) + '?vid=' + link2;\n        var h2 = request(l, {\n            headers: {\n                'Referer': 'http://yhdm16.com/',\n                'User-Agent': MOBILE_UA\n            }\n        })\n        var src = decodeURIComponent(pdfh(h2, '#playiframe&&src'))\n        src = 'video://' + src + ';get;UTF-8;{Referer@http://yhdm16.com/}'\n        //log(src)\n        log(src)*/\n\n        const m = $.require(\"hiker://page/yhlink\");\n        var iurls = m.gc(link1)\n\n\n        //iurls.unshift('主线;'+link1)\n\n        //log(iurls)\n\n        /*var urls = pdfh(h2, 'Html&&script,1&&Html')\n        eval(urls)\n        log(urls)*/\n\n        var lazy = $('').lazyRule(() => {\n            return 'video://' + input\n        })\n\n        var turls = []\n        var tjx = []\n        for (let i = 0; i < iurls.length; i++) {\n            var name = iurls[i].split(';')[0]\n            var link = 'video://' + iurls[i].split(';')[1]\n            tjx.push(name)\n            turls.push(link)\n        }\n\n        //input = link1\n        //log(input)\n        //var jx = src.replace(/url=.+/gm, 'url=')\n        var vipUrl = link2\n        try {\n            var bfurl = turls;\n            var jxs = tjx\n            //log(bfurl)\n        } catch (e) {\n            var bfurl = [];\n        }\n        /*log('debug')\n        log(vipUrl)\n        log(parse)\n        log(bfurl)*/\n\n        return $.require(\"hiker://page/mulParse?rule=配置助手\").mulParse(vipUrl, bfurl, jxs, [{\n            \"User-Agent\": MOBILE_UA\n        }]);\n    })\n    \n    \n    \n    var lazyx = $('').lazyRule(() => {\n        const m = $.require(\"hiker://page/yhlink\");\n        var iurls = m.gc(input)\n        log(iurls)\n        names = iurls.map(x => x.split(';')[0])\n        urls= iurls.map(x => x.split(';')[1])\n        urls = iurls.map(x => {\n            var url = x.split(';')[1]\n            if (url.includes('shenjw')) {\n                url = url + '.m3u8'\n            }\n            if(url.includes('?url=')){\n                url='video://'+url+'@Referer='\n            }\n            return url\n        })\n\n        return {\n            urls: urls,\n            names: names\n        }\n    })\n}\n\n\n//log(playlist)\n// log(so)\n\nfor (let play of playlist) {\n    var p = eval(play).filter(x => x != null)\n    if (!p[0].includes('http')) {\n        //tabs.shift()\n        //continue\n    }\n    var pl = p.map((x, i) => {\n        var t = unescape(x.split(',')[2]);\n        var u = x.split(',')[0];\n        if (isofficial(u)) {\n            if (lazy != '') {\n                //u = u + lazy\n                u = MY_URL + (i + 1) + '.html;' + u + lazydm\n            } else {\n                u = 'video://' + MY_URL + (i + 1) + '.html'\n            }\n        } else if (u.includes('http')) {\n            if (!u.endsWith('m3u8')) {\n                u = u + '.m3u8'\n            }\n        } else {\n            u = 'video://'+ MY_URL + (i + 1) + '.html'\n        }\n        return {\n            title: t,\n            url: u\n        }\n    })\n    lists.push(pl)\n}\n\nvar m = tabs.indexOf('主线')\n\nif (m != -1) {\n    tabs = swapArr(tabs, m, 0)\n    lists = swapArr(lists, m, 0)\n}\n\n\nvar ff = JSON.parse(JSON.stringify(MY_PARAMS));\n\nvar 状态 = '状态: ' + pdfh(html, '.name&&span&&Text')\nvar 导演 = eval(config.导演)\nvar 主演 = eval(config.主演)\nvar 简介 = eval(config.简介)\nvar 类型 = eval(config.类型)\nif (主演 == '') {\n    主演 = '类型：' + 类型\n}\n\n\nlet hd = {\n    导演: ff.dire != undefined ? ff.dire : 导演,\n    主演: ff.star != undefined ? ff.star : 主演,\n    //显示的白色大字\n    大字: ff.state != undefined ? ff.state : 状态,\n    //片名搜索用\n    片名: ff.title != undefined ? ff.title : title,\n    //图片一定不要加Referer\n    图片: ff.img != undefined ? ff.img : eval(config.二级图片),\n    //图片: eval(config.二级图片),\n    //描述里用<br>换行\n    描述: (ff.content != undefined ? ff.desc : 简介),\n}\nif (hd.图片 != '') {\n    try {\n hd.图片 = convertBase64Image(hd.图片)\n    }catch {}\n}\nx5header(d, hd)\n\nlet pushx = getMyVar('pushx', '')\nif (pushx != '') {\n    二级推送组件(d);\n}\n\nvar searchexp = getMyVar('exp', '')\n//log(searchexp)\n//独立快捷版搜索\nif (searchexp == 'exp' || tabs.length == 1) {\n    eval(JSON.parse(fetch('hiker://page/qsearchd', {})).rule);\n}\n\n\nsetTabs(tabs, MY_URL);\nsetLists(lists, getMyVar(MY_URL, '0'));\n//log(lists)\n\n//扩展函数\n//eval(JSON.parse(request('hiker://page/extend')).rule)\n\n//var matches=/lianzaijs_?(\\w{0,})_ed/gm.matchAll(so)\n\n//log(matches.map(x=>x[1]))\n\n\n\n\nsetHomeResult(d)","sdetail_col_type":"movie_1","sdetail_find_rule":"*","ua":"mobile","preRule":"var ui = getPath('hiker://files/rules/zetalpha/hkUi.js')\n\nvar hkui = 'https://gitee.com/zetalpha/hikerview/raw/master/support/js/hkUi.js'\n\ninitConfig({\n    主演: \"pdfh(html, '.info&&dd:matches(演员)&&Text').split(' ').slice(0, 8).join(' ')\",\n    类型: \"pdfa(html, '.info&&dd:matches(类型)&&a').map(x=>pdfh(x,'Text')).join(' ')\",\n    导演: \"pdfh(html, '.info&&dd:matches(地区)&&Text')\",\n    简介: \"pdfh(html, '.des2&&Text')\",\n    二级图片: \"pdfh(html,'.lazy&&data-original')\",\n    首页: 'http://yhdm81.com/',\n    ui: ui,\n    hkui: hkui,\n});\n\neval(request('https://gitee.com/zetalpha/hikerview/raw/master/support/js/Ver.js'))\n\ncheckInFiles(['hkUi.js', 'descStyle.html'])\n\nrunOncePerDay(\"Updata(['hkUi.js', 'descStyle.html'])\")","pages":"[{\"col_type\":\"movie_3\",\"name\":\"扩展函数\",\"path\":\"extend\",\"rule\":\"//url解析\\nfunction urlParse(u) {\\n    var dict = {}\\n    dict.Source = u;\\n    let params = (url) => {\\n        let queryParams = {};\\n        let reg = /([^?=&]+)=([^?=&]+)/g;\\n        url.replace(reg, function() {\\n            queryParams[arguments[1]] = arguments[2];\\n        })\\n        return queryParams\\n    }\\n    var javaUrl = JavaImporter(java.net.URL);\\n    with(javaUrl) {\\n        var url = new URL(u);\\n        dict.Protocol = url.getProtocol();\\n        dict.Host = url.getHost();\\n        dict.Port = url.getPort();\\n        dict.File = url.getFile();\\n        dict.Path = url.getPath();\\n        dict.Ref = url.getRef();\\n    }\\n    dict.Params = params(u);\\n    return dict;\\n}\\n\\n//扩展split,e是否去除空值\\nString.prototype.Split = function(s, e) {\\n    if (e) {\\n        return this.split(s).filter(item => item != '');\\n    } else {\\n        return this.split(s);\\n    }\\n}\\n\\n//json对象转查询字符串\\nObject.ToParams = function() {\\n    var json = arguments[0];\\n    return Object.keys(json).map(key => key + '=' + json[key]).join('&');\\n}\\n\\n//正则提取\\nRegExp.prototype.matchAll = function(string) {\\n    var match = null;\\n    var matches = new Array();\\n    while (match = this.exec(string)) {\\n        var matchArray = [];\\n        for (i in match) {\\n            if (parseInt(i) == i) {\\n                matchArray.push(match[i]);\\n            }\\n        }\\n        matches.push(matchArray);\\n    }\\n    return matches;\\n}\\n\\nfunction getMaxLength(arr) {\\n    const maxLength = arr.reduce((acc, item) => Math.max(acc, item.length), 0);\\n    return maxLength\\n}\\n\\n//左填充字符串\\nString.prototype.PadLeft = function(len, charStr) {\\n    var s = this + '';\\n    return new Array(len - s.length + 1).join(charStr, '') + s;\\n}\\n\\n//右填充字符串\\nString.prototype.PadRight = function(len, charStr) {\\n    var s = this + '';\\n    return s + new Array(len - s.length + 1).join(charStr, '');\\n}\\n\\n//重复字符串\\nlet strRepeat = (s, i) => {\\n    return s.repeat(i);\\n};\"},{\"col_type\":\"movie_3\",\"name\":\"快捷搜索\",\"path\":\"qsearchd\",\"rule\":\"//搜索，以下基本不需要修改。\\nd.push({\\n    col_type: 'line'\\n})\\n\\n\\ntry {\\n    \\n    var title = getPageTitle();\\n    var Color = \\\"#f13b66a\\\";\\n    var Color1 = \\\"#098AC1\\\";\\n\\n\\n\\n    function getHead(title) {\\n        return '‘‘’’<strong><font color=\\\"' + Color + '\\\">' + title + '</front></strong>';\\n    }\\n} catch {}\\n\\nvar rules = {\\n    \\\"quickSearchConfigs\\\": {\\n        \\\"mode\\\": \\\"icon_round_small_4\\\",\\n        \\\"order\\\": [\\\"海阔搜索\\\", \\\"风影\\\", \\\"香情\\\", \\\"聚影\\\"],\\n        \\\"海阔搜索\\\": {\\n            \\\"name\\\": \\\"\\\",\\n            \\\"pic\\\": \\\"https://lanmeiguojiang.com/tubiao/movie/135.svg\\\"\\n        },\\n        \\\"风影\\\": {\\n            \\\"name\\\": \\\"风影\\\",\\n            \\\"pic\\\": \\\"https://pic1.imgdb.cn/item/6346beda16f2c2beb1f1bbde.jpg\\\",\\n            \\\"rule\\\": \\\"copy://https://netcut.cn/p/f6fe3bec87025d5e\\\"\\n        },\\n        \\\"香情\\\": {\\n            \\\"name\\\": \\\"香情影视\\\",\\n            \\\"pic\\\": \\\"https://codeberg.org/lzk23559/PublicRule/raw/branch/master/xqys.png\\\"\\n        },\\n        \\\"聚影\\\": {\\n            \\\"name\\\": \\\"聚影√\\\",\\n            \\\"pic\\\": \\\"https://img.vinua.cn/images/QqyC.png\\\",\\n            \\\"rule\\\": \\\"copy:https://pasteme.tyrantg.com/xxxxxx/vkvhbqopv5u6u6op\\\"\\n        }\\n    }\\n}\\n\\nvar json = rules;\\nvar list = json.quickSearchConfigs.order;\\n\\nfor (l in list) {\\n    var obj = json.quickSearchConfigs[list[l]];\\n    //log(obj.name)\\n\\n\\n    d.push({\\n        title: list[l],\\n        url: $('#noLoading#').lazyRule((obj, home, title) => {\\n            let ruleList = JSON.parse(request(home));\\n            let hasRule = ruleList.some(item => item.title === obj.name);\\n            if (hasRule || obj.name == '') {\\n                //toast(\\\"请配置快速搜索\\\")\\n                return 'hiker://search?s=' + title + '&rule=' + obj.name;\\n            } else {\\n\\n                if (obj.hasOwnProperty(\\\"rule\\\")) {\\n                    if (obj.rule.indexOf('copy')!=-1) {\\n                        toast(\\\"已经复制请导入规则\\\")\\n                    }\\n                    return obj.rule\\n                } else {\\n                    return \\\"toast://请安装\\\" + obj.name + \\\"小程序\\\";\\n                }\\n            }\\n        }, obj, \\\"hiker://home\\\", title),\\n        pic_url: obj.pic,\\n        col_type: json.quickSearchConfigs.mode,\\n        extra:{id:'qsearch'}\\n    })\\n}\\n\\n\\n/*    $().lazyRule((obj, home, title) => {\\n        let ruleList = JSON.parse(request(home));\\n        let hasRule = ruleList.some(item => item.title === obj.name);\\n        if (hasRule) {\\n\\n            //toast(\\\"请配置快速搜索\\\")\\n            return 'hiker://search?s=' + title + '&rule=' + obj.name,\\n        } else {\\n            //toast(\\\"请安装青豆小程序\\\")\\n            if (obj.hasOwnProperty(\\\"rule\\\")) {\\n                return \\\"toast://请安装\\\" + obj.name + \\\"小程序\\\";\\n            } else {\\n\\n                return '2'\\n            }\\n        }\\n    }, obj, \\\"hiker://home\\\", title)*/\\n\\n\\n\\n\\n/*d.push({\\n    col_type: 'line'\\n})\\n*/\\n\\n/*d.push({\\n    title: '配置',\\n    col_type: 'flex_button',\\n    url: $().lazyRule(() => {\\n        toast(\\\"点击设置配置快速搜索\\\");\\n        return 'hiker://home@青豆'\\n    })\\n\\n})*/\"},{\"col_type\":\"movie_3\",\"name\":\"动态分类\",\"path\":\"dtfl\",\"rule\":\"const empty = \\\"hiker://empty\\\"\\n\\nif (typeof(拼接分类) != 'undefined' && 拼接分类 != '') {\\n    var categories = pdfa(html, 大类定位).concat(pdfa(html, 拼接分类))\\n} else {\\n    var categories = pdfa(html, 大类定位)\\n}\\n\\nlet init_cate = []\\n\\nfor (let i = 0; i < 20; i++) {\\n    init_cate.push(\\\"0\\\")\\n}\\n\\nconst fold = getVar(MY_RULE.group, \\\"0\\\")\\nconst cate_temp_json = getVar(MY_RULE.title, JSON.stringify(init_cate))\\nconst cate_temp = JSON.parse(cate_temp_json)\\n\\nif (parseInt(page) === 1) {\\n    d.push({\\n        title: fold === '1' ? '““””' + '😺'.fontcolor(\\\"#FF0000\\\") + '' : '““””' + '🐱'.fontcolor(\\\"#1aad19\\\") + '',\\n        url: $().lazyRule((fold) => {\\n            putVar(MY_RULE.group, fold === '1' ? '0' : '1');\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, fold),\\n        col_type: 'scroll_button',\\n    })\\n    categories.forEach((category, index) => {\\n        let sub_categories = pdfa(category, 小类定位);\\n        if (index === 0) {\\n            sub_categories.forEach((item, key) => {\\n                let title = pdfh(item, 分类标题)\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\")\\n                }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\n                        let new_cate = []\\n                        params.cate_temp.forEach((cate, index) => {\\n                            new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\")\\n                        })\\n                        putVar(MY_RULE.title, JSON.stringify(new_cate))\\n                        putVar(MY_RULE.url, input)\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        key: key,\\n                        page: page,\\n                    }),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        } else if (fold === '1') {\\n            sub_categories.forEach((item, key) => {\\n                let title = pdfh(item, 分类标题)\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\")\\n                }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\n                        params.cate_temp[params.index] = params.key.toString()\\n\\n                        putVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\n                        putVar(MY_RULE.url, input)\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        index: index,\\n                        key: key,\\n                        page: page,\\n                    }),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        }\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"樱花链接\",\"path\":\"yhlink\",\"rule\":\"js:\\nfunction getContent(link) {\\n    //扩展函数\\n    eval(JSON.parse(request('hiker://page/extend')).rule)\\n\\n    var u = urlParse(link)\\n    u2 = u.File.Split('/', true)\\n\\n    var coll = u2[2].replace('.html', '')\\n\\n    var html = fetch(link)\\n    var s1 = pdfh(html, 'head&&script,-2&&Html')\\n    eval(s1)\\n    var s2 = pdfh(html, 'head&&script,-1&&src')\\n    require(s2)\\n    //log(s1)\\n    //log(s2)\\n\\n\\n    //log(cars_zyw)\\n\\n    function CheckPlayTypeOk(playtype, playji) {\\n        if (typeof(playarr) != 'undefined') {\\n            var tt = CheckPlayTypeOk_playarray(playarr, playji);\\n            if (tt != '') {\\n                return tt;\\n            }\\n        }\\n        for (var k = 0; k < cars_zyw.length; k++) {\\n\\n            real_playarr = get_play_array(cars_zyw[k]);\\n            \\n            if (real_playarr != null) {\\n                var tt = CheckPlayTypeOk_playarray(real_playarr, playji);\\n                \\n                if (tt != '') {\\n                    main_line_null_qp_has = cars_zyw[k];\\n                    main_line_null_qp_has_qp_string = tt;\\n                    return tt;\\n                }\\n            }\\n        }\\n        return '';\\n    }\\n\\n    function CheckPlayTypeOk_playarray(playarr_order_1, playji) {\\n        if (typeof(playarr_order_1) == 'undefined') {\\n            return '';\\n        }\\n        if (typeof(playarr_order_1[playji]) == 'undefined') {\\n            return '';\\n        }\\n        return playarr_order_1[playji];\\n    }\\n\\n    function get_o_l(playarr_567, n, real_ji) {\\n        yb_vid_ret = '';\\n        if (typeof(playarr_567) != 'undefined') {\\n            if (playarr_567 == null) return '';\\n            if (typeof(playarr_567[n]) != 'undefined') {\\n                var arr_temp = playarr_567[n].split(',');\\n                //log(arr_temp)\\n                \\n                if (arr_temp.length >= 3) {\\n\\n                    //if (arr_temp[2] == real_ji) {\\n                        yb_vid_ret = arr_temp[0];\\n                        yb_vid_ret = yb_vid_ret.replace(\\\".com\\\", \\\".com497\\\");\\n                    //}\\n                }\\n                //log(yb_vid_ret)\\n            }\\n            if (yb_vid_ret == '') {\\n                for (k = 0; k < playarr_567.length; k++) {\\n                    if (typeof(playarr_567[k]) != 'undefined') {\\n                        arr_temp = playarr_567[k].split(',');\\n                        if (arr_temp.length >= 3) {\\n                            if (arr_temp[2] == real_ji) {\\n                                yb_vid_ret = arr_temp[0];\\n                                yb_vid_ret = yb_vid_ret.replace(\\\".com\\\", \\\".com497\\\");\\n                                break;\\n                            }\\n                        }\\n                    }\\n                }\\n            }\\n        }\\n        //alert('yb_vid_ret'+yb_vid_ret);\\n        return yb_vid_ret;\\n    }\\n\\n    function get_oth_line(_qiep_365, n, real_ji) {\\n        //循环每 \\t\\n        yb_all_ret = '';\\n        for (var k = 0; k < cars_zyw.length; k++) {\\n            var qp_name = cars_zyw[k]; //if(_qiep_365 == qp_name) continue; \\t\\t\\n            playarr_567 = get_play_array(qp_name);\\n            \\n           //log(qp_name+':'+playarr_567); \\t\\t\\n            yb_vid_ret = get_o_l(playarr_567, n, real_ji);\\n            \\n            //log(yb_vid_ret)\\n            if (yb_vid_ret != '') {\\n                var url_31 = qp_name + '|||' + yb_vid_ret;\\n                if (yb_all_ret == '') yb_all_ret = url_31;\\n                else yb_all_ret = yb_all_ret + '$$$' + url_31;\\n            }\\n        }\\n        return yb_all_ret;\\n    }\\n\\n\\n\\n    function get_main_0(n) {\\n        if (typeof(playarr) == 'undefined') {\\n            return '';\\n        }\\n        return get_plist_js(pl_dy, n, playarr);\\n    }\\n\\n    function get_r_url(playarr_r, n) {\\n        var url_ret = '';\\n        if (typeof(playarr_r) != 'undefined') {\\n            if (typeof(playarr_r[n]) != 'undefined') {\\n                var arr_temp = playarr_r[n].split(',');\\n                url_ret = arr_temp[0];\\n            }\\n        }\\n        return url_ret;\\n    }\\n\\n    function getQueryVariable(variable) {\\n        var query = '';\\n        if (variable.includes('?')) {\\n            query = variable.replace(/.*\\\\?/gm, '')\\n        }\\n        var vars = query.split(\\\"&\\\");\\n\\n        for (var i = 0; i < vars.length; i++) {\\n            var pair = vars[i].split(\\\"=\\\");\\n            if (pair[0] == variable) {\\n                return pair[1];\\n            }\\n        }\\n        return (false);\\n    }\\n\\n    function get_plist_js(pl_dy, n, real_playarr) {\\n        var str = '';\\n        var strli_style = '';\\n        //if(pl_dy==3)  strli_style =' style=\\\"width:100%;text-align:left\\\"';\\n        for (i in real_playarr) {\\n            var arr1 = real_playarr[i].split(',');\\n            if (arr1.length < 3) {\\n                ok = 0;\\n                break;\\n            }\\n            var t = unescape(arr1[2]);\\n            if (t == '') {\\n                if (pl_dy == 1) t = '正片';\\n            }\\n            var cstr = (i == n) ? ' current' : '';\\n\\n            if (pl_dy == 1) {\\n                str += '<li><a class=\\\"twidth' + cstr + '\\\" href=\\\"' + i + '.html\\\">' + t + '</a></li>';\\n\\n            } else {\\n                str = '<li' + strli_style + '><a class=\\\"twidth' + cstr + '\\\" href=\\\"' + i + '.html\\\">' + t + '</a></li>' + str;\\n            }\\n        }\\n        return str;\\n    }\\n\\n    function get_last_type(qp_type) {\\n        real_playarr = null;\\n        if (qp_type == 'fs') {\\n            if (typeof(playarr_fs) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_fs;\\n        } else if (qp_type == 'jy') {\\n            if (typeof(playarr_jy) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_jy;\\n        } \\n        return real_playarr;\\n    }\\n\\n    function get_play_array(qp_type) {\\n        \\n        real_playarr = null;\\n        real_playarr = get_last_type(qp_type);\\n        \\n        if (real_playarr != null) return real_playarr;\\n        if (qp_type == 'zd') {\\n            if (typeof(playarr_1) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_1;\\n        } else if (qp_type == 'yj') {\\n            if (typeof(playarr_2) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_2;\\n        } else if (qp_type == 'gs') {\\n            if (typeof(playarr_gs) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_gs;\\n        } else if (qp_type == 'sn') {\\n            if (typeof(playarr_sn) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_sn;\\n        } else if (qp_type == 'hn') {\\n            if (typeof(playarr_hn) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_hn;\\n        } else if (qp_type == 'wl') {\\n            if (typeof(playarr_wl) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_wl;\\n        } else if (qp_type == 'lz') {\\n            if (typeof(playarr_lz) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_lz;\\n        } else if (qp_type == 'wj') {\\n            if (typeof(playarr_wj) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_wj;\\n        } else if (qp_type == 'uk') {\\n            if (typeof(playarr_uk) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_uk;\\n        } else if (qp_type == 'bj') {\\n            if (typeof(playarr_bj) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_bj;\\n        } else if (qp_type == 'bd') {\\n            if (typeof(playarr_bd) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_bd;\\n        } else if (qp_type == 'xk') {\\n            if (typeof(playarr_xk) == 'undefined') {\\n                return null\\n            };\\n            real_playarr = playarr_xk;\\n        } else if (qp_type == 'kb') {\\n            if (typeof(playarr_kb) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_kb;\\n        } else if (qp_type == 'sd') {\\n            if (typeof(playarr_sd) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_sd;\\n        } else if (qp_type == 'tk') {\\n            if (typeof(playarr_tk) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_tk;\\n        } else if (qp_type == 'ss') {\\n            if (typeof(playarr_ss) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_ss;\\n        } else if (qp_type == 'ff') {\\n            if (typeof(playarr_ff) == 'undefined') {\\n                return null;\\n            }\\n            real_playarr = playarr_ff;\\n        }\\n        return real_playarr;\\n    }\\n\\n\\n    function goplay(iscom, n) {\\n\\n        var sl = '0';\\n        var def_server = 0;\\n        var aiqi = 1;\\n        var qiyi_url = '';\\n        var serindex = 0;\\n        var zuida = 0;\\n\\n        var _qiep_365 = getQueryVariable('qp');\\n        if (_qiep_365 == false) _qiep_365 = '';\\n\\n        var _qp_get = 0;\\n        var real_playarr_get = null;\\n        var ok = 0;\\n        var str = '';\\n\\n        if (_qiep_365 != '') {\\n            serindex = 1;\\n            _qp_get = 1;\\n            real_playarr_get = get_play_array(_qiep_365);\\n\\n            if (real_playarr_get != null && real_playarr_get != 'undefined') {\\n                serindex = 1;\\n                _qp_get = 1;\\n            }\\n\\n        }\\n\\n        if (0 == _qp_get) {\\n            if (typeof(lianzaijs) == 'undefined') {\\n                lianzaijs = 0;\\n                aiqi = 0;\\n                serindex = -1;\\n            }\\n            if (typeof(playarr_2) != 'undefined') {\\n                if (serindex == -1) serindex = 2;\\n                if (lianzaijs_2 > lianzaijs) {\\n                    lianzaijs = lianzaijs_2;\\n                    zuida = 2;\\n                }\\n            }\\n            if (typeof(playarr_1) != 'undefined') {\\n                if (serindex == -1) serindex = 1;\\n                if (lianzaijs_1 > lianzaijs) {\\n                    lianzaijs = lianzaijs_1;\\n                    zuida = 1;\\n                }\\n            }\\n\\n            if (typeof(pl_dy) == 'undefined') {\\n\\n            }\\n        }\\n\\n        var real_playarr = null;\\n        if (_qp_get == 1) {\\n            real_playarr = real_playarr_get;\\n\\n        } else {\\n\\n            if (pl_dy == 3 || pl_dy == 1) {\\n                if (serindex == 0) {\\n                    if (typeof(playarr) != 'undefined') real_playarr = playarr;\\n                } else if (serindex == 2) {\\n                    if (typeof(playarr_2) != 'undefined') real_playarr = playarr_2;\\n                } else if (serindex == 1) {\\n                    if (typeof(playarr_1) != 'undefined') real_playarr = playarr_1;\\n                }\\n            } else {\\n                if (zuida == 0) {\\n                    if (typeof(playarr) != 'undefined') real_playarr = playarr;\\n                } else if (zuida == 2) {\\n                    if (typeof(playarr_2) != 'undefined') real_playarr = playarr_2;\\n                } else if (zuida == 1) {\\n                    if (typeof(playarr_1) != 'undefined') real_playarr = playarr_1;\\n                }\\n            }\\n        }\\n\\n        if (real_playarr != null) {\\n            str = get_plist_js(pl_dy, n, real_playarr);\\n        }\\n\\n\\n        var yun_bo = '';\\n        var all_bo = '';\\n        var yb_url = '';\\n        var playtype = 0;\\n        if (_qp_get == 1) {\\n            var url_qp = get_r_url(real_playarr_get, n); //是主线\\n\\n            if (1 == is_m_line(url_qp) || 1 == is_m_line_2(url_qp)) {\\n                playtype = 0;\\n                sl = '1'\\n                qiyi_url = url_qp;\\n            } else //是切片\\n            {\\n                playtype = 2;\\n                yun_bo += '1';\\n                yb_vid = url_qp;\\n                yb_vid = yb_vid.replace(\\\".com\\\", \\\".com497\\\");\\n                yb_url = yb_url + yb_vid;\\n\\n            }\\n        } else {\\n            if (typeof(playarr) != 'undefined') {\\n                if (typeof(playarr[n]) != 'undefined') {\\n                    sl = '1';\\n                    var arr_temp = playarr[n].split(',');\\n                    qiyi_url = arr_temp[0];\\n                }\\n            }\\n            if (typeof(playarr_2) != 'undefined') {\\n                if (typeof(playarr_2[n]) != 'undefined') {\\n                    yun_bo += '1';\\n                    var arr_temp = playarr_2[n].split(',');\\n                    yb_vid = arr_temp[0];\\n                    yb_vid = yb_vid.replace(\\\".com\\\", \\\".com497\\\");\\n                    yb_url = yb_url + yb_vid;\\n                }\\n            }\\n            if (typeof(playarr_1) != 'undefined') {\\n                if (typeof(playarr_1[n]) != 'undefined') {\\n                    yun_bo += '2';\\n                    var arr_temp = playarr_1[n].split(',');\\n                    yb_vid = arr_temp[0];\\n                    yb_vid = yb_vid.replace(\\\".com\\\", \\\".com497\\\");\\n                    if (yb_url == '') {\\n                        yb_url = yb_vid;\\n                    } else {\\n                        yb_url = yb_url + '$$$' + yb_vid;\\n                    }\\n                }\\n            }\\n        }\\n\\n        //alert(all_yb);\\n        var vid = '';\\n        var default_line = 0;\\n\\n        var url_string = '';\\n        main_line_null_qp_has = '';\\n\\n        if (_qp_get == 0) {\\n            if (typeof(def_line) != 'undefined') //是否有默认线\\n            {\\n                default_line = def_line;\\n            }\\n            if (typeof(line_array) != 'undefined') {\\n                if (typeof(line_array[n]) != 'undefined') {\\n                    default_line = line_array[n];\\n                }\\n            }\\n        }\\n\\n        if (_qp_get == 1) {\\n            url_string = CheckPlayTypeOk_playarray(real_playarr_get, n);\\n            if (url_string != '') {\\n                ok = 1;\\n            }\\n        } else //主线不带参数的\\n        {\\n            url_string = CheckPlayTypeOk(playtype, n);\\n            if (main_line_null_qp_has != '') {\\n                playtype = 2;\\n                _qiep_365 = main_line_null_qp_has;\\n                var arr_temp = main_line_null_qp_has_qp_string.split(',');\\n                url_qp = arr_temp[0];\\n                yun_bo = '1';\\n                yb_vid = url_qp;\\n                yb_vid = yb_vid.replace(\\\".com\\\", \\\".com497\\\");\\n                yb_url = yb_url + yb_vid;\\n\\n            }\\n\\n        }\\n\\n\\n        var type11 = '';\\n        var real_ji_string = '';\\n        if (url_string != '') {\\n            var arr = url_string.split(',');\\n            vid = arr[0];\\n            type11 = arr[1];\\n            real_ji_string = arr[2];\\n        }\\n\\n\\n        var all_yb = get_oth_line(_qiep_365, n, real_ji_string);\\n        var now_ji_0 = n;\\n        if (_qp_get == 1) {\\n            now_ji_0 = -1;\\n        }\\n        var str_main0 = get_main_0(now_ji_0);\\n        //log(str_main0)\\n        /*if (str_main0 == '') {\\n            log('hide()')\\n            // $('#tab11').hide();\\n        }*/\\n\\n        //if ($('.dramaNumList').length > 0) $('.dramaNumList').html(str_main0);\\n\\n        var r_height = pl_r_height_org_1 + 'px';\\n        var r_height_1 = pl_r_height_org_1;\\n        var ipad = 0;\\n        var sh = 1344;\\n        if (sh >= 720) {\\n            r_height = pl_r_height_720 + 'px';\\n            r_height_1 = pl_r_height_720;\\n        } else {\\n            r_height = '210px';\\n            r_height_1 = 210;\\n        }\\n\\n        /*if (is_iPad()) {\\n            r_height = '450px';\\n            r_height_1 = 450;\\n            ipad = 1;\\n        }*/\\n\\n        if (playtype == 0) {\\n            if (qiyi_url.indexOf('.mp4') > 0) {\\n                if (default_line != 13 && default_line != 9) default_line = 10;\\n            } else if (qiyi_url.indexOf('.m3u8') > 0) {\\n                if (default_line == 0) {\\n                    default_line = 10;\\n                }\\n            } else if (qiyi_url.indexOf('tcpspc.com') > 0) {\\n                if (qiyi_url.indexOf('share') > 0) default_line = 9;\\n            } else if (qiyi_url.indexOf('guiji365.com/share') > 0) {\\n                default_line = 9;\\n            } else if (qiyi_url.indexOf('.jpg') > 0) {\\n                default_line = 10;\\n            } else if (qiyi_url.indexOf('player.s1905.com') > 0) {\\n                default_line = 9;\\n            } else if (qiyi_url.indexOf('qigaituan.com') > 0) {\\n                default_line = 9;\\n            } else if (qiyi_url.indexOf('744zy.com/share') > 0) {\\n                default_line = 9;\\n            } else if (qiyi_url.indexOf('pan.jiningwanjun.com') > 0) {\\n                default_line = 9;\\n            }\\n        } else if (playtype == 1 || playtype == 2) {\\n            //$(\\\"#showyubo\\\").text(\\\"云播加载慢,多点击几次后稍等\\\");\\n        }\\n\\n        if (typeof(h_other_) == 'undefined') h_other_ = '';\\n\\n        //navigator.userAgent.toLowerCase();\\n\\n        var is_al_p = 0;\\n        var sUserAgent = MOBILE_UA;\\n        if (sUserAgent.indexOf('mqqbrowser') > 0 || sUserAgent.indexOf('ucbrowser') > 0 || sUserAgent.indexOf('miuibrowser') > 0) {\\n            is_al_p = 1;\\n        }\\n\\n\\n        //var mobile_style = ' style=\\\"position:absolute;z-index:3;\\\"';\\n        var cp_text = '&cp=0';\\n        _s2_dplayer_2 = unescape(_s2_dplayer_2);\\n        _s2_dplayer_2_mb = unescape(_s2_dplayer_2_mb);\\n        var dpfile = _s2_dplayer_2_mb;\\n        if (iscom == 1) {\\n            dpfile = _s2_dplayer_2;\\n            r_height = '100%';\\n            //mobile_style = '';\\n            cp_text = '&cp=1';\\n        }\\n\\n        var real_frame_2 = '100%';\\n        //real_frame_2 = get_f_width(iscom, _pc_da_3);\\n\\n        g_i4 = '720';\\n        if (default_line == 9 || default_line == 10) {\\n            qiyi_url = encodeURIComponent(qiyi_url);\\n        } else if (default_line == 13) {\\n            qiyi_url = encodeURIComponent(qiyi_url);\\n            qiyi_url = encodeURIComponent(qiyi_url);\\n\\n        }\\n        //log(all_yb)\\n\\n        var url = dpfile + '?vid=' + qiyi_url + '&m=' + type11 + cp_text + '&dy=' + pl_dy + '&i=' + pl_id + '&pt=' + playtype + '&line=' + default_line + '&_qp_get=' + _qiep_365 + '&sl=' + sl + '&all_yb=' + all_yb + '&yb=' + yun_bo + '&yb_url=' + yb_url + '&i4=' + r_height_1 + '&ipad=' + ipad + '&is_al_p=' + is_al_p + '&oth=' + h_other_;\\n        return url\\n        //finalurl = url;\\n\\n        //var ifrmaurl = '<iframe id=\\\"playiframe\\\" allowFullscreen=\\\"true\\\" src=\\\"' + url + '\\\" width=' + real_frame_2 + ' height=\\\"' + r_height + '\\\"' + mobile_style + '  scrolling=\\\"no\\\" frameborder=\\\"no\\\" border=\\\"0\\\" marginwidth=\\\"0\\\" marginheight=\\\"0\\\" id=\\\"player_iframe\\\" allowfullscreen=\\\"true\\\" ></iframe>';\\n\\n        //g_ifrmaurl = ifrmaurl;\\n        //g_r_height = r_height;\\n\\n        //if (iscom == 0) $(\\\"#player\\\").css(\\\"height\\\", r_height);\\n\\n        //$(\\\"#player\\\").html(ifrmaurl);\\n    }\\n\\n\\n\\n    function get9Line(linkurl) {\\n        if (linkurl.indexOf('tcpspc.com') > 0) {\\n            if (linkurl.indexOf('share') > 0) return html_9_line + linkurl;\\n        } else if (linkurl.indexOf('guiji365.com') > 0) {\\n            if (linkurl.indexOf('share') > 0) return html_9_line + linkurl;\\n        } else if (linkurl.indexOf('creativemas.cn/share') > 0) {\\n            return html_9_line + linkurl;\\n        } else if (linkurl.indexOf('pan.jiningwanjun.com') > 0) {\\n            return html_9_line + linkurl;\\n        } else if (linkurl.indexOf('qigaituan.com') > 0) {\\n            return html_9_line + linkurl;\\n        } else if (linkurl.indexOf('744zy.com') > 0) {\\n            if (linkurl.indexOf('share') > 0) return html_9_line + linkurl;\\n        } else if (linkurl.indexOf('.m3u8') <= 0 && linkurl.indexOf('.mp4') <= 0) {\\n            if (linkurl.indexOf('%2Fshare%2F') > 0) return html_9_line + linkurl;\\n        }\\n        return '';\\n    }\\n\\n    function get_url_parse(linkur) {\\n        var hj = linkur.substring(0, 5);\\n        var sUserAgent = MOBILE_UA;\\n        var is_al_p = 0;\\n        if (sUserAgent.indexOf('mqqbrowser') > 0 || sUserAgent.indexOf('ucbrowser') > 0) {\\n            is_al_p = 1;\\n        }\\n        if (hj == '1098_' || hj == '1006_' || hj == '1075_' || hj == '1097_') {\\n            var u_temp = line3_free_2 + i4_width + '&url=' + linkur;\\n            return u_temp;\\n        } else if (linkur.indexOf('v2.shenjw.com') != -1) {\\n            return v2_jshen_2 + linkur;\\n        } else if (linkur.indexOf('0_7_3_') != -1) {\\n            return html_aliplayere_2 + linkur;\\n        } else if (linkur.indexOf('9_5_2_') != -1) {\\n            return v2_xigua88_aliplayer + linkur;\\n        } else if (linkur.indexOf('yj3456__') != -1) {\\n            return line3_free_2 + linkur;\\n        } else if (linkur.indexOf('.ssdm.cc') != -1) {\\n            return html_aliplayere_2 + linkur;\\n        } else if (linkur.indexOf('v2.yiziyy.com') != -1) {\\n            return html_aliplayere_2 + linkur;\\n        } else {\\n            if (is_al_p == 1) return parseurl_url + linkur;\\n            else return html_aliplayere_2 + linkur;\\n        }\\n    }\\n\\n    function get_qp_name44(qp_type) {\\n        if (qp_type == 'zd') return '最大';\\n        if (qp_type == 'yj') return '永久';\\n        if (qp_type == 'hn') return '牛牛';\\n        if (qp_type == 'gs') return '光波';\\n        if (qp_type == 'sn') return '新朗';\\n        if (qp_type == 'wl') return '涡轮';\\n        if (qp_type == 'lz') return '良子';\\n        if (qp_type == 'fs') return 'F速';\\n        if (qp_type == 'bd') return '百度';\\n        if (qp_type == 'uk') return '酷U';\\n        if (qp_type == 'wj') return '无天';\\n        if (qp_type == 'bj') return '八戒';\\n        if (qp_type == 'tk') return '天空';\\n        if (qp_type == 'ss') return '速速';\\n        if (qp_type == 'kb') return '酷播';\\n        if (qp_type == 'sd') return '闪电';\\n        if (qp_type == 'xk') return '看看';\\n        if (qp_type == 'tp') return '淘淘';\\n        if (qp_type == 'jy') return '精英';\\n        if (qp_type == 'ff') return '飞飞';\\n\\n        return qp_type;\\n    }\\n\\n\\n    var turl = goplay(1, coll)\\n    var h2 = request(turl, {\\n        headers: {\\n            'Referer': 'http://yhdm16.com/',\\n            'User-Agent': MOBILE_UA\\n        }\\n    })\\n    //log(turl)\\n    var playxl = pdfa(h2, '#playroad&&a:matches(线路):not([style*=none])')\\n\\n    var playArrText = []\\n\\n    for (let p of playxl) {\\n        playArrText.push(pdfh(p, 'a&&Text'))\\n    }\\n\\n\\n    //log(playArrText)\\n    var yb_url_arr = []\\n    var urls = pdfh(h2, 'Html&&script,1&&Html')\\n    //eval()\\n    var src = decodeURIComponent(pdfh(h2, '#playiframe&&src'))\\n\\n    var jx = src.replace(/url=.+/gm, 'url=')\\n    var urls2 = urls.replace('var yb_url_arr =new Array()', 'var yb_url_arr =new Object()')\\n    //log(urls2)\\n    eval(urls2)\\n\\n\\n    var urlarr = []\\n    if (playArrText.length == 1) {\\n        iurl.push(jx)\\n    } else {\\n        for (let t of playArrText) {\\n            var i = t.replace(`线路`, '')\\n            var jx = iurl[i - 1]\\n            var link = decodeURIComponent(aiyi_url)\\n            var pare = `${t};${jx}${link}`\\n            //log(pare)\\n            urlarr.push(pare)\\n        }\\n    }\\n\\n\\n    //iurl = Array.from(new Set(iurl)).splice(0, 4);\\n\\n\\n    if (Object.keys(yb_url_arr).length > 0) {\\n        for (let it of Object.keys(yb_url_arr)) {\\n            var yb_txt = yb_url_arr[it]\\n\\n            var name = get_qp_name44(it)\\n            //log(name)\\n            urlarr.push(name + ';' + decodeURIComponent(yb_txt))\\n        }\\n    }\\n\\n    /*iurl = iurl.map((x, i) => {\\n        var url = ''\\n        if (!x.includes(';')) {\\n            url = `线路${(i+1)};` + x + decodeURIComponent(aiyi_url)\\n        } else {\\n            url = x\\n        }\\n        return url\\n    })*/\\n\\n    return urlarr\\n\\n}\\n\\n\\n$.exports.gc = getContent\"},{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"sift\",\"rule\":\"js:\\n//动态分类定义 需根据实际修改\\nconst 分类颜色 = getRangeColors()\\nconst 大类定位 = 'body&&.nav-pc'\\nconst 拼接分类 = 'body&&dd'\\nconst 小类定位 = 'body&&a:not(:matches(播出|首页|番表))'\\nconst 分类标题 = 'a&&Text'\\nconst 分类链接 = 'a&&href'\\n//扩展函数\\neval(JSON.parse(request('hiker://page/extend')).rule)\\n\\n//log(getVar(MY_RULE.url))\\n\\nif (true_url == config.首页) {\\n    true_url = config.首页 + 'acg/'\\n\\n    putVar(MY_RULE.title, JSON.stringify([\\\"2\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\", \\\"0\\\"]))\\n\\n}\\nvar urlp = urlParse(true_url)\\n\\n//log(urlp)\\n\\nvar up = urlp.File.Split('/', true)\\nif (up.length == 1) {\\n    true_url = true_url + (`0/0/all/${page}.html`)\\n} else if (up.length) {\\n    true_url = true_url.replace(/\\\\/\\\\d+.html$/gm, `/${page}.html`)\\n}\\n//log(true_url)\\n\\nvar html = request(true_url)\\n\\nvar script1 = pdfh(html, '.nav-down-mb&&script&&Html')\\nvar script2 = pdfh(html, '.main&&script&&Html')\\neval(script1 + script2)\\n\\nvar params = {\\n    action: fj_action_,\\n    page: fj_page_,\\n    year: fj_year,\\n    area: fj_area,\\n    class: fj_class,\\n    dect: dect,\\n    id: fj_id_\\n}\\n\\nvar content = fetch(_yu_gda_s + '?' + Object.ToParams(params))\\n\\n//动态分类\\neval(JSON.parse(request('hiker://page/dtfl')).rule)\\ntry {\\n        appedData(d, content, selects, true, true)\\n\\n} catch (e) {\\n    var i = getMyVar('i', 1)\\n    var id = `aline${i}`\\n    if (findItem('lastid') == null) {\\n        addItemAfter(id, {\\n            title: \\\"““””<font color='gray'>到底了<font>\\\",\\n            url: 'hiker://empty',\\n            col_type: 'text_center_1',\\n            extra: {\\n                id: 'lastid'\\n            }\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"界面\",\"path\":\"ui\",\"rule\":\"js:\\nlet getTimeState = () => {\\n    let timeNow = new Date();\\n    let hours = timeNow.getHours();\\n    let text = ``;\\n    if (hours >= 7 && hours <= 18) {\\n        text = `☀️`;\\n    } else {\\n        text = '🌙';\\n    }\\n    return text;\\n};\\n\\nfunction getWeekData(html, text) {\\n    var data = []\\n    var s = pdfa(html, text.replace('**', 7))\\n    data.push(s)\\n    for (let i = 1; i <= 6; i++) {\\n        var h = pdfa(html, text.replace('**', i))\\n        data.push(h)\\n    }\\n    //log(data.length)\\n    return data\\n}\\n\\n\\nfunction weekAppend(d, obj) {\\n    //定义常量和方法\\n    var 礼拜 = [\\\"日\\\", \\\"一\\\", \\\"二\\\", \\\"三\\\", \\\"四\\\", \\\"五\\\", \\\"六\\\"];\\n\\n    let 星期 = (x, y) => {\\n        let day = x.getDay();\\n        return y[day];\\n    }\\n    var 日期 = new Date();\\n\\n    //传递变量\\n    var data = obj.data\\n    var title = obj.title\\n    var daynight = obj.dn\\n    var img = obj.img\\n    var url = obj.url\\n    var show = obj.show\\n    var wcolor = obj.wcolor\\n    var wstr = obj.wstr\\n\\n    d.push({\\n        title: title,\\n        col_type: 'avatar',\\n        img: img,\\n        url: url\\n    })\\n\\n    if (show == '展开') {\\n        var day = new Date().getDay()\\n        var week = getMyVar('week', day + '')\\n        we = 礼拜[week]\\n        for (var i = 0; i < 礼拜.length; i++) {\\n            d.push({\\n                title: week == i ? '““””' + daynight + `<font color=\\\"${wcolor}\\\"><b>` + wstr + we + '</b></font>' : 礼拜[i],\\n                url: $(\\\"#noLoading#\\\").lazyRule((it) => {\\n                    putMyVar(\\\"week\\\", Number(it));\\n                    refreshPage(true);\\n                    return 'hiker://empty'\\n                }, i),\\n                col_type: \\\"scroll_button\\\",\\n                extra: {\\n                    id: 'week' + i,\\n                }\\n            })\\n        }\\n\\n        d.push({\\n            col_type: \\\"line\\\",\\n            pic: \\\"\\\",\\n            extra: {\\n                id: \\\"good\\\"\\n            }\\n        })\\n\\n        data[week].forEach((x) => {\\n            var t = pdfh(x, 'a&&title')\\n            var s = pdfh(x, 'span&&Text')\\n            d.push({\\n                title: `““””<small>[<font color=\\\"#999\\\">${s}</font>]${t}</small>`,\\n                url: pd(x, 'a&&href') + '#immersiveTheme#',\\n                col_type: 'text_1',\\n                extra: {\\n                    title: t,\\n                    inheritTitle: false\\n                }\\n            })\\n        })\\n    }\\n}\\n\\nfunction appedData(d, html, selects, line, dyc) {\\n\\n    var i = getMyVar('i', i);\\n    if (line) {\\n        i = Number(i)\\n    }\\n    var ii = 1\\n\\n    \\n    var item = selects.item\\n    var list = selects.list\\n    var imgx = selects.img\\n    var title = selects.title\\n    var desc = selects.desc\\n    var url = selects.url\\n    var col_type = selects.col_type\\n    \\n\\n    var list = eval(list)\\n    if (list.length == 0 && line == true) {\\n        throw 'Error:没有了'\\n        return\\n    }\\n\\n\\n    list.forEach(item => {\\n        var img = eval(imgx)\\n        //log(item)\\n        var arr = {\\n            title: eval(title),\\n            desc: eval(desc),\\n            //img: (img.endsWith('0') ? img + '/' : img) + '@Referer=',\\n            img: img + '@Referer=',\\n            url: eval(url) + '#immersiveTheme#',\\n            col_type: col_type,\\n            extra: {\\n                title: eval(title),\\n                img: img,\\n                state: eval(desc),\\n\\n            }\\n        }\\n        if (dyc) {\\n            if (ii == 1) {\\n                arr.extra.id = 'video1'\\n                d.push(arr)\\n            }\\n            arr.extra.id = 'video2'\\n            addItemAfter('video1', arr);\\n        } else {\\n            d.push(arr)\\n        }\\n    })\\n    if (line) {\\n        i++\\n        d.push({\\n            col_type: \\\"line\\\",\\n            extra: {\\n                id: 'aline' + i.toString()\\n            }\\n        })\\n        putMyVar('i', i)\\n    }\\n    \\n}\\n\\nfunction jumpMore(d, html, obj) {\\n\\n    var name = obj.name\\n    var title = obj.title\\n    var img = obj.img\\n    var url = obj.url\\n    var seles = obj.seles\\n    seles.list = obj.nlist\\n\\n    if (name != undefined) {\\n\\n        let dm = 0;\\n        for (let i = 0; i < d.length; i++) {\\n            var b = (new RegExp(`^${name}$`).test(d[i].title))\\n            if (b) {\\n                dm = i;\\n                break;\\n            }\\n        }\\n        url = d[dm].url\\n\\n    }\\n\\n    d.push({\\n        title: title,\\n        col_type: 'avatar',\\n        img: img,\\n        url: url\\n    })\\n    appedData(d, html, seles)\\n}\\n\\n\\nfunction rankAdd(d, html, obj) {\\n    var name = obj.name\\n    var title = obj.title\\n    var img = obj.img\\n    var url = obj.url\\n    var seles = obj.seles\\n    seles.list = obj.nlist\\n    seles.title = obj.ntitle\\n    seles.desc = obj.ndesc\\n\\n    /*d.push({\\n        title: title,\\n        col_type: 'avatar',\\n        img: img,\\n        url: url\\n    })*/\\n\\n    var list = eval(seles.list)\\n\\n    list.map((item, i) => {\\n        i = i + 1\\n        var stitle = eval(seles.title)\\n        var desc = ''\\n        if (seles.desc != undefined) {\\n            desc = eval(seles.desc)\\n            desc = desc != '' ? `<font color=\\\"#808080\\\">[${desc}]</font>` : ''\\n        }\\n\\n\\n        var title = i + '.' + eval(seles.title)\\n\\n\\n        switch (i) {\\n            case 1:\\n                title = `““””<small><font color=\\\"#ff3d5e\\\">${title}</font> ${desc}</small>`\\n                break;\\n            case 2:\\n                title = `““””<small><font color=\\\"#f37000\\\">${title}</font> ${desc}</small>`\\n                break;\\n            case 3:\\n                title = `““””<small><font color=\\\"#ffa82e\\\">${title}</font> ${desc}</small>`\\n                break;\\n            default:\\n                title = `““””<small><font color=\\\"\\\">${title}</font> ${desc}</small>`\\n                break;\\n        }\\n\\n        d.push({\\n            title: `${title}`,\\n            col_type: seles.col_type,\\n            url: eval(seles.url) + '#immersiveTheme#',\\n            extra: {\\n                pageTitle: stitle,\\n                inheritTitle: false\\n            }\\n        })\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"main\",\"rule\":\"js:\\n\\naddListener('onClose', () => {\\n    //log('页面关闭')\\n    putMyVar('week', new Date().getDay())\\n    putMyVar('i', '1')\\n\\n})\\n\\naddListener('onRefresh', () => {\\n    //log('页面刷新')\\n})\\n\\neval(JSON.parse(request('hiker://page/ui')).rule)\\n\\nif(MY_PAGE>1)\\nsetResult(d)\\n\\nvar html = request(true_url)\\n\\n//eval(JSON.parse(request('hiker://page/dtfl')).rule)\\n\\nvar data = getWeekData(html, '#con_dm_**&&li')\\n\\nvar show = storage0.getItem('show', '展开')\\n\\nvar obj = {\\n    data: data,\\n    title: `番剧表${strRepeat('\\\\t',35)}[${show}]`,\\n    dn: getTimeState(),\\n    img: 'https://lanmeiguojiang.com/tubiao/more/277.png',\\n    url: $(\\\"#noLoading#\\\").lazyRule((s) => {\\n        if (s == '收起') {\\n            storage0.setItem('show', '展开');\\n        } else {\\n            storage0.setItem('show', '收起');\\n        }\\n        refreshPage()\\n        return 'hiker://empty'\\n    }, show),\\n    show: show,\\n    wcolor: getRangeColors(),\\n    wstr: '星期',\\n}\\n\\nweekAppend(d, obj)\\n\\ntempc=[\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\",\\\"0\\\"]\\n\\nvar acg = {\\n    seles: selects,\\n    nlist: \\\"pdfa(html,'body&&.mb:has([href*=acg])')\\\",\\n    title: `动漫${strRepeat('\\\\t',37)}[更多]`,\\n    img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n    url: $('').lazyRule((h,t,i,c) => {\\n        putVar(MY_RULE.url,h)\\n        storage0.putMyVar('tindex', i)\\n        t[0]=String(c)\\n        putVar(MY_RULE.title, JSON.stringify(t))\\n        refreshPage()\\n    },config.首页+'acg/',tempc,1,2)\\n}\\njumpMore(d, html, acg)\\n\\nvar tv = {\\n    seles: selects,\\n    nlist: \\\"pdfa(html,'body&&.mb:has([href*=tv])')\\\",\\n    title: `电视剧${strRepeat('\\\\t',35)}[更多]`,\\n    img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n    url: $('').lazyRule((h,t,i,c) => {\\n        putVar(MY_RULE.url,h)\\n        storage0.putMyVar('tindex', i)\\n        t[0]=String(c)\\n        putVar(MY_RULE.title, JSON.stringify(t))\\n        refreshPage()\\n    },config.首页+'tv/',tempc,1,0)\\n\\n}\\njumpMore(d, html, tv)\\n\\nvar mv = {\\n    seles: selects,\\n    nlist: \\\"pdfa(html,'body&&.mb:has([href*=mov])')\\\",\\n    title: `电影${strRepeat('\\\\t',37)}[更多]`,\\n    img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n    url: $('').lazyRule((h,t,i,c) => {\\n        putVar(MY_RULE.url,h)\\n        storage0.putMyVar('tindex', i)\\n        t[0]=String(c)\\n        putVar(MY_RULE.title, JSON.stringify(t))\\n        refreshPage()\\n    },config.首页+'mov/',tempc,1,1)\\n}\\njumpMore(d, html, mv)\\n\\nvar zy = {\\n    seles: selects,\\n    nlist: \\\"pdfa(html,'body&&.mb:has([href*=zongyi])')\\\",\\n    title: `综艺${strRepeat('\\\\t',37)}[更多]`,\\n    img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n    url: $('').lazyRule((h,t,i,c) => {\\n        putVar(MY_RULE.url,h)\\n        storage0.putMyVar('tindex', i)\\n        t[0]=String(c)\\n        putVar(MY_RULE.title, JSON.stringify(t))\\n        refreshPage()\\n    },config.首页+'zongyi/',tempc,1,3)\\n}\\njumpMore(d, html, zy)\"},{\"col_type\":\"movie_3\",\"name\":\"排行\",\"path\":\"rank\",\"rule\":\"js:\\ntrue_url = config.首页\\nvar html=fetch(true_url)\\n\\neval(JSON.parse(request('hiker://page/ui')).rule)\\n\\nvar ranks = ['动漫', '电视剧', '电影', '综艺']\\n\\nvar rindex = getMyVar('rindex', '0')\\n\\nranks.map((x, i) => {\\n    var title = i == rindex ? `““””<small><b><font color=\\\"#1E90FF\\\">${x}排行</font></b></small>` : `““””<small>${x}排行</small>`\\n    d.push({\\n        title: title,\\n        col_type: 'icon_round_small_4', img:'https://lanmeiguojiang.com/tubiao/ke/159.png',\\n        url: $('').lazyRule((i) => {\\n            putMyVar('rindex', i)\\n            refreshPage()\\n            return 'hiker://empty'\\n        }, i)\\n    })\\n})\\n\\n\\nvar sle = {\\n    col_type: 'text_1',\\n    url: \\\"pd(item,'a&&href')\\\",\\n    //desc: \\\"pdfh(item,'.rank_value&&Text')\\\"\\n}\\n\\nvar ranksele=`'body&&.index-list-r,${rindex}&&li'`\\n\\nvar Hot1 = {\\n    seles: sle,\\n    nlist: \\\"pdfa(html,\\\"+ranksele+\\\")\\\",\\n    ntitle: \\\"pdfh(item,'a&&title')\\\",\\n    ndesc:\\\"pdfh(item,'span,0&&Text')\\\",\\n}\\nrankAdd(d, html, Hot1)\"},{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"search\",\"rule\":\"js:\\n\\nfunction 搜索建议(arr, pic) {\\n    var rule_name = MY_RULE.title;\\n    var imgs = storage0.getItem(rule_name + '建议海报');\\n    var names = storage0.getItem(rule_name + '建议片名');\\n    if (imgs.length < 3) {\\n\\n        for (let i = 0; i < 3; i++) {\\n            if (imgs[i] == undefined) {\\n                imgs[i] = 'https://p.qlogo.cn/hy_personal/3e28f14aa05168423e37010863748431632970d0703fc75d9e701bd117b2a9db/0.gif'\\n                names[i]=''\\n            }\\n        }\\n    }\\n    \\n\\n    if (pic == '海报开') {\\n        var timgs = ['img0', 'img1', 'img2']\\n        timgs.map((x, i) => {\\n            arr.push({\\n                img: imgs[i],\\n                col_type: 'pic_3',\\n                extra: {\\n                    id: x\\n                },\\n                desc: \\\"0\\\",\\n                url: 'hiker://search?s=' + names[i] + '&rule=' + rule_name,\\n            })\\n        })\\n    }\\n    arr.push({\\n        title: \\\"🔍\\\",\\n        url: '\\\"hiker://search?s=\\\" + input + \\\"&rule=\\\"+MY_RULE.title ',\\n        desc: \\\"搜点什么...\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            onChange: $.toString((rule_name) => {\\n                let sug = config.sug || [];\\n                for (let i in sug) {\\n                    deleteItem(sug[i]);\\n                }\\n                if (input == '') deleteItemByCls(\\\"#s\\\");\\n                if (input) {\\n                    if (input == '清除搜索记录') writeFile('hiker://files/cache/搜索记录.json', '');\\n                    initConfig({\\n                        sug: [input]\\n                    });\\n                    http.fetch(`https://m.douban.com/search/?query=${input}&type=1002`, {}).success(data => {\\n                        //var gg = JSON.parse(data.split('fn\\\\(')[1].replace('\\\\}\\\\)', '\\\\}')).item;\\n                        var list = pdfa(data, 'body&&.search-module&&li&&a:not([href*=\\\"javascript\\\"])')\\n                        var gg = list.map(x => {\\n                            var title = pdfh(x, '.subject-title&&Text')\\n                            var img = pdfh(x, 'img&&src')\\n                            return {\\n                                word: title,\\n                                dc: img\\n                            }\\n                        })\\n                        //log(gg)\\n\\n                        putVar('建议数据', gg)\\n\\n                        var dd = gg.slice(0, 3)\\n                        \\n\\n                        if (dd.length > 0) {\\n                            storage0.setItem(rule_name + '建议海报', dd.map(x => x.dc))\\n                            storage0.setItem(rule_name + '建议片名', dd.map(x => x.word))\\n                            \\n\\n                            dd.map((x, i) => {\\n\\n                                updateItem('img' + i, {\\n                                    img: x.dc,\\n                                    url: 'hiker://search?s=' + x.word + '&rule=' + rule_name,\\n                                    extra: {\\n                                        id: 'img' + i\\n                                    }\\n                                })\\n                            })\\n                        }\\n                    }).error(msg => log(msg.toString())).start(log(2))\\n                    var gg = JSON.parse(getVar('建议数据'));\\n                    deleteItemByCls(\\\"#s\\\");\\n                    for (let i in gg) {\\n                        var nn = gg[i].word;\\n                        addItemAfter(\\\"12input\\\", {\\n                            title: nn,\\n                            url: $(\\\"#noLoading#\\\").lazyRule((nn, rule_name) => {\\n                                let localData = request('hiker://files/cache/搜索记录.json');\\n                                if (!localData) localData = \\\"[]\\\";\\n                                let lishi = JSON.parse(localData);\\n                                let ccc = lishi.indexOf(nn);\\n                                if (ccc > -1) {\\n                                    lishi.splice(ccc, 1)\\n                                };\\n                                lishi.push(nn);\\n                                lishi = lishi.slice(-3);\\n                                writeFile('hiker://files/cache/搜索记录.json', JSON.stringify(lishi));\\n                                return 'hiker://search?s=' + nn + '&rule=' + rule_name\\n                            }, nn, rule_name),\\n                            col_type: \\\"text_1\\\",\\n                            extra: {\\n                                id: input,\\n                                cls: \\\"#s\\\"\\n                            }\\n                        });\\n                    }\\n                } else {\\n                    //默认\\n                    let localData = request('hiker://files/cache/搜索记录.json');\\n                    if (!localData) localData = \\\"[]\\\";\\n                    let lishi = JSON.parse(localData).slice(-3);\\n                    config.sug = lishi;\\n                    initConfig({\\n                        sug: config.sug\\n                    });\\n                    for (let it of config.sug) {\\n                        addItemAfter(\\\"12input\\\", {\\n                            title: it,\\n                            url: 'hiker://search?s=' + it + '&rule=' + rule_name,\\n                            col_type: \\\"text_3\\\",\\n                            extra: {\\n                                id: it,\\n                                cls: \\\"#s\\\"\\n                            }\\n                        });\\n                    }\\n                }\\n            }, rule_name),\\n            titleVisible: false,\\n            id: \\\"12input\\\"\\n        }\\n    });\\n    for (let i = 0; i < 10; i++) {\\n        arr.push({\\n            col_type: \\\"blank_block\\\"\\n        })\\n    }\\n    //setResult(d)\\n}\\n\\nif (MY_PAGE == 1) {\\n    搜索建议(d, '海报开')\\n}\\n\\nsetHomeResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"旧版\",\"path\":\"old\",\"rule\":\"js:\\nvar d = []\\n\\nMY_URL = MY_URL.split('##')[1]\\n\\n//log(MY_URL)\\n\\naddListener('onClose', () => {\\n    //log('页面关闭')\\n    putMyVar('week', new Date().getDay())\\n    putMyVar('i', '1')\\n\\n})\\n\\naddListener('onRefresh', () => {\\n    //log('页面刷新')\\n})\\n\\n//随机颜色\\nvar getRangeColors = function() {       \\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);     \\n}\\n//动态分类定义 需根据实际修改\\nconst 分类颜色 = getRangeColors()\\nconst 大类定位 = 'body&&.nav-pc'\\nconst 拼接分类 = 'body&&dd'\\nconst 小类定位 = 'body&&a:not(:matches(播出))'\\nconst 分类标题 = 'a&&Text'\\nconst 分类链接 = 'a&&href'\\nMY_URL = MY_URL.replace('hiker://empty##', '')\\n\\nlet true_url = getVar(MY_RULE.url, MY_URL)\\nconst page = MY_PAGE\\n//log(page)\\n\\n//扩展函数\\neval(JSON.parse(request('hiker://page/extend')).rule)\\n\\nvar urlp = urlParse(true_url)\\n//log(urlp)\\n\\nvar up = urlp.File.Split('/', true)\\nif (up.length == 1) {\\n    true_url = true_url + (`0/0/all/${page}.html`)\\n} else if (up.length) {\\n    true_url = true_url.replace(/\\\\/\\\\d+.html$/gm, `/${page}.html`)\\n}\\n\\n//log(true_url)\\n\\nif (page == 1) {\\n    d.push({\\n        title: \\\"🔍\\\",\\n        url: $.toString((r) => {\\n            putMyVar('keyword', input);\\n            return 'hiker://search?rule=' + r + '&s=' + input;\\n        }, MY_RULE.title),\\n        desc: '搜点什么',\\n        col_type: \\\"input\\\",\\n        extra: {\\n            defaultValue: getMyVar('keyword', '') || \\\"\\\",\\n        }\\n    });\\n}\\n\\n\\nlet getTimeState = () => {\\n    let timeNow = new Date();\\n    let hours = timeNow.getHours();\\n    let text = ``;\\n    if (hours >= 7 && hours <= 18) {\\n        text = `☀️`;\\n    } else {\\n        text = '🌙';\\n    }\\n    return text;\\n};\\n\\n\\nfunction getWeekData(html, text) {\\n    var data = []\\n    var s = pdfa(html, text.replace('**', 7))\\n    data.push(s)\\n    for (let i = 1; i <= 6; i++) {\\n        var h = pdfa(html, text.replace('**', i))\\n        data.push(h)\\n    }\\n    //log(data.length)\\n    return data\\n}\\n\\n\\n\\nfunction weekAppend(d, obj) {\\n    //定义常量和方法\\n    var 礼拜 = [\\\"日\\\", \\\"一\\\", \\\"二\\\", \\\"三\\\", \\\"四\\\", \\\"五\\\", \\\"六\\\"];\\n\\n    let 星期 = (x, y) => {\\n        let day = x.getDay();\\n        return y[day];\\n    }\\n    var 日期 = new Date();\\n\\n    //传递变量\\n    var data = obj.data\\n    var title = obj.title\\n    var daynight = obj.dn\\n    var img = obj.img\\n    var url = obj.url\\n    var show = obj.show\\n    var wcolor = obj.wcolor\\n    var wstr = obj.wstr\\n\\n    d.push({\\n        title: title,\\n        col_type: 'avatar',\\n        img: img,\\n        url: url\\n    })\\n\\n    if (show == '展开') {\\n        var day = new Date().getDay()\\n        var week = getMyVar('week', day + '')\\n        we = 礼拜[week]\\n        for (var i = 0; i < 礼拜.length; i++) {\\n            d.push({\\n                title: week == i ? '““””' + daynight + `<font color=\\\"${wcolor}\\\"><b>` + wstr + we + '</b></font>' : 礼拜[i],\\n                url: $(\\\"#noLoading#\\\").lazyRule((it) => {\\n                    putMyVar(\\\"week\\\", Number(it));\\n                    refreshPage(true);\\n                    return 'hiker://empty'\\n                }, i),\\n                col_type: \\\"scroll_button\\\",\\n                extra: {\\n                    id: 'week' + i,\\n                }\\n            })\\n        }\\n\\n        d.push({\\n            col_type: \\\"line\\\",\\n            pic: \\\"\\\",\\n            extra: {\\n                id: \\\"good\\\"\\n            }\\n        })\\n\\n        data[week].forEach((x) => {\\n            var t = pdfh(x, 'a&&title')\\n            var s = pdfh(x, 'span&&Text')\\n            d.push({\\n                title: `““””<small>[<font color=\\\"#999\\\">${s}</font>]${t}</small>`,\\n                url: pd(x, 'a&&href') + '#immersiveTheme#',\\n                col_type: 'text_1',\\n                extra: {\\n                    title:t\\n                }\\n            })\\n        })\\n    }\\n}\\n\\nfunction appedData(d, html, selects, line, dyc) {\\n    var i = getMyVar('i', i);\\n    if (line) {\\n        i = Number(i)\\n    }\\n    var ii = 1\\n\\n    var item = selects.item\\n    var list = selects.list\\n    var imgx = selects.img\\n    var title = selects.title\\n    var desc = selects.desc\\n    var url = selects.url\\n    var col_type = selects.col_type\\n\\n    var list = eval(list)\\n    if (list.length == 0 && line == true) {\\n        throw 'Error:没有了'\\n        return\\n    }\\n\\n    list.forEach(item => {\\n        var img = eval(imgx)\\n        //log(item)\\n        var arr = {\\n            title: eval(title),\\n            desc: eval(desc),\\n            //img: (img.endsWith('0') ? img + '/' : img) + '@Referer=',\\n            img:img+'@Referer=',\\n            url: eval(url) + '#immersiveTheme#',\\n            col_type: col_type,\\n            extra: {\\n                title: eval(title),\\n                img: img,\\n                state: eval(desc),\\n\\n            }\\n        }\\n        if (dyc) {\\n            if (ii == 1) {\\n                arr.extra.id = 'video1'\\n                d.push(arr)\\n            }\\n            arr.extra.id = 'video2'\\n            addItemAfter('video1', arr);\\n        } else {\\n            d.push(arr)\\n        }\\n    })\\n    if (line) {\\n        i++\\n        d.push({\\n            col_type: \\\"line\\\",\\n            extra: {\\n                id: 'aline' + i.toString()\\n            }\\n        })\\n        putMyVar('i', i)\\n    }\\n}\\n\\n//list 列表 item每项\\nvar selects = {\\n    item: 'item',\\n    list: \\\"pdfa(html, 'body&&.mb')\\\",\\n    img: \\\"pd(item, 'img&&data-original')\\\",\\n    title: \\\"pdfh(item, 'a&&title')\\\",\\n    desc: \\\"pdfh(item, '.bz&&Text')\\\",\\n    url: \\\"pd(item, 'a&&href')\\\",\\n    col_type: 'movie_3_marquee'\\n}\\n\\nfunction jumpMore(d, html, obj) {\\n\\n    var name = obj.name\\n    var title = obj.title\\n    var img = obj.img\\n    var url = obj.url\\n    var seles = obj.seles\\n    seles.list = obj.nlist\\n\\n    if (name != undefined) {\\n        let dm = 0;\\n        for (let i = 0; i < d.length; i++) {\\n            var b = (new RegExp(`^${name}$`).test(d[i].title))\\n            if (b) {\\n                dm = i;\\n                break;\\n            }\\n        }\\n        url = d[dm].url\\n    }\\n\\n    d.push({\\n        title: title,\\n        col_type: 'avatar',\\n        img: img,\\n        url: url\\n    })\\n    appedData(d, html, seles)\\n}\\n\\n\\nif (true_url == config.首页) {\\n\\n    if (page == 1) {\\n        var html = request(true_url)\\n\\n        eval(JSON.parse(request('hiker://page/dtfl')).rule)\\n\\n        var data = getWeekData(html, '#con_dm_**&&li')\\n\\n        var show = storage0.getItem('show', '展开')\\n\\n        var obj = {\\n            data: data,\\n            title: `番剧表${strRepeat('\\\\t',35)}[${show}]`,\\n            dn: getTimeState(),\\n            img: 'https://lanmeiguojiang.com/tubiao/more/277.png',\\n            url: $(\\\"#noLoading#\\\").lazyRule((s) => {\\n                if (s == '收起') {\\n                    storage0.setItem('show', '展开');\\n                } else {\\n                    storage0.setItem('show', '收起');\\n                }\\n                refreshPage()\\n                return 'hiker://empty'\\n            }, show),\\n            show: show,\\n            wcolor: getRangeColors(),\\n            wstr: '星期',\\n        }\\n\\n        weekAppend(d, obj)\\n\\n\\n        var acg = {\\n            name: '动漫',\\n            seles: selects,\\n            nlist: \\\"pdfa(html,'body&&.mb:has([href*=acg])')\\\",\\n            title: `动漫${strRepeat('\\\\t',37)}[更多]`,\\n            img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n        }\\n        jumpMore(d, html, acg)\\n\\n        var tv = {\\n            name: '电视剧',\\n            seles: selects,\\n            nlist: \\\"pdfa(html,'body&&.mb:has([href*=tv])')\\\",\\n            title: `电视剧${strRepeat('\\\\t',35)}[更多]`,\\n            img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n        }\\n        jumpMore(d, html, tv)\\n\\n        var mv = {\\n            name: '电影',\\n            seles: selects,\\n            nlist: \\\"pdfa(html,'body&&.mb:has([href*=mov])')\\\",\\n            title: `电影${strRepeat('\\\\t',37)}[更多]`,\\n            img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n        }\\n        jumpMore(d, html, mv)\\n\\n        var zy = {\\n            name: '综艺',\\n            seles: selects,\\n            nlist: \\\"pdfa(html,'body&&.mb:has([href*=zongyi])')\\\",\\n            title: `综艺${strRepeat('\\\\t',37)}[更多]`,\\n            img: 'https://lanmeiguojiang.com/tubiao/more/228.png',\\n        }\\n        jumpMore(d, html, zy)\\n\\n    }\\n\\n    //appedData(d, html, selects1)\\n\\n\\n} else {\\n    var html = request(true_url)\\n    var script1 = pdfh(html, '.nav-down-mb&&script&&Html')\\n    var script2 = pdfh(html, '.main&&script&&Html')\\n    eval(script1 + script2)\\n\\n    var params = {\\n        action: fj_action_,\\n        page: fj_page_,\\n        year: fj_year,\\n        area: fj_area,\\n        class: fj_class,\\n        dect: dect,\\n        id: fj_id_\\n    }\\n\\n    var content = fetch(_yu_gda_s + '?' + Object.ToParams(params))\\n\\n    //动态分类\\n    eval(JSON.parse(request('hiker://page/dtfl')).rule)\\n    try {\\n        appedData(d, content, selects, true, true)\\n    } catch (e) {\\n        var i = getMyVar('i', 1)\\n        var id = `aline${i}`\\n        if (findItem('lastid') == null) {\\n            addItemAfter(id, {\\n                title: \\\"““””<font color='gray'>到底了<font>\\\",\\n                url: 'hiker://empty',\\n                col_type: 'text_center_1',\\n                extra: {\\n                    id: 'lastid'\\n                }\\n            });\\n        }\\n    }\\n}\\n\\n\\nsetResult(d);\"}]","icon":"http://yhdm81.com/favicon.ico","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!