File: sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.sourcemap.txt

package info (click to toggle)
node-typescript 3.3.3333-1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 324,548 kB
  • sloc: makefile: 6; sh: 3
file content (2685 lines) | stat: -rw-r--r-- 126,499 bytes parent folder | download
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
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
===================================================================
JsFile: sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.js
mapUrl: sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.js.map
sourceRoot: 
sources: sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.ts
===================================================================
-------------------------------------------------------------------
emittedFile:tests/cases/compiler/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.js
sourceFile:sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.ts
-------------------------------------------------------------------
>>>var robotA = [1, "mower", "mowing"];
1 >
2 >^^^^
3 >    ^^^^^^
4 >          ^^^
5 >             ^
6 >              ^
7 >               ^^
8 >                 ^^^^^^^
9 >                        ^^
10>                          ^^^^^^^^
11>                                  ^
12>                                   ^
13>                                    ^^^^^->
1 >declare var console: {
  >    log(msg: any): void;
  >}
  >type Robot = [number, string, string];
  >type MultiSkilledRobot = [string, [string, string]];
  >
  >
2 >let 
3 >    robotA
4 >          : Robot = 
5 >             [
6 >              1
7 >               , 
8 >                 "mower"
9 >                        , 
10>                          "mowing"
11>                                  ]
12>                                   ;
1 >Emitted(1, 1) Source(7, 1) + SourceIndex(0)
2 >Emitted(1, 5) Source(7, 5) + SourceIndex(0)
3 >Emitted(1, 11) Source(7, 11) + SourceIndex(0)
4 >Emitted(1, 14) Source(7, 21) + SourceIndex(0)
5 >Emitted(1, 15) Source(7, 22) + SourceIndex(0)
6 >Emitted(1, 16) Source(7, 23) + SourceIndex(0)
7 >Emitted(1, 18) Source(7, 25) + SourceIndex(0)
8 >Emitted(1, 25) Source(7, 32) + SourceIndex(0)
9 >Emitted(1, 27) Source(7, 34) + SourceIndex(0)
10>Emitted(1, 35) Source(7, 42) + SourceIndex(0)
11>Emitted(1, 36) Source(7, 43) + SourceIndex(0)
12>Emitted(1, 37) Source(7, 44) + SourceIndex(0)
---
>>>var robotB = [2, "trimmer", "trimming"];
1->
2 >^^^^
3 >    ^^^^^^
4 >          ^^^
5 >             ^
6 >              ^
7 >               ^^
8 >                 ^^^^^^^^^
9 >                          ^^
10>                            ^^^^^^^^^^
11>                                      ^
12>                                       ^
1->
  >
2 >let 
3 >    robotB
4 >          : Robot = 
5 >             [
6 >              2
7 >               , 
8 >                 "trimmer"
9 >                          , 
10>                            "trimming"
11>                                      ]
12>                                       ;
1->Emitted(2, 1) Source(8, 1) + SourceIndex(0)
2 >Emitted(2, 5) Source(8, 5) + SourceIndex(0)
3 >Emitted(2, 11) Source(8, 11) + SourceIndex(0)
4 >Emitted(2, 14) Source(8, 21) + SourceIndex(0)
5 >Emitted(2, 15) Source(8, 22) + SourceIndex(0)
6 >Emitted(2, 16) Source(8, 23) + SourceIndex(0)
7 >Emitted(2, 18) Source(8, 25) + SourceIndex(0)
8 >Emitted(2, 27) Source(8, 34) + SourceIndex(0)
9 >Emitted(2, 29) Source(8, 36) + SourceIndex(0)
10>Emitted(2, 39) Source(8, 46) + SourceIndex(0)
11>Emitted(2, 40) Source(8, 47) + SourceIndex(0)
12>Emitted(2, 41) Source(8, 48) + SourceIndex(0)
---
>>>var robots = [robotA, robotB];
1 >
2 >^^^^
3 >    ^^^^^^
4 >          ^^^
5 >             ^
6 >              ^^^^^^
7 >                    ^^
8 >                      ^^^^^^
9 >                            ^
10>                             ^
1 >
  >
2 >let 
3 >    robots
4 >           = 
5 >             [
6 >              robotA
7 >                    , 
8 >                      robotB
9 >                            ]
10>                             ;
1 >Emitted(3, 1) Source(9, 1) + SourceIndex(0)
2 >Emitted(3, 5) Source(9, 5) + SourceIndex(0)
3 >Emitted(3, 11) Source(9, 11) + SourceIndex(0)
4 >Emitted(3, 14) Source(9, 14) + SourceIndex(0)
5 >Emitted(3, 15) Source(9, 15) + SourceIndex(0)
6 >Emitted(3, 21) Source(9, 21) + SourceIndex(0)
7 >Emitted(3, 23) Source(9, 23) + SourceIndex(0)
8 >Emitted(3, 29) Source(9, 29) + SourceIndex(0)
9 >Emitted(3, 30) Source(9, 30) + SourceIndex(0)
10>Emitted(3, 31) Source(9, 31) + SourceIndex(0)
---
>>>function getRobots() {
1 >
2 >^^^^^^^^^
3 >         ^^^^^^^^^
4 >                  ^->
1 >
  >
2 >function 
3 >         getRobots
1 >Emitted(4, 1) Source(10, 1) + SourceIndex(0)
2 >Emitted(4, 10) Source(10, 10) + SourceIndex(0)
3 >Emitted(4, 19) Source(10, 19) + SourceIndex(0)
---
>>>    return robots;
1->^^^^
2 >    ^^^^^^^
3 >           ^^^^^^
4 >                 ^
1->() {
  >    
2 >    return 
3 >           robots
4 >                 ;
1->Emitted(5, 5) Source(11, 5) + SourceIndex(0)
2 >Emitted(5, 12) Source(11, 12) + SourceIndex(0)
3 >Emitted(5, 18) Source(11, 18) + SourceIndex(0)
4 >Emitted(5, 19) Source(11, 19) + SourceIndex(0)
---
>>>}
1 >
2 >^
3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >
2 >}
1 >Emitted(6, 1) Source(12, 1) + SourceIndex(0)
2 >Emitted(6, 2) Source(12, 2) + SourceIndex(0)
---
>>>var multiRobotA = ["mower", ["mowing", ""]];
1->
2 >^^^^
3 >    ^^^^^^^^^^^
4 >               ^^^
5 >                  ^
6 >                   ^^^^^^^
7 >                          ^^
8 >                            ^
9 >                             ^^^^^^^^
10>                                     ^^
11>                                       ^^
12>                                         ^
13>                                          ^
14>                                           ^
15>                                            ^^^^^^^^^^^->
1->
  >
  >
2 >let 
3 >    multiRobotA
4 >               : MultiSkilledRobot = 
5 >                  [
6 >                   "mower"
7 >                          , 
8 >                            [
9 >                             "mowing"
10>                                     , 
11>                                       ""
12>                                         ]
13>                                          ]
14>                                           ;
1->Emitted(7, 1) Source(14, 1) + SourceIndex(0)
2 >Emitted(7, 5) Source(14, 5) + SourceIndex(0)
3 >Emitted(7, 16) Source(14, 16) + SourceIndex(0)
4 >Emitted(7, 19) Source(14, 38) + SourceIndex(0)
5 >Emitted(7, 20) Source(14, 39) + SourceIndex(0)
6 >Emitted(7, 27) Source(14, 46) + SourceIndex(0)
7 >Emitted(7, 29) Source(14, 48) + SourceIndex(0)
8 >Emitted(7, 30) Source(14, 49) + SourceIndex(0)
9 >Emitted(7, 38) Source(14, 57) + SourceIndex(0)
10>Emitted(7, 40) Source(14, 59) + SourceIndex(0)
11>Emitted(7, 42) Source(14, 61) + SourceIndex(0)
12>Emitted(7, 43) Source(14, 62) + SourceIndex(0)
13>Emitted(7, 44) Source(14, 63) + SourceIndex(0)
14>Emitted(7, 45) Source(14, 64) + SourceIndex(0)
---
>>>var multiRobotB = ["trimmer", ["trimming", "edging"]];
1->
2 >^^^^
3 >    ^^^^^^^^^^^
4 >               ^^^
5 >                  ^
6 >                   ^^^^^^^^^
7 >                            ^^
8 >                              ^
9 >                               ^^^^^^^^^^
10>                                         ^^
11>                                           ^^^^^^^^
12>                                                   ^
13>                                                    ^
14>                                                     ^
1->
  >
2 >let 
3 >    multiRobotB
4 >               : MultiSkilledRobot = 
5 >                  [
6 >                   "trimmer"
7 >                            , 
8 >                              [
9 >                               "trimming"
10>                                         , 
11>                                           "edging"
12>                                                   ]
13>                                                    ]
14>                                                     ;
1->Emitted(8, 1) Source(15, 1) + SourceIndex(0)
2 >Emitted(8, 5) Source(15, 5) + SourceIndex(0)
3 >Emitted(8, 16) Source(15, 16) + SourceIndex(0)
4 >Emitted(8, 19) Source(15, 38) + SourceIndex(0)
5 >Emitted(8, 20) Source(15, 39) + SourceIndex(0)
6 >Emitted(8, 29) Source(15, 48) + SourceIndex(0)
7 >Emitted(8, 31) Source(15, 50) + SourceIndex(0)
8 >Emitted(8, 32) Source(15, 51) + SourceIndex(0)
9 >Emitted(8, 42) Source(15, 61) + SourceIndex(0)
10>Emitted(8, 44) Source(15, 63) + SourceIndex(0)
11>Emitted(8, 52) Source(15, 71) + SourceIndex(0)
12>Emitted(8, 53) Source(15, 72) + SourceIndex(0)
13>Emitted(8, 54) Source(15, 73) + SourceIndex(0)
14>Emitted(8, 55) Source(15, 74) + SourceIndex(0)
---
>>>var multiRobots = [multiRobotA, multiRobotB];
1 >
2 >^^^^
3 >    ^^^^^^^^^^^
4 >               ^^^
5 >                  ^
6 >                   ^^^^^^^^^^^
7 >                              ^^
8 >                                ^^^^^^^^^^^
9 >                                           ^
10>                                            ^
1 >
  >
