From ef41eac5ac9348b4f1fb223d9c4ab9e22effb985 Mon Sep 17 00:00:00 2001 From: yulong Date: Mon, 29 Sep 2025 14:54:48 +0000 Subject: [PATCH] =?UTF-8?q?=E4=B8=8A=E4=BC=A0=E6=96=87=E4=BB=B6=E8=87=B3?= =?UTF-8?q?=20jtxtv10/lib?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- jtxtv10/lib/hm.json | 22 ++ jtxtv10/lib/huya2.js | 1 + jtxtv10/lib/ip.json | 1 + jtxtv10/lib/jinja.js | 577 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 601 insertions(+) create mode 100644 jtxtv10/lib/hm.json create mode 100644 jtxtv10/lib/huya2.js create mode 100644 jtxtv10/lib/ip.json create mode 100644 jtxtv10/lib/jinja.js diff --git a/jtxtv10/lib/hm.json b/jtxtv10/lib/hm.json new file mode 100644 index 0000000..27a3d03 --- /dev/null +++ b/jtxtv10/lib/hm.json @@ -0,0 +1,22 @@ +{ + "SiteUrl": "https://www.haimianxz.com,https://www.hmxz.org,https://www.5536806.xyz,http://haimian.eu.org", + "Classes": [ + { + "type_name": "电影", + "type_id": "1" + }, + { + "type_name": "剧集", + "type_id": "2" + }, + { + "type_name": "综艺", + "type_id": "5" + }, + { + "type_name": "动漫", + "type_id": "3" + } + ], + "Cookie": "bbs_sid=nll6gb39qj1e4fgkvsjh930ti5; _xn_accesscount_visited=1; __51uvsct__K2MEuBiiS0iv1Gsb=1; __51vcke__K2MEuBiiS0iv1Gsb=df02f20c-b83d-507b-b310-c3f8ab36a87a; __51vuft__K2MEuBiiS0iv1Gsb=1745249876903; bbs_token=rhHYDxTHFdsKEOsD84q8NBkSi6aTY8KlfnqpjudmsOxKBcJe; __vtins__K2MEuBiiS0iv1Gsb=%7B%22sid%22%3A%20%2299dcbd93-0d23-5a24-abb5-ec507c6c248a%22%2C%20%22vd%22%3A%2017%2C%20%22stt%22%3A%20464771%2C%20%22dr%22%3A%201425%2C%20%22expires%22%3A%201745251199999%2C%20%22ct%22%3A%201745250341665%7D" +} \ No newline at end of file diff --git a/jtxtv10/lib/huya2.js b/jtxtv10/lib/huya2.js new file mode 100644 index 0000000..11aceac --- /dev/null +++ b/jtxtv10/lib/huya2.js @@ -0,0 +1 @@ +**var rule={title:"虎牙直播",host:"https://www.huya.com",homeUrl:"/cache.php?m=LiveList&do=getLiveListByPage&gameId=2168&tagAll=0&page=1",url:"/cache.php?m=LiveList&do=getLiveListByPage&gameId=fyfilter&tagAll=0&page=fypage",class_name:"娱乐&网游&单机&手游",class_url:"8&1&2&3",detailUrl:"https://m.huya.com/fyid",filterable:1,filter_url:"{{fl.cateId}}",filter_def:{8:{cateId:"2135"},1:{cateId:"1"},2:{cateId:"1732"},3:{cateId:"2336"}},filter:{8:[{key:"cateId",name:"分类",value:[{n:"星秀",v:"1663"},{n:"户外",v:"2165"},{n:"一起看",v:"2135"},{n:"二次元",v:"2633"},{n:"虚拟偶像",v:"6055"},{n:"旅游",v:"6791"},{n:"放映厅",v:"6245"},{n:"娱乐天地",v:"100022"},{n:"交友",v:"4079"},{n:"组队",v:"5367"},{n:"吃喝玩乐",v:"100044"},{n:"原创",v:"6861"},{n:"虎牙文化",v:"4089"},{n:"体育",v:"2356"},{n:"虎牙地方",v:"5123"},{n:"颜值",v:"2168"},{n:"科技",v:"2408"},{n:"音乐",v:"3793"},{n:"趣分享",v:"5883"},{n:"一起买",v:"7759"},{n:"派对",v:"7785"}]}],1:[{key:"cateId",name:"分类",value:[{n:"英雄联盟",v:"1"},{n:"CS2",v:"862"},{n:"穿越火线",v:"4"},{n:"lol云顶之弈",v:"5485"},{n:"无畏契约",v:"5937"},{n:"CFHD",v:"6079"},{n:"逆战",v:"135"},{n:"炉石传说",v:"393"},{n:"DOTA2",v:"7"},{n:"地下城与勇士",v:"2"},{n:"魔兽世界",v:"8"},{n:"坦克世界",v:"802"},{n:"DOTA1",v:"6"},{n:"梦三国",v:"489"},{n:"魔兽争霸3",v:"4615"},{n:"问道",v:"107"},{n:"命运方舟",v:"3058"},{n:"QQ飞车",v:"9"},{n:"星际争霸",v:"5"},{n:"网游竞技",v:"100023"},{n:"射击综合游戏",v:"100141"},{n:"暴雪专区",v:"100043"},{n:"彩虹岛Online",v:"683"},{n:"剑灵",v:"897"},{n:"军事游戏",v:"100133"},{n:"冒险岛",v:"2243"},{n:"暗黑破坏神",v:"1123"},{n:"诛仙3",v:"1646"},{n:"热血江湖",v:"387"},{n:"英魂之刃",v:"1830"},{n:"武林外传一世琴缘",v:"1661"},{n:"起凡：群雄逐鹿",v:"1612"},{n:"神武4电脑版",v:"3227"},{n:"龙之谷",v:"15"},{n:"炉石战棋",v:"5751"},{n:"御龙在天",v:"675"},{n:"逆水寒",v:"2952"},{n:"千年3",v:"878"},{n:"永恒之塔",v:"446"},{n:"体育游戏",v:"100135"},{n:"寻仙",v:"734"},{n:"战舰世界",v:"1947"},{n:"QQ三国",v:"1090"},{n:"流放之路",v:"427"},{n:"反恐精英Online",v:"1918"},{n:"反恐行动online",v:"861"},{n:"征途",v:"2715"},{n:"战争雷霆",v:"624"},{n:"丝路传说2",v:"1026"},{n:"星际战甲",v:"627"},{n:"NBA2KOL系列",v:"3959"},{n:"九阴真经",v:"1009"},{n:"跑跑卡丁车",v:"162"},{n:"诛仙世界",v:"7749"},{n:"QQ华夏",v:"1878"},{n:"天涯明月刀",v:"1219"},{n:"大话西游：归来",v:"8239"},{n:"荒野行动PC版",v:"3185"},{n:"新剑侠情缘",v:"586"},{n:"剑网3",v:"900"},{n:"生死狙击2",v:"6091"},{n:"全球使命",v:"939"},{n:"梦想世界3",v:"486"},{n:"枪神纪",v:"496"},{n:"新天龙八部",v:"5671"},{n:"铁甲雄兵",v:"2765"},{n:"神泣",v:"2531"},{n:"斗战神",v:"591"},{n:"造梦西游OL",v:"6815"},{n:"天堂",v:"1966"},{n:"大话西游2",v:"2975"},{n:"使命召唤：战区",v:"5911"},{n:"希望OL",v:"1161"},{n:"极光世界 弑神传",v:"514"},{n:"守望先锋归来",v:"2174"},{n:"QQ自由幻想",v:"1862"},{n:"命运2",v:"2942"},{n:"奇迹世界2",v:"766"},{n:"坦克大战",v:"4359"},{n:"生死狙击",v:"2471"},{n:"天翼决",v:"779"},{n:"QQ幻想",v:"2419"},{n:"新飞飞(FlyFF)",v:"1582"},{n:"刀剑英雄",v:"915"},{n:"FIFA Online系列",v:"100079"},{n:"全球使命3",v:"2953"},{n:"完美端游系列",v:"3034"},{n:"战意",v:"2599"},{n:"泡泡堂",v:"440"},{n:"赛尔号",v:"2755"},{n:"大唐无双零",v:"1584"},{n:"QQ炫舞",v:"2440"},{n:"007：传奇",v:"1135"},{n:"天下",v:"1597"},{n:"天谕",v:"1899"},{n:"新倩女幽魂",v:"1579"},{n:"传世无双",v:"984"},{n:"剑侠世界",v:"903"},{n:"Warhaven",v:"9053"},{n:"诺亚传说",v:"190"},{n:"新挑战",v:"583"},{n:"超激斗梦境",v:"5691"},{n:"QQ音速",v:"1085"},{n:"征途2",v:"677"},{n:"征程",v:"678"},{n:"蜀门",v:"4711"},{n:"完美世界：诸神之战",v:"7217"},{n:"战之刃：幸存者",v:"8627"},{n:"黎明之光",v:"41"},{n:"天命西游",v:"1086"},{n:"炫舞时代",v:"3353"},{n:"荣誉空间",v:"225"},{n:"卡拉彼丘",v:"9073"},{n:"成吉思汗怀旧版",v:"640"},{n:"英雄年代3",v:"1232"},{n:"天书奇谈",v:"2225"},{n:"劲舞团",v:"2420"},{n:"远征Online梦想版",v:"142"},{n:"奇迹：传奇",v:"3917"},{n:"封印者",v:"2294"},{n:"上古世纪",v:"1046"},{n:"梦幻诛仙2",v:"488"},{n:"TERA Online",v:"1072"},{n:"倚天Ⅱ",v:"959"},{n:"街头篮球",v:"206"},{n:"永恒轮回：无限",v:"7847"},{n:"火线精英",v:"2550"},{n:"忍者村大战2",v:"2369"},{n:"领地人生",v:"2282"},{n:"仙侠世界",v:"995"},{n:"洛奇英雄传",v:"432"},{n:"KARDS",v:"8261"},{n:"无限法则",v:"3189"},{n:"全面战争：竞技场",v:"5901"},{n:"自由篮球",v:"243"},{n:"FC Online4",v:"3683"},{n:"战地之王",v:"618"},{n:"古剑奇谭OL",v:"1892"},{n:"QQ仙侠传",v:"2291"},{n:"300英雄",v:"1132"}]}],2:[{key:"cateId",name:"分类",value:[{n:"天天吃鸡",v:"2793"},{n:"永劫无间",v:"6219"},{n:"主机游戏",v:"100032"},{n:"猛兽派对",v:"6165"},{n:"互动点播",v:"5907"},{n:"我的世界",v:"1732"},{n:"方舟",v:"1997"},{n:"单机热游",v:"100002"},{n:"怀旧游戏",v:"100125"},{n:"逃离塔科夫",v:"3493"},{n:"俄罗斯钓鱼4",v:"5495"},{n:"部落：上升",v:"1318"},{n:"Dark and Darker",v:"7905"},{n:"The Front",v:"9497"},{n:"Apex英雄",v:"5011"},{n:"生化危机4重制版",v:"8013"},{n:"DayZ独立版",v:"1125"},{n:"星空",v:"7857"},{n:"互动剧游",v:"6919"},{n:"艾尔登法环",v:"5801"},{n:"恐惧之间",v:"6679"},{n:"SCUM",v:"4245"},{n:"Dread Hunger",v:"7601"},{n:"塞尔达传说：王国之泪",v:"7883"},{n:"欧洲卡车模拟",v:"475"},{n:"洛克王国",v:"2864"},{n:"卧龙：苍天陨落",v:"7859"},{n:"无人深空",v:"2566"},{n:"帝国神话",v:"6821"},{n:"饥荒",v:"74"},{n:"森林之子",v:"7943"},{n:"星球大战系列",v:"554"},{n:"极限竞速：地平线",v:"2634"},{n:"最终幻想16",v:"7869"},{n:"Among Us",v:"6163"},{n:"怪物猎人：崛起",v:"6479"},{n:"怪物猎人物语",v:"7101"},{n:"骑马与砍杀系列",v:"4783"},{n:"荒野大镖客2",v:"4319"},{n:"太荒初境",v:"7685"},{n:"罗布乐思",v:"5771"},{n:"只狼：影逝二度",v:"4505"},{n:"双人成行",v:"6737"},{n:"重生边缘",v:"6201"},{n:"海贼王 寻秘世界",v:"5097"},{n:"战神：诸神黄昏",v:"7771"},{n:"恐鬼症",v:"6205"},{n:"鬼谷八荒",v:"6571"},{n:"霍格沃茨之遗",v:"7881"},{n:"全面战争",v:"3521"},{n:"仁王2",v:"5795"},{n:"奥拉星",v:"2846"},{n:"甜蜜之家",v:"6739"},{n:"仙剑奇侠传七",v:"6509"},{n:"消逝的光芒2",v:"7581"},{n:"渡神记",v:"6231"},{n:"归家异途",v:"2949"},{n:"博德之门3",v:"6147"},{n:"看门狗：军团",v:"6155"},{n:"使命召唤系列",v:"100137"},{n:"育碧游戏",v:"100139"},{n:"帝国时代4",v:"4835"},{n:"英灵神殿",v:"6609"},{n:"蛮荒志异：起源",v:"9709"},{n:"岛",v:"3019"},{n:"沙盒与副本",v:"9151"},{n:"扫雷",v:"2349"},{n:"街机游戏",v:"5999"},{n:"幽灵线：东京",v:"7669"},{n:"怪物猎人世界",v:"3519"},{n:"盗贼之海",v:"3641"},{n:"纸人",v:"5257"},{n:"黑色像素人",v:"28"},{n:"对马岛之魂",v:"6039"},{n:"瑞奇与叮当",v:"2455"},{n:"港诡实录",v:"5853"},{n:"剑士",v:"1467"},{n:"魔法门之英雄无敌系列",v:"2096"},{n:"星露谷物语",v:"2443"},{n:"仙剑奇侠传四",v:"1659"},{n:"伤害世界",v:"2337"},{n:"禁闭求生",v:"6065"},{n:"真三国无双",v:"1599"},{n:"恐怖黎明",v:"3435"},{n:"其他单机",v:"3069"},{n:"幽灵行动：荒野",v:"2794"},{n:"边缘",v:"151"},{n:"阿凡达",v:"106"},{n:"全面战争：三国",v:"3004"},{n:"黎明之星",v:"40"},{n:"翼星求生",v:"7463"},{n:"黎明传说",v:"39"},{n:"恶魔之魂",v:"6151"},{n:"艾兰岛",v:"3855"},{n:"龙与地下城：秘影历代记HD",v:"17"},{n:"龙与地下城：匕首谷",v:"18"},{n:"沙石镇时光",v:"7687"},{n:"三国志曹操传",v:"2592"},{n:"FIFA足球",v:"1888"},{n:"最终幻想7：重制版",v:"5809"},{n:"四海兄弟",v:"5995"},{n:"最终幻想：起源",v:"7653"},{n:"摔跤城大乱斗",v:"7773"},{n:"音乐游戏",v:"2761"},{n:"精灵与萤火意志",v:"5895"},{n:"桥梁建造师",v:"3275"},{n:"哈迪斯",v:"6153"},{n:"小缇娜的奇幻之地",v:"7647"},{n:"宝可梦：剑盾",v:"5715"},{n:"边境",v:"4779"},{n:"人类一败涂地",v:"3289"},{n:"糖豆人：终极淘汰赛",v:"6083"},{n:"精灵宝可梦Let's Go",v:"4375"},{n:"战锤40K：暗潮",v:"3016"},{n:"石油骚动",v:"2585"},{n:"紫塞秋风",v:"6045"},{n:"阿尔比恩",v:"8115"},{n:"猎人：荒野的召唤",v:"2906"},{n:"FIFA 23",v:"7789"},{n:"都市：天际线",v:"2201"},{n:"乐高大电影：游戏版",v:"1439"},{n:"全面战争：阿提拉",v:"2383"},{n:"斩妖行",v:"6105"},{n:"马里奥赛车8",v:"5947"},{n:"复仇者联盟",v:"6121"},{n:"霓虹深渊",v:"5743"}]}],3:[{key:"cateId",name:"分类",value:[{n:"王者荣耀",v:"2336"},{n:"和平精英",v:"3203"},{n:"英雄联盟手游",v:"6203"},{n:"CF手游",v:"2413"},{n:"金铲铲之战",v:"7185"},{n:"三国杀",v:"1669"},{n:"原神",v:"5489"},{n:"棋牌桌游",v:"100036"},{n:"综合手游",v:"100029"},{n:"劲乐幻想",v:"7691"},{n:"新游广场",v:"100052"},{n:"崩坏：星穹铁道",v:"7349"},{n:"火影忍者手游",v:"2429"},{n:"第五人格",v:"3115"},{n:"问道手游",v:"2477"},{n:"暗区突围",v:"7209"},{n:"QQ飞车手游",v:"2928"},{n:"球球大作战",v:"2411"},{n:"明日之后",v:"3483"},{n:"皇室战争",v:"2439"},{n:"COD手游",v:"4769"},{n:"手游休闲",v:"100004"},{n:"二次元手游",v:"100091"},{n:"摸了个鱼",v:"9283"},{n:"MMORPG",v:"100273"},{n:"动作游戏",v:"100197"},{n:"战争冲突",v:"7449"},{n:"王者模拟战",v:"5699"},{n:"逆水寒手游",v:"7725"},{n:"幻塔",v:"6437"},{n:"欢乐斗地主",v:"1749"},{n:"神武4手游",v:"3135"},{n:"阴阳师",v:"2598"},{n:"DNF手游",v:"4921"},{n:"欢乐麻将",v:"1751"},{n:"英雄联盟电竞经理",v:"7177"},{n:"狼人杀手游",v:"100049"},{n:"新天龙八部手游",v:"6945"},{n:"中国象棋",v:"1671"},{n:"天天象棋",v:"4997"},{n:"传奇世界3D",v:"3961"},{n:"御龙在天手游",v:"2568"},{n:"高能英雄",v:"8359"},{n:"天龙八部手游",v:"2852"},{n:"三国志战略版",v:"5619"},{n:"忍者必须死3",v:"4041"},{n:"SKY光遇",v:"3719"},{n:"虎牙领主争霸",v:"7529"},{n:"云上城之歌",v:"5977"},{n:"晶核",v:"7279"},{n:"仙境传说RO",v:"2675"},{n:"天天狼人",v:"2774"},{n:"JJ棋牌",v:"3841"},{n:"奇迹MU：觉醒",v:"3116"},{n:"指尖四川麻将",v:"7215"},{n:"部落冲突",v:"1797"},{n:"新剑侠情缘手游",v:"6259"},{n:"萌宠远征",v:"9385"},{n:"暗黑破坏神：不朽",v:"6385"},{n:"英雄杀",v:"2688"},{n:"热血江湖手游",v:"2817"},{n:"蛋仔派对",v:"6909"},{n:"完美世界手游",v:"4237"},{n:"巅峰战舰",v:"2502"},{n:"狼人杀",v:"2785"},{n:"斗罗大陆：魂师对决",v:"6745"},{n:"武侠乂手游",v:"4929"},{n:"诛仙手游",v:"2647"},{n:"斗破苍穹手游",v:"4337"},{n:"迷你世界",v:"2683"},{n:"风云",v:"3061"},{n:"妄想山海",v:"6007"},{n:"曙光英雄",v:"6169"},{n:"三国战纪2",v:"6049"},{n:"梦幻新诛仙",v:"5975"},{n:"黎明觉醒：生机",v:"6131"},{n:"远征",v:"7837"},{n:"航海王：燃烧意志",v:"3943"},{n:"火炬之光：无限",v:"6399"},{n:"巅峰极速",v:"6979"},{n:"圣境之塔",v:"7055"},{n:"魔力宝贝",v:"2891"},{n:"香肠派对",v:"3639"},{n:"创造与魔法",v:"2931"},{n:"JJ斗地主",v:"6271"},{n:"永恒纪元：戒",v:"2646"},{n:"天涯明月刀手游",v:"5115"},{n:"狼人杀官方",v:"3679"},{n:"混沌起源",v:"5985"},{n:"多多自走棋",v:"5133"},{n:"梦幻诛仙手游",v:"2672"},{n:"鸿图之下",v:"6027"},{n:"新笑傲江湖",v:"5669"},{n:"凡人修仙传：人界篇",v:"8297"},{n:"多乐棋牌",v:"6209"},{n:"口袋觉醒",v:"5953"},{n:"跑跑卡丁车手游",v:"2620"},{n:"奶块",v:"2775"},{n:"月圆之夜",v:"4339"},{n:"率土之滨",v:"2691"},{n:"征途2手游",v:"2811"},{n:"英魂之刃口袋版",v:"2760"},{n:"精灵盛典：黎明",v:"6123"},{n:"方舟手游",v:"4035"},{n:"掼蛋",v:"6225"},{n:"绝世仙王",v:"6619"},{n:"流星群侠传",v:"3927"},{n:"寻仙手游",v:"2979"},{n:"一梦江湖",v:"3082"},{n:"Lost Light（萤火突击国际服）",v:"6859"},{n:"弹幕云游戏",v:"7001"},{n:"猎魂觉醒",v:"3071"},{n:"冒险岛：枫之传说",v:"8005"},{n:"征途手游",v:"2556"},{n:"海岛奇兵",v:"2624"},{n:"倩女幽魂手游",v:"2503"},{n:"超凡先锋",v:"6507"},{n:"龙之谷2手游",v:"2736"},{n:"崩坏3",v:"2639"},{n:"猫和老鼠",v:"2758"},{n:"七人传奇：光与暗之交战",v:"8125"},{n:"JJ麻将",v:"9487"},{n:"拉轰西游",v:"9543"},{n:"三国战纪",v:"6047"},{n:"自由幻想手游",v:"4015"},{n:"秦时明月世界",v:"5279"},{n:"新斗罗大陆",v:"6657"},{n:"新神魔大陆",v:"5939"},{n:"逃跑吧！少年",v:"4137"},{n:"太古神王2",v:"6649"},{n:"剑侠世界3",v:"7183"},{n:"天天吃鸡手机版",v:"4341"},{n:"时空猎人3",v:"6411"},{n:"合金弹头：觉醒",v:"6931"},{n:"明日方舟",v:"4925"},{n:"原始征途",v:"7713"},{n:"奇迹：最强者",v:"3215"},{n:"天天酷跑",v:"1715"},{n:"FC 足球世界",v:"3873"},{n:"万国觉醒",v:"6159"},{n:"机动都市阿尔法",v:"5411"},{n:"航海王热血航线",v:"6181"},{n:"幻世九歌",v:"7199"},{n:"植物大战僵尸",v:"485"},{n:"无悔华夏",v:"7063"},{n:"时空猎人",v:"1742"},{n:"荒野乱斗",v:"4613"},{n:"拳皇98终极之战OL",v:"2687"},{n:"蛇蛇争霸",v:"2680"},{n:"王牌竞速",v:"6463"},{n:"重返帝国",v:"6955"},{n:"吞噬星空：黎明",v:"6651"},{n:"口袋妖怪",v:"2541"},{n:"QQ炫舞手游",v:"2991"},{n:"一拳超人：最强之男",v:"4629"},{n:"荣耀新三国",v:"6943"},{n:"少年三国志2",v:"6125"},{n:"我的起源",v:"5365"},{n:"决战平安京",v:"3064"},{n:"剑灵2",v:"7223"},{n:"开心消消乐",v:"1712"},{n:"小小蚁国",v:"7803"},{n:"最强NBA",v:"2988"},{n:"剑侠情缘手游",v:"2621"},{n:"长安幻想",v:"6727"},{n:"我叫MT4",v:"4087"},{n:"全明星街球派对",v:"8401"},{n:"大话西游手游",v:"2626"},{n:"荣耀大天使",v:"6477"},{n:"镇魂街：天生为王",v:"6557"},{n:"摩尔庄园",v:"5981"},{n:"游戏王：决斗链接",v:"4451"},{n:"剑侠世界2手游",v:"3150"},{n:"青云诀2",v:"6009"},{n:"战地无疆",v:"7909"},{n:"一念逍遥",v:"6419"},{n:"永劫无间手游",v:"7579"},{n:"尘白禁区",v:"7297"},{n:"元梦之星",v:"9521"},{n:"不良人3",v:"5891"},{n:"剑灵：革命",v:"4545"},{n:"魔力宝贝：旅人",v:"7573"},{n:"米加小镇",v:"7269"},{n:"龙武手游",v:"5219"},{n:"斗罗大陆2：绝世唐门",v:"6581"},{n:"西行纪燃魂",v:"8303"},{n:"坦克世界闪击战",v:"4977"},{n:"军棋",v:"2561"},{n:"饥荒：新家",v:"6491"},{n:"拳皇命运",v:"3379"},{n:"实况足球",v:"3741"},{n:"战舰世界闪击战",v:"4101"},{n:"时空召唤",v:"2551"},{n:"王牌战争：文明重启",v:"5479"},{n:"雀魂麻将",v:"7107"},{n:"欢乐升级",v:"3925"},{n:"绿色征途",v:"4227"},{n:"弹弹堂手游",v:"2857"},{n:"太极熊猫3：猎龙",v:"2778"},{n:"哈利波特：魔法觉醒",v:"5835"},{n:"天地劫：幽城再临",v:"5987"},{n:"热血街篮",v:"5859"},{n:"神雕侠侣手游",v:"1781"},{n:"山海镜花",v:"5089"},{n:"三国志战棋版",v:"7937"},{n:"神雕侠侣2",v:"4209"},{n:"仙魔决",v:"1674"},{n:"王者荣耀星之破晓",v:"7927"},{n:"我在江湖之神魔道",v:"7699"},{n:"梦幻模拟战",v:"3481"},{n:"单机手游",v:"2777"},{n:"斗罗大陆-斗神再临",v:"6631"},{n:"未来之役",v:"6831"},{n:"风云岛行动",v:"4695"},{n:"新游推荐",v:"3160"},{n:"火影忍者OL",v:"3901"},{n:"九灵神域",v:"7719"},{n:"武动乾坤",v:"3829"},{n:"秦时明月2",v:"1784"},{n:"文明与征服",v:"7071"},{n:"战双：帕弥什",v:"4133"},{n:"大航海时代：海上霸主",v:"6929"},{n:"剑网1：归来",v:"7361"},{n:"绝区零",v:"7711"},{n:"黑色沙漠手游",v:"7287"},{n:"虎牙吃鸡",v:"7465"},{n:"一剑斩仙",v:"6843"},{n:"传奇天下",v:"6927"},{n:"斗斗堂",v:"7133"},{n:"斗罗大陆",v:"6119"},{n:"天谕手游",v:"5925"},{n:"坎公骑冠剑",v:"6641"},{n:"最终幻想觉醒",v:"2721"},{n:"神将三国",v:"6621"},{n:"灌篮高手正版授权手游",v:"5399"},{n:"剑与家园",v:"2838"},{n:"极无双2",v:"7825"},{n:"光明大陆",v:"2832"},{n:"荒野行动",v:"3084"},{n:"战斗法则",v:"9513"},{n:"疯狂原始人",v:"4619"},{n:"逆战手游",v:"7575"},{n:"石器时代：觉醒",v:"9159"}]}]},searchUrl:"https://search.cdn.huya.com/?m=Search&do=getSearchContent&q=**&uid=0&v=4&typ=-5&livestate=0&rows=40&start=0",searchable:2,quickSearch:0,headers:{"User-Agent":"MOBILE_UA"},timeout:5e3,limit:8,play_parse:!0,lazy:"js:\n        let rid = input.match(/\\/ (\\d + ) / )[1];\n        function getRealUrl(live_url) {\n            let [i, b] = live_url.split('?');\n            let r = i.split('/').pop();\n            let s = r.replace(/.(flv|m3u8)/, '');\n            let c_tmp = b.split('&').filter(n => n);\n            let n = {};\n            let c_tmp2 = [];\n            c_tmp.forEach(function(tmp, index) {\n                if (index < 3) {\n                    n[tmp.split('=')[0]] = tmp.split('=')[1]\n                } else {\n                    c_tmp2.push(tmp)\n                }\n            });\n            let tmp2 = c_tmp2.join('&');\n            n[tmp2.split('=')[0]] = tmp2.split('=')[1];\n            let fm = decodeURIComponent(n.fm).split('&')[0];\n            let u = base64Decode(fm);\n            let p = u.split('_')[0];\n            let f = new Date().getTime() + '0000';\n            let ll = n.wsTime;\n            let t = '0';\n            let h = [p, t, s, f, ll].join('_');\n            let m = md5(h);\n            return (i + '?wsSecret=' + m + '&wsTime=' + ll + '&u=' + t + '&seqid=' + f + '&' + c_tmp2.pop()).replace('hls', 'flv').replace('m3u8', 'flv')\n        }\n        let purl = JSON.parse(request('https://mp.huya.com/cache.php?m=Live&do=profileRoom&roomid=' + rid)).data.stream.flv.multiLine[0].url;\n        input = {\n            jx: 0,\n            url: getRealUrl(purl),\n            parse: 0,\n            header: JSON.stringify({\n                'user-agent': 'Mozilla/5.0'\n            })\n        }\n    ","推荐":"js:\n        let d = [];\n        let jo = JSON.parse(request(input)).data.datas;\n        jo.forEach(it => {\n                d.push({\n                    url: it.profileRoom,\n                    title: it.introduction,\n                    img: it.screenshot,\n                    desc: '👁' + it.totalCount + '  🆙' + it.nick,\n                })\n        });\n        setResult(d);\n    ","一级":"js:\n        let d = [];\n        let jo = JSON.parse(request(input)).data.datas;\n        jo.forEach(it => {\n                d.push({\n                    url: it.profileRoom,\n                    title: it.introduction,\n                    img: it.screenshot,\n                    desc: '👁' + it.totalCount + '  🆙' + it.nick,\n                })\n        });\n        setResult(d);\n    ","二级":"*","搜索":"json:response.3.docs;game_roomName;game_screenshot;game_nick;room_id"}; \ No newline at end of file diff --git a/jtxtv10/lib/ip.json b/jtxtv10/lib/ip.json new file mode 100644 index 0000000..37b2e41 --- /dev/null +++ b/jtxtv10/lib/ip.json @@ -0,0 +1 @@ +https://test.cms.bidiys.com/ \ No newline at end of file diff --git a/jtxtv10/lib/jinja.js b/jtxtv10/lib/jinja.js new file mode 100644 index 0000000..80737af --- /dev/null +++ b/jtxtv10/lib/jinja.js @@ -0,0 +1,577 @@ +/*! + * Jinja Templating for JavaScript v0.1.8 + * https://github.com/sstur/jinja-js + * + * This is a slimmed-down Jinja2 implementation [http://jinja.pocoo.org/] + * + * In the interest of simplicity, it deviates from Jinja2 as follows: + * - Line statements, cycle, super, macro tags and block nesting are not implemented + * - auto escapes html by default (the filter is "html" not "e") + * - Only "html" and "safe" filters are built in + * - Filters are not valid in expressions; `foo|length > 1` is not valid + * - Expression Tests (`if num is odd`) not implemented (`is` translates to `==` and `isnot` to `!=`) + * + * Notes: + * - if property is not found, but method '_get' exists, it will be called with the property name (and cached) + * - `{% for n in obj %}` iterates the object's keys; get the value with `{% for n in obj %}{{ obj[n] }}{% endfor %}` + * - subscript notation `a[0]` takes literals or simple variables but not `a[item.key]` + * - `.2` is not a valid number literal; use `0.2` + * + */ +/*global require, exports, module, define */ + +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jinja = {})); +})(this, (function (jinja) { + "use strict"; + var STRINGS = /'(\\.|[^'])*'|"(\\.|[^"'"])*"/g; + var IDENTS_AND_NUMS = /([$_a-z][$\w]*)|([+-]?\d+(\.\d+)?)/g; + var NUMBER = /^[+-]?\d+(\.\d+)?$/; + //non-primitive literals (array and object literals) + var NON_PRIMITIVES = /\[[@#~](,[@#~])*\]|\[\]|\{([@i]:[@#~])(,[@i]:[@#~])*\}|\{\}/g; + //bare identifiers such as variables and in object literals: {foo: 'value'} + var IDENTIFIERS = /[$_a-z][$\w]*/ig; + var VARIABLES = /i(\.i|\[[@#i]\])*/g; + var ACCESSOR = /(\.i|\[[@#i]\])/g; + var OPERATORS = /(===?|!==?|>=?|<=?|&&|\|\||[+\-\*\/%])/g; + //extended (english) operators + var EOPS = /(^|[^$\w])(and|or|not|is|isnot)([^$\w]|$)/g; + var LEADING_SPACE = /^\s+/; + var TRAILING_SPACE = /\s+$/; + + var START_TOKEN = /\{\{\{|\{\{|\{%|\{#/; + var TAGS = { + '{{{': /^('(\\.|[^'])*'|"(\\.|[^"'"])*"|.)+?\}\}\}/, + '{{': /^('(\\.|[^'])*'|"(\\.|[^"'"])*"|.)+?\}\}/, + '{%': /^('(\\.|[^'])*'|"(\\.|[^"'"])*"|.)+?%\}/, + '{#': /^('(\\.|[^'])*'|"(\\.|[^"'"])*"|.)+?#\}/ + }; + + var delimeters = { + '{%': 'directive', + '{{': 'output', + '{#': 'comment' + }; + + var operators = { + and: '&&', + or: '||', + not: '!', + is: '==', + isnot: '!=' + }; + + var constants = { + 'true': true, + 'false': false, + 'null': null + }; + + function Parser() { + this.nest = []; + this.compiled = []; + this.childBlocks = 0; + this.parentBlocks = 0; + this.isSilent = false; + } + + Parser.prototype.push = function (line) { + if (!this.isSilent) { + this.compiled.push(line); + } + }; + + Parser.prototype.parse = function (src) { + this.tokenize(src); + return this.compiled; + }; + + Parser.prototype.tokenize = function (src) { + var lastEnd = 0, parser = this, trimLeading = false; + matchAll(src, START_TOKEN, function (open, index, src) { + //here we match the rest of the src against a regex for this tag + var match = src.slice(index + open.length).match(TAGS[open]); + match = (match ? match[0] : ''); + //here we sub out strings so we don't get false matches + var simplified = match.replace(STRINGS, '@'); + //if we don't have a close tag or there is a nested open tag + if (!match || ~simplified.indexOf(open)) { + return index + 1; + } + var inner = match.slice(0, 0 - open.length); + //check for white-space collapse syntax + if (inner.charAt(0) === '-') var wsCollapseLeft = true; + if (inner.slice(-1) === '-') var wsCollapseRight = true; + inner = inner.replace(/^-|-$/g, '').trim(); + //if we're in raw mode and we are not looking at an "endraw" tag, move along + if (parser.rawMode && (open + inner) !== '{%endraw') { + return index + 1; + } + var text = src.slice(lastEnd, index); + lastEnd = index + open.length + match.length; + if (trimLeading) text = trimLeft(text); + if (wsCollapseLeft) text = trimRight(text); + if (wsCollapseRight) trimLeading = true; + if (open === '{{{') { + //liquid-style: make {{{x}}} => {{x|safe}} + open = '{{'; + inner += '|safe'; + } + parser.textHandler(text); + parser.tokenHandler(open, inner); + }); + var text = src.slice(lastEnd); + if (trimLeading) text = trimLeft(text); + this.textHandler(text); + }; + + Parser.prototype.textHandler = function (text) { + this.push('write(' + JSON.stringify(text) + ');'); + }; + + Parser.prototype.tokenHandler = function (open, inner) { + var type = delimeters[open]; + if (type === 'directive') { + this.compileTag(inner); + } else if (type === 'output') { + var extracted = this.extractEnt(inner, STRINGS, '@'); + //replace || operators with ~ + extracted.src = extracted.src.replace(/\|\|/g, '~').split('|'); + //put back || operators + extracted.src = extracted.src.map(function (part) { + return part.split('~').join('||'); + }); + var parts = this.injectEnt(extracted, '@'); + if (parts.length > 1) { + var filters = parts.slice(1).map(this.parseFilter.bind(this)); + this.push('filter(' + this.parseExpr(parts[0]) + ',' + filters.join(',') + ');'); + } else { + this.push('filter(' + this.parseExpr(parts[0]) + ');'); + } + } + }; + + Parser.prototype.compileTag = function (str) { + var directive = str.split(' ')[0]; + var handler = tagHandlers[directive]; + if (!handler) { + throw new Error('Invalid tag: ' + str); + } + handler.call(this, str.slice(directive.length).trim()); + }; + + Parser.prototype.parseFilter = function (src) { + src = src.trim(); + var match = src.match(/[:(]/); + var i = match ? match.index : -1; + if (i < 0) return JSON.stringify([src]); + var name = src.slice(0, i); + var args = src.charAt(i) === ':' ? src.slice(i + 1) : src.slice(i + 1, -1); + args = this.parseExpr(args, {terms: true}); + return '[' + JSON.stringify(name) + ',' + args + ']'; + }; + + Parser.prototype.extractEnt = function (src, regex, placeholder) { + var subs = [], isFunc = typeof placeholder == 'function'; + src = src.replace(regex, function (str) { + var replacement = isFunc ? placeholder(str) : placeholder; + if (replacement) { + subs.push(str); + return replacement; + } + return str; + }); + return {src: src, subs: subs}; + }; + + Parser.prototype.injectEnt = function (extracted, placeholder) { + var src = extracted.src, subs = extracted.subs, isArr = Array.isArray(src); + var arr = (isArr) ? src : [src]; + var re = new RegExp('[' + placeholder + ']', 'g'), i = 0; + arr.forEach(function (src, index) { + arr[index] = src.replace(re, function () { + return subs[i++]; + }); + }); + return isArr ? arr : arr[0]; + }; + + //replace complex literals without mistaking subscript notation with array literals + Parser.prototype.replaceComplex = function (s) { + var parsed = this.extractEnt(s, /i(\.i|\[[@#i]\])+/g, 'v'); + parsed.src = parsed.src.replace(NON_PRIMITIVES, '~'); + return this.injectEnt(parsed, 'v'); + }; + + //parse expression containing literals (including objects/arrays) and variables (including dot and subscript notation) + //valid expressions: `a + 1 > b.c or c == null`, `a and b[1] != c`, `(a < b) or (c < d and e)`, 'a || [1]` + Parser.prototype.parseExpr = function (src, opts) { + opts = opts || {}; + //extract string literals -> @ + var parsed1 = this.extractEnt(src, STRINGS, '@'); + //note: this will catch {not: 1} and a.is; could we replace temporarily and then check adjacent chars? + parsed1.src = parsed1.src.replace(EOPS, function (s, before, op, after) { + return (op in operators) ? before + operators[op] + after : s; + }); + //sub out non-string literals (numbers/true/false/null) -> # + // the distinction is necessary because @ can be object identifiers, # cannot + var parsed2 = this.extractEnt(parsed1.src, IDENTS_AND_NUMS, function (s) { + return (s in constants || NUMBER.test(s)) ? '#' : null; + }); + //sub out object/variable identifiers -> i + var parsed3 = this.extractEnt(parsed2.src, IDENTIFIERS, 'i'); + //remove white-space + parsed3.src = parsed3.src.replace(/\s+/g, ''); + + //the rest of this is simply to boil the expression down and check validity + var simplified = parsed3.src; + //sub out complex literals (objects/arrays) -> ~ + // the distinction is necessary because @ and # can be subscripts but ~ cannot + while (simplified !== (simplified = this.replaceComplex(simplified))) ; + //now @ represents strings, # represents other primitives and ~ represents non-primitives + //replace complex variables (those with dot/subscript accessors) -> v + while (simplified !== (simplified = simplified.replace(/i(\.i|\[[@#i]\])+/, 'v'))) ; + //empty subscript or complex variables in subscript, are not permitted + simplified = simplified.replace(/[iv]\[v?\]/g, 'x'); + //sub in "i" for @ and # and ~ and v (now "i" represents all literals, variables and identifiers) + simplified = simplified.replace(/[@#~v]/g, 'i'); + //sub out operators + simplified = simplified.replace(OPERATORS, '%'); + //allow 'not' unary operator + simplified = simplified.replace(/!+[i]/g, 'i'); + var terms = opts.terms ? simplified.split(',') : [simplified]; + terms.forEach(function (term) { + //simplify logical grouping + while (term !== (term = term.replace(/\(i(%i)*\)/g, 'i'))) ; + if (!term.match(/^i(%i)*/)) { + throw new Error('Invalid expression: ' + src + " " + term); + } + }); + parsed3.src = parsed3.src.replace(VARIABLES, this.parseVar.bind(this)); + parsed2.src = this.injectEnt(parsed3, 'i'); + parsed1.src = this.injectEnt(parsed2, '#'); + return this.injectEnt(parsed1, '@'); + }; + + Parser.prototype.parseVar = function (src) { + var args = Array.prototype.slice.call(arguments); + var str = args.pop(), index = args.pop(); + //quote bare object identifiers (might be a reserved word like {while: 1}) + if (src === 'i' && str.charAt(index + 1) === ':') { + return '"i"'; + } + var parts = ['"i"']; + src.replace(ACCESSOR, function (part) { + if (part === '.i') { + parts.push('"i"'); + } else if (part === '[i]') { + parts.push('get("i")'); + } else { + parts.push(part.slice(1, -1)); + } + }); + return 'get(' + parts.join(',') + ')'; + }; + + //escapes a name to be used as a javascript identifier + Parser.prototype.escName = function (str) { + return str.replace(/\W/g, function (s) { + return '$' + s.charCodeAt(0).toString(16); + }); + }; + + Parser.prototype.parseQuoted = function (str) { + if (str.charAt(0) === "'") { + str = str.slice(1, -1).replace(/\\.|"/, function (s) { + if (s === "\\'") return "'"; + return s.charAt(0) === '\\' ? s : ('\\' + s); + }); + str = '"' + str + '"'; + } + //todo: try/catch or deal with invalid characters (linebreaks, control characters) + return JSON.parse(str); + }; + + + //the context 'this' inside tagHandlers is the parser instance + var tagHandlers = { + 'if': function (expr) { + this.push('if (' + this.parseExpr(expr) + ') {'); + this.nest.unshift('if'); + }, + 'else': function () { + if (this.nest[0] === 'for') { + this.push('}, function() {'); + } else { + this.push('} else {'); + } + }, + 'elseif': function (expr) { + this.push('} else if (' + this.parseExpr(expr) + ') {'); + }, + 'endif': function () { + this.nest.shift(); + this.push('}'); + }, + 'for': function (str) { + var i = str.indexOf(' in '); + var name = str.slice(0, i).trim(); + var expr = str.slice(i + 4).trim(); + this.push('each(' + this.parseExpr(expr) + ',' + JSON.stringify(name) + ',function() {'); + this.nest.unshift('for'); + }, + 'endfor': function () { + this.nest.shift(); + this.push('});'); + }, + 'raw': function () { + this.rawMode = true; + }, + 'endraw': function () { + this.rawMode = false; + }, + 'set': function (stmt) { + var i = stmt.indexOf('='); + var name = stmt.slice(0, i).trim(); + var expr = stmt.slice(i + 1).trim(); + this.push('set(' + JSON.stringify(name) + ',' + this.parseExpr(expr) + ');'); + }, + 'block': function (name) { + if (this.isParent) { + ++this.parentBlocks; + var blockName = 'block_' + (this.escName(name) || this.parentBlocks); + this.push('block(typeof ' + blockName + ' == "function" ? ' + blockName + ' : function() {'); + } else if (this.hasParent) { + this.isSilent = false; + ++this.childBlocks; + blockName = 'block_' + (this.escName(name) || this.childBlocks); + this.push('function ' + blockName + '() {'); + } + this.nest.unshift('block'); + }, + 'endblock': function () { + this.nest.shift(); + if (this.isParent) { + this.push('});'); + } else if (this.hasParent) { + this.push('}'); + this.isSilent = true; + } + }, + 'extends': function (name) { + name = this.parseQuoted(name); + var parentSrc = this.readTemplateFile(name); + this.isParent = true; + this.tokenize(parentSrc); + this.isParent = false; + this.hasParent = true; + //silence output until we enter a child block + this.isSilent = true; + }, + 'include': function (name) { + name = this.parseQuoted(name); + var incSrc = this.readTemplateFile(name); + this.isInclude = true; + this.tokenize(incSrc); + this.isInclude = false; + } + }; + + //liquid style + tagHandlers.assign = tagHandlers.set; + //python/django style + tagHandlers.elif = tagHandlers.elseif; + + var getRuntime = function runtime(data, opts) { + var defaults = {autoEscape: 'toJson'}; + var _toString = Object.prototype.toString; + var _hasOwnProperty = Object.prototype.hasOwnProperty; + var getKeys = Object.keys || function (obj) { + var keys = []; + for (var n in obj) if (_hasOwnProperty.call(obj, n)) keys.push(n); + return keys; + }; + var isArray = Array.isArray || function (obj) { + return _toString.call(obj) === '[object Array]'; + }; + var create = Object.create || function (obj) { + function F() { + } + + F.prototype = obj; + return new F(); + }; + var toString = function (val) { + if (val == null) return ''; + return (typeof val.toString == 'function') ? val.toString() : _toString.call(val); + }; + var extend = function (dest, src) { + var keys = getKeys(src); + for (var i = 0, len = keys.length; i < len; i++) { + var key = keys[i]; + dest[key] = src[key]; + } + return dest; + }; + //get a value, lexically, starting in current context; a.b -> get("a","b") + var get = function () { + var val, n = arguments[0], c = stack.length; + while (c--) { + val = stack[c][n]; + if (typeof val != 'undefined') break; + } + for (var i = 1, len = arguments.length; i < len; i++) { + if (val == null) continue; + n = arguments[i]; + val = (_hasOwnProperty.call(val, n)) ? val[n] : (typeof val._get == 'function' ? (val[n] = val._get(n)) : null); + } + return (val == null) ? '' : val; + }; + var set = function (n, val) { + stack[stack.length - 1][n] = val; + }; + var push = function (ctx) { + stack.push(ctx || {}); + }; + var pop = function () { + stack.pop(); + }; + var write = function (str) { + output.push(str); + }; + var filter = function (val) { + for (var i = 1, len = arguments.length; i < len; i++) { + var arr = arguments[i], name = arr[0], filter = filters[name]; + if (filter) { + arr[0] = val; + //now arr looks like [val, arg1, arg2] + val = filter.apply(data, arr); + } else { + throw new Error('Invalid filter: ' + name); + } + } + if (opts.autoEscape && name !== opts.autoEscape && name !== 'safe') { + //auto escape if not explicitly safe or already escaped + val = filters[opts.autoEscape].call(data, val); + } + output.push(val); + }; + var each = function (obj, loopvar, fn1, fn2) { + if (obj == null) return; + var arr = isArray(obj) ? obj : getKeys(obj), len = arr.length; + var ctx = {loop: {length: len, first: arr[0], last: arr[len - 1]}}; + push(ctx); + for (var i = 0; i < len; i++) { + extend(ctx.loop, {index: i + 1, index0: i}); + fn1(ctx[loopvar] = arr[i]); + } + if (len === 0 && fn2) fn2(); + pop(); + }; + var block = function (fn) { + push(); + fn(); + pop(); + }; + var render = function () { + return output.join(''); + }; + data = data || {}; + opts = extend(defaults, opts || {}); + var filters = extend({ + html: function (val) { + return toString(val) + .split('&').join('&') + .split('<').join('<') + .split('>').join('>') + .split('"').join('"'); + }, + safe: function (val) { + return val; + }, + toJson: function (val) { + if (typeof val === 'object') { + return JSON.stringify(val); + } + return toString(val); + } + }, opts.filters || {}); + var stack = [create(data || {})], output = []; + return { + get: get, + set: set, + push: push, + pop: pop, + write: write, + filter: filter, + each: each, + block: block, + render: render + }; + }; + + var runtime; + + jinja.compile = function (markup, opts) { + opts = opts || {}; + var parser = new Parser(); + parser.readTemplateFile = this.readTemplateFile; + var code = []; + code.push('function render($) {'); + code.push('var get = $.get, set = $.set, push = $.push, pop = $.pop, write = $.write, filter = $.filter, each = $.each, block = $.block;'); + code.push.apply(code, parser.parse(markup)); + code.push('return $.render();'); + code.push('}'); + code = code.join('\n'); + if (opts.runtime === false) { + var fn = new Function('data', 'options', 'return (' + code + ')(runtime(data, options))'); + } else { + runtime = runtime || (runtime = getRuntime.toString()); + fn = new Function('data', 'options', 'return (' + code + ')((' + runtime + ')(data, options))'); + } + return {render: fn}; + }; + + jinja.render = function (markup, data, opts) { + var tmpl = jinja.compile(markup); + return tmpl.render(data, opts); + }; + + jinja.templateFiles = []; + + jinja.readTemplateFile = function (name) { + var templateFiles = this.templateFiles || []; + var templateFile = templateFiles[name]; + if (templateFile == null) { + throw new Error('Template file not found: ' + name); + } + return templateFile; + }; + + + /*! + * Helpers + */ + + function trimLeft(str) { + return str.replace(LEADING_SPACE, ''); + } + + function trimRight(str) { + return str.replace(TRAILING_SPACE, ''); + } + + function matchAll(str, reg, fn) { + //copy as global + reg = new RegExp(reg.source, 'g' + (reg.ignoreCase ? 'i' : '') + (reg.multiline ? 'm' : '')); + var match; + while ((match = reg.exec(str))) { + var result = fn(match[0], match.index, str); + if (typeof result == 'number') { + reg.lastIndex = result; + } + } + } +})); \ No newline at end of file