@danielx/civet 0.3.7 → 0.3.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/README.md +2 -1
  2. package/dist/browser.js +288 -273
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +6 -6
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +288 -273
  7. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -445,6 +445,7 @@ var require_parser = __commonJS({
445
445
  CallExpression,
446
446
  CallExpressionRest,
447
447
  OptionalShorthand,
448
+ NonNullAssertion,
448
449
  SpacedApplication,
449
450
  ApplicationStart,
450
451
  AdditionalReservedWords,
@@ -707,119 +708,120 @@ var require_parser = __commonJS({
707
708
  var $L23 = $L("super");
708
709
  var $L24 = $L("import");
709
710
  var $L25 = $L(".");
710
- var $L26 = $L("[");
711
- var $L27 = $L("]");
712
- var $L28 = $L("::");
713
- var $L29 = $L("super[");
714
- var $L30 = $L("new.target");
715
- var $L31 = $L("import.meta");
716
- var $L32 = $L("");
717
- var $L33 = $L("...");
718
- var $L34 = $L("function");
719
- var $L35 = $L("->");
720
- var $L36 = $L("null");
721
- var $L37 = $L("true");
722
- var $L38 = $L("false");
723
- var $L39 = $L("get");
724
- var $L40 = $L("set");
725
- var $L41 = $L("**=");
726
- var $L42 = $L("*=");
727
- var $L43 = $L("/=");
728
- var $L44 = $L("%=");
729
- var $L45 = $L("+=");
730
- var $L46 = $L("-=");
731
- var $L47 = $L("<<=");
732
- var $L48 = $L(">>>=");
733
- var $L49 = $L(">>=");
734
- var $L50 = $L("&&=");
735
- var $L51 = $L("&=");
736
- var $L52 = $L("^=");
737
- var $L53 = $L("||=");
738
- var $L54 = $L("|=");
739
- var $L55 = $L("??=");
740
- var $L56 = $L("=");
741
- var $L57 = $L("**");
742
- var $L58 = $L("/");
743
- var $L59 = $L("%");
744
- var $L60 = $L("+");
745
- var $L61 = $L("-");
746
- var $L62 = $L("<=");
747
- var $L63 = $L(">=");
748
- var $L64 = $L("<<");
749
- var $L65 = $L(">>>");
750
- var $L66 = $L(">>");
751
- var $L67 = $L(">");
752
- var $L68 = $L("!==");
753
- var $L69 = $L("!=");
754
- var $L70 = $L("is");
755
- var $L71 = $L("===");
756
- var $L72 = $L("==");
757
- var $L73 = $L("and");
758
- var $L74 = $L("&&");
759
- var $L75 = $L("or");
760
- var $L76 = $L("||");
761
- var $L77 = $L("??");
762
- var $L78 = $L("instanceof");
763
- var $L79 = $L("in");
764
- var $L80 = $L("&");
765
- var $L81 = $L("^");
766
- var $L82 = $L("|");
767
- var $L83 = $L("delete");
768
- var $L84 = $L("void");
769
- var $L85 = $L("typeof");
770
- var $L86 = $L("if");
771
- var $L87 = $L("unless");
772
- var $L88 = $L(";");
773
- var $L89 = $L("else");
774
- var $L90 = $L("loop");
775
- var $L91 = $L("do");
776
- var $L92 = $L("while");
777
- var $L93 = $L("until");
778
- var $L94 = $L("var");
779
- var $L95 = $L("of");
780
- var $L96 = $L("for");
781
- var $L97 = $L("let");
782
- var $L98 = $L("const");
783
- var $L99 = $L("switch");
784
- var $L100 = $L("case");
785
- var $L101 = $L("default");
786
- var $L102 = $L("when");
787
- var $L103 = $L("try");
788
- var $L104 = $L("catch");
789
- var $L105 = $L("finally");
790
- var $L106 = $L("break");
791
- var $L107 = $L("continue");
792
- var $L108 = $L("debugger");
793
- var $L109 = $L("throw");
794
- var $L110 = $L("return");
795
- var $L111 = $L("import type");
796
- var $L112 = $L("from");
797
- var $L113 = $L("export");
798
- var $L114 = $L(":=");
799
- var $L115 = $L('"""');
800
- var $L116 = $L("'''");
801
- var $L117 = $L('"');
802
- var $L118 = $L("'");
803
- var $L119 = $L("`");
804
- var $L120 = $L("${");
805
- var $L121 = $L("/*");
806
- var $L122 = $L("*/");
807
- var $L123 = $L("###");
808
- var $L124 = $L("/>");
809
- var $L125 = $L("</");
810
- var $L126 = $L("<>");
811
- var $L127 = $L("</>");
812
- var $L128 = $L("declare");
813
- var $L129 = $L("type");
814
- var $L130 = $L("interface");
815
- var $L131 = $L("namespace");
816
- var $L132 = $L("readonly");
817
- var $L133 = $L("asserts");
818
- var $L134 = $L("keyof");
819
- var $L135 = $L("infer");
820
- var $L136 = $L("[]");
821
- var $L137 = $L(" ");
822
- var $L138 = $L(" ");
711
+ var $L26 = $L("!");
712
+ var $L27 = $L("[");
713
+ var $L28 = $L("]");
714
+ var $L29 = $L("::");
715
+ var $L30 = $L("super[");
716
+ var $L31 = $L("new.target");
717
+ var $L32 = $L("import.meta");
718
+ var $L33 = $L("");
719
+ var $L34 = $L("...");
720
+ var $L35 = $L("function");
721
+ var $L36 = $L("->");
722
+ var $L37 = $L("null");
723
+ var $L38 = $L("true");
724
+ var $L39 = $L("false");
725
+ var $L40 = $L("get");
726
+ var $L41 = $L("set");
727
+ var $L42 = $L("**=");
728
+ var $L43 = $L("*=");
729
+ var $L44 = $L("/=");
730
+ var $L45 = $L("%=");
731
+ var $L46 = $L("+=");
732
+ var $L47 = $L("-=");
733
+ var $L48 = $L("<<=");
734
+ var $L49 = $L(">>>=");
735
+ var $L50 = $L(">>=");
736
+ var $L51 = $L("&&=");
737
+ var $L52 = $L("&=");
738
+ var $L53 = $L("^=");
739
+ var $L54 = $L("||=");
740
+ var $L55 = $L("|=");
741
+ var $L56 = $L("??=");
742
+ var $L57 = $L("=");
743
+ var $L58 = $L("**");
744
+ var $L59 = $L("/");
745
+ var $L60 = $L("%");
746
+ var $L61 = $L("+");
747
+ var $L62 = $L("-");
748
+ var $L63 = $L("<=");
749
+ var $L64 = $L(">=");
750
+ var $L65 = $L("<<");
751
+ var $L66 = $L(">>>");
752
+ var $L67 = $L(">>");
753
+ var $L68 = $L(">");
754
+ var $L69 = $L("!==");
755
+ var $L70 = $L("!=");
756
+ var $L71 = $L("is");
757
+ var $L72 = $L("===");
758
+ var $L73 = $L("==");
759
+ var $L74 = $L("and");
760
+ var $L75 = $L("&&");
761
+ var $L76 = $L("or");
762
+ var $L77 = $L("||");
763
+ var $L78 = $L("??");
764
+ var $L79 = $L("instanceof");
765
+ var $L80 = $L("in");
766
+ var $L81 = $L("&");
767
+ var $L82 = $L("^");
768
+ var $L83 = $L("|");
769
+ var $L84 = $L("delete");
770
+ var $L85 = $L("void");
771
+ var $L86 = $L("typeof");
772
+ var $L87 = $L("if");
773
+ var $L88 = $L("unless");
774
+ var $L89 = $L(";");
775
+ var $L90 = $L("else");
776
+ var $L91 = $L("loop");
777
+ var $L92 = $L("do");
778
+ var $L93 = $L("while");
779
+ var $L94 = $L("until");
780
+ var $L95 = $L("var");
781
+ var $L96 = $L("of");
782
+ var $L97 = $L("for");
783
+ var $L98 = $L("let");
784
+ var $L99 = $L("const");
785
+ var $L100 = $L("switch");
786
+ var $L101 = $L("case");
787
+ var $L102 = $L("default");
788
+ var $L103 = $L("when");
789
+ var $L104 = $L("try");
790
+ var $L105 = $L("catch");
791
+ var $L106 = $L("finally");
792
+ var $L107 = $L("break");
793
+ var $L108 = $L("continue");
794
+ var $L109 = $L("debugger");
795
+ var $L110 = $L("throw");
796
+ var $L111 = $L("return");
797
+ var $L112 = $L("import type");
798
+ var $L113 = $L("from");
799
+ var $L114 = $L("export");
800
+ var $L115 = $L(":=");
801
+ var $L116 = $L('"""');
802
+ var $L117 = $L("'''");
803
+ var $L118 = $L('"');
804
+ var $L119 = $L("'");
805
+ var $L120 = $L("`");
806
+ var $L121 = $L("${");
807
+ var $L122 = $L("/*");
808
+ var $L123 = $L("*/");
809
+ var $L124 = $L("###");
810
+ var $L125 = $L("/>");
811
+ var $L126 = $L("</");
812
+ var $L127 = $L("<>");
813
+ var $L128 = $L("</>");
814
+ var $L129 = $L("declare");
815
+ var $L130 = $L("type");
816
+ var $L131 = $L("interface");
817
+ var $L132 = $L("namespace");
818
+ var $L133 = $L("readonly");
819
+ var $L134 = $L("asserts");
820
+ var $L135 = $L("keyof");
821
+ var $L136 = $L("infer");
822
+ var $L137 = $L("[]");
823
+ var $L138 = $L(" ");
824
+ var $L139 = $L(" ");
823
825
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
824
826
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
825
827
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -1312,7 +1314,7 @@ var require_parser = __commonJS({
1312
1314
  return CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
1313
1315
  }
1314
1316
  }
1315
- var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1317
+ var CallExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), Arguments);
1316
1318
  var CallExpressionRest$1 = MemberExpressionRest;
1317
1319
  var CallExpressionRest$2 = SpacedApplication;
1318
1320
  var CallExpressionRest$3 = TemplateLiteral;
@@ -1333,6 +1335,18 @@ var require_parser = __commonJS({
1333
1335
  return OptionalShorthand$0(state);
1334
1336
  }
1335
1337
  }
1338
+ var NonNullAssertion$0 = $T($EXPECT($L26, fail, 'NonNullAssertion "!"'), function(value) {
1339
+ return { "ts": true, "children": value };
1340
+ });
1341
+ function NonNullAssertion(state) {
1342
+ if (state.verbose)
1343
+ console.log("ENTER:", "NonNullAssertion");
1344
+ if (state.tokenize) {
1345
+ return $TOKEN("NonNullAssertion", state, NonNullAssertion$0(state));
1346
+ } else {
1347
+ return NonNullAssertion$0(state);
1348
+ }
1349
+ }
1336
1350
  var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
1337
1351
  function SpacedApplication(state) {
1338
1352
  if (state.verbose)
@@ -1377,22 +1391,23 @@ var require_parser = __commonJS({
1377
1391
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1378
1392
  }
1379
1393
  }
1380
- var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
1394
+ var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), $EXPECT($L27, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L28, fail, 'MemberExpressionRest "]"'));
1381
1395
  var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
1382
- var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1396
+ var MemberExpressionRest$2 = $TS($S($EXPECT($L29, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1383
1397
  var id = $2;
1384
1398
  if (id)
1385
1399
  return [".prototype.", id];
1386
1400
  return ".prototype";
1387
1401
  });
1402
+ var MemberExpressionRest$3 = NonNullAssertion;
1388
1403
  function MemberExpressionRest(state) {
1389
1404
  if (state.tokenize) {
1390
- return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
1405
+ return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state));
1391
1406
  } else {
1392
- return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
1407
+ return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
1393
1408
  }
1394
1409
  }