2 >let 
3 >    multiRobots
4 >                = 
5 >                  [
6 >                   multiRobotA
7 >                              , 
8 >                                multiRobotB
9 >                                           ]
10>                                            ;
1 >Emitted(9, 1) Source(16, 1) + SourceIndex(0)
2 >Emitted(9, 5) Source(16, 5) + SourceIndex(0)
3 >Emitted(9, 16) Source(16, 16) + SourceIndex(0)
4 >Emitted(9, 19) Source(16, 19) + SourceIndex(0)
5 >Emitted(9, 20) Source(16, 20) + SourceIndex(0)
6 >Emitted(9, 31) Source(16, 31) + SourceIndex(0)
7 >Emitted(9, 33) Source(16, 33) + SourceIndex(0)
8 >Emitted(9, 44) Source(16, 44) + SourceIndex(0)
9 >Emitted(9, 45) Source(16, 45) + SourceIndex(0)
10>Emitted(9, 46) Source(16, 46) + SourceIndex(0)
---
>>>function getMultiRobots() {
1 >
2 >^^^^^^^^^
3 >         ^^^^^^^^^^^^^^
4 >                       ^->
1 >
  >
2 >function 
3 >         getMultiRobots
1 >Emitted(10, 1) Source(17, 1) + SourceIndex(0)
2 >Emitted(10, 10) Source(17, 10) + SourceIndex(0)
3 >Emitted(10, 24) Source(17, 24) + SourceIndex(0)
---
>>>    return multiRobots;
1->^^^^
2 >    ^^^^^^^
3 >           ^^^^^^^^^^^
4 >                      ^
1->() {
  >    
2 >    return 
3 >           multiRobots
4 >                      ;
1->Emitted(11, 5) Source(18, 5) + SourceIndex(0)
2 >Emitted(11, 12) Source(18, 12) + SourceIndex(0)
3 >Emitted(11, 23) Source(18, 23) + SourceIndex(0)
4 >Emitted(11, 24) Source(18, 24) + SourceIndex(0)
---
>>>}
1 >
2 >^
3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >
2 >}
1 >Emitted(12, 1) Source(19, 1) + SourceIndex(0)
2 >Emitted(12, 2) Source(19, 2) + SourceIndex(0)
---
>>>for (var _i = 0, robots_1 = robots; _i < robots_1.length; _i++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^^^^^^^^^^^^^
6 >                                  ^^
7 >                                    ^^^^^^^^^^^^^^^^^^^^
8 >                                                        ^^
9 >                                                          ^^^^
10>                                                              ^^
11>                                                                ^^^^^^^^^^^^^^->
1->
  >
  >
2 >for (let [, nameA = "noName"] of 
3 >     robots
4 >               
5 >                 robots
6 >                                  
7 >                                    robots
8 >                                                        
9 >                                                          robots
10>                                                              ) 
1->Emitted(13, 1) Source(21, 1) + SourceIndex(0)
2 >Emitted(13, 6) Source(21, 34) + SourceIndex(0)
3 >Emitted(13, 16) Source(21, 40) + SourceIndex(0)
4 >Emitted(13, 18) Source(21, 34) + SourceIndex(0)
5 >Emitted(13, 35) Source(21, 40) + SourceIndex(0)
6 >Emitted(13, 37) Source(21, 34) + SourceIndex(0)
7 >Emitted(13, 57) Source(21, 40) + SourceIndex(0)
8 >Emitted(13, 59) Source(21, 34) + SourceIndex(0)
9 >Emitted(13, 63) Source(21, 40) + SourceIndex(0)
10>Emitted(13, 65) Source(21, 42) + SourceIndex(0)
---
>>>    var _a = robots_1[_i], _b = _a[1], nameA = _b === void 0 ? "noName" : _b;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^
4 >                         ^^
5 >                           ^^^^^^^^^^
6 >                                     ^^
7 >                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [, nameA = "noName"]
4 >                         
5 >                           nameA = "noName"
6 >                                     
7 >                                       nameA = "noName"
1->Emitted(14, 5) Source(21, 10) + SourceIndex(0)
2 >Emitted(14, 9) Source(21, 10) + SourceIndex(0)
3 >Emitted(14, 26) Source(21, 30) + SourceIndex(0)
4 >Emitted(14, 28) Source(21, 13) + SourceIndex(0)
5 >Emitted(14, 38) Source(21, 29) + SourceIndex(0)
6 >Emitted(14, 40) Source(21, 13) + SourceIndex(0)
7 >Emitted(14, 77) Source(21, 29) + SourceIndex(0)
---
>>>    console.log(nameA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^
7 >                     ^
8 >                      ^
1 >] of robots) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameA
7 >                     )
8 >                      ;
1 >Emitted(15, 5) Source(22, 5) + SourceIndex(0)
2 >Emitted(15, 12) Source(22, 12) + SourceIndex(0)
3 >Emitted(15, 13) Source(22, 13) + SourceIndex(0)
4 >Emitted(15, 16) Source(22, 16) + SourceIndex(0)
5 >Emitted(15, 17) Source(22, 17) + SourceIndex(0)
6 >Emitted(15, 22) Source(22, 22) + SourceIndex(0)
7 >Emitted(15, 23) Source(22, 23) + SourceIndex(0)
8 >Emitted(15, 24) Source(22, 24) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(16, 2) Source(23, 2) + SourceIndex(0)
---
>>>for (var _c = 0, _d = getRobots(); _c < _d.length; _c++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^
6 >                      ^^^^^^^^^
7 >                               ^^
8 >                                 ^^
9 >                                   ^^^^^^^^^^^^^^
10>                                                 ^^
11>                                                   ^^^^
12>                                                       ^^
13>                                                         ^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [, nameA = "noName"] of 
3 >     getRobots()
4 >               
5 >                 
6 >                      getRobots
7 >                               ()
8 >                                 
9 >                                   getRobots()
10>                                                 
11>                                                   getRobots()
12>                                                       ) 
1->Emitted(17, 1) Source(24, 1) + SourceIndex(0)
2 >Emitted(17, 6) Source(24, 34) + SourceIndex(0)
3 >Emitted(17, 16) Source(24, 45) + SourceIndex(0)
4 >Emitted(17, 18) Source(24, 34) + SourceIndex(0)
5 >Emitted(17, 23) Source(24, 34) + SourceIndex(0)
6 >Emitted(17, 32) Source(24, 43) + SourceIndex(0)
7 >Emitted(17, 34) Source(24, 45) + SourceIndex(0)
8 >Emitted(17, 36) Source(24, 34) + SourceIndex(0)
9 >Emitted(17, 50) Source(24, 45) + SourceIndex(0)
10>Emitted(17, 52) Source(24, 34) + SourceIndex(0)
11>Emitted(17, 56) Source(24, 45) + SourceIndex(0)
12>Emitted(17, 58) Source(24, 47) + SourceIndex(0)
---
>>>    var _e = _d[_c], _f = _e[1], nameA = _f === void 0 ? "noName" : _f;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^
4 >                   ^^
5 >                     ^^^^^^^^^^
6 >                               ^^
7 >                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [, nameA = "noName"]
4 >                   
5 >                     nameA = "noName"
6 >                               
7 >                                 nameA = "noName"
1->Emitted(18, 5) Source(24, 10) + SourceIndex(0)
2 >Emitted(18, 9) Source(24, 10) + SourceIndex(0)
3 >Emitted(18, 20) Source(24, 30) + SourceIndex(0)
4 >Emitted(18, 22) Source(24, 13) + SourceIndex(0)
5 >Emitted(18, 32) Source(24, 29) + SourceIndex(0)
6 >Emitted(18, 34) Source(24, 13) + SourceIndex(0)
7 >Emitted(18, 71) Source(24, 29) + SourceIndex(0)
---
>>>    console.log(nameA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^
7 >                     ^
8 >                      ^
1 >] of getRobots()) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameA
7 >                     )
8 >                      ;
1 >Emitted(19, 5) Source(25, 5) + SourceIndex(0)
2 >Emitted(19, 12) Source(25, 12) + SourceIndex(0)
3 >Emitted(19, 13) Source(25, 13) + SourceIndex(0)
4 >Emitted(19, 16) Source(25, 16) + SourceIndex(0)
5 >Emitted(19, 17) Source(25, 17) + SourceIndex(0)
6 >Emitted(19, 22) Source(25, 22) + SourceIndex(0)
7 >Emitted(19, 23) Source(25, 23) + SourceIndex(0)
8 >Emitted(19, 24) Source(25, 24) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(20, 2) Source(26, 2) + SourceIndex(0)
---
>>>for (var _g = 0, _h = [robotA, robotB]; _g < _h.length; _g++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^^
6 >                       ^^^^^^
7 >                             ^^
8 >                               ^^^^^^
9 >                                     ^
10>                                      ^^
11>                                        ^^^^^^^^^^^^^^
12>                                                      ^^
13>                                                        ^^^^
14>                                                            ^^
15>                                                              ^^^^^^^^^^->
1->
  >
2 >for (let [, nameA = "noName"] of 
3 >     [robotA, robotB]
4 >               
5 >                 [
6 >                       robotA
7 >                             , 
8 >                               robotB
9 >                                     ]
10>                                      
11>                                        [robotA, robotB]
12>                                                      
13>                                                        [robotA, robotB]
14>                                                            ) 
1->Emitted(21, 1) Source(27, 1) + SourceIndex(0)
2 >Emitted(21, 6) Source(27, 34) + SourceIndex(0)
3 >Emitted(21, 16) Source(27, 50) + SourceIndex(0)
4 >Emitted(21, 18) Source(27, 34) + SourceIndex(0)
5 >Emitted(21, 24) Source(27, 35) + SourceIndex(0)
6 >Emitted(21, 30) Source(27, 41) + SourceIndex(0)
7 >Emitted(21, 32) Source(27, 43) + SourceIndex(0)
8 >Emitted(21, 38) Source(27, 49) + SourceIndex(0)
9 >Emitted(21, 39) Source(27, 50) + SourceIndex(0)
10>Emitted(21, 41) Source(27, 34) + SourceIndex(0)
11>Emitted(21, 55) Source(27, 50) + SourceIndex(0)
12>Emitted(21, 57) Source(27, 34) + SourceIndex(0)
13>Emitted(21, 61) Source(27, 50) + SourceIndex(0)
14>Emitted(21, 63) Source(27, 52) + SourceIndex(0)
---
>>>    var _j = _h[_g], _k = _j[1], nameA = _k === void 0 ? "noName" : _k;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^
4 >                   ^^
5 >                     ^^^^^^^^^^
6 >                               ^^
7 >                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [, nameA = "noName"]
4 >                   
5 >                     nameA = "noName"
6 >                               
7 >                                 nameA = "noName"
1->Emitted(22, 5) Source(27, 10) + SourceIndex(0)
2 >Emitted(22, 9) Source(27, 10) + SourceIndex(0)
3 >Emitted(22, 20) Source(27, 30) + SourceIndex(0)
4 >Emitted(22, 22) Source(27, 13) + SourceIndex(0)
5 >Emitted(22, 32) Source(27, 29) + SourceIndex(0)
6 >Emitted(22, 34) Source(27, 13) + SourceIndex(0)
7 >Emitted(22, 71) Source(27, 29) + SourceIndex(0)
---
>>>    console.log(nameA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^
7 >                     ^
8 >                      ^
1 >] of [robotA, robotB]) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameA
7 >                     )
8 >                      ;
1 >Emitted(23, 5) Source(28, 5) + SourceIndex(0)
2 >Emitted(23, 12) Source(28, 12) + SourceIndex(0)
3 >Emitted(23, 13) Source(28, 13) + SourceIndex(0)
4 >Emitted(23, 16) Source(28, 16) + SourceIndex(0)
5 >Emitted(23, 17) Source(28, 17) + SourceIndex(0)
6 >Emitted(23, 22) Source(28, 22) + SourceIndex(0)
7 >Emitted(23, 23) Source(28, 23) + SourceIndex(0)
8 >Emitted(23, 24) Source(28, 24) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(24, 2) Source(29, 2) + SourceIndex(0)
---
>>>for (var _l = 0, multiRobots_1 = multiRobots; _l < multiRobots_1.length; _l++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
6 >                                            ^^
7 >                                              ^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                       ^^
9 >                                                                         ^^^^
10>                                                                             ^^
11>                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [, [
  >    primarySkillA = "primary",
  >    secondarySkillA = "secondary"
  >] = ["skill1", "skill2"]] of 
3 >     multiRobots
4 >               
5 >                 multiRobots
6 >                                            
7 >                                              multiRobots
8 >                                                                       
9 >                                                                         multiRobots
10>                                                                             ) 
1->Emitted(25, 1) Source(30, 1) + SourceIndex(0)
2 >Emitted(25, 6) Source(33, 30) + SourceIndex(0)
3 >Emitted(25, 16) Source(33, 41) + SourceIndex(0)
4 >Emitted(25, 18) Source(33, 30) + SourceIndex(0)
5 >Emitted(25, 45) Source(33, 41) + SourceIndex(0)
6 >Emitted(25, 47) Source(33, 30) + SourceIndex(0)
7 >Emitted(25, 72) Source(33, 41) + SourceIndex(0)
8 >Emitted(25, 74) Source(33, 30) + SourceIndex(0)
9 >Emitted(25, 78) Source(33, 41) + SourceIndex(0)
10>Emitted(25, 80) Source(33, 43) + SourceIndex(0)
---
>>>    var _m = multiRobots_1[_l], _o = _m[1], _p = _o === void 0 ? ["skill1", "skill2"] : _o, _q = _p[0], primarySkillA = _q === void 0 ? "primary" : _q, _r = _p[1], secondarySkillA = _r === void 0 ? "secondary" : _r;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^^^^^^
4 >                              ^^
5 >                                ^^^^^^^^^^
6 >                                          ^^
7 >                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                                          ^^
9 >                                                                                            ^^^^^^^^^^
10>                                                                                                      ^^
11>                                                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                                      ^^
13>                                                                                                                                                        ^^^^^^^^^^
14>                                                                                                                                                                  ^^
15>                                                                                                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [, [
  >            primarySkillA = "primary",
  >            secondarySkillA = "secondary"
  >        ] = ["skill1", "skill2"]]
4 >                              
5 >                                [
  >                                    primarySkillA = "primary",
  >                                    secondarySkillA = "secondary"
  >                                ] = ["skill1", "skill2"]
6 >                                          
7 >                                            [
  >                                                primarySkillA = "primary",
  >                                                secondarySkillA = "secondary"
  >                                            ] = ["skill1", "skill2"]
8 >                                                                                          
9 >                                                                                            primarySkillA = "primary"
10>                                                                                                      
11>                                                                                                        primarySkillA = "primary"
12>                                                                                                                                                      ,
  >                                                                                                                                                          
