@danielx/civet 0.2.11 → 0.2.12

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 +6 -8
  2. package/dist/browser.js +281 -253
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +9 -9
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +281 -253
  7. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -508,6 +508,7 @@ var require_parser = __commonJS({
508
508
  LoopStatement,
509
509
  DoWhileStatement,
510
510
  WhileStatement,
511
+ WhileClause,
511
512
  ForStatement,
512
513
  ForInOfStatement,
513
514
  ForDeclaration,
@@ -672,113 +673,115 @@ var require_parser = __commonJS({
672
673
  var $L24 = $L("[");
673
674
  var $L25 = $L("]");
674
675
  var $L26 = $L(".");
675
- var $L27 = $L("super[");
676
- var $L28 = $L("new.target");
677
- var $L29 = $L("import.meta");
678
- var $L30 = $L("");
679
- var $L31 = $L("...");
680
- var $L32 = $L("function");
681
- var $L33 = $L("->");
682
- var $L34 = $L("true");
683
- var $L35 = $L("false");
684
- var $L36 = $L("null");
685
- var $L37 = $L("undefined");
686
- var $L38 = $L("get");
687
- var $L39 = $L("set");
688
- var $L40 = $L("**=");
689
- var $L41 = $L("*=");
690
- var $L42 = $L("/=");
691
- var $L43 = $L("%=");
692
- var $L44 = $L("+=");
693
- var $L45 = $L("-=");
694
- var $L46 = $L("<<=");
695
- var $L47 = $L(">>>=");
696
- var $L48 = $L(">>=");
697
- var $L49 = $L("&&=");
698
- var $L50 = $L("&=");
699
- var $L51 = $L("^=");
700
- var $L52 = $L("||=");
701
- var $L53 = $L("|=");
702
- var $L54 = $L("??=");
703
- var $L55 = $L("=");
704
- var $L56 = $L("**");
705
- var $L57 = $L("/");
706
- var $L58 = $L("%");
707
- var $L59 = $L("+");
708
- var $L60 = $L("-");
709
- var $L61 = $L("<=");
710
- var $L62 = $L(">=");
711
- var $L63 = $L("<<");
712
- var $L64 = $L(">>>");
713
- var $L65 = $L(">>");
714
- var $L66 = $L(">");
715
- var $L67 = $L("!==");
716
- var $L68 = $L("!=");
717
- var $L69 = $L("is");
718
- var $L70 = $L("===");
719
- var $L71 = $L("==");
720
- var $L72 = $L("and");
721
- var $L73 = $L("&&");
722
- var $L74 = $L("or");
723
- var $L75 = $L("||");
724
- var $L76 = $L("??");
725
- var $L77 = $L("instanceof");
726
- var $L78 = $L("in");
727
- var $L79 = $L("&");
728
- var $L80 = $L("^");
729
- var $L81 = $L("|");
730
- var $L82 = $L("delete");
731
- var $L83 = $L("void");
732
- var $L84 = $L("typeof");
733
- var $L85 = $L("if");
734
- var $L86 = $L("unless");
735
- var $L87 = $L(";");
736
- var $L88 = $L("else");
737
- var $L89 = $L("loop");
738
- var $L90 = $L("do");
739
- var $L91 = $L("while");
740
- var $L92 = $L("for");
741
- var $L93 = $L("var");
742
- var $L94 = $L("await");
743
- var $L95 = $L("of");
744
- var $L96 = $L("let");
745
- var $L97 = $L("const");
746
- var $L98 = $L("switch");
747
- var $L99 = $L("case");
748
- var $L100 = $L("default");
749
- var $L101 = $L("when");
750
- var $L102 = $L("try");
751
- var $L103 = $L("catch");
752
- var $L104 = $L("finally");
753
- var $L105 = $L("break");
754
- var $L106 = $L("continue");
755
- var $L107 = $L("debugger");
756
- var $L108 = $L("return");
757
- var $L109 = $L("throw");
758
- var $L110 = $L("import type");
759
- var $L111 = $L("from");
760
- var $L112 = $L("export");
761
- var $L113 = $L(":=");
762
- var $L114 = $L('"""');
763
- var $L115 = $L('"');
764
- var $L116 = $L("'");
765
- var $L117 = $L("\\");
766
- var $L118 = $L("`");
767
- var $L119 = $L("${");
768
- var $L120 = $L("/*");
769
- var $L121 = $L("*/");
770
- var $L122 = $L("###");
771
- var $L123 = $L("/>");
772
- var $L124 = $L("</");
773
- var $L125 = $L("<>");
774
- var $L126 = $L("</>");
775
- var $L127 = $L("readonly");
776
- var $L128 = $L("asserts");
777
- var $L129 = $L("keyof");
778
- var $L130 = $L("infer");
779
- var $L131 = $L("[]");
780
- var $L132 = $L(" ");
781
- var $L133 = $L(" ");
676
+ var $L27 = $L("::");
677
+ var $L28 = $L("super[");
678
+ var $L29 = $L("new.target");
679
+ var $L30 = $L("import.meta");
680
+ var $L31 = $L("");
681
+ var $L32 = $L("...");
682
+ var $L33 = $L("function");
683
+ var $L34 = $L("->");
684
+ var $L35 = $L("true");
685
+ var $L36 = $L("false");
686
+ var $L37 = $L("null");
687
+ var $L38 = $L("undefined");
688
+ var $L39 = $L("get");
689
+ var $L40 = $L("set");
690
+ var $L41 = $L("**=");
691
+ var $L42 = $L("*=");
692
+ var $L43 = $L("/=");
693
+ var $L44 = $L("%=");
694
+ var $L45 = $L("+=");
695
+ var $L46 = $L("-=");
696
+ var $L47 = $L("<<=");
697
+ var $L48 = $L(">>>=");
698
+ var $L49 = $L(">>=");
699
+ var $L50 = $L("&&=");
700
+ var $L51 = $L("&=");
701
+ var $L52 = $L("^=");
702
+ var $L53 = $L("||=");
703
+ var $L54 = $L("|=");
704
+ var $L55 = $L("??=");
705
+ var $L56 = $L("=");
706
+ var $L57 = $L("**");
707
+ var $L58 = $L("/");
708
+ var $L59 = $L("%");
709
+ var $L60 = $L("+");
710
+ var $L61 = $L("-");
711
+ var $L62 = $L("<=");
712
+ var $L63 = $L(">=");
713
+ var $L64 = $L("<<");
714
+ var $L65 = $L(">>>");
715
+ var $L66 = $L(">>");
716
+ var $L67 = $L(">");
717
+ var $L68 = $L("!==");
718
+ var $L69 = $L("!=");
719
+ var $L70 = $L("is");
720
+ var $L71 = $L("===");
721
+ var $L72 = $L("==");
722
+ var $L73 = $L("and");
723
+ var $L74 = $L("&&");
724
+ var $L75 = $L("or");
725
+ var $L76 = $L("||");
726
+ var $L77 = $L("??");
727
+ var $L78 = $L("instanceof");
728
+ var $L79 = $L("in");
729
+ var $L80 = $L("&");
730
+ var $L81 = $L("^");
731
+ var $L82 = $L("|");
732
+ var $L83 = $L("delete");
733
+ var $L84 = $L("void");
734
+ var $L85 = $L("typeof");
735
+ var $L86 = $L("if");
736
+ var $L87 = $L("unless");
737
+ var $L88 = $L(";");
738
+ var $L89 = $L("else");
739
+ var $L90 = $L("loop");
740
+ var $L91 = $L("do");
741
+ var $L92 = $L("while");
742
+ var $L93 = $L("until");
743
+ var $L94 = $L("for");
744
+ var $L95 = $L("var");
745
+ var $L96 = $L("await");
746
+ var $L97 = $L("of");
747
+ var $L98 = $L("let");
748
+ var $L99 = $L("const");
749
+ var $L100 = $L("switch");
750
+ var $L101 = $L("case");
751
+ var $L102 = $L("default");
752
+ var $L103 = $L("when");
753
+ var $L104 = $L("try");
754
+ var $L105 = $L("catch");
755
+ var $L106 = $L("finally");
756
+ var $L107 = $L("break");
757
+ var $L108 = $L("continue");
758
+ var $L109 = $L("debugger");
759
+ var $L110 = $L("return");
760
+ var $L111 = $L("throw");
761
+ var $L112 = $L("import type");
762
+ var $L113 = $L("from");
763
+ var $L114 = $L("export");
764
+ var $L115 = $L(":=");
765
+ var $L116 = $L('"""');
766
+ var $L117 = $L('"');
767
+ var $L118 = $L("'");
768
+ var $L119 = $L("\\");
769
+ var $L120 = $L("`");
770
+ var $L121 = $L("${");
771
+ var $L122 = $L("/*");
772
+ var $L123 = $L("*/");
773
+ var $L124 = $L("###");
774
+ var $L125 = $L("/>");
775
+ var $L126 = $L("</");
776
+ var $L127 = $L("<>");
777
+ var $L128 = $L("</>");
778
+ var $L129 = $L("readonly");
779
+ var $L130 = $L("asserts");
780
+ var $L131 = $L("keyof");
781
+ var $L132 = $L("infer");
782
+ var $L133 = $L("[]");
783
+ var $L134 = $L(" ");
784
+ var $L135 = $L(" ");
782
785
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
783
786
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
784
787
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -1188,12 +1191,18 @@ var require_parser = __commonJS({
1188
1191
  var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1189
1192
  var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
1190
1193
  var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1191
- var CallExpressionRest$3 = TemplateLiteral;
1194
+ var CallExpressionRest$3 = $TS($S($EXPECT($L27, fail, 'CallExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1195
+ var id = $2;
1196
+ if (id)
1197
+ return [".prototype.", id];
1198
+ return ".prototype";
1199
+ });
1200
+ var CallExpressionRest$4 = TemplateLiteral;
1192
1201
  function CallExpressionRest(state) {
1193
1202
  if (state.tokenize) {
1194
- return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
1203
+ return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state) || CallExpressionRest$4(state));
1195
1204
  } else {
1196
- return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1205
+ return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state) || CallExpressionRest$4(state);
1197
1206
  }
1198
1207
  }
1199
1208
  var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
@@ -1250,7 +1259,7 @@ var require_parser = __commonJS({
1250
1259
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1251
1260
  }
1252
1261
  }
1253
- var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
1262
+ var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
1254
1263
  function SuperProperty(state) {
1255
1264
  if (state.verbose)
1256
1265
  console.log("ENTER:", "SuperProperty");
@@ -1260,8 +1269,8 @@ var require_parser = __commonJS({
1260
1269
  return SuperProperty$0(state);
1261
1270
  }
1262
1271
  }
1263
- var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
1264
- var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
1272
+ var MetaProperty$0 = $EXPECT($L29, fail, 'MetaProperty "new.target"');
1273
+ var MetaProperty$1 = $EXPECT($L30, fail, 'MetaProperty "import.meta"');
1265
1274
  function MetaProperty(state) {
1266
1275
  if (state.tokenize) {
1267
1276
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1270,7 +1279,7 @@ var require_parser = __commonJS({
1270
1279
  }
1271
1280
  }
1272
1281
  var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1273
- var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
1282
+ var Parameters$1 = $T($EXPECT($L31, fail, 'Parameters ""'), function(value) {
1274
1283
  return "()";
1275
1284
  });
1276
1285
  function Parameters(state) {
@@ -1353,7 +1362,7 @@ var require_parser = __commonJS({
1353
1362
  return BindingProperty$0(state) || BindingProperty$1(state);
1354
1363
  }
1355
1364
  }
1356
- var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1365
+ var BindingRestProperty$0 = $S($EXPECT($L32, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1357
1366
  function BindingRestProperty(state) {
1358
1367
  if (state.verbose)
1359
1368
  console.log("ENTER:", "BindingRestProperty");
@@ -1373,7 +1382,7 @@ var require_parser = __commonJS({
1373
1382
  return BindingElement$0(state);
1374
1383
  }
1375
1384
  }
1376
- var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1385
+ var BindingRestElement$0 = $S($EXPECT($L32, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1377
1386
  function BindingRestElement(state) {
1378
1387
  if (state.verbose)
1379
1388
  console.log("ENTER:", "BindingRestElement");
@@ -1394,7 +1403,7 @@ var require_parser = __commonJS({
1394
1403
  }
1395
1404
  }
1396
1405
  var FunctionExpression$0 = ThinArrowFunction;
1397
- var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L32, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1406
+ var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L33, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1398
1407
  function FunctionExpression(state) {
1399
1408
  if (state.tokenize) {
1400
1409
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1402,7 +1411,7 @@ var require_parser = __commonJS({
1402
1411
  return FunctionExpression$0(state) || FunctionExpression$1(state);
1403
1412
  }
1404
1413
  }
1405
- var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1414
+ var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L34, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1406
1415
  var params = value[0];
1407
1416
  var suffix = value[1];
1408
1417
  var block = value[4];
@@ -1438,7 +1447,7 @@ var require_parser = __commonJS({
1438
1447
  return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
1439
1448
  }
1440
1449
  }
1441
- var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), $S(PopIndent, $N($EXPECT($L30, fail, 'SingleNestedBlockExpression ""')))), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
1450
+ var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), $S(PopIndent, $N($EXPECT($L31, fail, 'SingleNestedBlockExpression ""')))), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
1442
1451
  var exp = $2;
1443
1452
  if (exp)
1444
1453
  return exp;
@@ -1480,10 +1489,10 @@ var require_parser = __commonJS({
1480
1489
  }
1481
1490
  var Literal$0 = StringLiteral;
1482
1491
  var Literal$1 = NumericLiteral;
1483
- var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
1484
- var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
1485
- var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
1486
- var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
1492
+ var Literal$2 = $EXPECT($L35, fail, 'Literal "true"');
1493
+ var Literal$3 = $EXPECT($L36, fail, 'Literal "false"');
1494
+ var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
1495
+ var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
1487
1496
  function Literal(state) {
1488
1497
  if (state.tokenize) {
1489
1498
  return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
@@ -1600,7 +1609,7 @@ var require_parser = __commonJS({
1600
1609
  return InlineElementList$0(state);
1601
1610
  }
1602
1611
  }
1603
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1612
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L32, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1604
1613
  function ArrayElementExpression(state) {
1605
1614
  if (state.verbose)
1606
1615
  console.log("ENTER:", "ArrayElementExpression");
@@ -1683,7 +1692,7 @@ var require_parser = __commonJS({
1683
1692
  }
1684
1693
  var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1685
1694
  var PropertyDefinition$1 = MethodDefinition;
1686
- var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1695
+ var PropertyDefinition$2 = $S($EXPECT($L32, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1687
1696
  var PropertyDefinition$3 = IdentifierReference;
1688
1697
  function PropertyDefinition(state) {
1689
1698
  if (state.tokenize) {
@@ -1703,8 +1712,8 @@ var require_parser = __commonJS({
1703
1712
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1704
1713
  }
1705
1714
  }
1706
- var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1707
- var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1715
+ var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1716
+ var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1708
1717
  var MethodDefinition$2 = AsyncGeneratorMethod;
1709
1718
  var MethodDefinition$3 = AsyncMethod;
1710
1719
  var MethodDefinition$4 = GeneratorMethod;
@@ -1795,22 +1804,22 @@ var require_parser = __commonJS({
1795
1804
  return AsyncGeneratorBody$0(state);
1796
1805
  }
1797
1806
  }
1798
- var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
1799
- var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
1800
- var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
1801
- var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
1802
- var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
1803
- var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
1804
- var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
1805
- var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
1806
- var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
1807
- var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
1808
- var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
1809
- var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
1810
- var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
1811
- var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
1812
- var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
1813
- var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
1807
+ var AssignmentOp$0 = $EXPECT($L41, fail, 'AssignmentOp "**="');
1808
+ var AssignmentOp$1 = $EXPECT($L42, fail, 'AssignmentOp "*="');
1809
+ var AssignmentOp$2 = $EXPECT($L43, fail, 'AssignmentOp "/="');
1810
+ var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
1811
+ var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
1812
+ var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
1813
+ var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
1814
+ var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
1815
+ var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
1816
+ var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
1817
+ var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
1818
+ var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
1819
+ var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
1820
+ var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
1821
+ var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
1822
+ var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
1814
1823
  function AssignmentOp(state) {
1815
1824
  if (state.tokenize) {
1816
1825
  return $TOKEN("AssignmentOp", state, AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state));
@@ -1818,48 +1827,48 @@ var require_parser = __commonJS({
1818
1827
  return AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state);
1819
1828
  }
1820
1829
  }
1821
- var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
1830
+ var BinaryOp$0 = $EXPECT($L57, fail, 'BinaryOp "**"');
1822
1831
  var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
1823
- var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
1824
- var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
1825
- var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
1826
- var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
1827
- var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
1828
- var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
1829
- var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
1832
+ var BinaryOp$2 = $EXPECT($L58, fail, 'BinaryOp "/"');
1833
+ var BinaryOp$3 = $EXPECT($L59, fail, 'BinaryOp "%"');
1834
+ var BinaryOp$4 = $EXPECT($L60, fail, 'BinaryOp "+"');
1835
+ var BinaryOp$5 = $EXPECT($L61, fail, 'BinaryOp "-"');
1836
+ var BinaryOp$6 = $EXPECT($L62, fail, 'BinaryOp "<="');
1837
+ var BinaryOp$7 = $EXPECT($L63, fail, 'BinaryOp ">="');
1838
+ var BinaryOp$8 = $EXPECT($L64, fail, 'BinaryOp "<<"');
1830
1839
  var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
1831
- var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
1832
- var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
1833
- var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
1834
- var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
1835
- var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1840
+ var BinaryOp$10 = $EXPECT($L65, fail, 'BinaryOp ">>>"');
1841
+ var BinaryOp$11 = $EXPECT($L66, fail, 'BinaryOp ">>"');
1842
+ var BinaryOp$12 = $EXPECT($L67, fail, 'BinaryOp ">"');
1843
+ var BinaryOp$13 = $EXPECT($L68, fail, 'BinaryOp "!=="');
1844
+ var BinaryOp$14 = $TV($EXPECT($L69, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1836
1845
  if (global.coffeeCompat)
1837
1846
  return "!==";
1838
1847
  return $1;
1839
1848
  });
1840
- var BinaryOp$15 = $T($S($EXPECT($L69, fail, 'BinaryOp "is"'), NonIdContinue), function(value) {
1849
+ var BinaryOp$15 = $T($S($EXPECT($L70, fail, 'BinaryOp "is"'), NonIdContinue), function(value) {
1841
1850
  return "===";
1842
1851
  });
1843
- var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
1844
- var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1852
+ var BinaryOp$16 = $EXPECT($L71, fail, 'BinaryOp "==="');
1853
+ var BinaryOp$17 = $TV($EXPECT($L72, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1845
1854
  if (global.coffeeCompat)
1846
1855
  return "===";
1847
1856
  return $1;
1848
1857
  });
1849
- var BinaryOp$18 = $T($S($EXPECT($L72, fail, 'BinaryOp "and"'), NonIdContinue), function(value) {
1858
+ var BinaryOp$18 = $T($S($EXPECT($L73, fail, 'BinaryOp "and"'), NonIdContinue), function(value) {
1850
1859
  return "&&";
1851
1860
  });
1852
- var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
1853
- var BinaryOp$20 = $T($S($EXPECT($L74, fail, 'BinaryOp "or"'), NonIdContinue), function(value) {
1861
+ var BinaryOp$19 = $EXPECT($L74, fail, 'BinaryOp "&&"');
1862
+ var BinaryOp$20 = $T($S($EXPECT($L75, fail, 'BinaryOp "or"'), NonIdContinue), function(value) {
1854
1863
  return "||";
1855
1864
  });
1856
- var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
1857
- var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
1858
- var BinaryOp$23 = $S($EXPECT($L77, fail, 'BinaryOp "instanceof"'), NonIdContinue);
1859
- var BinaryOp$24 = $S($EXPECT($L78, fail, 'BinaryOp "in"'), NonIdContinue);
1860
- var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
1861
- var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
1862
- var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
1865
+ var BinaryOp$21 = $EXPECT($L76, fail, 'BinaryOp "||"');
1866
+ var BinaryOp$22 = $EXPECT($L77, fail, 'BinaryOp "??"');
1867
+ var BinaryOp$23 = $S($EXPECT($L78, fail, 'BinaryOp "instanceof"'), NonIdContinue);
1868
+ var BinaryOp$24 = $S($EXPECT($L79, fail, 'BinaryOp "in"'), NonIdContinue);
1869
+ var BinaryOp$25 = $EXPECT($L80, fail, 'BinaryOp "&"');
1870
+ var BinaryOp$26 = $EXPECT($L81, fail, 'BinaryOp "^"');
1871
+ var BinaryOp$27 = $EXPECT($L82, fail, 'BinaryOp "|"');
1863
1872
  function BinaryOp(state) {
1864
1873
  if (state.tokenize) {
1865
1874
  return $TOKEN("BinaryOp", state, BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state));
@@ -1868,7 +1877,7 @@ var require_parser = __commonJS({
1868
1877
  }
1869
1878
  }
1870
1879
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
1871
- var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
1880
+ var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
1872
1881
  function UnaryOp(state) {
1873
1882
  if (state.tokenize) {
1874
1883
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -1902,7 +1911,7 @@ var require_parser = __commonJS({
1902
1911
  return StatementListItem$0(state);
1903
1912
  }
1904
1913
  }
1905
- var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L85, fail, 'PostfixConditional "if"'), $EXPECT($L86, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
1914
+ 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) {
1906
1915
  var ws = $1;
1907
1916
  var cond = $2;
1908
1917
  var exp = $4;
@@ -1935,7 +1944,7 @@ var require_parser = __commonJS({
1935
1944
  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);
1936
1945
  }
1937
1946
  }
1938
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
1947
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
1939
1948
  function EmptyStatement(state) {
1940
1949
  if (state.verbose)
1941
1950
  console.log("ENTER:", "EmptyStatement");
@@ -1955,8 +1964,8 @@ var require_parser = __commonJS({
1955
1964
  return BlockStatement$0(state);
1956
1965
  }
1957
1966
  }
1958
- var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
1959
- var IfStatement$1 = $TS($S($EXPECT($L86, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1967
+ var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
1968
+ var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1960
1969
  var condition = $2;
1961
1970
  var block = $3;
1962
1971
  return ["if", condition.map((c) => {
@@ -1986,7 +1995,7 @@ var require_parser = __commonJS({
1986
1995
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
1987
1996
  }
1988
1997
  }
1989
- var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
1998
+ var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
1990
1999
  var b = $3;
1991
2000
  return ["while(true)", b];
1992
2001
  });
@@ -1999,7 +2008,7 @@ var require_parser = __commonJS({
1999
2008
  return LoopStatement$0(state);
2000
2009
  }
2001
2010
  }
2002
- var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
2011
+ var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2003
2012
  function DoWhileStatement(state) {
2004
2013
  if (state.verbose)
2005
2014
  console.log("ENTER:", "DoWhileStatement");
@@ -2009,7 +2018,7 @@ var require_parser = __commonJS({
2009
2018
  return DoWhileStatement$0(state);
2010
2019
  }
2011
2020
  }
2012
- var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), NonIdContinue, Condition, Block);
2021
+ var WhileStatement$0 = $S(WhileClause, Block);
2013
2022
  function WhileStatement(state) {
2014
2023
  if (state.verbose)
2015
2024
  console.log("ENTER:", "WhileStatement");
@@ -2019,7 +2028,26 @@ var require_parser = __commonJS({
2019
2028
  return WhileStatement$0(state);
2020
2029
  }
2021
2030
  }
2022
- var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2031
+ 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) {
2032
+ var kind = $1;
2033
+ var cond = $3;
2034
+ if (kind === "until") {
2035
+ cond[1] = "(!(";
2036
+ cond[5] = "))";
2037
+ return ["while", cond];
2038
+ }
2039
+ return $0;
2040
+ });
2041
+ function WhileClause(state) {
2042
+ if (state.verbose)
2043
+ console.log("ENTER:", "WhileClause");
2044
+ if (state.tokenize) {
2045
+ return $TOKEN("WhileClause", state, WhileClause$0(state));
2046
+ } else {
2047
+ return WhileClause$0(state);
2048
+ }
2049
+ }
2050
+ var ForStatement$0 = $S($EXPECT($L94, fail, 'ForStatement "for"'), NonIdContinue, __, $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);
2023
2051
  function ForStatement(state) {
2024
2052
  if (state.verbose)
2025
2053
  console.log("ENTER:", "ForStatement");
@@ -2029,10 +2057,10 @@ var require_parser = __commonJS({
2029
2057
  return ForStatement$0(state);
2030
2058
  }
2031
2059
  }
2032
- var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2033
- var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2034
- var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2035
- var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2060
+ var ForInOfStatement$0 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2061
+ var ForInOfStatement$1 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2062
+ var ForInOfStatement$2 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2063
+ var ForInOfStatement$3 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2036
2064
  function ForInOfStatement(state) {
2037
2065
  if (state.tokenize) {
2038
2066
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2040,7 +2068,7 @@ var require_parser = __commonJS({
2040
2068
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2041
2069
  }
2042
2070
  }
2043
- var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
2071
+ var ForDeclaration$0 = $S($C($EXPECT($L98, fail, 'ForDeclaration "let"'), $EXPECT($L99, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
2044
2072
  function ForDeclaration(state) {
2045
2073
  if (state.verbose)
2046
2074
  console.log("ENTER:", "ForDeclaration");
@@ -2059,7 +2087,7 @@ var require_parser = __commonJS({
2059
2087
  return ForBinding$0(state) || ForBinding$1(state);
2060
2088
  }
2061
2089
  }
2062
- var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2090
+ var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2063
2091
  function SwitchStatement(state) {
2064
2092
  if (state.verbose)
2065
2093
  console.log("ENTER:", "SwitchStatement");
@@ -2103,9 +2131,9 @@ var require_parser = __commonJS({
2103
2131
  return NestedCaseClause$0(state);
2104
2132
  }
2105
2133
  }
2106
- var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2134
+ var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2107
2135
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2108
- var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2136
+ var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2109
2137
  function CaseClause(state) {
2110
2138
  if (state.tokenize) {
2111
2139
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2113,7 +2141,7 @@ var require_parser = __commonJS({
2113
2141
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2114
2142
  }
2115
2143
  }
2116
- var When$0 = $T($S($EXPECT($L101, fail, 'When "when"'), NonIdContinue), function(value) {
2144
+ var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
2117
2145
  return "case";
2118
2146
  });
2119
2147
  function When(state) {
@@ -2126,7 +2154,7 @@ var require_parser = __commonJS({
2126
2154
  }
2127
2155
  }
2128
2156
  var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2129
- var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
2157
+ var ImpliedColon$1 = $T($EXPECT($L31, fail, 'ImpliedColon ""'), function(value) {
2130
2158
  return ":";
2131
2159
  });
2132
2160
  function ImpliedColon(state) {
@@ -2136,7 +2164,7 @@ var require_parser = __commonJS({
2136
2164
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2137
2165
  }
2138
2166
  }
2139
- var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2167
+ var TryStatement$0 = $TS($S($EXPECT($L104, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2140
2168
  var c = $3;
2141
2169
  var f = $4;
2142
2170
  if (!c && !f) {
@@ -2153,7 +2181,7 @@ var require_parser = __commonJS({
2153
2181
  return TryStatement$0(state);
2154
2182
  }
2155
2183
  }
2156
- var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2184
+ var Catch$0 = $S(__, $EXPECT($L105, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2157
2185
  function Catch(state) {
2158
2186
  if (state.verbose)
2159
2187
  console.log("ENTER:", "Catch");
@@ -2172,7 +2200,7 @@ var require_parser = __commonJS({
2172
2200
  return CatchBind$0(state) || CatchBind$1(state);
2173
2201
  }
2174
2202
  }
2175
- var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
2203
+ var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
2176
2204
  function Finally(state) {
2177
2205
  if (state.verbose)
2178
2206
  console.log("ENTER:", "Finally");
@@ -2210,12 +2238,12 @@ var require_parser = __commonJS({
2210
2238
  return ExpressionStatement$0(state);
2211
2239
  }
2212
2240
  }
2213
- var KeywordStatement$0 = $S($EXPECT($L105, fail, 'KeywordStatement "break"'), NonIdContinue);
2214
- var KeywordStatement$1 = $S($EXPECT($L106, fail, 'KeywordStatement "continue"'), NonIdContinue);
2215
- var KeywordStatement$2 = $S($EXPECT($L107, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2216
- var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue, Expression);
2217
- var KeywordStatement$4 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue);
2218
- var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2241
+ var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
2242
+ var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
2243
+ var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2244
+ var KeywordStatement$3 = $S($EXPECT($L110, fail, 'KeywordStatement "return"'), NonIdContinue, Expression);
2245
+ var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "return"'), NonIdContinue);
2246
+ var KeywordStatement$5 = $S($EXPECT($L111, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2219
2247
  function KeywordStatement(state) {
2220
2248
  if (state.tokenize) {
2221
2249
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
@@ -2223,7 +2251,7 @@ var require_parser = __commonJS({
2223
2251
  return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
2224
2252
  }
2225
2253
  }
2226
- var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2254
+ var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2227
2255
  return { "ts": true, "children": value };
2228
2256
  });
2229
2257
  var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ImportClause, __, FromClause);
@@ -2265,7 +2293,7 @@ var require_parser = __commonJS({
2265
2293
  return NamedImports$0(state);
2266
2294
  }
2267
2295
  }
2268
- var FromClause$0 = $S($EXPECT($L111, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
2296
+ var FromClause$0 = $S($EXPECT($L113, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
2269
2297
  function FromClause(state) {
2270
2298
  if (state.verbose)
2271
2299
  console.log("ENTER:", "FromClause");
@@ -2313,7 +2341,7 @@ var require_parser = __commonJS({
2313
2341
  return ImportedBinding$0(state);
2314
2342
  }
2315
2343
  }
2316
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2344
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2317
2345
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2318
2346
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2319
2347
  function ExportDeclaration(state) {
@@ -2333,7 +2361,7 @@ var require_parser = __commonJS({
2333
2361
  return As$0(state);
2334
2362
  }
2335
2363
  }
2336
- var Export$0 = $S($EXPECT($L112, fail, 'Export "export"'), NonIdContinue);
2364
+ var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
2337
2365
  function Export(state) {
2338
2366
  if (state.verbose)
2339
2367
  console.log("ENTER:", "Export");
@@ -2393,8 +2421,8 @@ var require_parser = __commonJS({
2393
2421
  return HoistableDeclaration$0(state);
2394
2422
  }
2395
2423
  }
2396
- var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2397
- var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
2424
+ var LexicalDeclaration$0 = $S($C($EXPECT($L98, fail, 'LexicalDeclaration "let"'), $EXPECT($L99, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2425
+ var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L115, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
2398
2426
  var bind = value[0];
2399
2427
  var suffix = value[1];
2400
2428
  var ws = value[2];
@@ -2417,7 +2445,7 @@ var require_parser = __commonJS({
2417
2445
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2418
2446
  }
2419
2447
  }
2420
- var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2448
+ var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2421
2449
  function Initializer(state) {
2422
2450
  if (state.verbose)
2423
2451
  console.log("ENTER:", "Initializer");
@@ -2427,7 +2455,7 @@ var require_parser = __commonJS({
2427
2455
  return Initializer$0(state);
2428
2456
  }
2429
2457
  }
2430
- var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2458
+ var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2431
2459
  function VariableStatement(state) {
2432
2460
  if (state.verbose)
2433
2461
  console.log("ENTER:", "VariableStatement");
@@ -2518,11 +2546,11 @@ var require_parser = __commonJS({
2518
2546
  return HexLiteral$0(state);
2519
2547
  }
2520
2548
  }
2521
- var StringLiteral$0 = $T($S($EXPECT($L114, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L114, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
2549
+ var StringLiteral$0 = $T($S($EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
2522
2550
  return ["`", value[1], "`"];
2523
2551
  });
2524
- var StringLiteral$1 = $S($EXPECT($L115, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\""'));
2525
- var StringLiteral$2 = $S($EXPECT($L116, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "\\\\'"`));
2552
+ var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
2553
+ var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
2526
2554
  function StringLiteral(state) {
2527
2555
  if (state.tokenize) {
2528
2556
  return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
@@ -2558,7 +2586,7 @@ var require_parser = __commonJS({
2558
2586
  return TripleDoubleStringCharacter$0(state);
2559
2587
  }
2560
2588
  }
2561
- var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R11, fail, "EscapeSequence /./")));
2589
+ var EscapeSequence$0 = $TEXT($S($EXPECT($L119, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R11, fail, "EscapeSequence /./")));
2562
2590
  function EscapeSequence(state) {
2563
2591
  if (state.verbose)
2564
2592
  console.log("ENTER:", "EscapeSequence");
@@ -2568,7 +2596,7 @@ var require_parser = __commonJS({
2568
2596
  return EscapeSequence$0(state);
2569
2597
  }
2570
2598
  }
2571
- var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2599
+ var RegularExpressionLiteral$0 = $S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2572
2600
  function RegularExpressionLiteral(state) {
2573
2601
  if (state.verbose)
2574
2602
  console.log("ENTER:", "RegularExpressionLiteral");
@@ -2607,7 +2635,7 @@ var require_parser = __commonJS({
2607
2635
  return RegularExpressionFlags$0(state);
2608
2636
  }
2609
2637
  }
2610
- var TemplateLiteral$0 = $S($EXPECT($L118, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L118, fail, 'TemplateLiteral "`"'));
2638
+ var TemplateLiteral$0 = $S($EXPECT($L120, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L120, fail, 'TemplateLiteral "`"'));
2611
2639
  function TemplateLiteral(state) {
2612
2640
  if (state.verbose)
2613
2641
  console.log("ENTER:", "TemplateLiteral");
@@ -2617,7 +2645,7 @@ var require_parser = __commonJS({
2617
2645
  return TemplateLiteral$0(state);
2618
2646
  }
2619
2647
  }
2620
- var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2648
+ var TemplateSubstitution$0 = $S($EXPECT($L121, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2621
2649
  function TemplateSubstitution(state) {
2622
2650
  if (state.verbose)
2623
2651
  console.log("ENTER:", "TemplateSubstitution");
@@ -2674,7 +2702,7 @@ var require_parser = __commonJS({
2674
2702
  return MultiLineComment$0(state) || MultiLineComment$1(state);
2675
2703
  }
2676
2704
  }
2677
- var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R11, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
2705
+ var JSMultiLineComment$0 = $S($EXPECT($L122, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'JSMultiLineComment "*/"')), $EXPECT($R11, fail, "JSMultiLineComment /./")))), $EXPECT($L123, fail, 'JSMultiLineComment "*/"'));
2678
2706
  function JSMultiLineComment(state) {
2679
2707
  if (state.verbose)
2680
2708
  console.log("ENTER:", "JSMultiLineComment");
@@ -2698,7 +2726,7 @@ var require_parser = __commonJS({
2698
2726
  return CoffeeSingleLineComment$0(state);
2699
2727
  }
2700
2728
  }
2701
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R11, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2729
+ var CoffeeMultiLineComment$0 = $T($S($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R11, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2702
2730
  return ["/*", value[1], "*/"];
2703
2731
  });
2704
2732
  function CoffeeMultiLineComment(state) {
@@ -2710,7 +2738,7 @@ var require_parser = __commonJS({
2710
2738
  return CoffeeMultiLineComment$0(state);
2711
2739
  }
2712
2740
  }
2713
- var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($R19, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L121, fail, 'InlineComment "*/"'));
2741
+ var InlineComment$0 = $S($EXPECT($L122, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'InlineComment "*/"')), $EXPECT($R19, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L123, fail, 'InlineComment "*/"'));
2714
2742
  function InlineComment(state) {
2715
2743
  if (state.verbose)
2716
2744
  console.log("ENTER:", "InlineComment");
@@ -2760,7 +2788,7 @@ var require_parser = __commonJS({
2760
2788
  return __$0(state);
2761
2789
  }
2762
2790
  }
2763
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2791
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2764
2792
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
2765
2793
  return [";", value];
2766
2794
  });
@@ -2795,7 +2823,7 @@ var require_parser = __commonJS({
2795
2823
  return JSXElement$0(state) || JSXElement$1(state);
2796
2824
  }
2797
2825
  }
2798
- var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
2826
+ var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L125, fail, 'JSXSelfClosingElement "/>"'));
2799
2827
  function JSXSelfClosingElement(state) {
2800
2828
  if (state.verbose)
2801
2829
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -2805,7 +2833,7 @@ var require_parser = __commonJS({
2805
2833
  return JSXSelfClosingElement$0(state);
2806
2834
  }
2807
2835
  }
2808
- var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
2836
+ var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
2809
2837
  function JSXOpeningElement(state) {
2810
2838
  if (state.verbose)
2811
2839
  console.log("ENTER:", "JSXOpeningElement");
@@ -2815,7 +2843,7 @@ var require_parser = __commonJS({
2815
2843
  return JSXOpeningElement$0(state);
2816
2844
  }
2817
2845
  }
2818
- var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
2846
+ var JSXClosingElement$0 = $S($EXPECT($L126, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
2819
2847
  function JSXClosingElement(state) {
2820
2848
  if (state.verbose)
2821
2849
  console.log("ENTER:", "JSXClosingElement");
@@ -2825,7 +2853,7 @@ var require_parser = __commonJS({
2825
2853
  return JSXClosingElement$0(state);
2826
2854
  }
2827
2855
  }
2828
- var JSXFragment$0 = $S($EXPECT($L125, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L126, fail, 'JSXFragment "</>"'));
2856
+ var JSXFragment$0 = $S($EXPECT($L127, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L128, fail, 'JSXFragment "</>"'));
2829
2857
  function JSXFragment(state) {
2830
2858
  if (state.verbose)
2831
2859
  console.log("ENTER:", "JSXFragment");
@@ -2865,7 +2893,7 @@ var require_parser = __commonJS({
2865
2893
  return JSXAttributes$0(state);
2866
2894
  }
2867
2895
  }
2868
- var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2896
+ var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L32, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2869
2897
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
2870
2898
  function JSXAttribute(state) {
2871
2899
  if (state.tokenize) {
@@ -2884,7 +2912,7 @@ var require_parser = __commonJS({
2884
2912
  return JSXAttributeName$0(state);
2885
2913
  }
2886
2914
  }
2887
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2915
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2888
2916
  function JSXAttributeInitializer(state) {
2889
2917
  if (state.verbose)
2890
2918
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -2937,7 +2965,7 @@ var require_parser = __commonJS({
2937
2965
  return JSXText$0(state);
2938
2966
  }
2939
2967
  }
2940
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2968
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L32, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2941
2969
  function JSXChildExpression(state) {
2942
2970
  if (state.verbose)
2943
2971
  console.log("ENTER:", "JSXChildExpression");
@@ -2947,7 +2975,7 @@ var require_parser = __commonJS({
2947
2975
  return JSXChildExpression$0(state);
2948
2976
  }
2949
2977
  }
2950
- var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
2978
+ var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
2951
2979
  return { "ts": true, "children": value };
2952
2980
  });
2953
2981
  var TypeDeclaration$1 = $T($S($EXPECT($R28, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
@@ -3005,7 +3033,7 @@ var require_parser = __commonJS({
3005
3033
  return InterfaceProperty$0(state);
3006
3034
  }
3007
3035
  }
3008
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
3036
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3009
3037
  var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
3010
3038
  var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3011
3039
  return ";";
@@ -3020,7 +3048,7 @@ var require_parser = __commonJS({
3020
3048
  return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
3021
3049
  }
3022
3050
  }
3023
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L127, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3051
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L129, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3024
3052
  function TypeIndexSignature(state) {
3025
3053
  if (state.verbose)
3026
3054
  console.log("ENTER:", "TypeIndexSignature");
@@ -3031,7 +3059,7 @@ var require_parser = __commonJS({
3031
3059
  }
3032
3060
  }
3033
3061
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3034
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3062
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3035
3063
  function TypeIndex(state) {
3036
3064
  if (state.tokenize) {
3037
3065
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3051,7 +3079,7 @@ var require_parser = __commonJS({
3051
3079
  return TypeSuffix$0(state);
3052
3080
  }
3053
3081
  }
3054
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L128, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3082
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L130, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3055
3083
  return { "ts": true, "children": value };
3056
3084
  });
3057
3085
  function ReturnTypeSuffix(state) {
@@ -3063,7 +3091,7 @@ var require_parser = __commonJS({
3063
3091
  return ReturnTypeSuffix$0(state);
3064
3092
  }
3065
3093
  }
3066
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3094
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3067
3095
  function TypePredicate(state) {
3068
3096
  if (state.verbose)
3069
3097
  console.log("ENTER:", "TypePredicate");
@@ -3113,9 +3141,9 @@ var require_parser = __commonJS({
3113
3141
  return TypeUnarySuffix$0(state);
3114
3142
  }
3115
3143
  }
3116
- var TypeUnaryOp$0 = $EXPECT($L129, fail, 'TypeUnaryOp "keyof"');
3117
- var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
3118
- var TypeUnaryOp$2 = $EXPECT($L130, fail, 'TypeUnaryOp "infer"');
3144
+ var TypeUnaryOp$0 = $EXPECT($L131, fail, 'TypeUnaryOp "keyof"');
3145
+ var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3146
+ var TypeUnaryOp$2 = $EXPECT($L132, fail, 'TypeUnaryOp "infer"');
3119
3147
  function TypeUnaryOp(state) {
3120
3148
  if (state.tokenize) {
3121
3149
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3156,8 +3184,8 @@ var require_parser = __commonJS({
3156
3184
  }
3157
3185
  }
3158
3186
  var TypeLiteral$0 = Literal;
3159
- var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3160
- var TypeLiteral$2 = $EXPECT($L131, fail, 'TypeLiteral "[]"');
3187
+ var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3188
+ var TypeLiteral$2 = $EXPECT($L133, fail, 'TypeLiteral "[]"');
3161
3189
  function TypeLiteral(state) {
3162
3190
  if (state.tokenize) {
3163
3191
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3165,8 +3193,8 @@ var require_parser = __commonJS({
3165
3193
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3166
3194
  }
3167
3195
  }
3168
- var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3169
- var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3196
+ var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3197
+ var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3170
3198
  function TypeBinaryOp(state) {
3171
3199
  if (state.tokenize) {
3172
3200
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3184,7 +3212,7 @@ var require_parser = __commonJS({
3184
3212
  return FunctionType$0(state);
3185
3213
  }
3186
3214
  }
3187
- var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L66, fail, 'TypeArguments ">"'));
3215
+ var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
3188
3216
  function TypeArguments(state) {
3189
3217
  if (state.verbose)
3190
3218
  console.log("ENTER:", "TypeArguments");
@@ -3194,7 +3222,7 @@ var require_parser = __commonJS({
3194
3222
  return TypeArguments$0(state);
3195
3223
  }
3196
3224
  }
3197
- var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L66, fail, 'TypeParameters ">"'));
3225
+ var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
3198
3226
  function TypeParameters(state) {
3199
3227
  if (state.verbose)
3200
3228
  console.log("ENTER:", "TypeParameters");
@@ -3225,8 +3253,8 @@ var require_parser = __commonJS({
3225
3253
  }
3226
3254
  }
3227
3255
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3228
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
3229
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3256
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3257
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3230
3258
  return ",";
3231
3259
  });
3232
3260
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3291,7 +3319,7 @@ var require_parser = __commonJS({
3291
3319
  return EOF$0(state);
3292
3320
  }
3293
3321
  }
3294
- var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
3322
+ var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
3295
3323
  return "(";
3296
3324
  });
3297
3325
  function InsertOpenParen(state) {
@@ -3303,7 +3331,7 @@ var require_parser = __commonJS({
3303
3331
  return InsertOpenParen$0(state);
3304
3332
  }
3305
3333
  }
3306
- var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
3334
+ var InsertCloseParen$0 = $T($EXPECT($L31, fail, 'InsertCloseParen ""'), function(value) {
3307
3335
  return ")";
3308
3336
  });
3309
3337
  function InsertCloseParen(state) {
@@ -3315,7 +3343,7 @@ var require_parser = __commonJS({
3315
3343
  return InsertCloseParen$0(state);
3316
3344
  }
3317
3345
  }
3318
- var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
3346
+ var InsertOpenBrace$0 = $T($EXPECT($L31, fail, 'InsertOpenBrace ""'), function(value) {
3319
3347
  return " {";
3320
3348
  });
3321
3349
  function InsertOpenBrace(state) {
@@ -3327,7 +3355,7 @@ var require_parser = __commonJS({
3327
3355
  return InsertOpenBrace$0(state);
3328
3356
  }
3329
3357
  }
3330
- var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
3358
+ var InsertCloseBrace$0 = $T($EXPECT($L31, fail, 'InsertCloseBrace ""'), function(value) {
3331
3359
  return "}";
3332
3360
  });
3333
3361
  function InsertCloseBrace(state) {
@@ -3339,7 +3367,7 @@ var require_parser = __commonJS({
3339
3367
  return InsertCloseBrace$0(state);
3340
3368
  }
3341
3369
  }
3342
- var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3370
+ var InsertNewline$0 = $TV($EXPECT($L31, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3343
3371
  return "\n";
3344
3372
  });
3345
3373
  function InsertNewline(state) {
@@ -3351,7 +3379,7 @@ var require_parser = __commonJS({
3351
3379
  return InsertNewline$0(state);
3352
3380
  }
3353
3381
  }
3354
- var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3382
+ var InsertIndent$0 = $TV($EXPECT($L31, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3355
3383
  return "".padStart(global.currentIndent * 2);
3356
3384
  });
3357
3385
  function InsertIndent(state) {
@@ -3363,7 +3391,7 @@ var require_parser = __commonJS({
3363
3391
  return InsertIndent$0(state);
3364
3392
  }
3365
3393
  }
3366
- var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
3394
+ var InsertSpace$0 = $T($EXPECT($L31, fail, 'InsertSpace ""'), function(value) {
3367
3395
  return " ";
3368
3396
  });
3369
3397
  function InsertSpace(state) {
@@ -3375,7 +3403,7 @@ var require_parser = __commonJS({
3375
3403
  return InsertSpace$0(state);
3376
3404
  }
3377
3405
  }
3378
- var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
3406
+ var InsertDot$0 = $T($EXPECT($L31, fail, 'InsertDot ""'), function(value) {
3379
3407
  return ".";
3380
3408
  });
3381
3409
  function InsertDot(state) {
@@ -3387,7 +3415,7 @@ var require_parser = __commonJS({
3387
3415
  return InsertDot$0(state);
3388
3416
  }
3389
3417
  }
3390
- var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
3418
+ var InsertBreak$0 = $T($EXPECT($L31, fail, 'InsertBreak ""'), function(value) {
3391
3419
  return "break;";
3392
3420
  });
3393
3421
  function InsertBreak(state) {
@@ -3399,7 +3427,7 @@ var require_parser = __commonJS({
3399
3427
  return InsertBreak$0(state);
3400
3428
  }
3401
3429
  }
3402
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3430
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L31, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3403
3431
  var directives = $2;
3404
3432
  global.currentIndent = 0;
3405
3433
  global.indentLevels = [0];
@@ -3419,7 +3447,7 @@ var require_parser = __commonJS({
3419
3447
  return Init$0(state);
3420
3448
  }
3421
3449
  }
3422
- var Indent$0 = $TV($Q($C($EXPECT($L132, fail, 'Indent " "'), $EXPECT($L133, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3450
+ var Indent$0 = $TV($Q($C($EXPECT($L134, fail, 'Indent " "'), $EXPECT($L135, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3423
3451
  return $1.length;
3424
3452
  });
3425
3453
  function Indent(state) {
@@ -3431,7 +3459,7 @@ var require_parser = __commonJS({
3431
3459
  return Indent$0(state);
3432
3460
  }
3433
3461
  }
3434
- var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3462
+ var PushIndent$0 = $TV($EXPECT($L31, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3435
3463
  global.currentIndent++;
3436
3464
  if (global.verbose) {
3437
3465
  console.log("pushing indent", global.currentIndent);
@@ -3448,7 +3476,7 @@ var require_parser = __commonJS({
3448
3476
  return PushIndent$0(state);
3449
3477
  }
3450
3478
  }
3451
- var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3479
+ var PopIndent$0 = $TV($EXPECT($L31, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3452
3480
  if (global.verbose) {
3453
3481
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3454
3482
  }