求主页，以前找到的，觉得可以现在找不到了，谢谢 cqtllzy 2021-03-03 12:57:18 求助 首页规则 获赞：0 评论：4 查看：858 AUTH 导入公众号的合集后首页空白了，恢复默认首页，导入自己分享的首页，显示错误。 分享下这个首页，谢谢！ 我导入的下面这个。 https://pasteme.cn/108315 规则名：我的主页
AUTH
导不了
海阔视界规则分享，当前分享的是：首页频道￥home_rule_v2￥base64://@我自己的主页 @{"firstHeader":"class","title":"我自己的主页","author":"","url":"hiker://empty","version":0,"col_type":"movie_2","class_name":"","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar d=[];\n//配置\nconst titles=[\n\"⚪ 不一样的视界，不一样的精彩!⚪\",\n\"🌾💚海阔视界不一样的精彩！💚 🌾\",\n\"   ⚪  小棉袄最帅，🌹不容反驳我!⚪\",\n\"🌴   💕    精彩不一样的视界！💕  🌴\",\n\"🎍     🌺🌺海阔视界新体验🌺🌺  🎍\",\n]\nconst title=titles[Math.floor((Math.random()*titles.length))];\n\nvar bigPicUrl=getVar(\"home_pic_url\",\"http://api.btstu.cn/sjbz#'+new? glideCache=skip\");\nconst avatarUrl=\"hiker://images/card_bg\";\nconst maxHomeCount=800;\nconst BarColor=\"#ffd000\";\nconst headColor=\"#358ccd\";\nconst eontColor=\"#43b244\";\nconst wontColor=\"#815f25\";\nconst jontColor=\"#1e9eb3\";\nconst iontColor=\"#1a94bc\";\nconst pontColor=\"#1a94bc\";\nconst yontColor=\"#5dbe8a\";\nconst lontColor=\"#e2d849\";\nconst aontColor=\"#579572\";\nconst date=new Date();\nconst picTag=date.getYear()+\"\"+date.getMonth()+date.getDate();\nfunction zero(s) {\n    return s < 10 ? '0' + s: s;};\nvar mydate = new Date();\nmonth = mydate.getMonth() + 1;\ndata = mydate.getDate();\n[mydate.getDay()];\nnewTime =  '微信公众号【新方圆小棉袄】' + zero(month) + '月' + zero(data) + '日';\nd.push({\n    title: '‘‘’’<font color=\"'+BarColor+'\">'+ newTime + '',\n    col_type: \"text_1\"\n});\nconst remotePicUrl=\"https://api.mmcee.cn/acgimg/acgurl.php#'+new?glideCache=skip\";\nif(bigPicUrl.indexOf(\"hiker\")!=0){\n    bigPicUrl=bigPicUrl+\"#time=\"+picTag;\n}\n//可以切换图片地址\nconst changePic = `http://api.btstu.cn/sjbz/api.php@lazyRule=.js:\\\nconst bigPicUrl=getVar(\"home_pic_url\",\"https://cdn.seovx.com/?mom=302#.jpgMon Jan 25 2021 12:39:17 GMT+0800 (GMT+08:00)#'+new ?glideCache=skip\");\\\nconst file=\"hiker://files/config/home.json\";\\\nconst diy=\"`+remotePicUrl+`\";\\\nconst loc=\"https://www.hlapi.cn/api/gqbz#'+new?glideCache=skip\";\\\nloc=\"https://acg.yanwz.cn/scenery/api.php?glideCache=skip\";\\\nconst newPic=bigPicUrl==loc?diy:loc;\\\nputVar(\"home_pic_url\",newPic);\\\nvar config=fetch(file);\\\nif(config == \"\"){\\\n    config={};\\\n}else{\\\n   config=JSON.parse(config);\\\n}\\\nconfig.bigPicUrl=newPic;\\\nwriteFile(file,JSON.stringify(config));\\\nrefreshPage();\\\n\"toast://大图已切换为\"+(bigPicUrl==loc?\"动漫图\":\"风景图\")\\\n`;\n//大图\nd.push({\n    title: title,\n    desc:'',\n    url:changePic,\n    col_type:\"pic_1_card\",\n    pic_url:bigPicUrl\n});\nd.push({\n    col_type:\"big_blank_block\",\n});\nfunction zero(s) {\n    return s < 10 ? '0' + s: s;\n};\nvar mydate = new Date();\nmonth = mydate.getMonth() + 1;\ndata = mydate.getDate();\nhour = mydate.getHours();\nminute = mydate.getMinutes();\nday = new Array(\"  周日  🔍\", \"  周一  🔎\", \"  周二  🔍\", \"  周三  🔎\", \"  周四  🔍\", \"  周五  🔎\", \"  周六  🔍\")[mydate.getDay()];\nnewTime =  '搜索或输入网址' + '\\t\\t\\t' + zero(hour) + ':' + zero(minute) + day;\nd.push({\n    title: '' + newTime + '',\n    url:'hiker://search',\n    col_type: \"icon_1_search\"\n});\nd.push({\n    title:'视界更多设置',\n    url:'hiker://settingMore',\n    col_type:\"icon_2\",\n    pic_url:\"https://s3.ax1x.com/2021/01/17/srB8ds.gif\"\n});\nd.push({\n    title:'视界百度一下',\n    url:'https://www.baidu.com/',\n    col_type:\"icon_2\",\n    pic_url:\"https://s3.ax1x.com/2021/01/17/sr2ECj.gif\"\n});\n\nconst shortcut_list=[\n    '书签@@hiker://bookmark@@https://s3.ax1x.com/2020/11/20/DQTd5d.png',\n    '历史@@hiker://history@@https://s3.ax1x.com/2020/11/20/DQLa9J.png',\n    '下载@@hiker://download@@https://s3.ax1x.com/2020/11/20/DQqFdU.png',\n    '插件@@hiker://js@@https://s3.ax1x.com/2020/11/20/DQqoY4.png'\n];\n\nfor(let i=0;i<shortcut_list.length;i++){\n    let k = shortcut_list[i].split(/\\s*@@\\s*/);\n    if (k.length < 2)\n       continue;\n    d.push({\n       title: k[0],\n       url: k[1],\n       pic_url: k[2],\n       col_type: \"icon_small_4\"\n    });\n}\n//混搭\n\nfunction getHead(title){\n    return '‘‘’’<strong><font color=\"'+headColor+'\">'+title+'</front></strong>';\n}\n\n//收藏\nlet collection=fetch(\"hiker://collection\");\nif(collection == null || collection == \"\"){\n    collection = \"[]\";\n}\ncollection =JSON.parse(collection);\n\nlet colPicUrl=bigPicUrl;\nfor(let i=collection.length-1;i>=0;i--){\n    if(collection[i].picUrl!=null){\n        colPicUrl=collection[i].picUrl;\n        break;\n    }\n}\n\nd.push({\n    desc:'我的🌜'+collection.length+'🌛收藏',\n    url:'hiker://collection',\n    col_type:\"movie_2\",\n    pic_url:colPicUrl\n});\n//频道\nlet home=fetch(\"hiker://home\");\nif(home == null || home == \"\"){\n    home = \"[]\";\n}\nhome =JSON.parse(home);\n\nd.push({\n    desc:'我的🌜'+home.length+'🌛规则  ',\n   url:'hiker://home',\n    col_type:\"movie_2\",\n    pic_url:\"http://api.btstu.cn/sjbz/?lx=m_meizi#'+new?glideCache=skip\"\n});\nconst card = [];\nlet cardArr = [];\ncard.push({\n    id: '1',\n    title:'‘‘’’<font color=\"'+aontColor+'\">🕳️…开启...🎬 精彩剧场 🎬...关📴闭…🕳️',\n    list: [\n    '视界HD@@hiker://home@视界HD@@https://paimgcdn.baidu.com/v.4F4D0BC1A6D77BAC0D0596E62A78D0DE?src=http%3A%2F%2Fms.bdimg.com%2Fdsp-image%2F4580643358.jpg&rz=sar_3_395_395',\n    '西瓜音乐@@https://m.ixigua.com/channel/music?logTag=xtQ_EftbZqPYSFJ2TBQSN&keyword=2020dj@@https://m.vxigua.com/statics/img/favicon.ico',\n    '豆瓣资源@@hiker://home@豆瓣&资源网@@https://p.pstatp.com/origin/1380600020d4df36d3f75',\n    '88影视@@hiker://home@88影视网@@https://m.88kan.com/favicon.ico',\n    'GIFK歌@@hiker://home@GIF K歌@@https://si1.go2yd.com/get-image/0nUZzCjOSES',\n    '肥牛看@@hiker://home@肥牛看@@https://p1-tt-ipv6.byteimg.com/origin/pgc-image/90c6fd3669b54a5487066d9c54408255',\n    '好看视频@@https://haokan.baidu.com/?pkg=1023613p&ckey=CK1443721957277&source=1022900y-0-1023613p&timestamp=1612851896569#recommend@@https://static.dongtu.com/netpic/20170211030328XL5SS1YES57SBKJJ_mc.gif',\n    '苹果DJ@@http://m.pingguodj.com/dance/id-31-1.html@@https://si1.go2yd.com/get-image/0njFusDayCu'\n],\n    listStyle: 'icon_round_4',\n    init: '折叠'\n});\ncard.push({\n    id: '2',\n    title:'‘‘’’<font color=\"'+jontColor+'\">...….…….….….…主页随机图.….….…….….…..',\n    list: [\n    '美图视频@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/sjbz/api.php?glideCache=skip',\n'美图视频1@@https://tvv.tw/xjj/get/@@http://api.mtyqx.cn/tapi/random.php?t=?glideCache=skip',\n'美图视频2@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/sjbz/zsy.php?glideCache=skip',\n'美图视频3@@https://tvv.tw/xjj/get/@@http://api.btstu.cn/sjbz/?lx=m_meizi?glideCache=skip',\n'美图视频4@@http://xjj.jusuzs.com/video.php@@http://api.nmb.show/xiaojiejie2.php?glideCache=skip',\n'美图视频5@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/?glideCache=skip',\n'美图视频6@@https://tvv.tw/xjj/get/@@http://api.nmb.show/xiaojiejie1.php?glideCache=skip',\n'美图视频7@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/sjbz/zsy.php?glideCache=skip',\n'美图视频8@@https://tvv.tw/xjj/get/@@http://api.btstu.cn/sjbz/?lx=m_meizi?glideCache=skip',\n'美图视频9@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/sjbz/?lx=m_meizi?glideCache=skip',\n'美图视频10@@https://tvv.tw/xjj/get/@@http://api.btstu.cn/sjbz/?lx=m_dongman?glideCache=skip',\n'美图视频11@@http://xjj.jusuzs.com/video.php@@https://api.mmcee.cn/acgimg/acgurl.php?glideCache=skip',\n'美图视频12@@https://tvv.tw/xjj/get/@@https://api.gejiba.com/100/3109.php?glideCache=skip',\n'美图视频13@@http://xjj.jusuzs.com/video.php@@https://api.nmb.show/1985acg.php?glideCache=skip',\n'美图视频14@@http://xjj.jusuzs.com/video.php@@http://api.mtyqx.cn/tapi/random.php?glideCache=skip',\n'美图视频15@@https://www.hlapi.cn/api/wyrb@@https://cdn.seovx.com/?mom=302#.jpgMon Jan 25 2021 12:39:17 GMT+0800 (GMT+08:00)?glideCache=skip',\n'美图视频16@@https://tvv.tw/xjj/get/@@https://api.ixiaowai.cn/gqapi/gqapi.php?glideCache=skip',\n'美图视频17@@https://www.hlapi.cn/api/wyrb@@http://api.btstu.cn/sjbz/api.php?glideCache=skip',\n'美图视频18@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/sjbz/zsy.php?glideCache=skip',\n'美图视频19@@https://tvv.tw/xjj/get/@@https://api.lyiqk.cn/sexylady?glideCache=skip',\n'美图视频20@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/sjbz/api.php?glideCache=skip',\n'美图视频21@@https://tvv.tw/xjj/get/@@http://api.btstu.cn/sjbz?glideCache=skip',\n'美图视频22@@http://xjj.jusuzs.com/video.php@@https://acg.yanwz.cn/scenery/api.php?glideCache=skip',\n'美图视频23@@http://xjj.jusuzs.com/video.php@@http://api.btstu.cn/sjbz/api.php?glideCache=skip'\n],\n    listStyle: 'movie_2',\n    init: '折叠'\n});\ncard.push({\n    id: '3',\n    title:'‘‘’’<font color=\"'+iontColor+'\">~~~~~~~~劲爆🎤热舞~~~~~~~~~',\n    list: [\n    '广东爱情@@https://vd4.bdstatic.com/mda-kem89w1diei4p3b6/hd/mda-kem89w1diei4p3b6.mp4?playlist=%5B%22hd%22%2C%22sc%22%5D&auth_key=1610694216-0-0-a1531f14944ef16b13231081ec3c4806&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=@@https://imgessl.kugou.com/stdmusic/400/20171019/20171019192011818056.jpg',\n'IG热舞@@https://vd3.bdstatic.com/mda-kdchszk6ccmretrd/v1-cae/hd/mda-kdchszk6ccmretrd.mp4?auth_key=1610694295-0-0-f631b01721bc19d8c131dcdd9f4f7dba&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/f0e8eb7e29df10a7ecfd353d3877f8e8.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'热舞美女@@https://vd2.bdstatic.com/mda-maamvhu2w4v04rpg/hd/mda-maamvhu2w4v04rpg.mp4?auth_key=1610694401-0-0-cc962a5813d3fcd1b929f30a701f3399&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=1789033354,1637064438&fm=26&gp=0.jpg',\n'热舞美女1@@https://vd2.bdstatic.com/mda-kc689spthdgcgtwp/hd/mda-kc689spthdgcgtwp.mp4?auth_key=1610695161-0-0-a4e5bf80b4baaba5e5ce34d2ef096349&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/dc9c1e8f0db37c2a2eb71ab4d835c8aa.jpeg?x-bce-process=image/resize,m_fill,w_480,h_270/format,f_jpg/quality,Q_100',\n'舞蹈丝袜@@https://vd3.bdstatic.com/mda-kk3fy7dv0ny51d6q/hd/mda-kk3fy7dv0ny51d6q.mp4?playlist=%5B%22hd%22%2C%22sc%22%5D&auth_key=1610694641-0-0-1b130868e2f30fb1c6bef4a5fc1bc26e&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/dba4b4cb80dcfbff65161873deae7156.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'舞蹈丝袜高跟鞋@@https://vd3.bdstatic.com/mda-kgmhzxxx0nnqfbfg/hd/mda-kgmhzxxx0nnqfbfg.mp4?playlist=%5B%22hd%22%5D&auth_key=1610694720-0-0-4e80a6721e27b61ca3a88516c16c6b53&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://paimgcdn.baidu.com/8661A0F7A030D8E2?src=http%3A%2F%2Fms.bdimg.com%2Fdsp-image%2F5499861798.jpg&rz=urar_2_750_750&v=0',\n'性感稳定@@https://vd3.bdstatic.com/mda-kdrkshk8rwik4kmp/hd/mda-kdrkshk8rwik4kmp.mp4?auth_key=1610694788-0-0-7e56dc347c7ae46282a2b7c4a9ed7fa9&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/f8f93d6afb40d23d10703360bb7ef179.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'劲爆热舞@@https://vd3.bdstatic.com/mda-kk9mu1p5xy54r00f/hd/mda-kk9mu1p5xy54r00f.mp4?playlist=%5B%22hd%22%5D&auth_key=1610694845-0-0-1816a75360412242a6bb4cdbf4bb58f3&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/69918cb2b155dcd69d69589e4ce465e0.png?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'青春热舞@@https://vd3.bdstatic.com/mda-kh5phxmzc92m4um5/hd/mda-kh5phxmzc92m4um5.mp4?playlist=%5B%22hd%22%5D&auth_key=1610694903-0-0-2c6f4a42ae43465e88833abb5c36cb14&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/e603c83b500037d4811ad0e5745b904b.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'韩国热舞@@https://vd3.bdstatic.com/mda-keup96qr12r0e7mg/hd/mda-keup96qr12r0e7mg.mp4?playlist=%5B%22hd%22%5D&auth_key=1610694968-0-0-c9120dc3f85f16e04e63df8833e77cdf&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/f539ab884445c3ca950a9e0c01534f35.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_255%2Ch_170',\n'日本热舞@@https://vd2.bdstatic.com/mda-kkbggpc9iz22tkng/mda-kkbggpc9iz22tkng.mp4?auth_key=1610695037-0-0-efb4edd639667332003ab0551e9eb506&bcevod_channel=searchbox_feed&pd=1&pt=3@@https://vdposter.bdstatic.com/40d9940fe1eec8916f08c8a23db5212d.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_255%2Ch_170',\n'主播热舞@@https://vd2.bdstatic.com/mda-kdhuuwpdhifr3hiq/hd/mda-kdhuuwpdhifr3hiq.mp4?auth_key=1610695124-0-0-6ad709233275b1fd71d9e7a98c6077ad&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=3332508259,1736270573&fm=26&gp=0.jpg',\n'广场热舞@@https://vd4.bdstatic.com/mda-ka0hr3eix3v0zhnc/hd/mda-ka0hr3eix3v0zhnc.mp4?auth_key=1610695213-0-0-04d4a5a3f5ecf514515369bc9bf6a2ae&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=2166750509,311479600&fm=26&gp=0.jpg',\n'热舞@@https://vd4.bdstatic.com/mda-jk7dht9su2n8xn8s/mda-jk7dht9su2n8xn8s.mp4?auth_key=1610695267-0-0-13d9aa394210c12b0ced3afdb5a34b31&bcevod_channel=searchbox_feed&pd=1&pt=3@@https://dss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=242778856,890082960&fm=26&gp=0.jpg',\n'丝袜@@https://vd2.bdstatic.com/mda-kfuhz08jb0pis3a9/hd/mda-kfuhz08jb0pis3a9.mp4?playlist=%5B%22hd%22%2C%22sc%22%5D&auth_key=1610695335-0-0-a954643fc18d0a2a030ce3e7de20e959&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=2735470576,2268784002&fm=26&gp=0.jpg',\n'空姐丝袜@@https://vd4.bdstatic.com/mda-jkvhehgyvz91bd8c/hd/mda-jkvhehgyvz91bd8c.mp4?playlist=%5B%22hd%22%2C%22sc%22%5D&auth_key=1610695373-0-0-8da6a91072d06a631a40dc6e80a29303&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=2870952216,162173825&fm=26&gp=0.jpg',\n'主播丝袜@@https://vd2.bdstatic.com/mda-kiryspzdpknd61h0/hd/mda-kiryspzdpknd61h0.mp4?playlist=%5B%22hd%22%5D&auth_key=1610695649-0-0-dd2fb4f991c1cf5f006f8c39ed1bb155&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=1217061827,2059916088&fm=26&gp=0.jpg',\n'一起看@@https://vd2.bdstatic.com/mda-kif1w6szdr97jngh/hd/mda-kif1w6szdr97jngh.mp4?playlist=%5B%22hd%22%2C%22sc%22%5D&auth_key=1610696472-0-0-c0e8eaec7b8160d2dc3adc5236343550&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/e4a6a864ce03366a8cd6c7bccda5a248.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'贪心@@https://vd4.bdstatic.com/mda-kb155usy66dscnp8/hd/mda-kb155usy66dscnp8.mp4?auth_key=1610696583-0-0-9b9917f9d905e4cba06242092c49dde3&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/e4a6a864ce03366a8cd6c7bccda5a248.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'泳装4K@@https://vd2.bdstatic.com/mda-jd0dc2wiw7bfxfe7/hd/mda-jd0dc2wiw7bfxfe7.mp4?auth_key=1610696684-0-0-c3cfd0f1e41abd953f95da120f6ae6ec&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/b1a5e38860e8de89bf69cc2b22e62d25.png?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'模特身上@@https://vd3.bdstatic.com/mda-khh21128ya70azxw/hd/mda-khh21128ya70azxw.mp4?playlist=%5B%22hd%22%2C%22sc%22%5D&auth_key=1610696736-0-0-2db2207a277327c47bf1cc45ae1bd6cf&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/8c53d052131ded0d307c9179a8cf3f18.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'泳装比基尼@@https://vd4.bdstatic.com/mda-maah1m3ew94wkt0c/v1-cae/hd/mda-maah1m3ew94wkt0c.mp4?auth_key=1610696813-0-0-e21df4deca2d92be309f7ad520610e3f&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/43fe16e2dbec7cd3b404309bf300dd56.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'台湾泳装@@https://vd3.bdstatic.com/mda-kiswty25hutj3g36/hd/mda-kiswty25hutj3g36.mp4?playlist=%5B%22hd%22%5D&auth_key=1610696886-0-0-3d0858240dc7aa563338bc72028edc72&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/ffb3b3e2eb8704e5cc066b18a4e15363.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'劲爆舞1@@https://vd2.bdstatic.com/mda-kfe1a8yh7afkkxv0/mda-kfe1a8yh7afkkxv0.mp4?auth_key=1610714432-0-0-c6cd5269b6cba680870fd1becea93f60&bcevod_channel=searchbox_feed&pd=1&pt=3@@https://vdposter.bdstatic.com/c20f6d18f3ac8aaf4f4a97a26384940f.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'劲爆舞2@@https://vd2.bdstatic.com/mda-jd4gj9ayvymk0vg9/hd/mda-jd4gj9ayvymk0vg9.mp4?auth_key=1610714499-0-0-b2c62b77d56524cf5c202c63d82efe57&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/5bfb8f25c90684f99045d7bc4edcf17a.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'劲爆舞3@@https://vd2.bdstatic.com/mda-jcrkpyvpxmv527ct/hd/mda-jcrkpyvpxmv527ct.mp4?auth_key=1610714550-0-0-0590a485b97a60b2f5fba40ec20fc95b&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/89f410d8a7f3d4cdb214cd2cc05ee987.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'日本管舞@@https://vd3.bdstatic.com/mda-khwr8ukrd1mw5bup/hd/mda-khwr8ukrd1mw5bup.mp4?playlist=%5B%22hd%22%5D&auth_key=1610714592-0-0-09cd96261d1adf9e199a401be06da1d7&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/2a6dea87698f666962eddc3969dc16b2.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'性感舞@@https://vd2.bdstatic.com/mda-kgkz9cs4srs544c5/hd/mda-kgkz9cs4srs544c5.mp4?playlist=%5B%22hd%22%5D&auth_key=1610714646-0-0-552622c915a46ef08690f005d56de918&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/25ee51054c5830d77a9224c44db6f114.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'外劲爆舞@@https://vd3.bdstatic.com/mda-kj2n2inkdz2dy7af/hd/mda-kj2n2inkdz2dy7af.mp4?playlist=%5B%22hd%22%5D&auth_key=1610714705-0-0-c565502993eedd84c1c4e24392ba527b&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://vdposter.bdstatic.com/838bd589a0bf2ef87f7cc395ab10f0cb.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'劲爆舞蹈6@@https://vd4.bdstatic.com/mda-jcskq7gngmxe1x0s/hd/mda-jcskq7gngmxe1x0s.mp4?auth_key=1610714800-0-0-0c25126cff21491e790fa3199fec6f19&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2647329782,3352332120&fm=26&gp=0.jpg',\n'劲爆舞蹈7@@https://vd4.bdstatic.com/mda-jd5zp9ztkhuqaujx/hd/mda-jd5zp9ztkhuqaujx.mp4?auth_key=1610714855-0-0-31b19c2aaee630d87e43f003fc32501f&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=1239739755,3023544977&fm=26&gp=0.jpg',\n'劲爆舞蹈8@@https://vd4.bdstatic.com/mda-jegqgu6ki4it1abu/hd/mda-jegqgu6ki4it1abu.mp4?auth_key=1610714907-0-0-b8ff2a7a7cb2989e4691e0c60685311f&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=3782257724,697547681&fm=26&gp=0.jpg',\n'劲爆舞蹈9@@https://vd4.bdstatic.com/mda-khdku1tufj2ypj6p/hd/mda-khdku1tufj2ypj6p.mp4?playlist=%5B%22hd%22%5D&auth_key=1610714953-0-0-905bb9bdca652c6c689ed2d522f5adab&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=all@@https://dss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2241245360,4188157692&fm=26&gp=0.jpg',\n'劲爆舞10@@https://vd3.bdstatic.com/mda-kehsiwe2akref9pz/mda-kehsiwe2akref9pz.mp4?auth_key=1610714993-0-0-a898e7bbc410d4ca00745b36279b293f&bcevod_channel=searchbox_feed&pd=1&pt=3@@https://vdposter.bdstatic.com/e2f7c95cf21276ac98a253b77623aad4.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'dj美女舞曲视频_伤过的心@@https://dj.djyyy.com:446/hls/spsj/2020/01/10/10906/playlist.m3u8@@https://vdposter.bdstatic.com/1f66156c7448f583782eaeafde562e5a.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'dj美女舞曲视频/dj/英雄谱@@https://dj.djyyy.com:446/hls/spsj/2020/04/28/11148/playlist.m3u8@@https://vdposter.bdstatic.com/ca8ffce91f94c3a00f77a42507965a5a.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'dj热舞视频dj放一百个心@@https://dj.djyyy.com:446/hls/spsj/2019/11/02/10777/playlist.m3u8@@https://vdposter.bdstatic.com/663444e3121cd3e29df5028331e63de7.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'十二美女高清完整版@@https://vdse.bdstatic.com//7742fc4155c5291bd9cfa505f488299a.mp4?authorization=bce-auth-v1%2F40f207e648424f47b2e3dfbb1014b1a5%2F2021-01-16T03%3A35%3A06Z%2F-1%2Fhost%2F844bf4764552ee9c5c5d50349a186ce3c9fcd827558a2347d3569f8ec06afc0f@@https://vdposter.bdstatic.com/001263508dce4fdf43934c7aaef095ea.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'劲爆网络DJ@@https://vd3.bdstatic.com/mda-kiecv5t0qh5gkabd/mda-kiecv5t0qh5gkabd.mp4?playlist=%5B%22hd%22%2C%22sc%22%5D&pd=20@@http://p2.music.126.net/pEYNW4UbcGMSG5tgh38ODQ==/5673479999426413.jpg?imageView&thumbnail=360y360&quality=75&tostatic=0'\n],\n    listStyle: 'movie_3_marquee',\n    init: '折叠'\n});\ncard.push({\n    id: '4',\n    title:'‘‘’’<font color=\"'+pontColor+'\">💎港澳台 📺央视 📺  卫视台     📺  iHOT💎',\n    list: [\n    '凤凰资讯@@http://117.148.187.100/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221228597/index.m3u8#mp4@@http://www.cietv.com/img/fhzx.jpg',\n'中央综合@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-1/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv1.jpg',\n'广东卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/guangdongstv/1.m3u8?IASHttpSessionId=0=$FHD#mp4@@http://www.cietv.com/img/gdws.jpg',\n'爱娱乐@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230077/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251J3250-L.jpg',\n'邵氏电影@@http://cn-jswx2-cmcc-live-01.bilivideo.com/live-bvc/817178/live_97065163_17925468.m3u8@@https://s3.ax1x.com/2020/12/02/D53zJx.jpg',\n'中央财经@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-2/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv2.jpg',\n'湖南卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/hunanstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/hunws.jpg',\n'爱时尚@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230109/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251H9580-L.jpg',\n'香港HKS@@http://zhibo.hkstv.tv/livestream/mutfysrq.flv@@http://www.cietv.com/img/xgws.jpg',\n'中央综艺@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-3/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv3.jpg',\n'浙江卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/zhejiangstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/zjws.jpg',\n'爱青春@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230130/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251J9210-L.jpg',\n'大爱I@@https://pulltv1.wanfudaluye.com/live/tv1.m3u8@@http://www.10000toptv.com/inddaext1.jpg',\n'中央国际@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-4/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv4.jpg',\n'深圳卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/hdshenzhenstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/szws.jpg',\n'爱谍战@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230092/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251J4330-L.jpg',\n'澳门莲花@@http://live-hls.macaulotustv.com/lotustv/5562e9e4d409d24c9600075c.m3u8@@http://www.cietv.com/img/lhws.jpg',\n'中央体育@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-5/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv5.jpg',\n'湖北卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/hubeistv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/hubws.jpg',\n'爱悬疑@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230098/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251I2380-L.jpg',\n'凤凰中文@@http://117.148.187.59/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221228608/index.m3u8#mp4@@http://www.nnzhibo.com/img/fhzw.jpg',\n'体育赛事@@http://39.134.115.163:8080/PLTV/88888910/224/3221225706/index.m3u8@@http://www.nnzhibo.com/img/cctv5+.jpg',\n'北京卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/beijingstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/bjws.jpg',\n'爱电竞@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230029/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251I5330-L.jpg',\n'原民電視@@http://streamipcf.akamaized.net/live/_definst_/live_720/key_b1500.m3u8@@https://www.nettvplus.live/uploads/18/1-1P50G04243A2.jpg',\n'中央电影@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-6/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv6.jpg',\n'青海卫视@@http://39.134.115.163:8080/PLTV/88888910/224/3221225727/index.m3u8@@http://www.cietv.com/img/qhws.jpg',\n'爱幼教@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230086/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251I3300-L.jpg',\n'耀才财经@@http://202.69.67.66:443/webcast/bshdlive-mobile/playlist.m3u8@@http://www.tvyan.com/uploads/dianshi/bschannel.jpg',\n'中央军事@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-7/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv7.jpg',\n'东南卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/dongnanstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/fjws.jpg',\n'爱玩具@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230026/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251I1460-L.jpg',\n'亚旅卫视@@http://hls.jingchangkan.tv/jingchangkan/156722438_0HaM/index.m3u8@@http://www.cietv.com/img/atv.jpg',\n'8电视剧@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-8/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv8.jpg',\n'天津卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/tianjinstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/tjws.jpg',\n'爱世界@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230046/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251I0500-L.jpg',\n'星空@@http://116.199.5.51:8114/00000000/index.m3u8?&Fsv_ctype=LIVES&Fsv_otype=1&FvSeid=5abd1660af1babb4&Fsv_filetype=1&Fsv_ctype=LIVES&Fsv_cid=0&Fsv_chan_hls_se_idx=234&Fsv_rate_id=0&Fsv_SV_PARAM1=0&Fsv_ShiftEnable=0&Fsv_ShiftTsp=0&Provider_id=&Pcontent_id=&Fsv_CMSID=&Fsv_otype=1mp4@@http://www.cietv.com/img/xkws.jpg',\n'中央纪录@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-news/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv9.jpg',\n'江苏卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/jiangsustv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/jsws.jpg',\n'爱怀旧@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230049/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251J2230-L.jpg',\n'大爱 II@@https://pulltv2.wanfudaluye.com/live/tv2.m3u8@@http://www.10000toptv.com/inddaext1.jpg',\n'中央科教@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-10/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.nnzhibo.com/img/cctv10.jpg',\n'东方卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/dongfangstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/dfws.jpg',\n'爱家庭@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230118/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251JK20-L.jpg',\n'大爱海外@@https://pulltv3.wanfudaluye.com/live/tv3.m3u8@@http://www.10000toptv.com/inddaext1.jpg',\n'中央戏曲@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-11/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv11.jpg',\n'辽宁卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/liaoningstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/lnws.jpg',\n'爱探索@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230112/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251J6430-L.jpg',\n'凤凰香港@@http://223.110.245.136/PLTV/3/224/3221226975/index.m3u8#mp4@@http://www.cietv.com/img/fhxg.jpg',\n'社会与法@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-12/1.m3u8?IASHttpSessionId=0=$FHD8@@http://www.cietv.com/img/cctv12.jpg',\n'江西卫视@@http://117.148.187.57/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230667/01.m3u8?fmt=ts2hls=$4M@@http://www.cietv.com/img/jxws.jpg',\n'爱旅行@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230052/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251J1040-L.jpg',\n'翡翠台@@http://116.199.5.52:8114/00000000/index.m3u8?&Fsv_ctype=LIVES&Fsv_otype=1&FvSeid=5abd1660af1babb4&Fsv_filetype=1&Fsv_ctype=LIVES&Fsv_cid=0&Fsv_chan_hls_se_idx=188&Fsv_rate_id=1&Fsv_SV_PARAM1=0&Fsv_ShiftEnable=0&Fsv_ShiftTsp=0&Provider_id=&Pcontent_id=&Fsv_CMSID=&Fsv_otype=1@@http://www.cietv.com/img/tvb.jpg',\n'中央新闻@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-13/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.nnzhibo.com/img/cctv13.jpg',\n'黑龙江卫视@@http://39.134.115.163:8080/PLTV/88888910/224/3221225736/index.m3u8@@http://www.cietv.com/img/hljws.jpg',\n'爱历史@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230100/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251HA20-L.jpg',\n'韩国女团@@http://tx2play1.douyucdn.cn/live/17732rtara.flv@@https://s3.ax1x.com/2021/01/18/s6uvEF.gif',\n'中央少儿@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-14/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cctv14.jpg',\n'重庆卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/chongqingstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/cqws.jpg',\n'爱浪漫@@http://101.71.255.229:6610/zjhs/2/10115/index.m3u8?virtualDomain=zjhs.live_hls.zte.com@@https://www.nettvplus.live/uploads/allimg/20/1-2003251H5480-L.jpg',\n'明珠台@@http://116.199.5.51:8114/00000000/2e368e04c76446bc9d30ca7a9f934dae/index.m3u8?Fsv_cid=1034&Fsv_chan_hls_se_idx=12&Fsv_ctype=LIVES&version=9&Fsv_rate_id=1&Fsv_otype=1&FvSeid=5abd1660af1babb4&Pcontent_id=7f88be5fb6fd426494f6aa240f1dc7a9&Provider_id=00000000&Fsv_filetype=1&Fsv_ShiftEnable=0&Fsv_SV_PARAM1=0&Fsv_ShiftTsp=240&Fsv_CMSID=00000000&AuthInfo=P2ZSH2gNMZ8aiVfV%2BjCYczoGsAYoDo4KY5I3eHfJhGTKdSzgLwCHoSet9it9fXrMLwehJxh9gmO%2F%0AOFrWyxI%2BtteLTJnZKT7Lg8BRYQNXMQU%3D%0A@@http://www.tvyan.com/uploads/dianshi/pearl.jpg',\n'中央音乐@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-15/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.nnzhibo.com/img/cctv15.jpg',\n'山东卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/shandongstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/sdws.jpg',\n'爱科幻@@http://101.71.255.229:6610/zjhs/2/10113/index.m3u8?virtualDomain=zjhs.live_hls.zte.com@@https://www.nettvplus.live/uploads/allimg/20/1-2003251H4440-L.jpg',\n'点掌财经@@http://202.69.69.180:443/webcast/bshdlive-mobile/playlist.m3u8@@http://www.tvyan.com/uploads/allimg/1701/1-1F129133S80-L.jpg',\n'奥运@@http://39.135.138.58:18890/PLTV/88888888/224/3221225675/index.m3u8@@https://ims-cdn0.sm.cn/ims?kt=MD5&at=smk&key=2CEC208E24A1D6472E5656633C3B5A78&tv=0_0&x.jpg',\n'河北卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/hebeistv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/hebws.jpg',\n'爱解密@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230080/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251H1090-L.jpg',\n'澳门卫视@@http://61.244.22.4/ch3/ch3.live/index.m3u8@@http://www.tvyan.com/uploads/dianshi/aomen-macau.jpg',\n'中央农业@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/cctv-17/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.tvyan.com/uploads/dianshi/cctv17.jpg',\n'夏门卫视@@http://cstvalic.v.myalicdn.com/cstv/xiamen_1/index.m3u8@@http://tb.91kds.cn/tb/xmws.jpg',\n'爱美食@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230115/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251HQ10-L.jpg',\n'澳视综艺@@http://61.244.22.5/ch6/_definst_/hd_ch6.live/playlist.m3u8#mp4@@https://vdposter.bdstatic.com/ef17a63709b4492fc9fffbd05939f192.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395%2Fquality%2Cq_60',\n'中国气象@@http://hls.weathertv.cn/tslslive/qCFIfHB/hls/live_sd.m3u8@@https://vdposter.bdstatic.com/28a05831be2787876adef4ef2f09d362.jpeg?x-bce-process=image%2Fresize%2Cm_fill%2Cw_593%2Ch_395',\n'安徽卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/anhuistv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/ahws.jpg',\n'爱猎奇@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230097/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251J5500-L.jpg',\n'玄幻影院@@https://tx.liveplay.live.kugou.com/live/fx_hifi_1308614369_avc.m3u8@@https://s3.ax1x.com/2020/12/02/D4YZUs.jpg',\n'爱上4K@@http://111.20.105.60:6060/yinhe/2/ch00000090990000001709/index.m3u8?virtualDomain=yinhe.live_hls.zte.com@@http://www.tvyan.com//uploads/dianshi/4k.jpg',\n'吉林卫视@@http://39.134.115.163:8080/PLTV/88888910/224/3221225680/index.m3u8@@http://www.cietv.com/img/jlws.jpg',\n'爱体育@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230034/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251I9560-L.jpg',\n'澳门葡语@@http://61.244.22.4/ch2/ch2.live/playelist.m3u8@@http://www.tvyan.com/uploads/dianshi/aoshi.jpg',\n'国际欧洲@@https://cctvtxyh5ca.liveplay.myqcloud.com/live/cctveurope_2/index.m3u8@@https://p2.img.cctvpic.com/photoAlbum/page/performance/img/2019/6/10/1560153162411_887.png',\n'四川卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/sichuanstv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/scws.jpg',\n'爱动漫@@http://112.17.40.140/hwltc.tv.cdn.zj.chinamobile.com/PLTV/88888888/224/3221230136/index.m3u8@@https://www.nettvplus.live/uploads/allimg/20/1-2003251GS70-L.jpg',\n'怡家@@http://v.iam7.cn/iptv/cibn.php?code=JiaoYu@@http://aanntv.com/upload/vod/20200226-1/b7acf844147f15d20d344937b5b5ffbe.jpg',\n'国际美洲@@https://cctvcnch5ca.v.wscdns.com/live/cctvamerica_2/index.m3u8@@https://p5.img.cctvpic.com/photoAlbum/page/performance/img/2019/6/10/1560153192667_279.png',\n'贵州卫视@@http://39.134.198.32:6410/yst.live.scmobile.com/otvzte.scmcc.com.cNF/ysten-businessmbble/live/guizhoustv/1.m3u8?IASHttpSessionId=0=$FHD@@http://www.cietv.com/img/gzws.jpg',\n'金牌综艺@@http://121.31.30.91:8081/ysten-business/live/saishijx/1.m3u8@@http://www.tvyan.com/uploads/dianshi/newtvzongyi.jpg',\n'本港A1@@https://15813114727637862976168173814320.live.prod.hkatv.com/a1_cbr_lo_720p.m3u8#mp4@@https://www.nettvplus.live/uploads/allimg/18/1-1Q0231445090-L.jpg',\n'惊悚悬疑@@http://121.31.30.91:8081/ysten-business/live/jingsongxy/1.m3u8@@http://www.tvyan.com/uploads/dianshi/newtvjingsong.jpg',\n'明星大片@@http://121.31.30.91:8081/ysten-business/live/mingxingdp/1.m3u8@@http://www.tvyan.com/uploads/dianshi/newtvdapian.jpg',\n'精品大剧@@http://121.31.30.91:8081/ysten-business/live/jdaju/1.m3u8@@http://www.tvyan.com/uploads/dianshi/newtvdaju.jpg',\n'动作电影@@http://121.31.30.91:8081/ysten-business/live/dongzuody/1.m3u8@@http://tb.91kds.cn/tb/yst.jpg',\n'军旅剧场@@http://121.31.30.91:8081/ysten-business/live/junlvjc/1.m3u8@@http://www.tvyan.com/uploads/dianshi/newtvjunlv.jpg',\n'精品体育@@http://121.31.30.91:8081/ysten-business/live/jtiyu/1.m3u8@@http://www.tvyan.com/uploads/dianshi/newtvjpty.jpg',\n'黑莓电影@@http://121.31.30.91:8081/ysten-business/live/jdianying/1.m3u8@@http://tb.91kds.cn/tb/yst.jpg',\n],\n    listStyle: 'icon_round_4',\n    init: '折叠'\n});\n\n\n//卡片\ncard.forEach(function (c) {\n    if(!getVar(c['id'])) putVar(c['id'], c['init']);\n    d.push({\n        title:c['title'],\nurl:'hiker://empty@lazyRule=.js:putVar(\"'+c['id']+'\", getVar(\"'+c['id']+'\")==\"折叠\"?\"开启\":\"关闭\");refreshPage();\"toast://已\"+getVar(\"'+c['id']+'\")',\n        col_type:'text_1'\n    });\n    if(getVar(c['id'])=='开启') {\n        c['list'].forEach(function (l) {\n            let a=l.split(/\\s*@@\\s*/);\n            d.push({\n                title:a[0],\n                url:a[1],\n                pic_url:a[2],\n                col_type:c['listStyle']\n            });\n        });\n    }\n});\nd.push({\n    title:'‘‘’’<font color=\"'+lontColor+'\">WeTV蓝光秒播',    url:'hiker://home@||https://m.wetv.vip/zh-cn?channel=1002',\n    col_type:\"text_2\"\n});\nd.push({\n    title:'‘‘’’<font color=\"'+lontColor+'\">奈菲影视蓝光秒播',\n    url:'hiker://home@||https://www.nfmovies.com/search.php?searchtype=5&tid=14&area=%E5%8F%B0%E6%B9%BE',\n    col_type:\"text_2\"\n});\nd.push({\n    title:'‘‘’’<font color=\"'+lontColor+'\">采集🖼️资源网',\n    url:'hiker://home@资源网采集.xyq||http://xjj.jusuzs.com/video.php',\n    col_type:\"text_2\"\n});\nd.push({\n    title:'‘‘’’<font color=\"'+lontColor+'\">爱车🧜🏎️MV',\n    url:'hiker://home@爱车MV||http://xjj.jusuzs.com/video.php',\n    col_type:\"text_2\"\n});\nd.push({\n    title:'‘‘’’<strong><font color=\"'+yontColor+'\">⚪VIP官方QQ群号:978260150 付（大佬众多）   ⚪        免费QQ群号:1101359539     ⚪',\nurl:'https://tvv.tw/xjj/get/',\n    col_type:\"text_1\"\n});\nd.push({\n    title:getHead(\"  ⚪         ⛲   海阔   视界  我    的  首 页 规 则   ⛲          ⚪\"),\n     url:'toast://'+title,\n    col_type:\"text_1\"\n});\nvar homeStart=1;\n\nfor(let i=homeStart;i<home.length && i<(maxHomeCount+homeStart);i++){\n    let k = home[i];\n    d.push({\n       title:k.title ,\n       url: \"hiker://home@\"+k.title,\n       col_type: \"text_3\"\n    });\n}\n\n\nsetResult(d)","search_url":"https://shimo.im/docs/KJR33P3wRhdjX33k/read#**","titleColor":"#ff13b66a","group":"0首页","searchFind":"js:\nvar res = {};\nvar items = [];\nvar html = getResCode();\nvar flag = MY_URL.split('#')[1];\nvar datas = parseDomForHtml(html, 'body&&.ql-editor&&Html').split('</a></p>');\nfor (var i = 0; i < datas.length - 1; i++) {\n    var data = datas[i];\n    if (data.indexOf(flag) > -1) {\n        var title = data.split(',')[1].split('</p>')[0];\n        var url = data.split('href=\"')[1].split('\"')[0].replace(/#.*/, '').replace(/&nbsp;/g, '').replace(/&amp;/g, '&');\n        var pic_url = data.split('vg-logo=\"')[1].split('\"')[0];\n        var desc = data.split('group-title=\"')[1].split('\"')[0];\n        items.push({\n            title: title,\n            desc: desc,\n            url: 'hiker://empty#' + url + '#' + title + '#' + pic_url + '#' + desc,\n            pic_url: pic_url\n        });\n    }\n}\nres.data = items;\nsetSearchResult(res);","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"js:\nvar res = {};\nvar items = [];\nvar data = MY_URL.split('#');\nitems.push({\n    title: data[2],\n    url: data[1] + `@lazyRule=.js:if(/(flv|m3u8|mp4|mkv)/.test(input)){input+'#mp4'}else{JSON.parse(fetch(input,{headers:{'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'},redirect:false, withHeaders:true})).headers.location[0]+'#mp4'}`,\n    pic_url: data[3],\n    desc: data[4]\n});\nres.data = items;\nsetHomeResult(res);","ua":"mobile","preRule":""}
谢谢，已找到，我也分享下，方便大家。
https://pasteme.cn/108315
规则名：我的主页
感谢！镇弟大佬分享！
论坛搜镇弟大佬贴子