13>                                                                                                                                                        secondarySkillA = "secondary"
14>                                                                                                                                                                  
15>                                                                                                                                                                    secondarySkillA = "secondary"
1->Emitted(26, 5) Source(30, 10) + SourceIndex(0)
2 >Emitted(26, 9) Source(30, 10) + SourceIndex(0)
3 >Emitted(26, 31) Source(33, 26) + SourceIndex(0)
4 >Emitted(26, 33) Source(30, 13) + SourceIndex(0)
5 >Emitted(26, 43) Source(33, 25) + SourceIndex(0)
6 >Emitted(26, 45) Source(30, 13) + SourceIndex(0)
7 >Emitted(26, 91) Source(33, 25) + SourceIndex(0)
8 >Emitted(26, 93) Source(31, 5) + SourceIndex(0)
9 >Emitted(26, 103) Source(31, 30) + SourceIndex(0)
10>Emitted(26, 105) Source(31, 5) + SourceIndex(0)
11>Emitted(26, 151) Source(31, 30) + SourceIndex(0)
12>Emitted(26, 153) Source(32, 5) + SourceIndex(0)
13>Emitted(26, 163) Source(32, 34) + SourceIndex(0)
14>Emitted(26, 165) Source(32, 5) + SourceIndex(0)
15>Emitted(26, 215) Source(32, 34) + SourceIndex(0)
---
>>>    console.log(primarySkillA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^^^^^^^
7 >                             ^
8 >                              ^
1 >
  >] = ["skill1", "skill2"]] of multiRobots) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                primarySkillA
7 >                             )
8 >                              ;
1 >Emitted(27, 5) Source(34, 5) + SourceIndex(0)
2 >Emitted(27, 12) Source(34, 12) + SourceIndex(0)
3 >Emitted(27, 13) Source(34, 13) + SourceIndex(0)
4 >Emitted(27, 16) Source(34, 16) + SourceIndex(0)
5 >Emitted(27, 17) Source(34, 17) + SourceIndex(0)
6 >Emitted(27, 30) Source(34, 30) + SourceIndex(0)
7 >Emitted(27, 31) Source(34, 31) + SourceIndex(0)
8 >Emitted(27, 32) Source(34, 32) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(28, 2) Source(35, 2) + SourceIndex(0)
---
>>>for (var _s = 0, _t = getMultiRobots(); _s < _t.length; _s++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^
6 >                      ^^^^^^^^^^^^^^
7 >                                    ^^
8 >                                      ^^
9 >                                        ^^^^^^^^^^^^^^
10>                                                      ^^
11>                                                        ^^^^
12>                                                            ^^
13>                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [, [
  >    primarySkillA = "primary",
  >    secondarySkillA = "secondary"
  >] = ["skill1", "skill2"]] of 
3 >     getMultiRobots()
4 >               
5 >                 
6 >                      getMultiRobots
7 >                                    ()
8 >                                      
9 >                                        getMultiRobots()
10>                                                      
11>                                                        getMultiRobots()
12>                                                            ) 
1->Emitted(29, 1) Source(36, 1) + SourceIndex(0)
2 >Emitted(29, 6) Source(39, 30) + SourceIndex(0)
3 >Emitted(29, 16) Source(39, 46) + SourceIndex(0)
4 >Emitted(29, 18) Source(39, 30) + SourceIndex(0)
5 >Emitted(29, 23) Source(39, 30) + SourceIndex(0)
6 >Emitted(29, 37) Source(39, 44) + SourceIndex(0)
7 >Emitted(29, 39) Source(39, 46) + SourceIndex(0)
8 >Emitted(29, 41) Source(39, 30) + SourceIndex(0)
9 >Emitted(29, 55) Source(39, 46) + SourceIndex(0)
10>Emitted(29, 57) Source(39, 30) + SourceIndex(0)
11>Emitted(29, 61) Source(39, 46) + SourceIndex(0)
12>Emitted(29, 63) Source(39, 48) + SourceIndex(0)
---
>>>    var _u = _t[_s], _v = _u[1], _w = _v === void 0 ? ["skill1", "skill2"] : _v, _x = _w[0], primarySkillA = _x === void 0 ? "primary" : _x, _y = _w[1], secondarySkillA = _y === void 0 ? "secondary" : _y;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^
4 >                   ^^
5 >                     ^^^^^^^^^^
6 >                               ^^
7 >                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                               ^^
9 >                                                                                 ^^^^^^^^^^
10>                                                                                           ^^
11>                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                           ^^
13>                                                                                                                                             ^^^^^^^^^^
14>                                                                                                                                                       ^^
15>                                                                                                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [, [
  >            primarySkillA = "primary",
  >            secondarySkillA = "secondary"
  >        ] = ["skill1", "skill2"]]
4 >                   
5 >                     [
  >                         primarySkillA = "primary",
  >                         secondarySkillA = "secondary"
  >                     ] = ["skill1", "skill2"]
6 >                               
7 >                                 [
  >                                     primarySkillA = "primary",
  >                                     secondarySkillA = "secondary"
  >                                 ] = ["skill1", "skill2"]
8 >                                                                               
9 >                                                                                 primarySkillA = "primary"
10>                                                                                           
11>                                                                                             primarySkillA = "primary"
12>                                                                                                                                           ,
  >                                                                                                                                               
13>                                                                                                                                             secondarySkillA = "secondary"
14>                                                                                                                                                       
15>                                                                                                                                                         secondarySkillA = "secondary"
1->Emitted(30, 5) Source(36, 10) + SourceIndex(0)
2 >Emitted(30, 9) Source(36, 10) + SourceIndex(0)
3 >Emitted(30, 20) Source(39, 26) + SourceIndex(0)
4 >Emitted(30, 22) Source(36, 13) + SourceIndex(0)
5 >Emitted(30, 32) Source(39, 25) + SourceIndex(0)
6 >Emitted(30, 34) Source(36, 13) + SourceIndex(0)
7 >Emitted(30, 80) Source(39, 25) + SourceIndex(0)
8 >Emitted(30, 82) Source(37, 5) + SourceIndex(0)
9 >Emitted(30, 92) Source(37, 30) + SourceIndex(0)
10>Emitted(30, 94) Source(37, 5) + SourceIndex(0)
11>Emitted(30, 140) Source(37, 30) + SourceIndex(0)
12>Emitted(30, 142) Source(38, 5) + SourceIndex(0)
13>Emitted(30, 152) Source(38, 34) + SourceIndex(0)
14>Emitted(30, 154) Source(38, 5) + SourceIndex(0)
15>Emitted(30, 204) Source(38, 34) + SourceIndex(0)
---
>>>    console.log(primarySkillA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^^^^^^^
7 >                             ^
8 >                              ^
1 >
  >] = ["skill1", "skill2"]] of getMultiRobots()) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                primarySkillA
7 >                             )
8 >                              ;
1 >Emitted(31, 5) Source(40, 5) + SourceIndex(0)
2 >Emitted(31, 12) Source(40, 12) + SourceIndex(0)
3 >Emitted(31, 13) Source(40, 13) + SourceIndex(0)
4 >Emitted(31, 16) Source(40, 16) + SourceIndex(0)
5 >Emitted(31, 17) Source(40, 17) + SourceIndex(0)
6 >Emitted(31, 30) Source(40, 30) + SourceIndex(0)
7 >Emitted(31, 31) Source(40, 31) + SourceIndex(0)
8 >Emitted(31, 32) Source(40, 32) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(32, 2) Source(41, 2) + SourceIndex(0)
---
>>>for (var _z = 0, _0 = [multiRobotA, multiRobotB]; _z < _0.length; _z++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^^
6 >                       ^^^^^^^^^^^
7 >                                  ^^
8 >                                    ^^^^^^^^^^^
9 >                                               ^
10>                                                ^^
11>                                                  ^^^^^^^^^^^^^^
12>                                                                ^^
13>                                                                  ^^^^
14>                                                                      ^^
15>                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [, [
  >    primarySkillA = "primary",
  >    secondarySkillA = "secondary"
  >] = ["skill1", "skill2"]] of 
3 >     [multiRobotA, multiRobotB]
4 >               
5 >                 [
6 >                       multiRobotA
7 >                                  , 
8 >                                    multiRobotB
9 >                                               ]
10>                                                
11>                                                  [multiRobotA, multiRobotB]
12>                                                                
13>                                                                  [multiRobotA, multiRobotB]
14>                                                                      ) 
1->Emitted(33, 1) Source(42, 1) + SourceIndex(0)
2 >Emitted(33, 6) Source(45, 30) + SourceIndex(0)
3 >Emitted(33, 16) Source(45, 56) + SourceIndex(0)
4 >Emitted(33, 18) Source(45, 30) + SourceIndex(0)
5 >Emitted(33, 24) Source(45, 31) + SourceIndex(0)
6 >Emitted(33, 35) Source(45, 42) + SourceIndex(0)
7 >Emitted(33, 37) Source(45, 44) + SourceIndex(0)
8 >Emitted(33, 48) Source(45, 55) + SourceIndex(0)
9 >Emitted(33, 49) Source(45, 56) + SourceIndex(0)
10>Emitted(33, 51) Source(45, 30) + SourceIndex(0)
11>Emitted(33, 65) Source(45, 56) + SourceIndex(0)
12>Emitted(33, 67) Source(45, 30) + SourceIndex(0)
13>Emitted(33, 71) Source(45, 56) + SourceIndex(0)
14>Emitted(33, 73) Source(45, 58) + SourceIndex(0)
---
>>>    var _1 = _0[_z], _2 = _1[1], _3 = _2 === void 0 ? ["skill1", "skill2"] : _2, _4 = _3[0], primarySkillA = _4 === void 0 ? "primary" : _4, _5 = _3[1], secondarySkillA = _5 === void 0 ? "secondary" : _5;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^
4 >                   ^^
5 >                     ^^^^^^^^^^
6 >                               ^^
7 >                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                               ^^
9 >                                                                                 ^^^^^^^^^^
10>                                                                                           ^^
11>                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                           ^^
13>                                                                                                                                             ^^^^^^^^^^
14>                                                                                                                                                       ^^
15>                                                                                                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [, [
  >            primarySkillA = "primary",
  >            secondarySkillA = "secondary"
  >        ] = ["skill1", "skill2"]]
4 >                   
5 >                     [
  >                         primarySkillA = "primary",
  >                         secondarySkillA = "secondary"
  >                     ] = ["skill1", "skill2"]
6 >                               
7 >                                 [
  >                                     primarySkillA = "primary",
  >                                     secondarySkillA = "secondary"
  >                                 ] = ["skill1", "skill2"]
8 >                                                                               
9 >                                                                                 primarySkillA = "primary"
10>                                                                                           
11>                                                                                             primarySkillA = "primary"
12>                                                                                                                                           ,
  >                                                                                                                                               
13>                                                                                                                                             secondarySkillA = "secondary"
14>                                                                                                                                                       
15>                                                                                                                                                         secondarySkillA = "secondary"
1->Emitted(34, 5) Source(42, 10) + SourceIndex(0)
2 >Emitted(34, 9) Source(42, 10) + SourceIndex(0)
3 >Emitted(34, 20) Source(45, 26) + SourceIndex(0)
4 >Emitted(34, 22) Source(42, 13) + SourceIndex(0)
5 >Emitted(34, 32) Source(45, 25) + SourceIndex(0)
6 >Emitted(34, 34) Source(42, 13) + SourceIndex(0)
7 >Emitted(34, 80) Source(45, 25) + SourceIndex(0)
8 >Emitted(34, 82) Source(43, 5) + SourceIndex(0)
9 >Emitted(34, 92) Source(43, 30) + SourceIndex(0)
10>Emitted(34, 94) Source(43, 5) + SourceIndex(0)
11>Emitted(34, 140) Source(43, 30) + SourceIndex(0)
12>Emitted(34, 142) Source(44, 5) + SourceIndex(0)
13>Emitted(34, 152) Source(44, 34) + SourceIndex(0)
14>Emitted(34, 154) Source(44, 5) + SourceIndex(0)
15>Emitted(34, 204) Source(44, 34) + SourceIndex(0)
---
>>>    console.log(primarySkillA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^^^^^^^
7 >                             ^
8 >                              ^
1 >
  >] = ["skill1", "skill2"]] of [multiRobotA, multiRobotB]) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                primarySkillA
