| 1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+51
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+63
+64
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+100
+101
+102
+103
+104
+105
+106
+107
+108
+109
+110
+111
+112
+113
+114
+115
+116
+117
+118
+119
+120
+121
+122
+123
+124
+125
+126
+127
+128
+129
+130
+131
+132
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+182
+183
+184
+185
+186
+187
+188
+189
+190
+191
+192
+193
+194
+195
+196
+197
+198
+199
+200
+201
+202
+203
+204
+205
+206
+207
+208
+209
+210
+211
+212
+213
+214
+215
+216
+217
+218
+219
+220
+221
+222
+223
+224
+225
+226
+227
+228
+229
+230
+231
+232
+233
+234
+235
+236
+237
+238
+239
+240
+241
+242
+243
+244
+245
+246
+247
+248
+249
+250
+251
+252
+253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+264
+265
+266
+267
+268
+269
+270
+271
+272
+273
+274
+275
+276
+277
+278
+279
+280
+281
+282
+283
+284
+285
+286
+287
+288
+289
+290
+291
+292
+293
+294
+295
+296
+297
+298
+299
+300
+301
+302
+303
+304
+305
+306
+307
+308
+309
+310
+311
+312
+313
+314
+315
+316
+317
+318
+319
+320
+321
+322
+323
+324
+325
+326
+327
+328
+329
+330
+331
+332
+333
+334
+335
+336
+337
+338
+339
+340
+341
+342
+343
+344
+345
+346
+347
+348
+349
+350
+351
+352
+353
+354
+355
+356
+357
+358
+359
+360
+361
+362
+363
+364
+365
+366
+367
+368
+369
+370
+371
+372
+373
+374
+375
+376
+377
+378
+379
+380
+381
+382
+383
+384
+385
+386
+387
+388
+389
+390
+391
+392
+393
+394
+395
+396
+397
+398
+399
+400
+401
+402
+403
+404
+405
+406
+407
+408
+409
+410
+411
+412
+413
+414
+415
+416
+417
+418
+419
+420
+421
+422
+423
+424
+425
+426
+427
+428
+429
+430
+431
+432
+433
+434
+435
+436
+437
+438
+439
+440
+441
+442
+443
+444
+445
+446
+447
+448
+449
+450
+451
+452
+453
+454
+455
+456
+457
+458
+459
+460
+461
+462
+463
+464
+465
+466
+467
+468
+469
+470
+471
+472
+473
+474
+475
+476
+477
+478
+479
+480
+481
+482
+483
+484
+485
+486
+487
+488
+489
+490
+491
+492
+493
+494
+495
+496
+497
+498
+499
+500
+501
+502
+503
+504
+505
+506
+507
+508
+509
+510
+511
+512
+513
+514
+515
+516
+517
+518
+519
+520
+521
+522
+523
+524
+525
+526
+527
+528
+529
+530
+531
+532
+533
+534
+535
+536
+537
+538
+539
+540
+541
+542
+543
+544
+545
+546
+547
+548
+549
+550
+551
+552
+553
+554
+555
+556
+557
+558
+559
+560
+561
+562
+563
+564
+565
+566
+567
+568
+569
+570
+571
+572
+573
+574
+575
+576
+577
+578
+579
+580
+581
+582
+583
+584
+585
+586
+587
+588
+589
+590
+591
+592
+593
+594
+595
+596
+597
+598
+599
+600
+601
+602
+603
+604
+605
+606
+607
+608
+609
+610
+611
+612
+613
+614
+615
+616
+617
+618
+619
+620
+621
+622
+623
+624
+625
+626
+627
+628
+629
+630
+631
+632
+633
+634
+635
+636
+637
+638
+639
+640
+641
+642
+643
+644
+645
+646
+647
+648
+649
+650
+651
+652
+653
+654
+655
+656
+657
+658
+659
+660
+661
+662
+663
+664
+665
+666
+667
+668
+669
+670
+671
+672
+673
+674
+675
+676
+677
+678
+679
+680
+681
+682
+683
+684
+685
+686
+687
+688
+689
+690
+691
+692
+693
+694
+695
+696
+697
+698
+699
+700
+701
+702
+703
+704
+705
+706
+707
+708
+709
+710
+711
+712
+713
+714
+715
+716
+717
+718
+719
+720
+721
+722
+723
+724
+725
+726
+727
+728
+729
+730
+731
+732
+733
+734
+735
+736
+737
+738
+739
+740
+741
+742
+743
+744
+745
+746
+747
+748
+749
+750
+751
+752
+753
+754
+755
+756
+757
+758
+759
+760
+761
+762
+763
+764
+765
+766
+767
+768
+769
+770
+771
+772
+773
+774
+775
+776
+777
+778
+779
+780
+781
+782
+783
+784
+785
+786
+787
+788
+789
+790
+791
+792
+793
+794
+795
+796
+797
+798
+799
+800
+801
+802
+803
+804
+805
+806
+807
+808
+809
+810
+811
+812
+813
+814
+815
+816
+817
+818
+819
+820
+821
+822
+823
+824
+825
+826
+827
+828
+829
+830
+831
+832
+833
+834
+835
+836
+837
+838
+839
+840
+841
+842
+843
+844
+845
+846
+847
+848
+849
+850
+851
+852
+853
+854
+855
+856
+857
+858
+859
+860
+861
+862
+863
+864
+865
+866
+867
+868
+869
+870
+871
+872
+873
+874
+875
+876
+877
+878
+879
+880
+881
+882
+883
+884
+885
+886
+887
+888
+889
+890
+891
+892
+893
+894
+895
+896
+897
+898
+899
+900
+901
+902
+903
+904
+905
+906
+907
+908
+909
+910
+911
+912
+913
+914
+915
+916
+917
+918
+919
+920
+921
+922
+923
+924
+925
+926
+927
+928
+929
+930
+931
+932
+933
+934
+935
+936
+937
+938
+939
+940
+941
+942
+943
+944
+945
+946
+947
+948
+949
+950
+951
+952
+953
+954
+955
+956
+957
+958
+959
+960
+961
+962
+963
+964
+965
+966
+967
+968
+969
+970
+971
+972
+973
+974
+975
+976
+977
+978
+979
+980
+981
+982
+983
+984
+985
+986
+987
+988
+989
+990
+991
+992
+993
+994
+995
+996
+997
+998
+999
+1000
+1001
+1002
+1003
+1004
+1005
+1006
+1007
+1008
+1009
+1010
+1011
+1012
+1013
+1014
+1015
+1016
+1017
+1018
+1019
+1020
+1021
+1022
+1023
+1024
+1025
+1026
+1027
+1028
+1029
+1030
+1031
+1032
+1033
+1034
+1035
+1036
+1037
+1038
+1039
+1040
+1041
+1042
+1043
+1044
+1045
+1046
+1047
+1048
+1049
+1050
+1051
+1052
+1053
+1054
+1055
+1056
+1057
+1058
+1059
+1060
+1061
+1062
+1063
+1064
+1065
+1066
+1067
+1068
+1069
+1070
+1071
+1072
+1073
+1074
+1075
+1076
+1077
+1078
+1079
+1080
+1081
+1082
+1083
+1084
+1085
+1086
+1087
+1088
+1089
+1090
+1091
+1092
+1093
+1094
+1095
+1096
+1097
+1098
+1099
+1100
+1101
+1102
+1103
+1104
+1105
+1106
+1107
+1108
+1109
+1110
+1111
+1112
+1113
+1114
+1115
+1116
+1117
+1118
+1119
+1120
+1121
+1122
+1123
+1124
+1125
+1126
+1127
+1128
+1129
+1130
+1131
+1132
+1133
+1134
+1135
+1136
+1137
+1138
+1139
+1140
+1141
+1142
+1143
+1144
+1145
+1146
+1147
+1148
+1149
+1150
+1151
+1152
+1153
+1154
+1155
+1156
+1157
+1158
+1159
+1160
+1161
+1162
+1163
+1164
+1165
+1166
+1167
+1168
+1169
+1170
+1171
+1172
+1173
+1174
+1175
+1176
+1177
+1178
+1179
+1180
+1181
+1182
+1183
+1184
+1185
+1186
+1187
+1188
+1189
+1190
+1191
+1192
+1193
+1194
+1195
+1196
+1197
+1198
+1199
+1200
+1201
+1202
+1203
+1204
+1205
+1206
+1207
+1208
+1209
+1210
+1211
+1212
+1213
+1214
+1215
+1216
+1217
+1218
+1219
+1220
+1221
+1222
+1223
+1224
+1225
+1226
+1227
+1228
+1229
+1230
+1231
+1232
+1233
+1234
+1235
+1236
+1237
+1238
+1239
+1240
+1241
+1242
+1243
+1244
+1245
+1246
+1247
+1248
+1249
+1250
+1251
+1252
+1253
+1254
+1255
+1256
+1257
+1258
+1259
+1260
+1261
+1262
+1263
+1264
+1265
+1266
+1267
+1268
+1269
+1270
+1271
+1272
+1273
+1274
+1275
+1276
+1277
+1278
+1279
+1280
+1281
+1282
+1283
+1284
+1285
+1286
+1287
+1288
+1289
+1290
+1291
+1292
+1293
+1294
+1295
+1296
+1297
+1298
+1299
+1300
+1301
+1302
+1303
+1304
+1305
+1306
+1307
+1308
+1309
+1310
+1311
+1312
+1313
+1314
+1315
+1316
+1317
+1318
+1319
+1320
+1321
+1322
+1323
+1324
+1325
+1326
+1327
+1328
+1329
+1330
+1331
+1332
+1333
+1334
+1335
+1336
+1337
+1338
+1339
+1340
+1341
+1342
+1343
+1344
+1345
+1346
+1347
+1348
+1349
+1350
+1351
+1352
+1353
+1354
+1355
+1356
+1357
+1358
+1359
+1360
+1361
+1362
+1363
+1364
+1365
+1366
+1367
+1368
+1369
+1370
+1371
+1372
+1373
+1374
+1375
+1376
+1377
+1378
+1379
+1380
+1381
+1382
+1383
+1384
+1385
+1386
+1387
+1388
+1389
+1390
+1391
+1392
+1393
+1394
+1395
+1396
+1397
+1398
+1399
+1400
+1401
+1402
+1403
+1404
+1405 | 2×
+
+
+
+
+
+
+
+
+
+2×
+
+
+2×
+
+1×
+20×
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2×
+28×
+32×
+32×
+32×
+32×
+
+
+
+
+
+2×
+210×
+
+
+2×
+2×
+
+
+
+2×
+2×
+
+
+
+
+2×
+1×
+62×
+
+
+
+
+
+
+
+
+
+
+
+2×
+1×
+2×
+
+
+
+
+
+6×
+6×
+
+
+
+
+
+
+
+
+
+6×
+
+4×
+
+
+6×
+6×
+11×
+6×
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2×
+2×
+2×
+2×
+2×
+
+
+2×
+2×
+
+2×
+2×
+2×
+2×
+
+
+
+
+
+1×
+104×
+104×
+104×
+
+
+2×
+88×
+
+
+
+
+
+
+
+
+
+50×
+
+88×
+88×
+88×
+48×
+34×
+
+14×
+14×
+38×
+
+
+48×
+
+88×
+
+
+
+
+
+
+
+1×
+282×
+282×
+
+
+
+156×
+156×
+
+282×
+282×
+
+
+
+
+
+
+1×
+48×
+
+
+
+
+
+
+
+
+
+48×
+48×
+48×
+
+30×
+18×
+18×
+18×
+
+
+
+
+20×
+16×
+
+
+16×
+
+
+
+14×
+
+
+4×
+4×
+
+10×
+
+
+
+
+
+48×
+36×
+
+
+36×
+34×
+4×
+
+2×
+2×
+
+
+30×
+30×
+2×
+2×
+
+
+
+
+
+
+
+
+
+1×
+4×
+4×
+6×
+4×
+4×
+
+
+
+
+
+
+1×
+104×
+104×
+286×
+
+
+
+114×
+114×
+
+
+
+46×
+28×
+28×
+
+
+68×
+68×
+2×
+
+66×
+
+
+
+
+
+114×
+
+4×
+4×
+
+
+168×
+6×
+6×
+6×
+162×
+2×
+
+
+162×
+162×
+78×
+78×
+4×
+
+74×
+
+
+
+24×
+24×
+
+10×
+10×
+12×
+
+10×
+10×
+
+40×
+12×
+
+40×
+4×
+4×
+
+36×
+78×
+4×
+
+
+
+
+36×
+36×
+
+
+84×
+24×
+
+
+
+
+
+
+60×
+4×
+56×
+10×
+46×
+4×
+42×
+4×
+38×
+28×
+28×
+28×
+28×
+28×
+10×
+4×
+
+6×
+
+162×
+
+
+
+
+
+
+
+
+
+1×
+118×
+
+
+
+
+
+
+
+56×
+56×
+48×
+48×
+
+
+
+
+
+
+
+
+
+
+
+
+
+1×
+228×
+
+
+
+
+
+322×
+322×
+
+118×
+118×
+118×
+
+66×
+64×
+64×
+
+66×
+
+138×
+
+
+
+4×
+4×
+
+138×
+
+
+
+
+
+
+
+2×
+
+
+
+
+2×
+
+
+
+
+
+2×
+2×
+2×
+2×
+
+
+
+
+2×
+
+
+
+
+2×
+2×
+206×
+2×
+
+
+
+
+
+
+
+2×
+
+
+2×
+
+
+
+
+
+
+1×
+4×
+
+
+
+1×
+2×
+
+
+
+1×
+62×
+
+
+
+
+
+
+
+90×
+90×
+
+
+
+66×
+
+
+62×
+
+
+
+1×
+142×
+
+
+
+
+1×
+138×
+
+
+
+
+
+
+
+1×
+136×
+136×
+136×
+136×
+136×
+136×
+
+64×
+
+
+
+
+
+
+64×
+
+136×
+
+
+
+1×
+1×
+1×
+
+135×
+135×
+72×
+
+63×
+
+
+136×
+
+
+
+1×
+2×
+2×
+2×
+1×
+1×
+1×
+
+1×
+1×
+1×
+
+2×
+
+
+
+1×
+72×
+
+
+
+
+1×
+4×
+4×
+4×
+
+
+
+
+1×
+46×
+46×
+4×
+4×
+
+46×
+
+
+
+1×
+10×
+10×
+2×
+8×
+2×
+6×
+2×
+
+4×
+
+
+
+
+1×
+10×
+10×
+8×
+
+
+
+
+
+1×
+84×
+
+
+
+1×
+100×
+
+
+
+
+1×
+6×
+6×
+
+42×
+
+
+18×
+
+
+
+
+
+1×
+156×
+24×
+
+
+
+
+1×
+156×
+156×
+
+
+104×
+104×
+
+48×
+48×
+
+4×
+4×
+
+156×
+
+
+
+1×
+116×
+
+
+
+
+
+
+
+2×
+
+2×
+164×
+
+90×
+
+
+
+
+
+
+
+
+
+2×
+
+1×
+1×
+
+78×
+
+
+
+
+
+55×
+
+
+
+
+
+
+
+
+2×
+
+1×
+
+
+1×
+1×
+101×
+
+
+
+
+2×
+21×
+
+
+
+
+
+
+2×
+
+
+2×
+
+
+2×
+1×
+206×
+206×
+
+
+
+
+2×
+
+69×
+
+
+5×
+
+
+
+
+6×
+
+
+
+
+2×
+
+162×
+
+
+
+
+
+
+390×
+390×
+205×
+
+162×
+
+101×
+
+
+
+2×
+
+82×
+137×
+137×
+
+61×
+61×
+
+76×
+76×
+
+
+82×
+
+
+82×
+137×
+
+82×
+
+
+
+2×
+2×
+2×
+38×
+
+
+2×
+48×
+
+
+
+2×
+
+
+2×
+
+
+2×
+
+
+2×
+
+
+
+2×
+2×
+2×
+2×
+
+206×
+
+
+
+
+
+144×
+
+206×
+
+
+62×
+
+
+
+
+
+
+
+
+2×
+
+21×
+15×
+
+15×
+
+21×
+
+2×
+
+18×
+12×
+
+14×
+
+18×
+
+
+1×
+40×
+40×
+10×
+10×
+
+
+
+
+1×
+36×
+10×
+
+26×
+
+
+
+
+
+1×
+46×
+
+
+
+
+
+
+
+
+82×
+
+8×
+8×
+6×
+
+8×
+8×
+
+36×
+36×
+36×
+36×
+36×
+36×
+36×
+36×
+
+
+
+
+
+26×
+26×
+
+
+4×
+
+
+10×
+10×
+
+36×
+
+
+
+36×
+6×
+
+
+
+
+
+30×
+
+
+
+
+
+36×
+30×
+
+36×
+
+
+38×
+
+
+
+
+
+38×
+38×
+
+
+46×
+
+
+
+1×
+32×
+
+
+
+
+
+
+46×
+46×
+46×
+
+
+
+
+
+
+32×
+32×
+
+
+
+
+
+
+
+
+1×
+110×
+110×
+110×
+110×
+110×
+110×
+
+
+
+
+
+1×
+116×
+116×
+116×
+
+
+4×
+4×
+
+64×
+64×
+
+
+
+64×
+
+
+48×
+48×
+48×
+
+116×
+
+
+
+
+92×
+
+116×
+
+
+
+
+
+1×
+124×
+
+
+
+
+
+
+110×
+110×
+
+
+
+
+
+
+124×
+124×
+
+
+
+1×
+282×
+300×
+
+
+
+
+
+1×
+156×
+156×
+156×
+
+156×
+124×
+124×
+124×
+124×
+
+32×
+
+156×
+
+
+
+
+
+
+
+1×
+60×
+
+1×
+60×
+60×
+
+
+60×
+
+
+1×
+90×
+62×
+62×
+8×
+
+62×
+
+90×
+
+
+60×
+
+14×
+14×
+14×
+10×
+10×
+10×
+14×
+10×
+2×
+2×
+
+
+
+
+2×
+
+8×
+8×
+
+
+14×
+14×
+
+
+14×
+
+
+76×
+76×
+52×
+52×
+52×
+
+76×
+76×
+
+
+
+
+1×
+46×
+46×
+46×
+46×
+12×
+12×
+
+46×
+24×
+24×
+
+46×
+
+
+
+
+
+
+
+
+
+
+
+2×
+
+
+
+
+2×
+
+
+
+
+
+
+2×
+
+
+
+
+
+
+
+
+1×
+60×
+
+
+
+
+60×
+26×
+24×
+
+26×
+
+34×
+4×
+4×
+
+30×
+
+
+
+
+
+
+
+
+
+
+
+2×
+104×
+104×
+88×
+88×
+88×
+88×
+
+104×
+
+
+2×
+
+
+
+
+
+
+
+1×
+30×
+30×
+30×
+30×
+30×
+30×
+30×
+30×
+30×
+30×
+30×
+30×
+50×
+30×
+46×
+46×
+46×
+46×
+46×
+84×
+84×
+84×
+84×
+
+
+
+
+84×
+
+46×
+
+30×
+
+
+
+1×
+28×
+
+
+
+
+
+
+
+
+
+1×
+30×
+
+
+
+
+
+
+
+
+30×
+50×
+50×
+50×
+50×
+50×
+50×
+50×
+42×
+42×
+42×
+16×
+
+
+8×
+6×
+6×
+
+
+2×
+2×
+
+
+30×
+2×
+
+30×
+2×
+
+30×
+
+
+
+1×
+30×
+
+
+
+
+
+30×
+20×
+20×
+8×
+8×
+2×
+2×
+
+6×
+6×
+
+
+6×
+
+8×
+
+20×
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2× | var hyperHTML = (function (globalDocument, majinbuu) {'use strict';
+
+ /*! (c) 2017 Andrea Giammarchi @WebReflection, (ISC) */
+
+ // ---------------------------------------------
+ // hyperHTML Public API
+ // ---------------------------------------------
+
+ // The document must be swap-able at runtime.
+ // Needed by both basicHTML and nativeHTML
+ hyper.document = globalDocument;
+
+ // friendly destructuring
+ hyper.hyper = hyper;
+
+ function hyper(HTML) {
+ return arguments.length < 2 ?
+ (HTML == null ?
+ wireContent('html') :
+ (typeof HTML === 'string' ?
+ wire(null, HTML) :
+ ('raw' in HTML ?
+ wireContent('html')(HTML) :
+ ('nodeType' in HTML ?
+ bind(HTML) :
+ wireWeakly(HTML, 'html')
+ )
+ )
+ )) :
+ ('raw' in HTML ?
+ wireContent('html') : wire
+ ).apply(null, arguments);
+ }
+
+ // hyper.adopt(el) 🐣
+ // import an already live DOM structure
+ // described as TL
+ hyper.adopt = function adopt(node) {
+ return function () {
+ notAdopting = false;
+ render.apply(node, arguments);
+ notAdopting = true;
+ return node;
+ };
+ };
+
+ // hyper.bind(el) ⚡️
+ // render TL inside a DOM node used as context
+ hyper.bind = bind;
+ function bind(context) { return render.bind(context); }
+
+ // hyper.define('transformer', callback) 🌀
+ hyper.define = function define(transformer, callback) {
+ transformers[transformer] = callback;
+ };
+
+ // hyper.escape('<html>') => '<text>' 🏃
+ hyper.escape = function escape(html) {
+ return html.replace(/[&<>'"]/g, fnEscape);
+ };
+
+ // hyper.wire(obj, 'type:ID') ➰
+ // relate a renderer to a generic object
+ hyper.wire = wire;
+ function wire(obj, type) {
+ return arguments.length < 1 ?
+ wireContent('html') :
+ (obj == null ?
+ wireContent(type || 'html') :
+ wireWeakly(obj, type || 'html')
+ );
+ }
+
+ // hyper.Component([initialState]) 🍻
+ // An overly-simplified Component class.
+ // For full Custom Elements support
+ // see HyperHTMLElement instead.
+ hyper.Component = Component;
+ function Component() {}
+ Object.defineProperties(
+ Component.prototype,
+ {
+ // same as HyperHTMLElement handleEvent
+ handleEvent: {value: function (e) {
+ // both IE < 11 and JSDOM lack dataset
+ var ct = e.currentTarget;
+ this[
+ ('getAttribute' in ct && ct.getAttribute('data-call')) ||
+ ('on' + e.type)
+ ](e);
+ }},
+ // returns its own HTML wire or create it once on comp.render()
+ html: lazyGetter('html', wireContent),
+ // returns its own SVG wire or create it once on comp.render()
+ svg: lazyGetter('svg', wireContent),
+ // same as HyperHTMLElement state
+ state: lazyGetter('state', function () { return this.defaultState; }),
+ // same as HyperHTMLElement get defaultState
+ defaultState: {get: function () { return {}; }},
+ // same as HyperHTMLElement setState
+ setState: {value: function (state) {
+ var target = this.state;
+ var source = typeof state === 'function' ? state.call(this, target) : state;
+ for (var key in source) target[key] = source[key];
+ this.render();
+ }}
+ // the render must be defined when extending hyper.Component
+ // the render **must** return either comp.html or comp.svg wire
+ // render() { return this.html`<p>that's it</p>`; }
+ }
+ );
+
+ // - - - - - - - - - - - - - - - - - - - - - - -
+
+ // ---------------------------------------------
+ // Constants
+ // ---------------------------------------------
+
+ // Node.CONSTANTS
+ // without assuming Node is globally available
+ // since this project is used on the backend too
+ var ELEMENT_NODE = 1;
+ var ATTRIBUTE_NODE = 2;
+ var TEXT_NODE = 3;
+ var COMMENT_NODE = 8;
+ var DOCUMENT_FRAGMENT_NODE = 11;
+
+ // SVG related
+ var OWNER_SVG_ELEMENT = 'ownerSVGElement';
+ var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+
+ var SHOULD_USE_ATTRIBUTE = /^style$/i;
+ var EXPANDO = '_hyper: ';
+ var UID = EXPANDO + ((Math.random() * new Date) | 0) + ';';
+ var UIDC = '<!--' + UID + '-->';
+
+ // ---------------------------------------------
+ // DOM Manipulation
+ // ---------------------------------------------
+
+ function Aura(node, childNodes) {
+ this.node = node;
+ this.childNodes = childNodes;
+ return majinbuu.aura(this, childNodes);
+ }
+
+ Aura.prototype.splice = function splice(start, deleteCount) {
+ for (var
+ tmp,
+ i = start,
+ ph = this.node,
+ cn = this.childNodes,
+ pn = ph.parentNode,
+ length = cn.length,
+ end = deleteCount == null ? length : (start + deleteCount);
+ i < length && i < end; i++
+ ) {
+ pn.removeChild(cn[i]);
+ }
+ i = 2;
+ length = arguments.length;
+ if (i < length) {
+ if ((length - i) === 1) {
+ tmp = arguments[i];
+ } else {
+ tmp = createDocumentFragment(pn.ownerDocument);
+ while (i < length) {
+ tmp.appendChild(arguments[i++]);
+ }
+ }
+ pn.insertBefore(tmp, cn[end] || ph);
+ }
+ return cn.splice.apply(cn, arguments);
+ };
+
+ // ---------------------------------------------
+ // hyperHTML Operations
+ // ---------------------------------------------
+
+ // entry point for all TL => DOM operations
+ function render(template) {
+ var hyper = hypers.get(this);
+ if (
+ !hyper ||
+ hyper.template !== TL(template)
+ ) {
+ hyper = upgrade.apply(this, arguments);
+ hypers.set(this, hyper);
+ }
+ update.apply(hyper.updates, arguments);
+ return this;
+ }
+
+ // `<div class="${'attr'}"></div>`
+ // `<div onclick="${function () {... }}"></div>`
+ // `<div onclick="${{handleEvent(){ ... }}}"></div>`
+ // `<div contenteditable="${true}"></div>`
+ function setAttribute(attribute, removeAttributes, name) {
+ var
+ node = attribute.ownerElement,
+ isEvent = /^on/.test(name),
+ isSpecial = name === 'data' ||
+ (isSpecialAttribute(node, name) &&
+ !SHOULD_USE_ATTRIBUTE.test(name)),
+ type = isEvent ? name.slice(2) : '',
+ noOwner = isEvent || isSpecial,
+ oldValue
+ ;
+ if (isEvent && name.toLowerCase() in node) type = type.toLowerCase();
+ if (noOwner) removeAttributes.push(node, name);
+ return isEvent ?
+ function eventAttr(newValue) {
+ if (oldValue !== newValue) {
+ if (oldValue) node.removeEventListener(type, oldValue, false);
+ oldValue = newValue;
+ if (newValue) node.addEventListener(type, newValue, false);
+ }
+ } :
+ (isSpecial ?
+ function specialAttr(newValue) {
+ if (oldValue !== newValue) {
+ oldValue = newValue;
+ // WebKit moves the cursor if input.value
+ // is set again, even if same value
+ if (node[name] !== newValue) {
+ // let the browser handle the case
+ // input.value = null;
+ // input.value; // ''
+ if (newValue == null) {
+ // reflect the null intent,
+ // do not pass undefined!
+ node[name] = null;
+ node.removeAttribute(name);
+ } else {
+ node[name] = newValue;
+ }
+ }
+ }
+ } :
+ function normalAttr(newValue) {
+ if (oldValue !== newValue) {
+ oldValue = newValue;
+ // avoid triggering again attributeChangeCallback
+ // if the value was identical
+ if (attribute.value !== newValue) {
+ if (newValue == null) {
+ if (!noOwner) {
+ // TODO: should attribute.value = null here?
+ noOwner = true;
+ node.removeAttributeNode(attribute);
+ }
+ } else {
+ attribute.value = newValue;
+ if (noOwner) {
+ noOwner = false;
+ node.setAttributeNode(attribute);
+ }
+ }
+ }
+ }
+ }
+ );
+ }
+
+ // `<style>${'text'}</style>`
+ function setTextContent(node) {
+ var oldValue;
+ return function (value) {
+ if (value !== oldValue) {
+ oldValue = value;
+ node.textContent = value;
+ }
+ };
+ }
+
+ // `<p>${'any'}</p>`
+ // `<li>a</li>${'virtual'}<li>c</li>`
+ function setAnyContent(node, childNodes, aura) {
+ var oldValue;
+ return function anyContent(value) {
+ switch (typeof value) {
+ case 'string':
+ case 'number':
+ case 'boolean':
+ var length = childNodes.length;
+ if (
+ length === 1 &&
+ childNodes[0].nodeType === TEXT_NODE
+ ) {
+ if (oldValue !== value) {
+ oldValue = value;
+ childNodes[0].textContent = value;
+ }
+ } else {
+ oldValue = value;
+ if (length) {
+ aura.splice(0, length, createText(node, value));
+ } else {
+ childNodes[0] = node.parentNode.insertBefore(
+ createText(node, value),
+ node
+ );
+ }
+ }
+ break;
+ case 'function':
+ anyContent(value(node.parentNode, childNodes, 0));
+ break;
+ case 'object':
+ case 'undefined':
+ if (value == null) {
+ oldValue = value;
+ anyContent('');
+ break;
+ } else if (value instanceof Component) {
+ value = value.render();
+ }
+ default:
+ oldValue = value;
+ if (isArray(value)) {
+ var length = value.length;
+ if (length === 0) {
+ aura.splice(0);
+ } else {
+ switch (typeof value[0]) {
+ case 'string':
+ case 'number':
+ case 'boolean':
+ anyContent({html: value});
+ break;
+ case 'function':
+ var parentNode = node.parentNode;
+ for (var i = 0; i < length; i++) {
+ value[i] = value[i](parentNode, childNodes, i);
+ }
+ anyContent(value.concat.apply([], value));
+ break;
+ case 'object':
+ if (isArray(value[0])) {
+ value = value.concat.apply([], value);
+ }
+ if (isPromise_ish(value[0])) {
+ Promise.all(value).then(anyContent);
+ break;
+ } else {
+ for (var i = 0, length = value.length; i < length; i++) {
+ if (value[i] instanceof Component) {
+ value[i] = value[i].render();
+ }
+ }
+ }
+ default:
+ majinbuu(aura, value, hyper.MAX_LIST_SIZE);
+ break;
+ }
+ }
+ } else if (isNode_ish(value)) {
+ majinbuu(
+ aura,
+ value.nodeType === DOCUMENT_FRAGMENT_NODE ?
+ slice.call(value.childNodes) :
+ [value],
+ hyper.MAX_LIST_SIZE
+ );
+ } else if (isPromise_ish(value)) {
+ value.then(anyContent);
+ } else if ('placeholder' in value) {
+ invokeAtDistance(anyContent, value);
+ } else if ('text' in value) {
+ anyContent(String(value.text));
+ } else if ('any' in value) {
+ anyContent(value.any);
+ } else if ('html' in value) {
+ var html = [].concat(value.html).join('');
+ aura.splice(0);
+ var fragment = createFragment(node, html);
+ childNodes.push.apply(childNodes, fragment.childNodes);
+ node.parentNode.insertBefore(fragment, node);
+ } else if ('length' in value) {
+ anyContent(slice.call(value));
+ } else {
+ anyContent(invokeTransformer(value));
+ }
+ break;
+ }
+ };
+ }
+
+ // ---------------------------------------------
+ // DOM Traversing
+ // ---------------------------------------------
+
+ // look for attributes that contains the comment text
+ function attributesSeeker(node, paths, parts) {
+ for (var
+ name,
+ attribute,
+ value = UID,
+ attributes = node.attributes,
+ i = 0, length = attributes.length;
+ i < length; i++
+ ) {
+ attribute = attributes[i];
+ if (attribute.value === value) {
+ name = parts.shift().replace(/^(?:|[\S\s]*?\s)(\S+?)=['"]?$/, '$1');
+ paths.push(
+ Path(
+ 'attr',
+ // this is needed in both jsdom
+ // and in not-so-standard browsers/engines
+ node.attributes[name.toLowerCase()],
+ name
+ )
+ );
+ }
+ }
+ }
+
+ // walk the fragment tree in search of comments
+ function hyperSeeker(node, paths, parts) {
+ for (var
+ child,
+ childNodes = node.childNodes,
+ length = childNodes.length,
+ i = 0; i < length; i++
+ ) {
+ child = childNodes[i];
+ switch (child.nodeType) {
+ case ELEMENT_NODE:
+ attributesSeeker(child, paths, parts);
+ hyperSeeker(child, paths, parts);
+ break;
+ case COMMENT_NODE:
+ if (child.textContent === UID) {
+ parts.shift();
+ paths.push(Path('any', child));
+ }
+ break;
+ case TEXT_NODE:
+ if (
+ SHOULD_USE_ATTRIBUTE.test(node.nodeName) &&
+ trim.call(child.textContent) === UIDC
+ ) {
+ parts.shift();
+ paths.push(Path('text', node));
+ }
+ break;
+ }
+ }
+ }
+
+ // ---------------------------------------------
+ // Features detection / ugly UA sniffs
+ // ---------------------------------------------
+ var featureFragment = createDocumentFragment(globalDocument);
+
+ // Firefox < 55 has non standard template literals.
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1108941
+ // TODO: is there any better way to feature detect this ?
+ var FF = typeof navigator === 'object' &&
+ /Firefox\/(\d+)/.test(navigator.userAgent) &&
+ parseFloat(RegExp.$1) < 55;
+
+ // If attributes order is shuffled, threat the browser differently
+ // Usually this is a well known IE only limitation but some older FF does the same.
+ var IE = (function () {
+ var p = globalDocument.createElement('p');
+ p.innerHTML = '<i data-i="" class=""></i>';
+ return /class/i.test(p.firstChild.attributes[0].name);
+ }());
+
+
+ // beside IE, old WebKit browsers don't have `children` in DocumentFragment
+ var WK = !('children' in featureFragment);
+
+ // both Firefox < 55 and TypeScript have issues with template literals
+ // this lazy defined callback should spot issues right away
+ // and in the best case scenario become a no-op
+ var TL = function (template) {
+ if (template.propertyIsEnumerable('raw') || FF) TL = unique;
+ else TL = function (t) { return t; };
+ return TL(template);
+ };
+
+ // ---------------------------------------------
+ // Helpers
+ // ---------------------------------------------
+
+ // used to convert childNodes to Array
+ var slice = [].slice;
+
+ // used to sanitize html
+ var oEscape = {
+ '&': '&',
+ '<': '<',
+ '>': '>',
+ "'": ''',
+ '"': '"'
+ };
+ function fnEscape(m) {
+ return oEscape[m];
+ }
+
+ // return content as html
+ function asHTML(html) {
+ return {html: html};
+ }
+
+ // return a single node or an Array or nodes
+ function createContent(node) {
+ for (var
+ child,
+ content = [],
+ childNodes = node.childNodes,
+ i = 0,
+ length = childNodes.length;
+ i < length; i++
+ ) {
+ child = childNodes[i];
+ if (
+ child.nodeType === ELEMENT_NODE ||
+ trim.call(child.textContent).length !== 0
+ ) {
+ content.push(child);
+ }
+ }
+ return content.length === 1 ? content[0] : content;
+ }
+
+ // just a minifier friendly indirection
+ function createDocumentFragment(document) {
+ return document.createDocumentFragment();
+ }
+
+ // given a node, inject some html and return
+ // the resulting template document fragment
+ function createFragment(node, html) {
+ return (
+ OWNER_SVG_ELEMENT in node ?
+ createSVGFragment :
+ createHTMLFragment
+ )(node, html.replace(no, comments));
+ }
+
+ // create fragment for HTML
+ function createHTMLFragment(node, html) {
+ var fragment;
+ var document = node.ownerDocument;
+ var container = document.createElement('template');
+ var hasContent = 'content' in container;
+ var needsTableWrap = false;
+ if (!hasContent) {
+ // DO NOT MOVE THE FOLLOWING LINE ELSEWHERE
+ fragment = createDocumentFragment(document);
+ // (a jsdom + nodejs tests coverage gotcha)
+
+ // el.innerHTML = '<td></td>'; is not possible
+ // if the content is a partial internal table content
+ // it needs to be wrapped around once injected.
+ // HTMLTemplateElement does not suffer this issue.
+ needsTableWrap = /^[^\S]*?<(col(?:group)?|t(?:head|body|foot|r|d|h))/i.test(html);
+ }
+ if (needsTableWrap) {
+ // secure the RegExp.$1 result ASAP to avoid issues
+ // in case a non-browser DOM library uses RegExp internally
+ // when HTML content is injected (basicHTML / jsdom / others...)
+ var selector = RegExp.$1;
+ container.innerHTML = '<table>' + html + '</table>';
+ appendNodes(fragment, slice.call(container.querySelectorAll(selector)));
+ } else {
+ container.innerHTML = html;
+ if (hasContent) {
+ fragment = container.content;
+ } else {
+ appendNodes(fragment, slice.call(container.childNodes));
+ }
+ }
+ return fragment;
+ }
+
+ // create a fragment for SVG
+ function createSVGFragment(node, html) {
+ var document = node.ownerDocument;
+ var fragment = createDocumentFragment(document);
+ if (IE || WK) {
+ var container = document.createElement('div');
+ container.innerHTML = '<svg xmlns="' + SVG_NAMESPACE + '">' + html + '</svg>';
+ appendNodes(fragment, slice.call(container.firstChild.childNodes));
+ } else {
+ var container = document.createElementNS(SVG_NAMESPACE, 'svg');
+ container.innerHTML = html;
+ appendNodes(fragment, slice.call(container.childNodes));
+ }
+ return fragment;
+ }
+
+ // given a node, it does what is says
+ function createText(node, text) {
+ return node.ownerDocument.createTextNode(text);
+ }
+
+ // returns current customElements reference
+ // compatible with basicHTML too
+ function getCEClass(node) {
+ var doc = hyper.document;
+ var ce = doc.customElements || doc.defaultView.customElements;
+ return ce && ce.get(node.nodeName.toLowerCase());
+ }
+
+ // verify that an attribute has
+ // a special meaning for the node
+ function isSpecialAttribute(node, name) {
+ var notSVG = !(OWNER_SVG_ELEMENT in node);
+ if (notSVG && /-/.test(node.nodeName)) {
+ var Class = getCEClass(node);
+ if (Class) node = Class.prototype;
+ }
+ return notSVG && name in node;
+ }
+
+ // use a placeholder and resolve with the right callback
+ function invokeAtDistance(callback, value) {
+ callback(value.placeholder);
+ if ('text' in value) {
+ Promise.resolve(value.text).then(String).then(callback);
+ } else if ('any' in value) {
+ Promise.resolve(value.any).then(callback);
+ } else if ('html' in value) {
+ Promise.resolve(value.html).then(asHTML).then(callback);
+ } else {
+ Promise.resolve(invokeTransformer(value)).then(callback);
+ }
+ }
+
+ // last attempt to transform content
+ function invokeTransformer(object) {
+ for (var key in transformers) {
+ if (object.hasOwnProperty(key)) {
+ return transformers[key](object[key]);
+ }
+ }
+ }
+
+ // quick and dirty Node check
+ function isNode_ish(value) {
+ return 'ELEMENT_NODE' in value;
+ }
+
+ // quick and dirty Promise check
+ function isPromise_ish(value) {
+ return value != null && 'then' in value;
+ }
+
+ // return a descriptor that lazily initialize a property
+ // unless it hasn't be previously set directly
+ function lazyGetter(type, fn) {
+ var secret = '_' + type + '$';
+ return {
+ get: function () {
+ return this[secret] || (this[type] = fn.call(this, type));
+ },
+ set: function (value) {
+ defineProperty(this, secret, {configurable: true, value: value});
+ }
+ };
+ }
+
+ // remove a list of [node, attribute]
+ function removeAttributeList(list) {
+ for (var i = 0, length = list.length; i < length; i++) {
+ list[i++].removeAttribute(list[i]);
+ }
+ }
+
+ // specify the content to update
+ function setContent(info, target, removeAttributes, childNodes) {
+ var update;
+ switch (info.type) {
+ case 'any':
+ // TODO: don't pass the target, it shouldn't be needed
+ update = setAnyContent(target, childNodes, new Aura(target, childNodes));
+ break;
+ case 'attr':
+ update = setAttribute(target, removeAttributes, info.name);
+ break;
+ case 'text':
+ update = setTextContent(target);
+ break;
+ }
+ return update;
+ }
+
+ // used for common path creation.
+ function Path(type, node, name) {
+ return {type: type, path: createPath(node), name: name};
+ }
+
+ // ---------------------------------------------
+ // Hybrid Shims
+ // ---------------------------------------------
+
+ // WeakMap with partial EXPANDO fallback
+ var $WeakMap = typeof WeakMap === typeof $WeakMap ?
+ function () {
+ return {
+ get: function (obj) { return obj[EXPANDO]; },
+ set: function (obj, value) {
+ Object.defineProperty(obj, EXPANDO, {
+ configurable: true,
+ value: value
+ });
+ }
+ };
+ } :
+ WeakMap;
+
+ // Map with partial double Array fallback
+ var $Map = typeof Map === typeof $Map ?
+ function () {
+ var k = [], v = [];
+ return {
+ get: function (obj) {
+ return v[k.indexOf(obj)];
+ },
+ // being used with unique template literals
+ // there is never a case when a value is overwritten
+ // no need to check upfront for the indexOf
+ set: function (obj, value) {
+ v[k.push(obj) - 1] = value;
+ }
+ };
+ } :
+ Map;
+
+ // TODO: which browser needs these partial polyfills here?
+
+ // BB7 and webOS need this
+ var isArray = Array.isArray ||
+ (function () {
+ var toString = {}.toString;
+ // I once had an engine returning [array Array]
+ // and I've got scared since!
+ var s = toString.call([]);
+ return function (a) {
+ return toString.call(a) === s;
+ };
+ }());
+
+ // older WebKit need this
+ var trim = EXPANDO.trim ||
+ function () { return this.replace(/^\s+|\s+$/g, ''); };
+
+ // ---------------------------------------------
+ // Shared variables
+ // ---------------------------------------------
+
+ // recycled defineProperty shortcut
+ var defineProperty = Object.defineProperty;
+
+ // transformers registry
+ var transformers = {};
+
+ // normalize Firefox issue with template literals
+ var templateObjects = {}, unique;
+ function unique(template) {
+ var key = '_' + template.join(UIDC);
+ return templateObjects[key] ||
+ (templateObjects[key] = template);
+ }
+
+ // use native .append(...childNodes) where available
+ var appendNodes = 'append' in featureFragment ?
+ function (node, childNodes) {
+ node.append.apply(node, childNodes);
+ } :
+ function appendNodes(node, childNodes) {
+ for (var
+ i = 0,
+ length = childNodes.length;
+ i < length; i++
+ ) {
+ node.appendChild(childNodes[i]);
+ }
+ };
+
+ // returns children or retrieve them in IE/Edge
+ var getChildren = WK || IE ?
+ function (node) {
+ for (var
+ child,
+ children = [],
+ childNodes = node.childNodes,
+ j = 0, i = 0, length = childNodes.length;
+ i < length; i++
+ ) {
+ child = childNodes[i];
+ if (child.nodeType === ELEMENT_NODE)
+ children[j++] = child;
+ }
+ return children;
+ } :
+ function (node) { return node.children; };
+
+ // return the correct node walking through a path
+ // fixes IE/Edge issues with attributes and children (fixes old WebKit too)
+ var getNode = IE || WK ?
+ function (parentNode, path) {
+ for (var name, i = 0, length = path.length; i < length; i++) {
+ name = path[i++];
+ switch (name) {
+ case 'children':
+ parentNode = getChildren(parentNode)[path[i]];
+ break;
+ default:
+ parentNode = parentNode[name][path[i]];
+ break;
+ }
+ }
+ return parentNode;
+ } :
+ function (parentNode, path) {
+ for (var i = 0, length = path.length; i < length; i++) {
+ parentNode = parentNode[path[i++]][path[i]];
+ }
+ return parentNode;
+ };
+
+ // sanitizes interpolations as comments
+ var no = /(<[a-z]+[a-z0-9:_-]*)((?:[^\S]+[a-z0-9:_-]+(?:=(?:'.*?'|".*?"|<.+?>|\S+))?)+)([^\S]*\/?>)/gi;
+ var findAttributes = new RegExp('([^\\S][a-z]+[a-z0-9:_-]*=)([\'"]?)' + UIDC + '\\2', 'gi');
+ var comments = function ($0, $1, $2, $3) {
+ return $1 + $2.replace(findAttributes, replaceAttributes) + $3;
+ };
+
+ var replaceAttributes = function ($0, $1, $2) {
+ return $1 + ($2 || '"') + UID + ($2 || '"');
+ };
+
+ // [element] = {template, updates};
+ var hypers = new $WeakMap;
+
+ // [element] = {template, updates};
+ var wires = new $WeakMap;
+
+ // [template] = {fragment, paths};
+ var templates = new $Map;
+
+ // internal signal to switch adoption
+ var notAdopting = true;
+
+ // IE 11 has problems with cloning templates too
+ // it "forgets" empty childNodes
+ var cloneNode = (function () {
+ featureFragment.appendChild(createText(featureFragment, 'g'));
+ featureFragment.appendChild(createText(featureFragment, ''));
+ return featureFragment.cloneNode(true).childNodes.length === 1 ?
+ function (node) {
+ for (var
+ clone = node.cloneNode(),
+ childNodes = node.childNodes || [],
+ i = 0, length = childNodes.length;
+ i < length; i++
+ ) {
+ clone.appendChild(cloneNode(childNodes[i]));
+ }
+ return clone;
+ } :
+ function (fragment) {
+ return fragment.cloneNode(true);
+ };
+ }());
+
+ // ---------------------------------------------
+ // Adopting Nodes
+ // ---------------------------------------------
+
+ // IE/Edge gotcha with comment nodes
+ var nextElementSibling = IE ?
+ function (node) {
+ while (node = node.nextSibling) {
+ if (node.nodeType === ELEMENT_NODE) return node;
+ }
+ return undefined;
+ } :
+ function (node) { return node.nextElementSibling; };
+
+ var previousElementSibling = IE ?
+ function (node) {
+ while (node = node.previousSibling) {
+ if (node.nodeType === ELEMENT_NODE) return node;
+ }
+ return undefined;
+ } :
+ function (node) { return node.previousElementSibling; };
+
+ // remove all text nodes from a virtual space
+ function removePreviousText(parentNode, node) {
+ var previousSibling = node.previousSibling;
+ if (previousSibling && previousSibling.nodeType === TEXT_NODE) {
+ parentNode.removeChild(previousSibling);
+ removePreviousText(parentNode, node);
+ }
+ }
+
+ // avoid errors on obsolete platforms
+ function insertBefore(parentNode, target, after) {
+ if (after) {
+ parentNode.insertBefore(target, after);
+ } else {
+ parentNode.appendChild(target);
+ }
+ }
+
+ // given an info, tries to find out the best option
+ // to replace or update the content
+ function discoverNode(parentNode, virtual, info, childNodes) {
+ for (var
+ target = parentNode,
+ document = parentNode.ownerDocument,
+ path = info.path,
+ virtualNode = getNode(virtual, path),
+ i = 0,
+ length = path.length;
+ i < length; i++
+ ) {
+ switch (path[i++]) {
+ case 'attributes':
+ var name = virtualNode.name;
+ if (!parentNode.hasAttribute(name)) {
+ parentNode.setAttribute(name, '');
+ }
+ target = parentNode.attributes[name];
+ break;
+ case 'childNodes':
+ var children = getChildren(parentNode);
+ var virtualChildren = getChildren(virtualNode.parentNode);
+ target = previousElementSibling(virtualNode);
+ var before = target ? (path.indexOf.call(virtualChildren, target) + 1) : -1;
+ target = nextElementSibling(virtualNode);
+ var after = target ? path.indexOf.call(virtualChildren, target) : -1;
+ target = document.createComment(UID);
+ switch (true) {
+ // `${'virtual'}` is actually resolved as `${'any'}`
+ // case before < 0 && after < 0: before = 0;
+
+ // `</a>${'virtual'}`
+ case after < 0:
+ after = children.length;
+ break;
+ // `${'virtual'}<b>`
+ case before < 0:
+ before = 0;
+ // `</a>${'virtual'}<b>`
+ default:
+ after = -(virtualChildren.length - after);
+ break;
+ }
+ childNodes.push.apply(
+ childNodes,
+ slice.call(children, before, after)
+ );
+ if (childNodes.length) {
+ insertBefore(
+ parentNode,
+ target,
+ nextElementSibling(childNodes[childNodes.length - 1])
+ );
+ } else {
+ insertBefore(
+ parentNode,
+ target,
+ slice.call(children, after)[0]
+ );
+ }
+ if (childNodes.length === 0) {
+ removePreviousText(parentNode, target);
+ }
+ break;
+ default:
+ // if the node is not there, create it
+ target = getChildren(parentNode)[path[i]] ||
+ parentNode.appendChild(
+ parentNode.ownerDocument.createElement(
+ getNode(virtual, path.slice(0, i + 1)).nodeName
+ )
+ );
+ parentNode = target;
+ break;
+ }
+ }
+ return target;
+ }
+
+ // like createUpdates but for nodes with already a content
+ function discoverUpdates(fragment, paths) {
+ for (var
+ info, childNodes,
+ updates = [],
+ removeAttributes = [],
+ i = 0, length = paths.length;
+ i < length; i++
+ ) {
+ childNodes = [];
+ info = paths[i];
+ updates[i] = setContent(
+ info,
+ discoverNode(this, fragment, info, childNodes),
+ removeAttributes,
+ childNodes
+ );
+ }
+ removeAttributeList(removeAttributes);
+ return updates;
+ }
+
+ // ---------------------------------------------
+ // Template related utilities
+ // ---------------------------------------------
+
+ // given a unique template object
+ // create, parse, and store retrieved info
+ function createTemplate(template) {
+ var paths = [];
+ var fragment = createFragment(this, template.join(UIDC));
+ var info = {fragment: fragment, paths: paths};
+ hyperSeeker(fragment, paths, template.slice());
+ templates.set(template, info);
+ return info;
+ }
+
+ // given a generic node, returns a path capable
+ // of retrieving such path back again.
+ // TODO: worth passing the index when available ?
+ function createPath(node) {
+ var path = [];
+ var parentNode;
+ switch(node.nodeType) {
+ case ELEMENT_NODE:
+ case DOCUMENT_FRAGMENT_NODE:
+ parentNode = node;
+ break;
+ case COMMENT_NODE:
+ parentNode = node.parentNode;
+ path.unshift(
+ 'childNodes',
+ path.indexOf.call(parentNode.childNodes, node)
+ );
+ break;
+ case ATTRIBUTE_NODE:
+ default: // jsdom here does not provide a nodeType 2 ...
+ parentNode = node.ownerElement;
+ path.unshift('attributes', node.name);
+ break;
+ }
+ for (
+ node = parentNode;
+ parentNode = parentNode.parentNode;
+ node = parentNode
+ ) {
+ path.unshift('children', path.indexOf.call(getChildren(parentNode), node));
+ }
+ return path;
+ }
+
+ // given a root node and a list of paths
+ // creates an array of updates to invoke
+ // whenever the next interpolation happens
+ function createUpdates(fragment, paths) {
+ for (var
+ info,
+ updates = [],
+ removeAttributes = [],
+ i = 0, length = paths.length;
+ i < length; i++
+ ) {
+ info = paths[i];
+ updates[i] = setContent(
+ info,
+ getNode(fragment, info.path),
+ removeAttributes,
+ []
+ );
+ }
+ removeAttributeList(removeAttributes);
+ return updates;
+ }
+
+ // invokes each update function passing interpolated value
+ function update() {
+ for (var i = 1, length = arguments.length; i < length; i++) {
+ this[i - 1](arguments[i]);
+ }
+ }
+
+ // create a template, if unknown
+ // upgrade a node to use such template for future updates
+ function upgrade(template) {
+ template = TL(template);
+ var updates;
+ var info = templates.get(template) ||
+ createTemplate.call(this, template);
+ if (notAdopting) {
+ var fragment = cloneNode(info.fragment);
+ updates = createUpdates.call(this, fragment, info.paths);
+ this.textContent = '';
+ this.appendChild(fragment);
+ } else {
+ updates = discoverUpdates.call(this, info.fragment, info.paths);
+ }
+ return {template: template, updates: updates};
+ }
+
+ // ---------------------------------------------
+ // Wires
+ // ---------------------------------------------
+
+ // create a new wire for generic DOM content
+ function wireContent(type) {
+ var adopter, content, container, fragment, render, setup, template;
+
+ function before(document) {
+ fragment = createDocumentFragment(document);
+ container = type === 'svg' ?
+ document.createElementNS(SVG_NAMESPACE, 'svg') :
+ fragment;
+ render = bind(container);
+ }
+
+ function after() {
+ if (setup) {
+ setup = false;
+ if (type === 'svg') {
+ appendNodes(fragment, slice.call(container.childNodes));
+ }
+ content = createContent(fragment);
+ }
+ return content;
+ }
+
+ return type === 'adopt' ?
+ function adopt(statics) {
+ var args = arguments;
+ statics = TL(statics);
+ if (template !== statics) {
+ setup = true;
+ template = statics;
+ adopter = function (parentNode, children, i) {
+ if (setup) {
+ if (i < children.length) {
+ container = children[i];
+ fragment = {
+ ownerDocument: container.ownerDocument,
+ childNodes: [container],
+ children: [container]
+ };
+ render = hyper.adopt(fragment);
+ } else {
+ if (OWNER_SVG_ELEMENT in parentNode) type = 'svg';
+ before(parentNode.ownerDocument);
+ }
+ }
+ render.apply(null, args);
+ return after();
+ };
+ }
+ return adopter;
+ } :
+ function update(statics) {
+ statics = TL(statics);
+ if (template !== statics) {
+ setup = true;
+ template = statics;
+ before(hyper.document);
+ }
+ render.apply(null, arguments);
+ return after();
+ };
+ }
+
+ // setup a weak reference if needed and return a wire by ID
+ function wireWeakly(obj, type) {
+ var wire = wires.get(obj);
+ var i = type.indexOf(':');
+ var id = type;
+ if (-1 < i) {
+ id = type.slice(i + 1);
+ type = type.slice(0, i) || 'html';
+ }
+ if (!wire) {
+ wire = {};
+ wires.set(obj, wire);
+ }
+ return wire[id] || (wire[id] = wireContent(type));
+ }
+
+ // avoid processing too many nodes
+ // this is about the algorithm used
+ // to calculate the least amount of DOM
+ // changes needed to show the a new list
+ // where there was another one.
+ // There is a limit, in terms of performance,
+ // on how big can the optimal computation be,
+ // so if you change this value be sure your
+ // target hardware is good enough.
+ hyper.MAX_LIST_SIZE = 1000;
+
+ // ---------------------------------------------
+ // ⚡️ ️️The End ➰
+ // ---------------------------------------------
+ return hyper;
+
+}(document, function () {'use strict';
+
+ /*! Copyright (c) 2017, Andrea Giammarchi, @WebReflection */
+
+ // grid operations
+ var
+ DELETE = 'del',
+ INSERT = 'ins',
+ SUBSTITUTE = 'sub',
+ TypedArray = /^u/.test(typeof Int32Array) ? Array : Int32Array
+ ;
+
+ // readapted from:
+ // http://webreflection.blogspot.co.uk/2009/02/levenshtein-algorithm-revisited-25.html
+ function majinbuu(from, to, MAX_SIZE) {
+ var
+ fromLength = from.length,
+ toLength = to.length,
+ TOO_MANY = (MAX_SIZE || Infinity) < Math.sqrt(fromLength * toLength)
+ ;
+ if (fromLength < 1 || TOO_MANY) {
+ if (toLength || TOO_MANY) {
+ from.splice.apply(from, [0, fromLength].concat(to));
+ }
+ return;
+ }
+ if (toLength < 1) {
+ from.splice(0);
+ return;
+ }
+ performOperations(
+ from,
+ getOperations(from, to, levenstein(from, to))
+ );
+ }
+
+ // given an object that would like to intercept
+ // all splice operations performed through a list,
+ // wraps the list.splice method to delegate such object
+ // and it puts back original splice right before
+ // every invocation.
+ // Note: do not use the same list in two different aura
+ majinbuu.aura = function aura(splicer, list) {
+ var splice = list.splice;
+ list.splice = function hodor() {
+ list.splice = splice;
+ var result = splicer.splice.apply(splicer, arguments);
+ list.splice = hodor;
+ return result;
+ };
+ return list;
+ };
+
+ return majinbuu;
+
+ // Helpers - - - - - - - - - - - - - - - - - - - - - -
+
+ // originally readapted from:
+ // http://webreflection.blogspot.co.uk/2009/02/levenshtein-algorithm-revisited-25.html
+ // then rewritten in C for Emscripten (see levenstein.c)
+ // then "screw you ASM" due no much gain but very bloated code
+ function levenstein(from, to) {
+ var fromLength = from.length + 1;
+ var toLength = to.length + 1;
+ var size = fromLength * toLength;
+ var x = 0;
+ var y = 0;
+ var X = 0;
+ var Y = 0;
+ var crow = 0;
+ var prow = 0;
+ var del, ins, sub;
+ var grid = new TypedArray(size);
+ grid[0] = 0;
+ while (++x < toLength) grid[x] = x;
+ while (++y < fromLength) {
+ X = x = 0;
+ crow = y * toLength;
+ prow = Y * toLength;
+ grid[crow + x] = y;
+ while (++x < toLength) {
+ del = grid[prow + x] + 1;
+ ins = grid[crow + X] + 1;
+ sub = grid[prow + X] + (from[Y] == to[X] ? 0 : 1);
+ grid[crow + x] = del < ins ?
+ (del < sub ?
+ del : sub) :
+ (ins < sub ?
+ ins : sub);
+ ++X;
+ };
+ ++Y;
+ }
+ return grid;
+ }
+
+ // add operations (in reversed order)
+ function addOperation(list, type, x, y, count, items) {
+ list.unshift({
+ type: type,
+ x: x,
+ y: y,
+ count: count,
+ items: items
+ });
+ }
+
+ // walk the Levenshtein grid bottom -> up
+ function getOperations(Y, X, grid) {
+ var
+ list = [],
+ YL = Y.length + 1,
+ XL = X.length + 1,
+ y = YL - 1,
+ x = XL - 1,
+ cell, top, left, diagonal,
+ crow, prow
+ ;
+ while (x && y) {
+ crow = y * XL;
+ prow = (y - 1) * XL;
+ cell = grid[crow + x];
+ top = grid[prow + x];
+ left = grid[crow + x - 1];
+ diagonal = grid[prow + x - 1];
+ if (diagonal <= left && diagonal <= top && diagonal <= cell) {
+ x--;
+ y--;
+ if (diagonal < cell) {
+ addOperation(list, SUBSTITUTE, x, y, 1, [X[x]]);
+ }
+ }
+ else if (left <= top && left <= cell) {
+ x--;
+ addOperation(list, INSERT, x, y, 0, [X[x]]);
+ }
+ else {
+ y--;
+ addOperation(list, DELETE, x, y, 1, []);
+ }
+ }
+ while (x--) {
+ addOperation(list, INSERT, x, y, 0, [X[x]]);
+ }
+ while (y--) {
+ addOperation(list, DELETE, x, y, 1, []);
+ }
+ return list;
+ }
+
+ /* grouped operations */
+ function performOperations(target, operations) {
+ var
+ diff = 0,
+ i = 1,
+ length = operations.length,
+ curr, prev, op
+ ;
+ if (length) {
+ op = (prev = operations[0]);
+ while (i < length) {
+ curr = operations[i++];
+ if (prev.type === curr.type && (curr.x - prev.x) <= 1 && (curr.y - prev.y) <= 1) {
+ op.count += curr.count;
+ op.items = op.items.concat(curr.items);
+ } else {
+ target.splice.apply(target, [op.y + diff, op.count].concat(op.items));
+ diff += op.type === INSERT ?
+ op.items.length : (op.type === DELETE ?
+ -op.count : 0);
+ op = curr;
+ }
+ prev = curr;
+ }
+ target.splice.apply(target, [op.y + diff, op.count].concat(op.items));
+ }
+ }
+
+ /* one-by-one operation (testing purpose)
+ function performOperations(target, operations) {
+ for (var op, diff = 0, i = 0, length = operations.length; i < length; i++) {
+ op = operations[i];
+ target.splice.apply(target, [op.y + diff, op.count].concat(op.items));
+ diff += op.type === INSERT ?
+ op.items.length : (op.type === DELETE ?
+ -op.count : 0);
+ }
+ }
+ // */
+
+}()));
+
+// umd.KISS
+try { module.exports = hyperHTML; } catch(o_O) {} |
+