1395
- var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1410
+ var PropertyAccess$0 = $S($E($C($EXPECT($L3, fail, 'PropertyAccess "?"'), NonNullAssertion)), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1396
1411
  function PropertyAccess(state) {
1397
1412
  if (state.verbose)
1398
1413
  console.log("ENTER:", "PropertyAccess");
@@ -1402,7 +1417,7 @@ var require_parser = __commonJS({
1402
1417
  return PropertyAccess$0(state);
1403
1418
  }
1404
1419
  }
1405
- var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
1420
+ var SuperProperty$0 = $S($EXPECT($L30, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L28, fail, 'SuperProperty "]"'));
1406
1421
  function SuperProperty(state) {
1407
1422
  if (state.verbose)
1408
1423
  console.log("ENTER:", "SuperProperty");
@@ -1412,8 +1427,8 @@ var require_parser = __commonJS({
1412
1427
  return SuperProperty$0(state);
1413
1428
  }
1414
1429
  }
1415
- var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
1416
- var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
1430
+ var MetaProperty$0 = $EXPECT($L31, fail, 'MetaProperty "new.target"');
1431
+ var MetaProperty$1 = $EXPECT($L32, fail, 'MetaProperty "import.meta"');
1417
1432
  function MetaProperty(state) {
1418
1433
  if (state.tokenize) {
1419
1434
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1422,7 +1437,7 @@ var require_parser = __commonJS({
1422
1437
  }
1423
1438
  }
1424
1439
  var Parameters$0 = $S($E(TypeParameters), $EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1425
- var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
1440
+ var Parameters$1 = $T($EXPECT($L33, fail, 'Parameters ""'), function(value) {
1426
1441
  return "()";
1427
1442
  });
1428
1443
  function Parameters(state) {
@@ -1486,7 +1501,7 @@ var require_parser = __commonJS({
1486
1501
  return ObjectBindingPattern$0(state);
1487
1502
  }
1488
1503
  }
1489
- var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
1504
+ var ArrayBindingPattern$0 = $S($EXPECT($L27, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L28, fail, 'ArrayBindingPattern "]"'));
1490
1505
  function ArrayBindingPattern(state) {
1491
1506
  if (state.verbose)
1492
1507
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1505,7 +1520,7 @@ var require_parser = __commonJS({
1505
1520
  return BindingProperty$0(state) || BindingProperty$1(state);
1506
1521
  }
1507
1522
  }
1508
- var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1523
+ var BindingRestProperty$0 = $S($EXPECT($L34, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1509
1524
  function BindingRestProperty(state) {
1510
1525
  if (state.verbose)
1511
1526
  console.log("ENTER:", "BindingRestProperty");
@@ -1525,7 +1540,7 @@ var require_parser = __commonJS({
1525
1540
  return BindingElement$0(state);
1526
1541
  }
1527
1542
  }
1528
- var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1543
+ var BindingRestElement$0 = $S($EXPECT($L34, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1529
1544
  function BindingRestElement(state) {
1530
1545
  if (state.verbose)
1531
1546
  console.log("ENTER:", "BindingRestElement");
@@ -1546,7 +1561,7 @@ var require_parser = __commonJS({
1546
1561
  }
1547
1562
  }
1548
1563
  var FunctionExpression$0 = ThinArrowFunction;
1549
- var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L34, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1564
+ var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L35, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1550
1565
  function FunctionExpression(state) {
1551
1566
  if (state.tokenize) {
1552
1567
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1575,7 +1590,7 @@ var require_parser = __commonJS({
1575
1590
  return ThinArrowFunction$0(state);
1576
1591
  }
1577
1592
  }
1578
- var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1593
+ var Arrow$0 = $TV($EXPECT($L36, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1579
1594
  return { $loc, token: $1 };
1580
1595
  });
1581
1596
  function Arrow(state) {
@@ -1668,7 +1683,7 @@ var require_parser = __commonJS({
1668
1683
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1669
1684
  }
1670
1685
  }
1671
- var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1686
+ var NullLiteral$0 = $TV($EXPECT($L37, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1672
1687
  return { $loc, token: $1 };
1673
1688
  });
1674
1689
  function NullLiteral(state) {
@@ -1680,7 +1695,7 @@ var require_parser = __commonJS({
1680
1695
  return NullLiteral$0(state);
1681
1696
  }
1682
1697
  }
1683
- var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1698
+ var BooleanLiteral$0 = $TV($C($EXPECT($L38, fail, 'BooleanLiteral "true"'), $EXPECT($L39, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1684
1699
  return { $loc, token: $1 };
1685
1700
  });
1686
1701
  function BooleanLiteral(state) {
@@ -1737,8 +1752,8 @@ var require_parser = __commonJS({
1737
1752
  return IdentifierReference$0(state);
1738
1753
  }
1739
1754
  }
1740
- var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1741
- var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1755
+ var ArrayLiteral$0 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1756
+ var ArrayLiteral$1 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1742
1757
  function ArrayLiteral(state) {
1743
1758
  if (state.tokenize) {
1744
1759
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1772,8 +1787,8 @@ var require_parser = __commonJS({
1772
1787
  }
1773
1788
  }
1774
1789
  var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1775
- var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
1776
- var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1790
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L28, fail, 'ArrayElementDelimiter "]"')));
1791
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L28, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1777
1792
  return ",";
1778
1793
  });
1779
1794
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1806,7 +1821,7 @@ var require_parser = __commonJS({
1806
1821
  return InlineElementList$0(state);
1807
1822
  }
1808
1823
  }
1809
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1824
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L34, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1810
1825
  function ArrayElementExpression(state) {
1811
1826
  if (state.verbose)
1812
1827
  console.log("ENTER:", "ArrayElementExpression");
@@ -1889,7 +1904,7 @@ var require_parser = __commonJS({
1889
1904
  }
1890
1905
  var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L14, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1891
1906
  var PropertyDefinition$1 = MethodDefinition;
1892
- var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1907
+ var PropertyDefinition$2 = $S($EXPECT($L34, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1893
1908
  var PropertyDefinition$3 = IdentifierReference;
1894
1909
  function PropertyDefinition(state) {
1895
1910
  if (state.tokenize) {
@@ -1901,7 +1916,7 @@ var require_parser = __commonJS({
1901
1916
  var PropertyName$0 = NumericLiteral;
1902
1917
  var PropertyName$1 = StringLiteral;
1903
1918
  var PropertyName$2 = IdentifierName;
1904
- var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
1919
+ var PropertyName$3 = $S($EXPECT($L27, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L28, fail, 'PropertyName "]"'));
1905
1920
  function PropertyName(state) {
1906
1921
  if (state.tokenize) {
1907
1922
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1909,8 +1924,8 @@ var require_parser = __commonJS({
1909
1924
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1910
1925
  }
1911
1926
  }
1912
- var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1913
- var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1927
+ var MethodDefinition$0 = $S($EXPECT($L40, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1928
+ var MethodDefinition$1 = $S($EXPECT($L41, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1914
1929
  var MethodDefinition$2 = AsyncGeneratorMethod;
1915
1930
  var MethodDefinition$3 = AsyncMethod;
1916
1931
  var MethodDefinition$4 = GeneratorMethod;
@@ -1922,7 +1937,7 @@ var require_parser = __commonJS({
1922
1937
  return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
1923
1938
  }
1924
1939
  }
1925
- var MethodModifier$0 = $S($C($EXPECT($L39, fail, 'MethodModifier "get"'), $EXPECT($L40, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
1940
+ var MethodModifier$0 = $S($C($EXPECT($L40, fail, 'MethodModifier "get"'), $EXPECT($L41, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
1926
1941
  function MethodModifier(state) {
1927
1942
  if (state.verbose)
1928
1943
  console.log("ENTER:", "MethodModifier");
@@ -2033,22 +2048,22 @@ var require_parser = __commonJS({
2033
2048
  return AssignmentOp$0(state);
2034
2049
  }
2035
2050
  }
2036
- var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
2037
- var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
2038
- var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
2039
- var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
2040
- var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
2041
- var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
2042
- var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
2043
- var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
2044
- var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
2045
- var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
2046
- var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
2047
- var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
2048
- var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
2049
- var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
2050
- var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
2051
- var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
2051
+ var AssignmentOpSymbol$0 = $EXPECT($L42, fail, 'AssignmentOpSymbol "**="');
2052
+ var AssignmentOpSymbol$1 = $EXPECT($L43, fail, 'AssignmentOpSymbol "*="');
2053
+ var AssignmentOpSymbol$2 = $EXPECT($L44, fail, 'AssignmentOpSymbol "/="');
2054
+ var AssignmentOpSymbol$3 = $EXPECT($L45, fail, 'AssignmentOpSymbol "%="');
2055
+ var AssignmentOpSymbol$4 = $EXPECT($L46, fail, 'AssignmentOpSymbol "+="');
2056
+ var AssignmentOpSymbol$5 = $EXPECT($L47, fail, 'AssignmentOpSymbol "-="');
2057
+ var AssignmentOpSymbol$6 = $EXPECT($L48, fail, 'AssignmentOpSymbol "<<="');
2058
+ var AssignmentOpSymbol$7 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>>="');
2059
+ var AssignmentOpSymbol$8 = $EXPECT($L50, fail, 'AssignmentOpSymbol ">>="');
2060
+ var AssignmentOpSymbol$9 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&&="');
2061
+ var AssignmentOpSymbol$10 = $EXPECT($L52, fail, 'AssignmentOpSymbol "&="');
2062
+ var AssignmentOpSymbol$11 = $EXPECT($L53, fail, 'AssignmentOpSymbol "^="');
2063
+ var AssignmentOpSymbol$12 = $EXPECT($L54, fail, 'AssignmentOpSymbol "||="');
2064
+ var AssignmentOpSymbol$13 = $EXPECT($L55, fail, 'AssignmentOpSymbol "|="');
2065
+ var AssignmentOpSymbol$14 = $EXPECT($L56, fail, 'AssignmentOpSymbol "??="');
2066
+ var AssignmentOpSymbol$15 = $EXPECT($L57, fail, 'AssignmentOpSymbol "="');
2052
2067
  function AssignmentOpSymbol(state) {
2053
2068
  if (state.tokenize) {
2054
2069
  return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state));
@@ -2068,48 +2083,48 @@ var require_parser = __commonJS({
2068
2083
  return BinaryOp$0(state);
2069
2084
  }
2070
2085
  }
2071
- var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
2086
+ var BinaryOpSymbol$0 = $EXPECT($L58, fail, 'BinaryOpSymbol "**"');
2072
2087
  var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
2073
- var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
2074
- var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
2075
- var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
2076
- var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
2077
- var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
2078
- var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
2079
- var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
2088
+ var BinaryOpSymbol$2 = $EXPECT($L59, fail, 'BinaryOpSymbol "/"');
2089
+ var BinaryOpSymbol$3 = $EXPECT($L60, fail, 'BinaryOpSymbol "%"');
2090
+ var BinaryOpSymbol$4 = $EXPECT($L61, fail, 'BinaryOpSymbol "+"');
2091
+ var BinaryOpSymbol$5 = $EXPECT($L62, fail, 'BinaryOpSymbol "-"');
2092
+ var BinaryOpSymbol$6 = $EXPECT($L63, fail, 'BinaryOpSymbol "<="');
2093
+ var BinaryOpSymbol$7 = $EXPECT($L64, fail, 'BinaryOpSymbol ">="');
2094
+ var BinaryOpSymbol$8 = $EXPECT($L65, fail, 'BinaryOpSymbol "<<"');
2080
2095
  var BinaryOpSymbol$9 = $EXPECT($L16, fail, 'BinaryOpSymbol "<"');
2081
- var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
2082
- var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
2083
- var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
2084
- var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
2085
- var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2096
+ var BinaryOpSymbol$10 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>>"');
2097
+ var BinaryOpSymbol$11 = $EXPECT($L67, fail, 'BinaryOpSymbol ">>"');
2098
+ var BinaryOpSymbol$12 = $EXPECT($L68, fail, 'BinaryOpSymbol ">"');
2099
+ var BinaryOpSymbol$13 = $EXPECT($L69, fail, 'BinaryOpSymbol "!=="');
2100
+ var BinaryOpSymbol$14 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2086
2101
  if (global.coffeeCompat)
2087
2102
  return "!==";
2088
2103
  return $1;
2089
2104
  });
2090
- var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2105
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2091
2106
  return "===";
2092
2107
  });
2093
- var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
2094
- var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2108
+ var BinaryOpSymbol$16 = $EXPECT($L72, fail, 'BinaryOpSymbol "==="');
2109
+ var BinaryOpSymbol$17 = $TV($EXPECT($L73, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2095
2110
  if (global.coffeeCompat)
2096
2111
  return "===";
2097
2112
  return $1;
2098
2113
  });
2099
- var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2114
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2100
2115
  return "&&";
2101
2116
  });
2102
- var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
2103
- var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2117
+ var BinaryOpSymbol$19 = $EXPECT($L75, fail, 'BinaryOpSymbol "&&"');
2118
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L76, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2104
2119
  return "||";
2105
2120
  });
2106
- var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
2107
- var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
2108
- var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2109
- var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2110
- var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
2111
- var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
2112
- var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
2121
+ var BinaryOpSymbol$21 = $EXPECT($L77, fail, 'BinaryOpSymbol "||"');
2122
+ var BinaryOpSymbol$22 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
2123
+ var BinaryOpSymbol$23 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2124
+ var BinaryOpSymbol$24 = $S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2125
+ var BinaryOpSymbol$25 = $EXPECT($L81, fail, 'BinaryOpSymbol "&"');
2126
+ var BinaryOpSymbol$26 = $EXPECT($L82, fail, 'BinaryOpSymbol "^"');
2127
+ var BinaryOpSymbol$27 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
2113
2128
  function BinaryOpSymbol(state) {
2114
2129
  if (state.tokenize) {
2115
2130
  return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
@@ -2118,7 +2133,7 @@ var require_parser = __commonJS({
2118
2133
  }
2119
2134
  }
2120
2135
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2121
- var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2136
+ var UnaryOp$1 = $S($C($EXPECT($L84, fail, 'UnaryOp "delete"'), $EXPECT($L85, fail, 'UnaryOp "void"'), $EXPECT($L86, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2122
2137
  function UnaryOp(state) {
2123
2138
  if (state.tokenize) {
2124
2139
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2152,7 +2167,7 @@ var require_parser = __commonJS({
2152
2167
  return StatementListItem$0(state);
2153
2168
  }
2154
2169
  }
2155
- var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L86, fail, 'PostfixConditional "if"'), $EXPECT($L87, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
2170
+ var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L87, fail, 'PostfixConditional "if"'), $EXPECT($L88, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
2156
2171
  var ws = $1;
2157
2172
  var cond = $2;
2158
2173
  var exp = $4;
@@ -2185,7 +2200,7 @@ var require_parser = __commonJS({
2185
2200
  return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
2186
2201
  }
2187
2202
  }
2188
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
2203
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L89, fail, 'EmptyStatement ";"')));
2189
2204
  function EmptyStatement(state) {
2190
2205
  if (state.verbose)
2191
2206
  console.log("ENTER:", "EmptyStatement");
@@ -2205,8 +2220,8 @@ var require_parser = __commonJS({
2205
2220
  return BlockStatement$0(state);
2206
2221
  }
2207
2222
  }
2208
- var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
2209
- var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2223
+ var IfStatement$0 = $S($EXPECT($L87, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L90, fail, 'IfStatement "else"'), Block)));
2224
+ var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2210
2225
  var condition = $2;
2211
2226
  var block = $3;
2212
2227
  return ["if", condition.map((c) => {
@@ -2236,7 +2251,7 @@ var require_parser = __commonJS({
2236
2251
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2237
2252
  }
2238
2253
  }
2239
- var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2254
+ var LoopStatement$0 = $TS($S($EXPECT($L91, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2240
2255
  var b = $3;
2241
2256
  return ["while(true)", b];
2242
2257
  });
@@ -2249,7 +2264,7 @@ var require_parser = __commonJS({
2249
2264
  return LoopStatement$0(state);
2250
2265
  }
2251
2266
  }
2252
- var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2267
+ var DoWhileStatement$0 = $S($EXPECT($L92, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2253
2268
  function DoWhileStatement(state) {
2254
2269
  if (state.verbose)
2255
2270
  console.log("ENTER:", "DoWhileStatement");
@@ -2269,7 +2284,7 @@ var require_parser = __commonJS({
2269
2284
  return WhileStatement$0(state);
2270
2285
  }
2271
2286
  }
2272
- var WhileClause$0 = $TS($S($C($EXPECT($L92, fail, 'WhileClause "while"'), $EXPECT($L93, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2287
+ var WhileClause$0 = $TS($S($C($EXPECT($L93, fail, 'WhileClause "while"'), $EXPECT($L94, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2273
2288
  var kind = $1;
2274
2289
  var cond = $3;
2275
2290
  if (kind === "until") {
@@ -2288,7 +2303,7 @@ var require_parser = __commonJS({
2288
2303
  return WhileClause$0(state);
2289
2304
  }
2290
2305
  }
2291
- var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2306
+ var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L89, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L89, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2292
2307
  function ForStatement(state) {
2293
2308
  if (state.verbose)
2294
2309
  console.log("ENTER:", "ForStatement");
@@ -2298,10 +2313,10 @@ var require_parser = __commonJS({
2298
2313
  return ForStatement$0(state);
2299
2314
  }
2300
2315
  }
2301
- var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2302
- var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2303
- var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2304
- var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2316
+ var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L80, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2317
+ var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L80, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2318
+ var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L96, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2319
+ var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L96, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2305
2320
  function ForInOfStatement(state) {
2306
2321
  if (state.tokenize) {
2307
2322
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2309,7 +2324,7 @@ var require_parser = __commonJS({
2309
2324
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2310
2325
  }
2311
2326
  }
2312
- var For$0 = $TS($S($EXPECT($L96, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2327
+ var For$0 = $TS($S($EXPECT($L97, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2313
2328
  return { $loc, token: $1 };
2314
2329
  });
2315
2330
  function For(state) {
@@ -2331,7 +2346,7 @@ var require_parser = __commonJS({
2331
2346
  return ForDeclaration$0(state);
2332
2347
  }
2333
2348
  }
2334
- var LetOrConst$0 = $TV($C($EXPECT($L97, fail, 'LetOrConst "let"'), $EXPECT($L98, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
2349
+ var LetOrConst$0 = $TV($C($EXPECT($L98, fail, 'LetOrConst "let"'), $EXPECT($L99, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
2335
2350
  return { $loc, token: $1 };
2336
2351
  });
2337
2352
  function LetOrConst(state) {
@@ -2352,7 +2367,7 @@ var require_parser = __commonJS({
2352
2367
  return ForBinding$0(state) || ForBinding$1(state);
2353
2368
  }
2354
2369
  }
2355
- var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2370
+ var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2356
2371
  function SwitchStatement(state) {
2357
2372
  if (state.verbose)
2358
2373
  console.log("ENTER:", "SwitchStatement");
@@ -2396,9 +2411,9 @@ var require_parser = __commonJS({
2396
2411
  return NestedCaseClause$0(state);
2397
2412
  }
2398
2413
  }
2399
- var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2414
+ var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2400
2415
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2401
- var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2416
+ var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2402
2417
  function CaseClause(state) {
2403
2418
  if (state.tokenize) {
2404
2419
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2406,7 +2421,7 @@ var require_parser = __commonJS({
2406
2421
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2407
2422
  }
2408
2423
  }
2409
- var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
2424
+ var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
2410
2425
  return "case";
2411
2426
  });
2412
2427
  function When(state) {
@@ -2419,7 +2434,7 @@ var require_parser = __commonJS({
2419
2434
  }
2420
2435
  }
2421
2436
  var ImpliedColon$0 = $S(__, $EXPECT($L14, fail, 'ImpliedColon ":"'));
2422
- var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
2437
+ var ImpliedColon$1 = $T($EXPECT($L33, fail, 'ImpliedColon ""'), function(value) {
2423
2438
  return ":";
2424
2439
  });
2425
2440
  function ImpliedColon(state) {
@@ -2429,7 +2444,7 @@ var require_parser = __commonJS({
2429
2444
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2430
2445
  }
2431
2446
  }
2432
- var TryStatement$0 = $TS($S($EXPECT($L103, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2447
+ var TryStatement$0 = $TS($S($EXPECT($L104, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2433
2448
  var c = $3;
2434
2449
  var f = $4;
2435
2450
  if (!c && !f) {
@@ -2446,7 +2461,7 @@ var require_parser = __commonJS({
2446
2461
  return TryStatement$0(state);
2447
2462
  }
2448
2463
  }
2449
- var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2464
+ var Catch$0 = $S(__, $EXPECT($L105, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2450
2465
  function Catch(state) {
2451
2466
  if (state.verbose)
2452
2467
  console.log("ENTER:", "Catch");
@@ -2465,7 +2480,7 @@ var require_parser = __commonJS({
2465
2480
  return CatchBind$0(state) || CatchBind$1(state);
2466
2481
  }
2467
2482
  }
2468
- var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
2483
+ var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
2469
2484
  function Finally(state) {
2470
2485
  if (state.verbose)
2471
2486
  console.log("ENTER:", "Finally");
@@ -2503,11 +2518,11 @@ var require_parser = __commonJS({
2503
2518
  return ExpressionStatement$0(state);
2504
2519
  }
2505
2520
  }
2506
- var KeywordStatement$0 = $S($EXPECT($L106, fail, 'KeywordStatement "break"'), NonIdContinue);
2507
- var KeywordStatement$1 = $S($EXPECT($L107, fail, 'KeywordStatement "continue"'), NonIdContinue);
2508
- var KeywordStatement$2 = $S($EXPECT($L108, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2521
+ var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
2522
+ var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
2523
+ var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2509
2524
  var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2510
- var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2525
+ var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2511
2526
  function KeywordStatement(state) {
2512
2527
  if (state.tokenize) {
2513
2528
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2524,7 +2539,7 @@ var require_parser = __commonJS({
2524
2539
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2525
2540
  }
2526
2541
  }
2527
- var Return$0 = $TS($S($EXPECT($L110, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2542
+ var Return$0 = $TS($S($EXPECT($L111, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2528
2543
  return { $loc, token: $1 };
2529
2544
  });
2530
2545
  function Return(state) {
@@ -2536,7 +2551,7 @@ var require_parser = __commonJS({
2536
2551
  return Return$0(state);
2537
2552
  }
2538
2553
  }
2539
- var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2554
+ var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2540
2555
  return { "ts": true, "children": value };
2541
2556
  });
2542
2557
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2549,7 +2564,7 @@ var require_parser = __commonJS({
2549
2564
  return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
2550
2565
  }
2551
2566
  }
2552
- var ImpliedImport$0 = $T($EXPECT($L32, fail, 'ImpliedImport ""'), function(value) {
2567
+ var ImpliedImport$0 = $T($EXPECT($L33, fail, 'ImpliedImport ""'), function(value) {
2553
2568
  return "import ";
2554
2569
  });
2555
2570
  function ImpliedImport(state) {
@@ -2613,7 +2628,7 @@ var require_parser = __commonJS({
2613
2628
  return FromClause$0(state);
2614
2629
  }
2615
2630
  }
2616
- var From$0 = $TS($S($EXPECT($L112, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2631
+ var From$0 = $TS($S($EXPECT($L113, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2617
2632
  return { $loc, token: $1 };
2618
2633
  });
2619
2634
  function From(state) {
@@ -2675,7 +2690,7 @@ var require_parser = __commonJS({
2675
2690
  return ImportedBinding$0(state);
2676
2691
  }
2677
2692
  }
2678
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2693
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2679
2694
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2680
2695
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2681
2696
  function ExportDeclaration(state) {
@@ -2695,7 +2710,7 @@ var require_parser = __commonJS({
2695
2710
  return As$0(state);
2696
2711
  }
2697
2712
  }
2698
- var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
2713
+ var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
2699
2714
  function Export(state) {
2700
2715
  if (state.verbose)
2701
2716
  console.log("ENTER:", "Export");
@@ -2779,7 +2794,7 @@ var require_parser = __commonJS({
2779
2794
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
2780
2795
  }
2781
2796
  }
2782
- var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2797
+ var ConstAssignment$0 = $TV($EXPECT($L115, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2783
2798
  return { $loc, token: $0 };
2784
2799
  });
2785
2800
  function ConstAssignment(state) {
@@ -2800,7 +2815,7 @@ var require_parser = __commonJS({
2800
2815
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2801
2816
  }
2802
2817
  }
2803
- var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2818
+ var Initializer$0 = $S(__, $EXPECT($L57, fail, 'Initializer "="'), AssignmentExpression);
2804
2819
  function Initializer(state) {
2805
2820
  if (state.verbose)
2806
2821
  console.log("ENTER:", "Initializer");
@@ -2810,7 +2825,7 @@ var require_parser = __commonJS({
2810
2825
  return Initializer$0(state);
2811
2826
  }
2812
2827
  }
2813
- var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2828
+ var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2814
2829
  function VariableStatement(state) {
2815
2830
  if (state.verbose)
2816
2831
  console.log("ENTER:", "VariableStatement");
@@ -2913,18 +2928,18 @@ var require_parser = __commonJS({
2913
2928
  return HexLiteral$0(state);
2914
2929
  }
2915
2930
  }
2916
- var StringLiteral$0 = $TS($S($EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
2931
+ var StringLiteral$0 = $TS($S($EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
2917
2932
  var str = $2;
2918
2933
  return { $loc, token: "`" + module2.dedentBlockString(str) + "`" };
2919
2934
  });
2920
- var StringLiteral$1 = $TS($S($EXPECT($L116, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
2935
+ var StringLiteral$1 = $TS($S($EXPECT($L117, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L117, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
2921
2936
  var str = $2;
2922
2937
  return { $loc, token: "`" + module2.dedentBlockString(str) + "`" };
2923
2938
  });
2924
- var StringLiteral$2 = $TV($TEXT($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2939
+ var StringLiteral$2 = $TV($TEXT($S($EXPECT($L118, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L118, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2925
2940
  return { $loc, token: $1 };
2926
2941
  });
2927
- var StringLiteral$3 = $TV($TEXT($S($EXPECT($L118, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L118, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2942
+ var StringLiteral$3 = $TV($TEXT($S($EXPECT($L119, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L119, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2928
2943
  return { $loc, token: $1 };
2929
2944
  });
2930
2945
  function StringLiteral(state) {
@@ -2974,7 +2989,7 @@ var require_parser = __commonJS({
2974
2989
  return TripleSingleStringCharacter$0(state);
2975
2990
  }
2976
2991
  }
2977
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2992
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L59, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L59, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2978
2993
  return { $loc, token: $1 };
2979
2994
  });
2980
2995
  function RegularExpressionLiteral(state) {
@@ -3016,7 +3031,7 @@ var require_parser = __commonJS({
3016
3031
  return RegularExpressionFlags$0(state);
3017
3032
  }
3018
3033
  }
3019
- var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
3034
+ var TemplateLiteral$0 = $S($EXPECT($L120, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L120, fail, 'TemplateLiteral "`"'));
3020
3035
  function TemplateLiteral(state) {
3021
3036
  if (state.verbose)
3022
3037
  console.log("ENTER:", "TemplateLiteral");
@@ -3026,7 +3041,7 @@ var require_parser = __commonJS({
3026
3041
  return TemplateLiteral$0(state);
3027
3042
  }
3028
3043
  }
3029
- var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
3044
+ var TemplateSubstitution$0 = $S($EXPECT($L121, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
3030
3045
  function TemplateSubstitution(state) {
3031
3046
  if (state.verbose)
3032
3047
  console.log("ENTER:", "TemplateSubstitution");
@@ -3083,7 +3098,7 @@ var require_parser = __commonJS({
3083
3098
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3084
3099
  }
3085
3100
  }
3086
- var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
3101
+ var JSMultiLineComment$0 = $S($EXPECT($L122, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L123, fail, 'JSMultiLineComment "*/"'));
3087
3102
  function JSMultiLineComment(state) {
3088
3103
  if (state.verbose)
3089
3104
  console.log("ENTER:", "JSMultiLineComment");
@@ -3107,7 +3122,7 @@ var require_parser = __commonJS({
3107
3122
  return CoffeeSingleLineComment$0(state);
3108
3123
  }
3109
3124
  }
3110
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), function(value) {
3125
+ var CoffeeMultiLineComment$0 = $T($S($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), function(value) {
3111
3126
  return ["/*", value[1], "*/"];
3112
3127
  });
3113
3128
  function CoffeeMultiLineComment(state) {
@@ -3119,7 +3134,7 @@ var require_parser = __commonJS({
3119
3134
  return CoffeeMultiLineComment$0(state);
3120
3135
  }
3121
3136
  }
3122
- var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L122, fail, 'InlineComment "*/"'));
3137
+ var InlineComment$0 = $S($EXPECT($L122, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L123, fail, 'InlineComment "*/"'));
3123
3138
  function InlineComment(state) {
3124
3139
  if (state.verbose)
3125
3140
  console.log("ENTER:", "InlineComment");
@@ -3169,7 +3184,7 @@ var require_parser = __commonJS({
3169
3184
  return __$0(state);
3170
3185
  }
3171
3186
  }
3172
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3187
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L89, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3173
3188
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
3174
3189
  return [";", value];
3175
3190
  });
@@ -3204,7 +3219,7 @@ var require_parser = __commonJS({
3204
3219
  return JSXElement$0(state) || JSXElement$1(state);
3205
3220
  }
3206
3221
  }
3207
- var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
3222
+ var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L125, fail, 'JSXSelfClosingElement "/>"'));
3208
3223
  function JSXSelfClosingElement(state) {
3209
3224
  if (state.verbose)
3210
3225
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3214,7 +3229,7 @@ var require_parser = __commonJS({
3214
3229
  return JSXSelfClosingElement$0(state);
3215
3230
  }
3216
3231
  }
3217
- var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
3232
+ var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L68, fail, 'JSXOpeningElement ">"'));
3218
3233
  function JSXOpeningElement(state) {
3219
3234
  if (state.verbose)
3220
3235
  console.log("ENTER:", "JSXOpeningElement");
@@ -3224,7 +3239,7 @@ var require_parser = __commonJS({
3224
3239
  return JSXOpeningElement$0(state);
3225
3240
  }
3226
3241
  }
3227
- var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
3242
+ var JSXClosingElement$0 = $S($EXPECT($L126, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L68, fail, 'JSXClosingElement ">"'));
3228
3243
  function JSXClosingElement(state) {
3229
3244
  if (state.verbose)
3230
3245
  console.log("ENTER:", "JSXClosingElement");
@@ -3234,7 +3249,7 @@ var require_parser = __commonJS({
3234
3249
  return JSXClosingElement$0(state);
3235
3250
  }
3236
3251
  }
3237
- var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
3252
+ var JSXFragment$0 = $S($EXPECT($L127, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L128, fail, 'JSXFragment "</>"'));
3238
3253
  function JSXFragment(state) {
3239
3254
  if (state.verbose)
3240
3255
  console.log("ENTER:", "JSXFragment");
@@ -3274,7 +3289,7 @@ var require_parser = __commonJS({
3274
3289
  return JSXAttributes$0(state);
3275
3290
  }
3276
3291
  }
3277
- var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
3292
+ var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L34, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
3278
3293
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3279
3294
  function JSXAttribute(state) {
3280
3295
  if (state.tokenize) {
@@ -3293,7 +3308,7 @@ var require_parser = __commonJS({
3293
3308
  return JSXAttributeName$0(state);
3294
3309
  }
3295
3310
  }
3296
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3311
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L57, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3297
3312
  function JSXAttributeInitializer(state) {
3298
3313
  if (state.verbose)
3299
3314
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -3346,7 +3361,7 @@ var require_parser = __commonJS({
3346
3361
  return JSXText$0(state);
3347
3362
  }
3348
3363
  }
3349
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3364
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L34, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3350
3365
  function JSXChildExpression(state) {
3351
3366
  if (state.verbose)
3352
3367
  console.log("ENTER:", "JSXChildExpression");
@@ -3368,8 +3383,8 @@ var require_parser = __commonJS({
3368
3383
  return TypeDeclaration$0(state);
3369
3384
  }
3370
3385
  }
3371
- var TypeDeclarationModifier$0 = $S($EXPECT($L128, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
3372
- var TypeDeclarationModifier$1 = $S($EXPECT($L113, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
3386
+ var TypeDeclarationModifier$0 = $S($EXPECT($L129, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
3387
+ var TypeDeclarationModifier$1 = $S($EXPECT($L114, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
3373
3388
  function TypeDeclarationModifier(state) {
3374
3389
  if (state.tokenize) {
3375
3390
  return $TOKEN("TypeDeclarationModifier", state, TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state));
@@ -3377,7 +3392,7 @@ var require_parser = __commonJS({
3377
3392
  return TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state);
3378
3393
  }
3379
3394
  }
3380
- var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclarationRest "="'), __, Type);
3395
+ var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L57, fail, 'TypeDeclarationRest "="'), __, Type);
3381
3396
  var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
3382
3397
  var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
3383
3398
  function TypeDeclarationRest(state) {
@@ -3387,7 +3402,7 @@ var require_parser = __commonJS({
3387
3402
  return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
3388
3403
  }
3389
3404
  }
3390
- var TypeKeyword$0 = $S($EXPECT($L129, fail, 'TypeKeyword "type"'), NonIdContinue);
3405
+ var TypeKeyword$0 = $S($EXPECT($L130, fail, 'TypeKeyword "type"'), NonIdContinue);
3391
3406
  function TypeKeyword(state) {
3392
3407
  if (state.verbose)
3393
3408
  console.log("ENTER:", "TypeKeyword");
@@ -3397,7 +3412,7 @@ var require_parser = __commonJS({
3397
3412
  return TypeKeyword$0(state);
3398
3413
  }
3399
3414
  }
3400
- var Interface$0 = $S($EXPECT($L130, fail, 'Interface "interface"'), NonIdContinue);
3415
+ var Interface$0 = $S($EXPECT($L131, fail, 'Interface "interface"'), NonIdContinue);
3401
3416
  function Interface(state) {
3402
3417
  if (state.verbose)
3403
3418
  console.log("ENTER:", "Interface");
@@ -3407,7 +3422,7 @@ var require_parser = __commonJS({
3407
3422
  return Interface$0(state);
3408
3423
  }
3409
3424
  }
3410
- var Namespace$0 = $S($EXPECT($L131, fail, 'Namespace "namespace"'), NonIdContinue);
3425
+ var Namespace$0 = $S($EXPECT($L132, fail, 'Namespace "namespace"'), NonIdContinue);
3411
3426
  function Namespace(state) {
3412
3427
  if (state.verbose)
3413
3428
  console.log("ENTER:", "Namespace");
@@ -3461,7 +3476,7 @@ var require_parser = __commonJS({
3461
3476
  return InterfaceProperty$0(state) || InterfaceProperty$1(state);
3462
3477
  }
3463
3478
  }
3464
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3479
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L89, fail, 'InterfacePropertyDelimiter ";"'));
3465
3480
  var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"')));
3466
3481
  var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3467
3482
  return ";";
@@ -3511,7 +3526,7 @@ var require_parser = __commonJS({
3511
3526
  return NestedTypeDeclaration$0(state);
3512
3527
  }
3513
3528
  }
3514
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L132, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3529
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L133, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L27, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L28, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3515
3530
  function TypeIndexSignature(state) {
3516
3531
  if (state.verbose)
3517
3532
  console.log("ENTER:", "TypeIndexSignature");
@@ -3522,7 +3537,7 @@ var require_parser = __commonJS({
3522
3537
  }
3523
3538
  }
3524
3539
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3525
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3540
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L80, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3526
3541
  function TypeIndex(state) {
3527
3542
  if (state.tokenize) {
3528
3543
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3542,7 +3557,7 @@ var require_parser = __commonJS({
3542
3557
  return TypeSuffix$0(state);
3543
3558
  }
3544
3559
  }
3545
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L133, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3560
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L134, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3546
3561
  return { "ts": true, "children": value };
3547
3562
  });
3548
3563
  function ReturnTypeSuffix(state) {
@@ -3554,7 +3569,7 @@ var require_parser = __commonJS({
3554
3569
  return ReturnTypeSuffix$0(state);
3555
3570
  }
3556
3571
  }
3557
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3572
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L71, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3558
3573
  function TypePredicate(state) {
3559
3574
  if (state.verbose)
3560
3575
  console.log("ENTER:", "TypePredicate");
@@ -3604,9 +3619,9 @@ var require_parser = __commonJS({
3604
3619
  return TypeUnarySuffix$0(state);
3605
3620
  }
3606
3621
  }
3607
- var TypeUnaryOp$0 = $EXPECT($L134, fail, 'TypeUnaryOp "keyof"');
3608
- var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3609
- var TypeUnaryOp$2 = $EXPECT($L135, fail, 'TypeUnaryOp "infer"');
3622
+ var TypeUnaryOp$0 = $EXPECT($L135, fail, 'TypeUnaryOp "keyof"');
3623
+ var TypeUnaryOp$1 = $EXPECT($L86, fail, 'TypeUnaryOp "typeof"');
3624
+ var TypeUnaryOp$2 = $EXPECT($L136, fail, 'TypeUnaryOp "infer"');
3610
3625
  function TypeUnaryOp(state) {
3611
3626
  if (state.tokenize) {
3612
3627
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3614,7 +3629,7 @@ var require_parser = __commonJS({
3614
3629
  return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3615
3630
  }
3616
3631
  }
3617
- var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
3632
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L27, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L28, fail, 'TypeIndexedAccess "]"'));
3618
3633
  function TypeIndexedAccess(state) {
3619
3634
  if (state.verbose)
3620
3635
  console.log("ENTER:", "TypeIndexedAccess");
@@ -3647,8 +3662,8 @@ var require_parser = __commonJS({
3647
3662
  }
3648
3663
  }
3649
3664
  var TypeLiteral$0 = Literal;
3650
- var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3651
- var TypeLiteral$2 = $EXPECT($L136, fail, 'TypeLiteral "[]"');
3665
+ var TypeLiteral$1 = $EXPECT($L85, fail, 'TypeLiteral "void"');
3666
+ var TypeLiteral$2 = $EXPECT($L137, fail, 'TypeLiteral "[]"');
3652
3667
  function TypeLiteral(state) {
3653
3668
  if (state.tokenize) {
3654
3669
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3656,8 +3671,8 @@ var require_parser = __commonJS({
3656
3671
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3657
3672
  }
3658
3673
  }
3659
- var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3660
- var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3674
+ var TypeBinaryOp$0 = $EXPECT($L83, fail, 'TypeBinaryOp "|"');
3675
+ var TypeBinaryOp$1 = $EXPECT($L81, fail, 'TypeBinaryOp "&"');
3661
3676
  function TypeBinaryOp(state) {
3662
3677
  if (state.tokenize) {
3663
3678
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3675,7 +3690,7 @@ var require_parser = __commonJS({
3675
3690
  return FunctionType$0(state);
3676
3691
  }
3677
3692
  }
3678
- var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
3693
+ var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L68, fail, 'TypeArguments ">"'));
3679
3694
  function TypeArguments(state) {
3680
3695
  if (state.verbose)
3681
3696
  console.log("ENTER:", "TypeArguments");
@@ -3685,7 +3700,7 @@ var require_parser = __commonJS({
3685
3700
  return TypeArguments$0(state);
3686
3701
  }
3687
3702
  }
3688
- var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
3703
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L68, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
3689
3704
  return { ts: true, children: $0 };
3690
3705
  });
3691
3706
  function TypeParameters(state) {
@@ -3718,8 +3733,8 @@ var require_parser = __commonJS({
3718
3733
  }
3719
3734
  }
3720
3735
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3721
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3722
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3736
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L68, fail, 'TypeParameterDelimiter ">"')));
3737
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L68, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3723
3738
  return ",";
3724
3739
  });
3725
3740
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3784,7 +3799,7 @@ var require_parser = __commonJS({
3784
3799
  return EOF$0(state);
3785
3800
  }
3786
3801
  }
3787
- var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3802
+ var Debugger$0 = $TV($EXPECT($L33, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3788
3803
  debugger;
3789
3804
  });
3790
3805
  function Debugger(state) {
@@ -3796,7 +3811,7 @@ var require_parser = __commonJS({
3796
3811
  return Debugger$0(state);
3797
3812
  }
3798
3813
  }
3799
- var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
3814
+ var InsertOpenParen$0 = $T($EXPECT($L33, fail, 'InsertOpenParen ""'), function(value) {
3800
3815
  return "(";
3801
3816
  });
3802
3817
  function InsertOpenParen(state) {
@@ -3808,7 +3823,7 @@ var require_parser = __commonJS({
3808
3823
  return InsertOpenParen$0(state);
3809
3824
  }
3810
3825
  }
3811
- var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
3826
+ var InsertCloseParen$0 = $T($EXPECT($L33, fail, 'InsertCloseParen ""'), function(value) {
3812
3827
  return ")";
3813
3828
  });
3814
3829
  function InsertCloseParen(state) {
@@ -3820,7 +3835,7 @@ var require_parser = __commonJS({
3820
3835
  return InsertCloseParen$0(state);
3821
3836
  }
3822
3837
  }
3823
- var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
3838
+ var InsertOpenBrace$0 = $T($EXPECT($L33, fail, 'InsertOpenBrace ""'), function(value) {
3824
3839
  return " {";
3825
3840
  });
3826
3841
  function InsertOpenBrace(state) {
@@ -3832,7 +3847,7 @@ var require_parser = __commonJS({
3832
3847
  return InsertOpenBrace$0(state);
3833
3848
  }
3834
3849
  }
3835
- var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
3850
+ var InsertCloseBrace$0 = $T($EXPECT($L33, fail, 'InsertCloseBrace ""'), function(value) {
3836
3851
  return "}";
3837
3852
  });
3838
3853
  function InsertCloseBrace(state) {
@@ -3844,7 +3859,7 @@ var require_parser = __commonJS({
3844
3859
  return InsertCloseBrace$0(state);
3845
3860
  }
3846
3861
  }
3847
- var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3862
+ var InsertNewline$0 = $TV($EXPECT($L33, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3848
3863
  return "\n";
3849
3864
  });
3850
3865
  function InsertNewline(state) {
@@ -3856,7 +3871,7 @@ var require_parser = __commonJS({
3856
3871
  return InsertNewline$0(state);
3857
3872
  }
3858
3873
  }
3859
- var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3874
+ var InsertIndent$0 = $TV($EXPECT($L33, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3860
3875
  return "".padStart(global.currentIndent * 2);
3861
3876
  });
3862
3877
  function InsertIndent(state) {
@@ -3868,7 +3883,7 @@ var require_parser = __commonJS({
3868
3883
  return InsertIndent$0(state);
3869
3884
  }
3870
3885
  }
3871
- var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
3886
+ var InsertSpace$0 = $T($EXPECT($L33, fail, 'InsertSpace ""'), function(value) {
3872
3887
  return " ";
3873
3888
  });
3874
3889
  function InsertSpace(state) {
@@ -3880,7 +3895,7 @@ var require_parser = __commonJS({
3880
3895
  return InsertSpace$0(state);
3881
3896
  }
3882
3897
  }
3883
- var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
3898
+ var InsertDot$0 = $T($EXPECT($L33, fail, 'InsertDot ""'), function(value) {
3884
3899
  return ".";
3885
3900
  });
3886
3901
  function InsertDot(state) {
@@ -3892,7 +3907,7 @@ var require_parser = __commonJS({
3892
3907
  return InsertDot$0(state);
3893
3908
  }
3894
3909
  }
3895
- var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
3910
+ var InsertBreak$0 = $T($EXPECT($L33, fail, 'InsertBreak ""'), function(value) {
3896
3911
  return "break;";
3897
3912
  });
3898
3913
  function InsertBreak(state) {
@@ -3904,7 +3919,7 @@ var require_parser = __commonJS({
3904
3919
  return InsertBreak$0(state);
3905
3920
  }
3906
3921
  }
3907
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3922
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L33, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3908
3923
  var directives = $2;
3909
3924
  global.currentIndent = 0;
3910
3925
  global.indentLevels = [0];
@@ -3932,7 +3947,7 @@ var require_parser = __commonJS({
3932
3947
  return Init$0(state);
3933
3948
  }
3934
3949
  }
3935
- var Indent$0 = $TV($Q($C($EXPECT($L137, fail, 'Indent " "'), $EXPECT($L138, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3950
+ var Indent$0 = $TV($Q($C($EXPECT($L138, fail, 'Indent " "'), $EXPECT($L139, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3936
3951
  return $1.length;
3937
3952
  });
3938
3953
  function Indent(state) {
@@ -3944,7 +3959,7 @@ var require_parser = __commonJS({
3944
3959
  return Indent$0(state);
3945
3960
  }
3946
3961
  }
3947
- var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3962
+ var PushIndent$0 = $TV($EXPECT($L33, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3948
3963
  global.currentIndent++;
3949
3964
  if (global.verbose) {
3950
3965
  console.log("pushing indent", global.currentIndent);
@@ -3961,7 +3976,7 @@ var require_parser = __commonJS({
3961
3976
  return PushIndent$0(state);
3962
3977
  }
3963
3978
  }
3964
- var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3979
+ var PopIndent$0 = $TV($EXPECT($L33, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3965
3980
  if (global.verbose) {
3966
3981
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3967
3982
  }