7 >                             )
8 >                              ;
1 >Emitted(35, 5) Source(46, 5) + SourceIndex(0)
2 >Emitted(35, 12) Source(46, 12) + SourceIndex(0)
3 >Emitted(35, 13) Source(46, 13) + SourceIndex(0)
4 >Emitted(35, 16) Source(46, 16) + SourceIndex(0)
5 >Emitted(35, 17) Source(46, 17) + SourceIndex(0)
6 >Emitted(35, 30) Source(46, 30) + SourceIndex(0)
7 >Emitted(35, 31) Source(46, 31) + SourceIndex(0)
8 >Emitted(35, 32) Source(46, 32) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(36, 2) Source(47, 2) + SourceIndex(0)
---
>>>for (var _6 = 0, robots_2 = robots; _6 < robots_2.length; _6++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^^^^^^^^^^^^^
6 >                                  ^^
7 >                                    ^^^^^^^^^^^^^^^^^^^^
8 >                                                        ^^
9 >                                                          ^^^^
10>                                                              ^^
11>                                                                ^->
1->
  >
  >
2 >for (let [numberB = -1] of 
3 >     robots
4 >               
5 >                 robots
6 >                                  
7 >                                    robots
8 >                                                        
9 >                                                          robots
10>                                                              ) 
1->Emitted(37, 1) Source(49, 1) + SourceIndex(0)
2 >Emitted(37, 6) Source(49, 28) + SourceIndex(0)
3 >Emitted(37, 16) Source(49, 34) + SourceIndex(0)
4 >Emitted(37, 18) Source(49, 28) + SourceIndex(0)
5 >Emitted(37, 35) Source(49, 34) + SourceIndex(0)
6 >Emitted(37, 37) Source(49, 28) + SourceIndex(0)
7 >Emitted(37, 57) Source(49, 34) + SourceIndex(0)
8 >Emitted(37, 59) Source(49, 28) + SourceIndex(0)
9 >Emitted(37, 63) Source(49, 34) + SourceIndex(0)
10>Emitted(37, 65) Source(49, 36) + SourceIndex(0)
---
>>>    var _7 = robots_2[_6][0], numberB = _7 === void 0 ? -1 : _7;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^^^^
4 >                            ^^
5 >                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        numberB = -1
4 >                            
5 >                              numberB = -1
1->Emitted(38, 5) Source(49, 11) + SourceIndex(0)
2 >Emitted(38, 9) Source(49, 11) + SourceIndex(0)
3 >Emitted(38, 29) Source(49, 23) + SourceIndex(0)
4 >Emitted(38, 31) Source(49, 11) + SourceIndex(0)
5 >Emitted(38, 64) Source(49, 23) + SourceIndex(0)
---
>>>    console.log(numberB);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^
7 >                       ^
8 >                        ^
1 >] of robots) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                numberB
7 >                       )
8 >                        ;
1 >Emitted(39, 5) Source(50, 5) + SourceIndex(0)
2 >Emitted(39, 12) Source(50, 12) + SourceIndex(0)
3 >Emitted(39, 13) Source(50, 13) + SourceIndex(0)
4 >Emitted(39, 16) Source(50, 16) + SourceIndex(0)
5 >Emitted(39, 17) Source(50, 17) + SourceIndex(0)
6 >Emitted(39, 24) Source(50, 24) + SourceIndex(0)
7 >Emitted(39, 25) Source(50, 25) + SourceIndex(0)
8 >Emitted(39, 26) Source(50, 26) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(40, 2) Source(51, 2) + SourceIndex(0)
---
>>>for (var _8 = 0, _9 = getRobots(); _8 < _9.length; _8++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^
4 >               ^^
5 >                 ^^^^^
6 >                      ^^^^^^^^^
7 >                               ^^
8 >                                 ^^
9 >                                   ^^^^^^^^^^^^^^
10>                                                 ^^
11>                                                   ^^^^
12>                                                       ^^
13>                                                         ^^^^^->
1->
  >
2 >for (let [numberB = -1] of 
3 >     getRobots()
4 >               
5 >                 
6 >                      getRobots
7 >                               ()
8 >                                 
9 >                                   getRobots()
10>                                                 
11>                                                   getRobots()
12>                                                       ) 
1->Emitted(41, 1) Source(52, 1) + SourceIndex(0)
2 >Emitted(41, 6) Source(52, 28) + SourceIndex(0)
3 >Emitted(41, 16) Source(52, 39) + SourceIndex(0)
4 >Emitted(41, 18) Source(52, 28) + SourceIndex(0)
5 >Emitted(41, 23) Source(52, 28) + SourceIndex(0)
6 >Emitted(41, 32) Source(52, 37) + SourceIndex(0)
7 >Emitted(41, 34) Source(52, 39) + SourceIndex(0)
8 >Emitted(41, 36) Source(52, 28) + SourceIndex(0)
9 >Emitted(41, 50) Source(52, 39) + SourceIndex(0)
10>Emitted(41, 52) Source(52, 28) + SourceIndex(0)
11>Emitted(41, 56) Source(52, 39) + SourceIndex(0)
12>Emitted(41, 58) Source(52, 41) + SourceIndex(0)
---
>>>    var _10 = _9[_8][0], numberB = _10 === void 0 ? -1 : _10;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^
4 >                       ^^
5 >                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        numberB = -1
4 >                       
5 >                         numberB = -1
1->Emitted(42, 5) Source(52, 11) + SourceIndex(0)
2 >Emitted(42, 9) Source(52, 11) + SourceIndex(0)
3 >Emitted(42, 24) Source(52, 23) + SourceIndex(0)
4 >Emitted(42, 26) Source(52, 11) + SourceIndex(0)
5 >Emitted(42, 61) Source(52, 23) + SourceIndex(0)
---
>>>    console.log(numberB);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^
7 >                       ^
8 >                        ^
1 >] of getRobots()) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                numberB
7 >                       )
8 >                        ;
1 >Emitted(43, 5) Source(53, 5) + SourceIndex(0)
2 >Emitted(43, 12) Source(53, 12) + SourceIndex(0)
3 >Emitted(43, 13) Source(53, 13) + SourceIndex(0)
4 >Emitted(43, 16) Source(53, 16) + SourceIndex(0)
5 >Emitted(43, 17) Source(53, 17) + SourceIndex(0)
6 >Emitted(43, 24) Source(53, 24) + SourceIndex(0)
7 >Emitted(43, 25) Source(53, 25) + SourceIndex(0)
8 >Emitted(43, 26) Source(53, 26) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(44, 2) Source(54, 2) + SourceIndex(0)
---
>>>for (var _11 = 0, _12 = [robotA, robotB]; _11 < _12.length; _11++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^
6 >                         ^^^^^^
7 >                               ^^
8 >                                 ^^^^^^
9 >                                       ^
10>                                        ^^
11>                                          ^^^^^^^^^^^^^^^^
12>                                                          ^^
13>                                                            ^^^^^
14>                                                                 ^^
1->
  >
2 >for (let [numberB = -1] of 
3 >     [robotA, robotB]
4 >                
5 >                  [
6 >                         robotA
7 >                               , 
8 >                                 robotB
9 >                                       ]
10>                                        
11>                                          [robotA, robotB]
12>                                                          
13>                                                            [robotA, robotB]
14>                                                                 ) 
1->Emitted(45, 1) Source(55, 1) + SourceIndex(0)
2 >Emitted(45, 6) Source(55, 28) + SourceIndex(0)
3 >Emitted(45, 17) Source(55, 44) + SourceIndex(0)
4 >Emitted(45, 19) Source(55, 28) + SourceIndex(0)
5 >Emitted(45, 26) Source(55, 29) + SourceIndex(0)
6 >Emitted(45, 32) Source(55, 35) + SourceIndex(0)
7 >Emitted(45, 34) Source(55, 37) + SourceIndex(0)
8 >Emitted(45, 40) Source(55, 43) + SourceIndex(0)
9 >Emitted(45, 41) Source(55, 44) + SourceIndex(0)
10>Emitted(45, 43) Source(55, 28) + SourceIndex(0)
11>Emitted(45, 59) Source(55, 44) + SourceIndex(0)
12>Emitted(45, 61) Source(55, 28) + SourceIndex(0)
13>Emitted(45, 66) Source(55, 44) + SourceIndex(0)
14>Emitted(45, 68) Source(55, 46) + SourceIndex(0)
---
>>>    var _13 = _12[_11][0], numberB = _13 === void 0 ? -1 : _13;
1 >^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^
4 >                         ^^
5 >                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1 >
2 >    
3 >        numberB = -1
4 >                         
5 >                           numberB = -1
1 >Emitted(46, 5) Source(55, 11) + SourceIndex(0)
2 >Emitted(46, 9) Source(55, 11) + SourceIndex(0)
3 >Emitted(46, 26) Source(55, 23) + SourceIndex(0)
4 >Emitted(46, 28) Source(55, 11) + SourceIndex(0)
5 >Emitted(46, 63) Source(55, 23) + SourceIndex(0)
---
>>>    console.log(numberB);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^
7 >                       ^
8 >                        ^
1 >] of [robotA, robotB]) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                numberB
7 >                       )
8 >                        ;
1 >Emitted(47, 5) Source(56, 5) + SourceIndex(0)
2 >Emitted(47, 12) Source(56, 12) + SourceIndex(0)
3 >Emitted(47, 13) Source(56, 13) + SourceIndex(0)
4 >Emitted(47, 16) Source(56, 16) + SourceIndex(0)
5 >Emitted(47, 17) Source(56, 17) + SourceIndex(0)
6 >Emitted(47, 24) Source(56, 24) + SourceIndex(0)
7 >Emitted(47, 25) Source(56, 25) + SourceIndex(0)
8 >Emitted(47, 26) Source(56, 26) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(48, 2) Source(57, 2) + SourceIndex(0)
---
>>>for (var _14 = 0, multiRobots_2 = multiRobots; _14 < multiRobots_2.length; _14++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
6 >                                             ^^
7 >                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                         ^^
9 >                                                                           ^^^^^
10>                                                                                ^^
1->
  >
2 >for (let [nameB = "noName"] of 
3 >     multiRobots
4 >                
5 >                  multiRobots
6 >                                             
7 >                                               multiRobots
8 >                                                                         
9 >                                                                           multiRobots
10>                                                                                ) 
1->Emitted(49, 1) Source(58, 1) + SourceIndex(0)
2 >Emitted(49, 6) Source(58, 32) + SourceIndex(0)
3 >Emitted(49, 17) Source(58, 43) + SourceIndex(0)
4 >Emitted(49, 19) Source(58, 32) + SourceIndex(0)
5 >Emitted(49, 46) Source(58, 43) + SourceIndex(0)
6 >Emitted(49, 48) Source(58, 32) + SourceIndex(0)
7 >Emitted(49, 74) Source(58, 43) + SourceIndex(0)
8 >Emitted(49, 76) Source(58, 32) + SourceIndex(0)
9 >Emitted(49, 81) Source(58, 43) + SourceIndex(0)
10>Emitted(49, 83) Source(58, 45) + SourceIndex(0)
---
>>>    var _15 = multiRobots_2[_14][0], nameB = _15 === void 0 ? "noName" : _15;
1 >^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
4 >                                   ^^
5 >                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1 >
2 >    
3 >        nameB = "noName"
4 >                                   
5 >                                     nameB = "noName"
1 >Emitted(50, 5) Source(58, 11) + SourceIndex(0)
2 >Emitted(50, 9) Source(58, 11) + SourceIndex(0)
3 >Emitted(50, 36) Source(58, 27) + SourceIndex(0)
4 >Emitted(50, 38) Source(58, 11) + SourceIndex(0)
5 >Emitted(50, 77) Source(58, 27) + SourceIndex(0)
---
>>>    console.log(nameB);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^
7 >                     ^
8 >                      ^
1 >] of multiRobots) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameB
7 >                     )
8 >                      ;
1 >Emitted(51, 5) Source(59, 5) + SourceIndex(0)
2 >Emitted(51, 12) Source(59, 12) + SourceIndex(0)
3 >Emitted(51, 13) Source(59, 13) + SourceIndex(0)
4 >Emitted(51, 16) Source(59, 16) + SourceIndex(0)
5 >Emitted(51, 17) Source(59, 17) + SourceIndex(0)
6 >Emitted(51, 22) Source(59, 22) + SourceIndex(0)
7 >Emitted(51, 23) Source(59, 23) + SourceIndex(0)
8 >Emitted(51, 24) Source(59, 24) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(52, 2) Source(60, 2) + SourceIndex(0)
---
>>>for (var _16 = 0, _17 = getMultiRobots(); _16 < _17.length; _16++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^
6 >                        ^^^^^^^^^^^^^^
7 >                                      ^^
8 >                                        ^^
9 >                                          ^^^^^^^^^^^^^^^^
10>                                                          ^^
11>                                                            ^^^^^
12>                                                                 ^^
13>                                                                   ^->
1->
  >
2 >for (let [nameB = "noName"] of 
3 >     getMultiRobots()
4 >                
5 >                  
6 >                        getMultiRobots
7 >                                      ()
8 >                                        
9 >                                          getMultiRobots()
10>                                                          
11>                                                            getMultiRobots()
12>                                                                 ) 
1->Emitted(53, 1) Source(61, 1) + SourceIndex(0)
2 >Emitted(53, 6) Source(61, 32) + SourceIndex(0)
3 >Emitted(53, 17) Source(61, 48) + SourceIndex(0)
4 >Emitted(53, 19) Source(61, 32) + SourceIndex(0)
5 >Emitted(53, 25) Source(61, 32) + SourceIndex(0)
6 >Emitted(53, 39) Source(61, 46) + SourceIndex(0)
7 >Emitted(53, 41) Source(61, 48) + SourceIndex(0)
8 >Emitted(53, 43) Source(61, 32) + SourceIndex(0)
9 >Emitted(53, 59) Source(61, 48) + SourceIndex(0)
10>Emitted(53, 61) Source(61, 32) + SourceIndex(0)
11>Emitted(53, 66) Source(61, 48) + SourceIndex(0)
12>Emitted(53, 68) Source(61, 50) + SourceIndex(0)
---
>>>    var _18 = _17[_16][0], nameB = _18 === void 0 ? "noName" : _18;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^
4 >                         ^^
5 >                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        nameB = "noName"
4 >                         
5 >                           nameB = "noName"
1->Emitted(54, 5) Source(61, 11) + SourceIndex(0)
2 >Emitted(54, 9) Source(61, 11) + SourceIndex(0)
3 >Emitted(54, 26) Source(61, 27) + SourceIndex(0)
4 >Emitted(54, 28) Source(61, 11) + SourceIndex(0)
5 >Emitted(54, 67) Source(61, 27) + SourceIndex(0)
---
>>>    console.log(nameB);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^
7 >                     ^
8 >                      ^
1 >] of getMultiRobots()) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameB
7 >                     )
8 >                      ;
1 >Emitted(55, 5) Source(62, 5) + SourceIndex(0)
2 >Emitted(55, 12) Source(62, 12) + SourceIndex(0)
3 >Emitted(55, 13) Source(62, 13) + SourceIndex(0)
4 >Emitted(55, 16) Source(62, 16) + SourceIndex(0)
5 >Emitted(55, 17) Source(62, 17) + SourceIndex(0)
6 >Emitted(55, 22) Source(62, 22) + SourceIndex(0)
7 >Emitted(55, 23) Source(62, 23) + SourceIndex(0)
8 >Emitted(55, 24) Source(62, 24) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(56, 2) Source(63, 2) + SourceIndex(0)
---
>>>for (var _19 = 0, _20 = [multiRobotA, multiRobotB]; _19 < _20.length; _19++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^
6 >                         ^^^^^^^^^^^
7 >                                    ^^
8 >                                      ^^^^^^^^^^^
9 >                                                 ^
10>                                                  ^^
11>                                                    ^^^^^^^^^^^^^^^^
12>                                                                    ^^
13>                                                                      ^^^^^
14>                                                                           ^^
1->
  >
2 >for (let [nameB = "noName"] of 
3 >     [multiRobotA, multiRobotB]
4 >                
5 >                  [
6 >                         multiRobotA
7 >                                    , 
8 >                                      multiRobotB
9 >                                                 ]
10>                                                  
11>                                                    [multiRobotA, multiRobotB]
12>                                                                    
13>                                                                      [multiRobotA, multiRobotB]
14>                                                                           ) 
1->Emitted(57, 1) Source(64, 1) + SourceIndex(0)
2 >Emitted(57, 6) Source(64, 32) + SourceIndex(0)
3 >Emitted(57, 17) Source(64, 58) + SourceIndex(0)
4 >Emitted(57, 19) Source(64, 32) + SourceIndex(0)
5 >Emitted(57, 26) Source(64, 33) + SourceIndex(0)
6 >Emitted(57, 37) Source(64, 44) + SourceIndex(0)
7 >Emitted(57, 39) Source(64, 46) + SourceIndex(0)
8 >Emitted(57, 50) Source(64, 57) + SourceIndex(0)
9 >Emitted(57, 51) Source(64, 58) + SourceIndex(0)
10>Emitted(57, 53) Source(64, 32) + SourceIndex(0)
11>Emitted(57, 69) Source(64, 58) + SourceIndex(0)
12>Emitted(57, 71) Source(64, 32) + SourceIndex(0)
13>Emitted(57, 76) Source(64, 58) + SourceIndex(0)
14>Emitted(57, 78) Source(64, 60) + SourceIndex(0)
---
>>>    var _21 = _20[_19][0], nameB = _21 === void 0 ? "noName" : _21;
1 >^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^
4 >                         ^^
5 >                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1 >
2 >    
3 >        nameB = "noName"
4 >                         
5 >                           nameB = "noName"
1 >Emitted(58, 5) Source(64, 11) + SourceIndex(0)
2 >Emitted(58, 9) Source(64, 11) + SourceIndex(0)
3 >Emitted(58, 26) Source(64, 27) + SourceIndex(0)
4 >Emitted(58, 28) Source(64, 11) + SourceIndex(0)
5 >Emitted(58, 67) Source(64, 27) + SourceIndex(0)
---
>>>    console.log(nameB);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^
7 >                     ^
8 >                      ^
1 >] of [multiRobotA, multiRobotB]) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameB
7 >                     )
8 >                      ;
1 >Emitted(59, 5) Source(65, 5) + SourceIndex(0)
2 >Emitted(59, 12) Source(65, 12) + SourceIndex(0)
3 >Emitted(59, 13) Source(65, 13) + SourceIndex(0)
4 >Emitted(59, 16) Source(65, 16) + SourceIndex(0)
5 >Emitted(59, 17) Source(65, 17) + SourceIndex(0)
6 >Emitted(59, 22) Source(65, 22) + SourceIndex(0)
7 >Emitted(59, 23) Source(65, 23) + SourceIndex(0)
8 >Emitted(59, 24) Source(65, 24) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(60, 2) Source(66, 2) + SourceIndex(0)
---
>>>for (var _22 = 0, robots_3 = robots; _22 < robots_3.length; _22++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^^^^^^^^^^^
6 >                                   ^^
7 >                                     ^^^^^^^^^^^^^^^^^^^^^
8 >                                                          ^^
9 >                                                            ^^^^^
10>                                                                 ^^
11>                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
  >
2 >for (let [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of 
3 >     robots
4 >                
5 >                  robots
6 >                                   
7 >                                     robots
8 >                                                          
9 >                                                            robots
10>                                                                 ) 
1->Emitted(61, 1) Source(68, 1) + SourceIndex(0)
2 >Emitted(61, 6) Source(68, 67) + SourceIndex(0)
3 >Emitted(61, 17) Source(68, 73) + SourceIndex(0)
4 >Emitted(61, 19) Source(68, 67) + SourceIndex(0)
5 >Emitted(61, 36) Source(68, 73) + SourceIndex(0)
6 >Emitted(61, 38) Source(68, 67) + SourceIndex(0)
7 >Emitted(61, 59) Source(68, 73) + SourceIndex(0)
8 >Emitted(61, 61) Source(68, 67) + SourceIndex(0)
9 >Emitted(61, 66) Source(68, 73) + SourceIndex(0)
10>Emitted(61, 68) Source(68, 75) + SourceIndex(0)
---
>>>    var _23 = robots_3[_22], _24 = _23[0], numberA2 = _24 === void 0 ? -1 : _24, _25 = _23[1], nameA2 = _25 === void 0 ? "noName" : _25, _26 = _23[2], skillA2 = _26 === void 0 ? "skill" : _26;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^^^
4 >                           ^^
5 >                             ^^^^^^^^^^^^
6 >                                         ^^
7 >                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                               ^^
9 >                                                                                 ^^^^^^^^^^^^
10>                                                                                             ^^
11>                                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                       ^^
13>                                                                                                                                         ^^^^^^^^^^^^
14>                                                                                                                                                     ^^
15>                                                                                                                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"]
4 >                           
5 >                             numberA2 = -1
6 >                                         
7 >                                           numberA2 = -1
8 >                                                                               , 
9 >                                                                                 nameA2 = "noName"
10>                                                                                             
11>                                                                                               nameA2 = "noName"
12>                                                                                                                                       , 
13>                                                                                                                                         skillA2 = "skill"
14>                                                                                                                                                     
15>                                                                                                                                                       skillA2 = "skill"
1->Emitted(62, 5) Source(68, 10) + SourceIndex(0)
2 >Emitted(62, 9) Source(68, 10) + SourceIndex(0)
3 >Emitted(62, 28) Source(68, 63) + SourceIndex(0)
4 >Emitted(62, 30) Source(68, 11) + SourceIndex(0)
5 >Emitted(62, 42) Source(68, 24) + SourceIndex(0)
6 >Emitted(62, 44) Source(68, 11) + SourceIndex(0)
7 >Emitted(62, 80) Source(68, 24) + SourceIndex(0)
8 >Emitted(62, 82) Source(68, 26) + SourceIndex(0)
9 >Emitted(62, 94) Source(68, 43) + SourceIndex(0)
10>Emitted(62, 96) Source(68, 26) + SourceIndex(0)
11>Emitted(62, 136) Source(68, 43) + SourceIndex(0)
12>Emitted(62, 138) Source(68, 45) + SourceIndex(0)
13>Emitted(62, 150) Source(68, 62) + SourceIndex(0)
14>Emitted(62, 152) Source(68, 45) + SourceIndex(0)
15>Emitted(62, 192) Source(68, 62) + SourceIndex(0)
---
>>>    console.log(nameA2);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^
7 >                      ^
8 >                       ^
1 >] of robots) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameA2
7 >                      )
8 >                       ;
1 >Emitted(63, 5) Source(69, 5) + SourceIndex(0)
2 >Emitted(63, 12) Source(69, 12) + SourceIndex(0)
3 >Emitted(63, 13) Source(69, 13) + SourceIndex(0)
4 >Emitted(63, 16) Source(69, 16) + SourceIndex(0)
5 >Emitted(63, 17) Source(69, 17) + SourceIndex(0)
6 >Emitted(63, 23) Source(69, 23) + SourceIndex(0)
7 >Emitted(63, 24) Source(69, 24) + SourceIndex(0)
8 >Emitted(63, 25) Source(69, 25) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(64, 2) Source(70, 2) + SourceIndex(0)
---
>>>for (var _27 = 0, _28 = getRobots(); _27 < _28.length; _27++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^
6 >                        ^^^^^^^^^
7 >                                 ^^
8 >                                   ^^
9 >                                     ^^^^^^^^^^^^^^^^
10>                                                     ^^
11>                                                       ^^^^^
12>                                                            ^^
13>                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of 
3 >     getRobots()
4 >                
5 >                  
6 >                        getRobots
7 >                                 ()
8 >                                   
9 >                                     getRobots()
10>                                                     
11>                                                       getRobots()
12>                                                            ) 
1->Emitted(65, 1) Source(71, 1) + SourceIndex(0)
2 >Emitted(65, 6) Source(71, 67) + SourceIndex(0)
3 >Emitted(65, 17) Source(71, 78) + SourceIndex(0)
4 >Emitted(65, 19) Source(71, 67) + SourceIndex(0)
5 >Emitted(65, 25) Source(71, 67) + SourceIndex(0)
6 >Emitted(65, 34) Source(71, 76) + SourceIndex(0)
7 >Emitted(65, 36) Source(71, 78) + SourceIndex(0)
8 >Emitted(65, 38) Source(71, 67) + SourceIndex(0)
9 >Emitted(65, 54) Source(71, 78) + SourceIndex(0)
10>Emitted(65, 56) Source(71, 67) + SourceIndex(0)
11>Emitted(65, 61) Source(71, 78) + SourceIndex(0)
12>Emitted(65, 63) Source(71, 80) + SourceIndex(0)
---
>>>    var _29 = _28[_27], _30 = _29[0], numberA2 = _30 === void 0 ? -1 : _30, _31 = _29[1], nameA2 = _31 === void 0 ? "noName" : _31, _32 = _29[2], skillA2 = _32 === void 0 ? "skill" : _32;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^
4 >                      ^^
5 >                        ^^^^^^^^^^^^
6 >                                    ^^
7 >                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                          ^^
9 >                                                                            ^^^^^^^^^^^^
10>                                                                                        ^^
11>                                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                  ^^
13>                                                                                                                                    ^^^^^^^^^^^^
14>                                                                                                                                                ^^
15>                                                                                                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"]
4 >                      
5 >                        numberA2 = -1
6 >                                    
7 >                                      numberA2 = -1
8 >                                                                          , 
9 >                                                                            nameA2 = "noName"
10>                                                                                        
11>                                                                                          nameA2 = "noName"
12>                                                                                                                                  , 
13>                                                                                                                                    skillA2 = "skill"
14>                                                                                                                                                
15>                                                                                                                                                  skillA2 = "skill"
1->Emitted(66, 5) Source(71, 10) + SourceIndex(0)
2 >Emitted(66, 9) Source(71, 10) + SourceIndex(0)
3 >Emitted(66, 23) Source(71, 63) + SourceIndex(0)
4 >Emitted(66, 25) Source(71, 11) + SourceIndex(0)
5 >Emitted(66, 37) Source(71, 24) + SourceIndex(0)
6 >Emitted(66, 39) Source(71, 11) + SourceIndex(0)
7 >Emitted(66, 75) Source(71, 24) + SourceIndex(0)
8 >Emitted(66, 77) Source(71, 26) + SourceIndex(0)
9 >Emitted(66, 89) Source(71, 43) + SourceIndex(0)
10>Emitted(66, 91) Source(71, 26) + SourceIndex(0)
11>Emitted(66, 131) Source(71, 43) + SourceIndex(0)
12>Emitted(66, 133) Source(71, 45) + SourceIndex(0)
13>Emitted(66, 145) Source(71, 62) + SourceIndex(0)
14>Emitted(66, 147) Source(71, 45) + SourceIndex(0)
15>Emitted(66, 187) Source(71, 62) + SourceIndex(0)
---
>>>    console.log(nameA2);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^
7 >                      ^
8 >                       ^
1 >] of getRobots()) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameA2
7 >                      )
8 >                       ;
1 >Emitted(67, 5) Source(72, 5) + SourceIndex(0)
2 >Emitted(67, 12) Source(72, 12) + SourceIndex(0)
3 >Emitted(67, 13) Source(72, 13) + SourceIndex(0)
4 >Emitted(67, 16) Source(72, 16) + SourceIndex(0)
5 >Emitted(67, 17) Source(72, 17) + SourceIndex(0)
6 >Emitted(67, 23) Source(72, 23) + SourceIndex(0)
7 >Emitted(67, 24) Source(72, 24) + SourceIndex(0)
8 >Emitted(67, 25) Source(72, 25) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(68, 2) Source(73, 2) + SourceIndex(0)
---
>>>for (var _33 = 0, _34 = [robotA, robotB]; _33 < _34.length; _33++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^
6 >                         ^^^^^^
7 >                               ^^
8 >                                 ^^^^^^
9 >                                       ^
10>                                        ^^
11>                                          ^^^^^^^^^^^^^^^^
12>                                                          ^^
13>                                                            ^^^^^
14>                                                                 ^^
15>                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of 
3 >     [robotA, robotB]
4 >                
5 >                  [
6 >                         robotA
7 >                               , 
8 >                                 robotB
9 >                                       ]
10>                                        
11>                                          [robotA, robotB]
12>                                                          
13>                                                            [robotA, robotB]
14>                                                                 ) 
1->Emitted(69, 1) Source(74, 1) + SourceIndex(0)
2 >Emitted(69, 6) Source(74, 67) + SourceIndex(0)
3 >Emitted(69, 17) Source(74, 83) + SourceIndex(0)
4 >Emitted(69, 19) Source(74, 67) + SourceIndex(0)
5 >Emitted(69, 26) Source(74, 68) + SourceIndex(0)
6 >Emitted(69, 32) Source(74, 74) + SourceIndex(0)
7 >Emitted(69, 34) Source(74, 76) + SourceIndex(0)
8 >Emitted(69, 40) Source(74, 82) + SourceIndex(0)
9 >Emitted(69, 41) Source(74, 83) + SourceIndex(0)
10>Emitted(69, 43) Source(74, 67) + SourceIndex(0)
11>Emitted(69, 59) Source(74, 83) + SourceIndex(0)
12>Emitted(69, 61) Source(74, 67) + SourceIndex(0)
13>Emitted(69, 66) Source(74, 83) + SourceIndex(0)
14>Emitted(69, 68) Source(74, 85) + SourceIndex(0)
---
>>>    var _35 = _34[_33], _36 = _35[0], numberA2 = _36 === void 0 ? -1 : _36, _37 = _35[1], nameA2 = _37 === void 0 ? "noName" : _37, _38 = _35[2], skillA2 = _38 === void 0 ? "skill" : _38;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^
4 >                      ^^
5 >                        ^^^^^^^^^^^^
6 >                                    ^^
7 >                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                          ^^
9 >                                                                            ^^^^^^^^^^^^
10>                                                                                        ^^
11>                                                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                  ^^
13>                                                                                                                                    ^^^^^^^^^^^^
14>                                                                                                                                                ^^
15>                                                                                                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [numberA2 = -1, nameA2 = "noName", skillA2 = "skill"]
4 >                      
5 >                        numberA2 = -1
6 >                                    
7 >                                      numberA2 = -1
8 >                                                                          , 
9 >                                                                            nameA2 = "noName"
10>                                                                                        
11>                                                                                          nameA2 = "noName"
12>                                                                                                                                  , 
13>                                                                                                                                    skillA2 = "skill"
14>                                                                                                                                                
15>                                                                                                                                                  skillA2 = "skill"
1->Emitted(70, 5) Source(74, 10) + SourceIndex(0)
2 >Emitted(70, 9) Source(74, 10) + SourceIndex(0)
3 >Emitted(70, 23) Source(74, 63) + SourceIndex(0)
4 >Emitted(70, 25) Source(74, 11) + SourceIndex(0)
5 >Emitted(70, 37) Source(74, 24) + SourceIndex(0)
6 >Emitted(70, 39) Source(74, 11) + SourceIndex(0)
7 >Emitted(70, 75) Source(74, 24) + SourceIndex(0)
8 >Emitted(70, 77) Source(74, 26) + SourceIndex(0)
9 >Emitted(70, 89) Source(74, 43) + SourceIndex(0)
10>Emitted(70, 91) Source(74, 26) + SourceIndex(0)
11>Emitted(70, 131) Source(74, 43) + SourceIndex(0)
12>Emitted(70, 133) Source(74, 45) + SourceIndex(0)
13>Emitted(70, 145) Source(74, 62) + SourceIndex(0)
14>Emitted(70, 147) Source(74, 45) + SourceIndex(0)
15>Emitted(70, 187) Source(74, 62) + SourceIndex(0)
---
>>>    console.log(nameA2);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^
7 >                      ^
8 >                       ^
1 >] of [robotA, robotB]) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameA2
7 >                      )
8 >                       ;
1 >Emitted(71, 5) Source(75, 5) + SourceIndex(0)
2 >Emitted(71, 12) Source(75, 12) + SourceIndex(0)
3 >Emitted(71, 13) Source(75, 13) + SourceIndex(0)
4 >Emitted(71, 16) Source(75, 16) + SourceIndex(0)
5 >Emitted(71, 17) Source(75, 17) + SourceIndex(0)
6 >Emitted(71, 23) Source(75, 23) + SourceIndex(0)
7 >Emitted(71, 24) Source(75, 24) + SourceIndex(0)
8 >Emitted(71, 25) Source(75, 25) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(72, 2) Source(76, 2) + SourceIndex(0)
---
>>>for (var _39 = 0, multiRobots_3 = multiRobots; _39 < multiRobots_3.length; _39++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
6 >                                             ^^
7 >                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                         ^^
9 >                                                                           ^^^^^
10>                                                                                ^^
11>                                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [nameMA = "noName", [
  >    primarySkillA = "primary",
  >    secondarySkillA = "secondary"
  >] = ["skill1", "skill2"]] of 
3 >     multiRobots
4 >                
5 >                  multiRobots
6 >                                             
7 >                                               multiRobots
8 >                                                                         
9 >                                                                           multiRobots
10>                                                                                ) 
1->Emitted(73, 1) Source(77, 1) + SourceIndex(0)
2 >Emitted(73, 6) Source(80, 30) + SourceIndex(0)
3 >Emitted(73, 17) Source(80, 41) + SourceIndex(0)
4 >Emitted(73, 19) Source(80, 30) + SourceIndex(0)
5 >Emitted(73, 46) Source(80, 41) + SourceIndex(0)
6 >Emitted(73, 48) Source(80, 30) + SourceIndex(0)
7 >Emitted(73, 74) Source(80, 41) + SourceIndex(0)
8 >Emitted(73, 76) Source(80, 30) + SourceIndex(0)
9 >Emitted(73, 81) Source(80, 41) + SourceIndex(0)
10>Emitted(73, 83) Source(80, 43) + SourceIndex(0)
---
>>>    var _40 = multiRobots_3[_39], _41 = _40[0], nameMA = _41 === void 0 ? "noName" : _41, _42 = _40[1], _43 = _42 === void 0 ? ["skill1", "skill2"] : _42, _44 = _43[0], primarySkillA = _44 === void 0 ? "primary" : _44, _45 = _43[1], secondarySkillA = _45 === void 0 ? "secondary" : _45;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^^^^^^^^
4 >                                ^^
5 >                                  ^^^^^^^^^^^^
6 >                                              ^^
7 >                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                                        ^^
9 >                                                                                          ^^^^^^^^^^^^
10>                                                                                                      ^^
11>                                                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                                         ^^
13>                                                                                                                                                           ^^^^^^^^^^^^
14>                                                                                                                                                                       ^^
15>                                                                                                                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
16>                                                                                                                                                                                                                         ^^
17>                                                                                                                                                                                                                           ^^^^^^^^^^^^
18>                                                                                                                                                                                                                                       ^^
19>                                                                                                                                                                                                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [nameMA = "noName", [
  >            primarySkillA = "primary",
  >            secondarySkillA = "secondary"
  >        ] = ["skill1", "skill2"]]
4 >                                
5 >                                  nameMA = "noName"
6 >                                              
7 >                                                nameMA = "noName"
8 >                                                                                        , 
9 >                                                                                          [
  >                                                                                              primarySkillA = "primary",
  >                                                                                              secondarySkillA = "secondary"
  >                                                                                          ] = ["skill1", "skill2"]
10>                                                                                                      
11>                                                                                                        [
  >                                                                                                            primarySkillA = "primary",
  >                                                                                                            secondarySkillA = "secondary"
  >                                                                                                        ] = ["skill1", "skill2"]
12>                                                                                                                                                         
13>                                                                                                                                                           primarySkillA = "primary"
14>                                                                                                                                                                       
15>                                                                                                                                                                         primarySkillA = "primary"
16>                                                                                                                                                                                                                         ,
  >                                                                                                                                                                                                                             
17>                                                                                                                                                                                                                           secondarySkillA = "secondary"
18>                                                                                                                                                                                                                                       
19>                                                                                                                                                                                                                                         secondarySkillA = "secondary"
1->Emitted(74, 5) Source(77, 10) + SourceIndex(0)
2 >Emitted(74, 9) Source(77, 10) + SourceIndex(0)
3 >Emitted(74, 33) Source(80, 26) + SourceIndex(0)
4 >Emitted(74, 35) Source(77, 11) + SourceIndex(0)
5 >Emitted(74, 47) Source(77, 28) + SourceIndex(0)
6 >Emitted(74, 49) Source(77, 11) + SourceIndex(0)
7 >Emitted(74, 89) Source(77, 28) + SourceIndex(0)
8 >Emitted(74, 91) Source(77, 30) + SourceIndex(0)
9 >Emitted(74, 103) Source(80, 25) + SourceIndex(0)
10>Emitted(74, 105) Source(77, 30) + SourceIndex(0)
11>Emitted(74, 154) Source(80, 25) + SourceIndex(0)
12>Emitted(74, 156) Source(78, 5) + SourceIndex(0)
13>Emitted(74, 168) Source(78, 30) + SourceIndex(0)
14>Emitted(74, 170) Source(78, 5) + SourceIndex(0)
15>Emitted(74, 218) Source(78, 30) + SourceIndex(0)
16>Emitted(74, 220) Source(79, 5) + SourceIndex(0)
17>Emitted(74, 232) Source(79, 34) + SourceIndex(0)
18>Emitted(74, 234) Source(79, 5) + SourceIndex(0)
19>Emitted(74, 286) Source(79, 34) + SourceIndex(0)
---
>>>    console.log(nameMA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^
7 >                      ^
8 >                       ^
1 >
  >] = ["skill1", "skill2"]] of multiRobots) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameMA
7 >                      )
8 >                       ;
1 >Emitted(75, 5) Source(81, 5) + SourceIndex(0)
2 >Emitted(75, 12) Source(81, 12) + SourceIndex(0)
3 >Emitted(75, 13) Source(81, 13) + SourceIndex(0)
4 >Emitted(75, 16) Source(81, 16) + SourceIndex(0)
5 >Emitted(75, 17) Source(81, 17) + SourceIndex(0)
6 >Emitted(75, 23) Source(81, 23) + SourceIndex(0)
7 >Emitted(75, 24) Source(81, 24) + SourceIndex(0)
8 >Emitted(75, 25) Source(81, 25) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(76, 2) Source(82, 2) + SourceIndex(0)
---
>>>for (var _46 = 0, _47 = getMultiRobots(); _46 < _47.length; _46++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^
6 >                        ^^^^^^^^^^^^^^
7 >                                      ^^
8 >                                        ^^
9 >                                          ^^^^^^^^^^^^^^^^
10>                                                          ^^
11>                                                            ^^^^^
12>                                                                 ^^
13>                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [nameMA = "noName", [
  >    primarySkillA = "primary",
  >    secondarySkillA = "secondary"
  >] = ["skill1", "skill2"]] of 
3 >     getMultiRobots()
4 >                
5 >                  
6 >                        getMultiRobots
7 >                                      ()
8 >                                        
9 >                                          getMultiRobots()
10>                                                          
11>                                                            getMultiRobots()
12>                                                                 ) 
1->Emitted(77, 1) Source(83, 1) + SourceIndex(0)
2 >Emitted(77, 6) Source(86, 30) + SourceIndex(0)
3 >Emitted(77, 17) Source(86, 46) + SourceIndex(0)
4 >Emitted(77, 19) Source(86, 30) + SourceIndex(0)
5 >Emitted(77, 25) Source(86, 30) + SourceIndex(0)
6 >Emitted(77, 39) Source(86, 44) + SourceIndex(0)
7 >Emitted(77, 41) Source(86, 46) + SourceIndex(0)
8 >Emitted(77, 43) Source(86, 30) + SourceIndex(0)
9 >Emitted(77, 59) Source(86, 46) + SourceIndex(0)
10>Emitted(77, 61) Source(86, 30) + SourceIndex(0)
11>Emitted(77, 66) Source(86, 46) + SourceIndex(0)
12>Emitted(77, 68) Source(86, 48) + SourceIndex(0)
---
>>>    var _48 = _47[_46], _49 = _48[0], nameMA = _49 === void 0 ? "noName" : _49, _50 = _48[1], _51 = _50 === void 0 ? ["skill1", "skill2"] : _50, _52 = _51[0], primarySkillA = _52 === void 0 ? "primary" : _52, _53 = _51[1], secondarySkillA = _53 === void 0 ? "secondary" : _53;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^
4 >                      ^^
5 >                        ^^^^^^^^^^^^
6 >                                    ^^
7 >                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                              ^^
9 >                                                                                ^^^^^^^^^^^^
10>                                                                                            ^^
11>                                                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                               ^^
13>                                                                                                                                                 ^^^^^^^^^^^^
14>                                                                                                                                                             ^^
15>                                                                                                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
16>                                                                                                                                                                                                               ^^
17>                                                                                                                                                                                                                 ^^^^^^^^^^^^
18>                                                                                                                                                                                                                             ^^
19>                                                                                                                                                                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [nameMA = "noName", [
  >            primarySkillA = "primary",
  >            secondarySkillA = "secondary"
  >        ] = ["skill1", "skill2"]]
4 >                      
5 >                        nameMA = "noName"
6 >                                    
7 >                                      nameMA = "noName"
8 >                                                                              , 
9 >                                                                                [
  >                                                                                    primarySkillA = "primary",
  >                                                                                    secondarySkillA = "secondary"
  >                                                                                ] = ["skill1", "skill2"]
10>                                                                                            
11>                                                                                              [
  >                                                                                                  primarySkillA = "primary",
  >                                                                                                  secondarySkillA = "secondary"
  >                                                                                              ] = ["skill1", "skill2"]
12>                                                                                                                                               
13>                                                                                                                                                 primarySkillA = "primary"
14>                                                                                                                                                             
15>                                                                                                                                                               primarySkillA = "primary"
16>                                                                                                                                                                                                               ,
  >                                                                                                                                                                                                                   
17>                                                                                                                                                                                                                 secondarySkillA = "secondary"
18>                                                                                                                                                                                                                             
19>                                                                                                                                                                                                                               secondarySkillA = "secondary"
1->Emitted(78, 5) Source(83, 10) + SourceIndex(0)
2 >Emitted(78, 9) Source(83, 10) + SourceIndex(0)
3 >Emitted(78, 23) Source(86, 26) + SourceIndex(0)
4 >Emitted(78, 25) Source(83, 11) + SourceIndex(0)
5 >Emitted(78, 37) Source(83, 28) + SourceIndex(0)
6 >Emitted(78, 39) Source(83, 11) + SourceIndex(0)
7 >Emitted(78, 79) Source(83, 28) + SourceIndex(0)
8 >Emitted(78, 81) Source(83, 30) + SourceIndex(0)
9 >Emitted(78, 93) Source(86, 25) + SourceIndex(0)
10>Emitted(78, 95) Source(83, 30) + SourceIndex(0)
11>Emitted(78, 144) Source(86, 25) + SourceIndex(0)
12>Emitted(78, 146) Source(84, 5) + SourceIndex(0)
13>Emitted(78, 158) Source(84, 30) + SourceIndex(0)
14>Emitted(78, 160) Source(84, 5) + SourceIndex(0)
15>Emitted(78, 208) Source(84, 30) + SourceIndex(0)
16>Emitted(78, 210) Source(85, 5) + SourceIndex(0)
17>Emitted(78, 222) Source(85, 34) + SourceIndex(0)
18>Emitted(78, 224) Source(85, 5) + SourceIndex(0)
19>Emitted(78, 276) Source(85, 34) + SourceIndex(0)
---
>>>    console.log(nameMA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^
7 >                      ^
8 >                       ^
1 >
  >] = ["skill1", "skill2"]] of getMultiRobots()) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameMA
7 >                      )
8 >                       ;
1 >Emitted(79, 5) Source(87, 5) + SourceIndex(0)
2 >Emitted(79, 12) Source(87, 12) + SourceIndex(0)
3 >Emitted(79, 13) Source(87, 13) + SourceIndex(0)
4 >Emitted(79, 16) Source(87, 16) + SourceIndex(0)
5 >Emitted(79, 17) Source(87, 17) + SourceIndex(0)
6 >Emitted(79, 23) Source(87, 23) + SourceIndex(0)
7 >Emitted(79, 24) Source(87, 24) + SourceIndex(0)
8 >Emitted(79, 25) Source(87, 25) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(80, 2) Source(88, 2) + SourceIndex(0)
---
>>>for (var _54 = 0, _55 = [multiRobotA, multiRobotB]; _54 < _55.length; _54++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^
6 >                         ^^^^^^^^^^^
7 >                                    ^^
8 >                                      ^^^^^^^^^^^
9 >                                                 ^
10>                                                  ^^
11>                                                    ^^^^^^^^^^^^^^^^
12>                                                                    ^^
13>                                                                      ^^^^^
14>                                                                           ^^
15>                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [nameMA = "noName", [
  >    primarySkillA = "primary",
  >    secondarySkillA = "secondary"
  >] = ["skill1", "skill2"]] of 
3 >     [multiRobotA, multiRobotB]
4 >                
5 >                  [
6 >                         multiRobotA
7 >                                    , 
8 >                                      multiRobotB
9 >                                                 ]
10>                                                  
11>                                                    [multiRobotA, multiRobotB]
12>                                                                    
13>                                                                      [multiRobotA, multiRobotB]
14>                                                                           ) 
1->Emitted(81, 1) Source(89, 1) + SourceIndex(0)
2 >Emitted(81, 6) Source(92, 30) + SourceIndex(0)
3 >Emitted(81, 17) Source(92, 56) + SourceIndex(0)
4 >Emitted(81, 19) Source(92, 30) + SourceIndex(0)
5 >Emitted(81, 26) Source(92, 31) + SourceIndex(0)
6 >Emitted(81, 37) Source(92, 42) + SourceIndex(0)
7 >Emitted(81, 39) Source(92, 44) + SourceIndex(0)
8 >Emitted(81, 50) Source(92, 55) + SourceIndex(0)
9 >Emitted(81, 51) Source(92, 56) + SourceIndex(0)
10>Emitted(81, 53) Source(92, 30) + SourceIndex(0)
11>Emitted(81, 69) Source(92, 56) + SourceIndex(0)
12>Emitted(81, 71) Source(92, 30) + SourceIndex(0)
13>Emitted(81, 76) Source(92, 56) + SourceIndex(0)
14>Emitted(81, 78) Source(92, 58) + SourceIndex(0)
---
>>>    var _56 = _55[_54], _57 = _56[0], nameMA = _57 === void 0 ? "noName" : _57, _58 = _56[1], _59 = _58 === void 0 ? ["skill1", "skill2"] : _58, _60 = _59[0], primarySkillA = _60 === void 0 ? "primary" : _60, _61 = _59[1], secondarySkillA = _61 === void 0 ? "secondary" : _61;
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^
4 >                      ^^
5 >                        ^^^^^^^^^^^^
6 >                                    ^^
7 >                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                              ^^
9 >                                                                                ^^^^^^^^^^^^
10>                                                                                            ^^
11>                                                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12>                                                                                                                                               ^^
13>                                                                                                                                                 ^^^^^^^^^^^^
14>                                                                                                                                                             ^^
15>                                                                                                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
16>                                                                                                                                                                                                               ^^
17>                                                                                                                                                                                                                 ^^^^^^^^^^^^
18>                                                                                                                                                                                                                             ^^
19>                                                                                                                                                                                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [nameMA = "noName", [
  >            primarySkillA = "primary",
  >            secondarySkillA = "secondary"
  >        ] = ["skill1", "skill2"]]
4 >                      
5 >                        nameMA = "noName"
6 >                                    
7 >                                      nameMA = "noName"
8 >                                                                              , 
9 >                                                                                [
  >                                                                                    primarySkillA = "primary",
  >                                                                                    secondarySkillA = "secondary"
  >                                                                                ] = ["skill1", "skill2"]
10>                                                                                            
11>                                                                                              [
  >                                                                                                  primarySkillA = "primary",
  >                                                                                                  secondarySkillA = "secondary"
  >                                                                                              ] = ["skill1", "skill2"]
12>                                                                                                                                               
13>                                                                                                                                                 primarySkillA = "primary"
14>                                                                                                                                                             
15>                                                                                                                                                               primarySkillA = "primary"
16>                                                                                                                                                                                                               ,
  >                                                                                                                                                                                                                   
17>                                                                                                                                                                                                                 secondarySkillA = "secondary"
18>                                                                                                                                                                                                                             
19>                                                                                                                                                                                                                               secondarySkillA = "secondary"
1->Emitted(82, 5) Source(89, 10) + SourceIndex(0)
2 >Emitted(82, 9) Source(89, 10) + SourceIndex(0)
3 >Emitted(82, 23) Source(92, 26) + SourceIndex(0)
4 >Emitted(82, 25) Source(89, 11) + SourceIndex(0)
5 >Emitted(82, 37) Source(89, 28) + SourceIndex(0)
6 >Emitted(82, 39) Source(89, 11) + SourceIndex(0)
7 >Emitted(82, 79) Source(89, 28) + SourceIndex(0)
8 >Emitted(82, 81) Source(89, 30) + SourceIndex(0)
9 >Emitted(82, 93) Source(92, 25) + SourceIndex(0)
10>Emitted(82, 95) Source(89, 30) + SourceIndex(0)
11>Emitted(82, 144) Source(92, 25) + SourceIndex(0)
12>Emitted(82, 146) Source(90, 5) + SourceIndex(0)
13>Emitted(82, 158) Source(90, 30) + SourceIndex(0)
14>Emitted(82, 160) Source(90, 5) + SourceIndex(0)
15>Emitted(82, 208) Source(90, 30) + SourceIndex(0)
16>Emitted(82, 210) Source(91, 5) + SourceIndex(0)
17>Emitted(82, 222) Source(91, 34) + SourceIndex(0)
18>Emitted(82, 224) Source(91, 5) + SourceIndex(0)
19>Emitted(82, 276) Source(91, 34) + SourceIndex(0)
---
>>>    console.log(nameMA);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^
7 >                      ^
8 >                       ^
1 >
  >] = ["skill1", "skill2"]] of [multiRobotA, multiRobotB]) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                nameMA
7 >                      )
8 >                       ;
1 >Emitted(83, 5) Source(93, 5) + SourceIndex(0)
2 >Emitted(83, 12) Source(93, 12) + SourceIndex(0)
3 >Emitted(83, 13) Source(93, 13) + SourceIndex(0)
4 >Emitted(83, 16) Source(93, 16) + SourceIndex(0)
5 >Emitted(83, 17) Source(93, 17) + SourceIndex(0)
6 >Emitted(83, 23) Source(93, 23) + SourceIndex(0)
7 >Emitted(83, 24) Source(93, 24) + SourceIndex(0)
8 >Emitted(83, 25) Source(93, 25) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(84, 2) Source(94, 2) + SourceIndex(0)
---
>>>for (var _62 = 0, robots_4 = robots; _62 < robots_4.length; _62++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^^^^^^^^^^^
6 >                                   ^^
7 >                                     ^^^^^^^^^^^^^^^^^^^^^
8 >                                                          ^^
9 >                                                            ^^^^^
10>                                                                 ^^
11>                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
  >
2 >for (let [numberA3 = -1, ...robotAInfo] of 
3 >     robots
4 >                
5 >                  robots
6 >                                   
7 >                                     robots
8 >                                                          
9 >                                                            robots
10>                                                                 ) 
1->Emitted(85, 1) Source(96, 1) + SourceIndex(0)
2 >Emitted(85, 6) Source(96, 44) + SourceIndex(0)
3 >Emitted(85, 17) Source(96, 50) + SourceIndex(0)
4 >Emitted(85, 19) Source(96, 44) + SourceIndex(0)
5 >Emitted(85, 36) Source(96, 50) + SourceIndex(0)
6 >Emitted(85, 38) Source(96, 44) + SourceIndex(0)
7 >Emitted(85, 59) Source(96, 50) + SourceIndex(0)
8 >Emitted(85, 61) Source(96, 44) + SourceIndex(0)
9 >Emitted(85, 66) Source(96, 50) + SourceIndex(0)
10>Emitted(85, 68) Source(96, 52) + SourceIndex(0)
---
>>>    var _63 = robots_4[_62], _64 = _63[0], numberA3 = _64 === void 0 ? -1 : _64, robotAInfo = _63.slice(1);
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^^^^^^
4 >                           ^^
5 >                             ^^^^^^^^^^^^
6 >                                         ^^
7 >                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                               ^^
9 >                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [numberA3 = -1, ...robotAInfo]
4 >                           
5 >                             numberA3 = -1
6 >                                         
7 >                                           numberA3 = -1
8 >                                                                               , 
9 >                                                                                 ...robotAInfo
1->Emitted(86, 5) Source(96, 10) + SourceIndex(0)
2 >Emitted(86, 9) Source(96, 10) + SourceIndex(0)
3 >Emitted(86, 28) Source(96, 40) + SourceIndex(0)
4 >Emitted(86, 30) Source(96, 11) + SourceIndex(0)
5 >Emitted(86, 42) Source(96, 24) + SourceIndex(0)
6 >Emitted(86, 44) Source(96, 11) + SourceIndex(0)
7 >Emitted(86, 80) Source(96, 24) + SourceIndex(0)
8 >Emitted(86, 82) Source(96, 26) + SourceIndex(0)
9 >Emitted(86, 107) Source(96, 39) + SourceIndex(0)
---
>>>    console.log(numberA3);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^^
7 >                        ^
8 >                         ^
1 >] of robots) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                numberA3
7 >                        )
8 >                         ;
1 >Emitted(87, 5) Source(97, 5) + SourceIndex(0)
2 >Emitted(87, 12) Source(97, 12) + SourceIndex(0)
3 >Emitted(87, 13) Source(97, 13) + SourceIndex(0)
4 >Emitted(87, 16) Source(97, 16) + SourceIndex(0)
5 >Emitted(87, 17) Source(97, 17) + SourceIndex(0)
6 >Emitted(87, 25) Source(97, 25) + SourceIndex(0)
7 >Emitted(87, 26) Source(97, 26) + SourceIndex(0)
8 >Emitted(87, 27) Source(97, 27) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(88, 2) Source(98, 2) + SourceIndex(0)
---
>>>for (var _65 = 0, _66 = getRobots(); _65 < _66.length; _65++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^
6 >                        ^^^^^^^^^
7 >                                 ^^
8 >                                   ^^
9 >                                     ^^^^^^^^^^^^^^^^
10>                                                     ^^
11>                                                       ^^^^^
12>                                                            ^^
13>                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [numberA3 = -1, ...robotAInfo] of 
3 >     getRobots()
4 >                
5 >                  
6 >                        getRobots
7 >                                 ()
8 >                                   
9 >                                     getRobots()
10>                                                     
11>                                                       getRobots()
12>                                                            ) 
1->Emitted(89, 1) Source(99, 1) + SourceIndex(0)
2 >Emitted(89, 6) Source(99, 44) + SourceIndex(0)
3 >Emitted(89, 17) Source(99, 55) + SourceIndex(0)
4 >Emitted(89, 19) Source(99, 44) + SourceIndex(0)
5 >Emitted(89, 25) Source(99, 44) + SourceIndex(0)
6 >Emitted(89, 34) Source(99, 53) + SourceIndex(0)
7 >Emitted(89, 36) Source(99, 55) + SourceIndex(0)
8 >Emitted(89, 38) Source(99, 44) + SourceIndex(0)
9 >Emitted(89, 54) Source(99, 55) + SourceIndex(0)
10>Emitted(89, 56) Source(99, 44) + SourceIndex(0)
11>Emitted(89, 61) Source(99, 55) + SourceIndex(0)
12>Emitted(89, 63) Source(99, 57) + SourceIndex(0)
---
>>>    var _67 = _66[_65], _68 = _67[0], numberA3 = _68 === void 0 ? -1 : _68, robotAInfo = _67.slice(1);
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^
4 >                      ^^
5 >                        ^^^^^^^^^^^^
6 >                                    ^^
7 >                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                          ^^
9 >                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [numberA3 = -1, ...robotAInfo]
4 >                      
5 >                        numberA3 = -1
6 >                                    
7 >                                      numberA3 = -1
8 >                                                                          , 
9 >                                                                            ...robotAInfo
1->Emitted(90, 5) Source(99, 10) + SourceIndex(0)
2 >Emitted(90, 9) Source(99, 10) + SourceIndex(0)
3 >Emitted(90, 23) Source(99, 40) + SourceIndex(0)
4 >Emitted(90, 25) Source(99, 11) + SourceIndex(0)
5 >Emitted(90, 37) Source(99, 24) + SourceIndex(0)
6 >Emitted(90, 39) Source(99, 11) + SourceIndex(0)
7 >Emitted(90, 75) Source(99, 24) + SourceIndex(0)
8 >Emitted(90, 77) Source(99, 26) + SourceIndex(0)
9 >Emitted(90, 102) Source(99, 39) + SourceIndex(0)
---
>>>    console.log(numberA3);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^^
7 >                        ^
8 >                         ^
1 >] of getRobots()) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                numberA3
7 >                        )
8 >                         ;
1 >Emitted(91, 5) Source(100, 5) + SourceIndex(0)
2 >Emitted(91, 12) Source(100, 12) + SourceIndex(0)
3 >Emitted(91, 13) Source(100, 13) + SourceIndex(0)
4 >Emitted(91, 16) Source(100, 16) + SourceIndex(0)
5 >Emitted(91, 17) Source(100, 17) + SourceIndex(0)
6 >Emitted(91, 25) Source(100, 25) + SourceIndex(0)
7 >Emitted(91, 26) Source(100, 26) + SourceIndex(0)
8 >Emitted(91, 27) Source(100, 27) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(92, 2) Source(101, 2) + SourceIndex(0)
---
>>>for (var _69 = 0, _70 = [robotA, robotB]; _69 < _70.length; _69++) {
1->
2 >^^^^^
3 >     ^^^^^^^^^^^
4 >                ^^
5 >                  ^^^^^^^
6 >                         ^^^^^^
7 >                               ^^
8 >                                 ^^^^^^
9 >                                       ^
10>                                        ^^
11>                                          ^^^^^^^^^^^^^^^^
12>                                                          ^^
13>                                                            ^^^^^
14>                                                                 ^^
15>                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1->
  >
2 >for (let [numberA3 = -1, ...robotAInfo] of 
3 >     [robotA, robotB]
4 >                
5 >                  [
6 >                         robotA
7 >                               , 
8 >                                 robotB
9 >                                       ]
10>                                        
11>                                          [robotA, robotB]
12>                                                          
13>                                                            [robotA, robotB]
14>                                                                 ) 
1->Emitted(93, 1) Source(102, 1) + SourceIndex(0)
2 >Emitted(93, 6) Source(102, 44) + SourceIndex(0)
3 >Emitted(93, 17) Source(102, 60) + SourceIndex(0)
4 >Emitted(93, 19) Source(102, 44) + SourceIndex(0)
5 >Emitted(93, 26) Source(102, 45) + SourceIndex(0)
6 >Emitted(93, 32) Source(102, 51) + SourceIndex(0)
7 >Emitted(93, 34) Source(102, 53) + SourceIndex(0)
8 >Emitted(93, 40) Source(102, 59) + SourceIndex(0)
9 >Emitted(93, 41) Source(102, 60) + SourceIndex(0)
10>Emitted(93, 43) Source(102, 44) + SourceIndex(0)
11>Emitted(93, 59) Source(102, 60) + SourceIndex(0)
12>Emitted(93, 61) Source(102, 44) + SourceIndex(0)
13>Emitted(93, 66) Source(102, 60) + SourceIndex(0)
14>Emitted(93, 68) Source(102, 62) + SourceIndex(0)
---
>>>    var _71 = _70[_69], _72 = _71[0], numberA3 = _72 === void 0 ? -1 : _72, robotAInfo = _71.slice(1);
1->^^^^
2 >    ^^^^
3 >        ^^^^^^^^^^^^^^
4 >                      ^^
5 >                        ^^^^^^^^^^^^
6 >                                    ^^
7 >                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
8 >                                                                          ^^
9 >                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^
1->
2 >    
3 >        [numberA3 = -1, ...robotAInfo]
4 >                      
5 >                        numberA3 = -1
6 >                                    
7 >                                      numberA3 = -1
8 >                                                                          , 
9 >                                                                            ...robotAInfo
1->Emitted(94, 5) Source(102, 10) + SourceIndex(0)
2 >Emitted(94, 9) Source(102, 10) + SourceIndex(0)
3 >Emitted(94, 23) Source(102, 40) + SourceIndex(0)
4 >Emitted(94, 25) Source(102, 11) + SourceIndex(0)
5 >Emitted(94, 37) Source(102, 24) + SourceIndex(0)
6 >Emitted(94, 39) Source(102, 11) + SourceIndex(0)
7 >Emitted(94, 75) Source(102, 24) + SourceIndex(0)
8 >Emitted(94, 77) Source(102, 26) + SourceIndex(0)
9 >Emitted(94, 102) Source(102, 39) + SourceIndex(0)
---
>>>    console.log(numberA3);
1 >^^^^
2 >    ^^^^^^^
3 >           ^
4 >            ^^^
5 >               ^
6 >                ^^^^^^^^
7 >                        ^
8 >                         ^
1 >] of [robotA, robotB]) {
  >    
2 >    console
3 >           .
4 >            log
5 >               (
6 >                numberA3
7 >                        )
8 >                         ;
1 >Emitted(95, 5) Source(103, 5) + SourceIndex(0)
2 >Emitted(95, 12) Source(103, 12) + SourceIndex(0)
3 >Emitted(95, 13) Source(103, 13) + SourceIndex(0)
4 >Emitted(95, 16) Source(103, 16) + SourceIndex(0)
5 >Emitted(95, 17) Source(103, 17) + SourceIndex(0)
6 >Emitted(95, 25) Source(103, 25) + SourceIndex(0)
7 >Emitted(95, 26) Source(103, 26) + SourceIndex(0)
8 >Emitted(95, 27) Source(103, 27) + SourceIndex(0)
---
>>>}
1 >^
2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
1 >
  >}
1 >Emitted(96, 2) Source(104, 2) + SourceIndex(0)
---
>>>//# sourceMappingURL=sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues.js.map