@danielx/civet 0.2.9 → 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 (8) hide show
  1. package/README.md +29 -13
  2. package/dist/browser.js +310 -260
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +12 -12
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +310 -260
  7. package/dist/types.d.ts +18 -0
  8. package/package.json +2 -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,
@@ -537,6 +538,8 @@ var require_parser = __commonJS({
537
538
  ModuleSpecifier,
538
539
  ImportedBinding,
539
540
  ExportDeclaration,
541
+ As,
542
+ Export,
540
543
  ExportFromClause,
541
544
  NamedExports,
542
545
  ExportSpecifier,
@@ -670,113 +673,115 @@ var require_parser = __commonJS({
670
673
  var $L24 = $L("[");
671
674
  var $L25 = $L("]");
672
675
  var $L26 = $L(".");
673
- var $L27 = $L("super[");
674
- var $L28 = $L("new.target");
675
- var $L29 = $L("import.meta");
676
- var $L30 = $L("");
677
- var $L31 = $L("...");
678
- var $L32 = $L("function");
679
- var $L33 = $L("->");
680
- var $L34 = $L("true");
681
- var $L35 = $L("false");
682
- var $L36 = $L("null");
683
- var $L37 = $L("undefined");
684
- var $L38 = $L("get");
685
- var $L39 = $L("set");
686
- var $L40 = $L("**=");
687
- var $L41 = $L("*=");
688
- var $L42 = $L("/=");
689
- var $L43 = $L("%=");
690
- var $L44 = $L("+=");
691
- var $L45 = $L("-=");
692
- var $L46 = $L("<<=");
693
- var $L47 = $L(">>>=");
694
- var $L48 = $L(">>=");
695
- var $L49 = $L("&&=");
696
- var $L50 = $L("&=");
697
- var $L51 = $L("^=");
698
- var $L52 = $L("||=");
699
- var $L53 = $L("|=");
700
- var $L54 = $L("??=");
701
- var $L55 = $L("=");
702
- var $L56 = $L("**");
703
- var $L57 = $L("/");
704
- var $L58 = $L("%");
705
- var $L59 = $L("+");
706
- var $L60 = $L("-");
707
- var $L61 = $L("<=");
708
- var $L62 = $L(">=");
709
- var $L63 = $L("<<");
710
- var $L64 = $L(">>>");
711
- var $L65 = $L(">>");
712
- var $L66 = $L(">");
713
- var $L67 = $L("!==");
714
- var $L68 = $L("!=");
715
- var $L69 = $L("is");
716
- var $L70 = $L("===");
717
- var $L71 = $L("==");
718
- var $L72 = $L("and");
719
- var $L73 = $L("&&");
720
- var $L74 = $L("or");
721
- var $L75 = $L("||");
722
- var $L76 = $L("??");
723
- var $L77 = $L("instanceof");
724
- var $L78 = $L("in");
725
- var $L79 = $L("&");
726
- var $L80 = $L("^");
727
- var $L81 = $L("|");
728
- var $L82 = $L("delete");
729
- var $L83 = $L("void");
730
- var $L84 = $L("typeof");
731
- var $L85 = $L("if");
732
- var $L86 = $L("unless");
733
- var $L87 = $L(";");
734
- var $L88 = $L("else");
735
- var $L89 = $L("loop");
736
- var $L90 = $L("do");
737
- var $L91 = $L("while");
738
- var $L92 = $L("for");
739
- var $L93 = $L("var");
740
- var $L94 = $L("await");
741
- var $L95 = $L("of");
742
- var $L96 = $L("let");
743
- var $L97 = $L("const");
744
- var $L98 = $L("switch");
745
- var $L99 = $L("case");
746
- var $L100 = $L("default");
747
- var $L101 = $L("when");
748
- var $L102 = $L("try");
749
- var $L103 = $L("catch");
750
- var $L104 = $L("finally");
751
- var $L105 = $L("break");
752
- var $L106 = $L("continue");
753
- var $L107 = $L("debugger");
754
- var $L108 = $L("return");
755
- var $L109 = $L("throw");
756
- var $L110 = $L("import type");
757
- var $L111 = $L("from");
758
- var $L112 = $L("export");
759
- var $L113 = $L(":=");
760
- var $L114 = $L('"""');
761
- var $L115 = $L('"');
762
- var $L116 = $L("'");
763
- var $L117 = $L("\\");
764
- var $L118 = $L("`");
765
- var $L119 = $L("${");
766
- var $L120 = $L("/*");
767
- var $L121 = $L("*/");
768
- var $L122 = $L("###");
769
- var $L123 = $L("/>");
770
- var $L124 = $L("</");
771
- var $L125 = $L("<>");
772
- var $L126 = $L("</>");
773
- var $L127 = $L("readonly");
774
- var $L128 = $L("asserts");
775
- var $L129 = $L("keyof");
776
- var $L130 = $L("infer");
777
- var $L131 = $L("[]");
778
- var $L132 = $L(" ");
779
- 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(" ");
780
785
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
781
786
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
782
787
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -1186,12 +1191,18 @@ var require_parser = __commonJS({
1186
1191
  var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1187
1192
  var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
1188
1193
  var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1189
- 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;
1190
1201
  function CallExpressionRest(state) {
1191
1202
  if (state.tokenize) {
1192
- 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));
1193
1204
  } else {
1194
- 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);
1195
1206
  }
1196
1207
  }
1197
1208
  var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
@@ -1248,7 +1259,7 @@ var require_parser = __commonJS({
1248
1259
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1249
1260
  }
1250
1261
  }
1251
- 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 "]"'));
1252
1263
  function SuperProperty(state) {
1253
1264
  if (state.verbose)
1254
1265
  console.log("ENTER:", "SuperProperty");
@@ -1258,8 +1269,8 @@ var require_parser = __commonJS({
1258
1269
  return SuperProperty$0(state);
1259
1270
  }
1260
1271
  }
1261
- var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
1262
- 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"');
1263
1274
  function MetaProperty(state) {
1264
1275
  if (state.tokenize) {
1265
1276
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1268,7 +1279,7 @@ var require_parser = __commonJS({
1268
1279
  }
1269
1280
  }
1270
1281
  var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1271
- var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
1282
+ var Parameters$1 = $T($EXPECT($L31, fail, 'Parameters ""'), function(value) {
1272
1283
  return "()";
1273
1284
  });
1274
1285
  function Parameters(state) {
@@ -1351,7 +1362,7 @@ var require_parser = __commonJS({
1351
1362
  return BindingProperty$0(state) || BindingProperty$1(state);
1352
1363
  }
1353
1364
  }
1354
- var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1365
+ var BindingRestProperty$0 = $S($EXPECT($L32, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1355
1366
  function BindingRestProperty(state) {
1356
1367
  if (state.verbose)
1357
1368
  console.log("ENTER:", "BindingRestProperty");
@@ -1371,7 +1382,7 @@ var require_parser = __commonJS({
1371
1382
  return BindingElement$0(state);
1372
1383
  }
1373
1384
  }
1374
- var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1385
+ var BindingRestElement$0 = $S($EXPECT($L32, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1375
1386
  function BindingRestElement(state) {
1376
1387
  if (state.verbose)
1377
1388
  console.log("ENTER:", "BindingRestElement");
@@ -1392,7 +1403,7 @@ var require_parser = __commonJS({
1392
1403
  }
1393
1404
  }
1394
1405
  var FunctionExpression$0 = ThinArrowFunction;
1395
- 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);
1396
1407
  function FunctionExpression(state) {
1397
1408
  if (state.tokenize) {
1398
1409
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1400,7 +1411,7 @@ var require_parser = __commonJS({
1400
1411
  return FunctionExpression$0(state) || FunctionExpression$1(state);
1401
1412
  }
1402
1413
  }
1403
- 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) {
1404
1415
  var params = value[0];
1405
1416
  var suffix = value[1];
1406
1417
  var block = value[4];
@@ -1436,7 +1447,7 @@ var require_parser = __commonJS({
1436
1447
  return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
1437
1448
  }
1438
1449
  }
1439
- 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) {
1440
1451
  var exp = $2;
1441
1452
  if (exp)
1442
1453
  return exp;
@@ -1478,10 +1489,10 @@ var require_parser = __commonJS({
1478
1489
  }
1479
1490
  var Literal$0 = StringLiteral;
1480
1491
  var Literal$1 = NumericLiteral;
1481
- var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
1482
- var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
1483
- var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
1484
- 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"');
1485
1496
  function Literal(state) {
1486
1497
  if (state.tokenize) {
1487
1498
  return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
@@ -1598,7 +1609,7 @@ var require_parser = __commonJS({
1598
1609
  return InlineElementList$0(state);
1599
1610
  }
1600
1611
  }
1601
- 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));
1602
1613
  function ArrayElementExpression(state) {
1603
1614
  if (state.verbose)
1604
1615
  console.log("ENTER:", "ArrayElementExpression");
@@ -1681,7 +1692,7 @@ var require_parser = __commonJS({
1681
1692
  }
1682
1693
  var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1683
1694
  var PropertyDefinition$1 = MethodDefinition;
1684
- var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1695
+ var PropertyDefinition$2 = $S($EXPECT($L32, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1685
1696
  var PropertyDefinition$3 = IdentifierReference;
1686
1697
  function PropertyDefinition(state) {
1687
1698
  if (state.tokenize) {
@@ -1701,8 +1712,8 @@ var require_parser = __commonJS({
1701
1712
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1702
1713
  }
1703
1714
  }
1704
- var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1705
- 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);
1706
1717
  var MethodDefinition$2 = AsyncGeneratorMethod;
1707
1718
  var MethodDefinition$3 = AsyncMethod;
1708
1719
  var MethodDefinition$4 = GeneratorMethod;
@@ -1793,22 +1804,22 @@ var require_parser = __commonJS({
1793
1804
  return AsyncGeneratorBody$0(state);
1794
1805
  }
1795
1806
  }
1796
- var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
1797
- var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
1798
- var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
1799
- var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
1800
- var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
1801
- var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
1802
- var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
1803
- var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
1804
- var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
1805
- var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
1806
- var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
1807
- var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
1808
- var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
1809
- var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
1810
- var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
1811
- 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 "="');
1812
1823
  function AssignmentOp(state) {
1813
1824
  if (state.tokenize) {
1814
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));
@@ -1816,48 +1827,48 @@ var require_parser = __commonJS({
1816
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);
1817
1828
  }
1818
1829
  }
1819
- var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
1830
+ var BinaryOp$0 = $EXPECT($L57, fail, 'BinaryOp "**"');
1820
1831
  var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
1821
- var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
1822
- var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
1823
- var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
1824
- var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
1825
- var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
1826
- var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
1827
- 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 "<<"');
1828
1839
  var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
1829
- var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
1830
- var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
1831
- var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
1832
- var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
1833
- 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) {
1834
1845
  if (global.coffeeCompat)
1835
1846
  return "!==";
1836
1847
  return $1;
1837
1848
  });
1838
- 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) {
1839
1850
  return "===";
1840
1851
  });
1841
- var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
1842
- 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) {
1843
1854
  if (global.coffeeCompat)
1844
1855
  return "===";
1845
1856
  return $1;
1846
1857
  });
1847
- 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) {
1848
1859
  return "&&";
1849
1860
  });
1850
- var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
1851
- 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) {
1852
1863
  return "||";
1853
1864
  });
1854
- var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
1855
- var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
1856
- var BinaryOp$23 = $S($EXPECT($L77, fail, 'BinaryOp "instanceof"'), NonIdContinue);
1857
- var BinaryOp$24 = $S($EXPECT($L78, fail, 'BinaryOp "in"'), NonIdContinue);
1858
- var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
1859
- var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
1860
- 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 "|"');
1861
1872
  function BinaryOp(state) {
1862
1873
  if (state.tokenize) {
1863
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));
@@ -1866,7 +1877,7 @@ var require_parser = __commonJS({
1866
1877
  }
1867
1878
  }
1868
1879
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
1869
- 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, __);
1870
1881
  function UnaryOp(state) {
1871
1882
  if (state.tokenize) {
1872
1883
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -1900,7 +1911,7 @@ var require_parser = __commonJS({
1900
1911
  return StatementListItem$0(state);
1901
1912
  }
1902
1913
  }
1903
- 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) {
1904
1915
  var ws = $1;
1905
1916
  var cond = $2;
1906
1917
  var exp = $4;
@@ -1933,7 +1944,7 @@ var require_parser = __commonJS({
1933
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);
1934
1945
  }
1935
1946
  }
1936
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
1947
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
1937
1948
  function EmptyStatement(state) {
1938
1949
  if (state.verbose)
1939
1950
  console.log("ENTER:", "EmptyStatement");
@@ -1953,8 +1964,8 @@ var require_parser = __commonJS({
1953
1964
  return BlockStatement$0(state);
1954
1965
  }
1955
1966
  }
1956
- var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
1957
- 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) {
1958
1969
  var condition = $2;
1959
1970
  var block = $3;
1960
1971
  return ["if", condition.map((c) => {
@@ -1984,8 +1995,8 @@ var require_parser = __commonJS({
1984
1995
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
1985
1996
  }
1986
1997
  }
1987
- var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
1988
- var b = $2;
1998
+ var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
1999
+ var b = $3;
1989
2000
  return ["while(true)", b];
1990
2001
  });
1991
2002
  function LoopStatement(state) {
@@ -1997,7 +2008,7 @@ var require_parser = __commonJS({
1997
2008
  return LoopStatement$0(state);
1998
2009
  }
1999
2010
  }
2000
- var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
2011
+ var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2001
2012
  function DoWhileStatement(state) {
2002
2013
  if (state.verbose)
2003
2014
  console.log("ENTER:", "DoWhileStatement");
@@ -2007,7 +2018,7 @@ var require_parser = __commonJS({
2007
2018
  return DoWhileStatement$0(state);
2008
2019
  }
2009
2020
  }
2010
- var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), Condition, Block);
2021
+ var WhileStatement$0 = $S(WhileClause, Block);
2011
2022
  function WhileStatement(state) {
2012
2023
  if (state.verbose)
2013
2024
  console.log("ENTER:", "WhileStatement");
@@ -2017,7 +2028,26 @@ var require_parser = __commonJS({
2017
2028
  return WhileStatement$0(state);
2018
2029
  }
2019
2030
  }
2020
- var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), __, $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);
2021
2051
  function ForStatement(state) {
2022
2052
  if (state.verbose)
2023
2053
  console.log("ENTER:", "ForStatement");
@@ -2027,10 +2057,10 @@ var require_parser = __commonJS({
2027
2057
  return ForStatement$0(state);
2028
2058
  }
2029
2059
  }
2030
- var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, $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);
2031
- var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2032
- var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $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);
2033
- var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $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);
2034
2064
  function ForInOfStatement(state) {
2035
2065
  if (state.tokenize) {
2036
2066
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2038,7 +2068,7 @@ var require_parser = __commonJS({
2038
2068
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2039
2069
  }
2040
2070
  }
2041
- var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), __, ForBinding);
2071
+ var ForDeclaration$0 = $S($C($EXPECT($L98, fail, 'ForDeclaration "let"'), $EXPECT($L99, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
2042
2072
  function ForDeclaration(state) {
2043
2073
  if (state.verbose)
2044
2074
  console.log("ENTER:", "ForDeclaration");
@@ -2057,7 +2087,7 @@ var require_parser = __commonJS({
2057
2087
  return ForBinding$0(state) || ForBinding$1(state);
2058
2088
  }
2059
2089
  }
2060
- var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
2090
+ var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2061
2091
  function SwitchStatement(state) {
2062
2092
  if (state.verbose)
2063
2093
  console.log("ENTER:", "SwitchStatement");
@@ -2101,9 +2131,9 @@ var require_parser = __commonJS({
2101
2131
  return NestedCaseClause$0(state);
2102
2132
  }
2103
2133
  }
2104
- var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2134
+ var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2105
2135
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2106
- var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
2136
+ var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2107
2137
  function CaseClause(state) {
2108
2138
  if (state.tokenize) {
2109
2139
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2111,7 +2141,7 @@ var require_parser = __commonJS({
2111
2141
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2112
2142
  }
2113
2143
  }
2114
- var When$0 = $T($EXPECT($L101, fail, 'When "when"'), function(value) {
2144
+ var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
2115
2145
  return "case";
2116
2146
  });
2117
2147
  function When(state) {
@@ -2124,7 +2154,7 @@ var require_parser = __commonJS({
2124
2154
  }
2125
2155
  }
2126
2156
  var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2127
- var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
2157
+ var ImpliedColon$1 = $T($EXPECT($L31, fail, 'ImpliedColon ""'), function(value) {
2128
2158
  return ":";
2129
2159
  });
2130
2160
  function ImpliedColon(state) {
@@ -2134,7 +2164,7 @@ var require_parser = __commonJS({
2134
2164
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2135
2165
  }
2136
2166
  }
2137
- 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) {
2138
2168
  var c = $3;
2139
2169
  var f = $4;
2140
2170
  if (!c && !f) {
@@ -2151,7 +2181,7 @@ var require_parser = __commonJS({
2151
2181
  return TryStatement$0(state);
2152
2182
  }
2153
2183
  }
2154
- 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);
2155
2185
  function Catch(state) {
2156
2186
  if (state.verbose)
2157
2187
  console.log("ENTER:", "Catch");
@@ -2170,7 +2200,7 @@ var require_parser = __commonJS({
2170
2200
  return CatchBind$0(state) || CatchBind$1(state);
2171
2201
  }
2172
2202
  }
2173
- var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
2203
+ var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
2174
2204
  function Finally(state) {
2175
2205
  if (state.verbose)
2176
2206
  console.log("ENTER:", "Finally");
@@ -2208,12 +2238,12 @@ var require_parser = __commonJS({
2208
2238
  return ExpressionStatement$0(state);
2209
2239
  }
2210
2240
  }
2211
- var KeywordStatement$0 = $EXPECT($L105, fail, 'KeywordStatement "break"');
2212
- var KeywordStatement$1 = $EXPECT($L106, fail, 'KeywordStatement "continue"');
2213
- var KeywordStatement$2 = $EXPECT($L107, fail, 'KeywordStatement "debugger"');
2214
- var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), Expression);
2215
- var KeywordStatement$4 = $EXPECT($L108, fail, 'KeywordStatement "return"');
2216
- var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), 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);
2217
2247
  function KeywordStatement(state) {
2218
2248
  if (state.tokenize) {
2219
2249
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
@@ -2221,11 +2251,11 @@ var require_parser = __commonJS({
2221
2251
  return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
2222
2252
  }
2223
2253
  }
2224
- var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
2254
+ var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2225
2255
  return { "ts": true, "children": value };
2226
2256
  });
2227
- var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
2228
- var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
2257
+ var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ImportClause, __, FromClause);
2258
+ var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ModuleSpecifier);
2229
2259
  function ImportDeclaration(state) {
2230
2260
  if (state.tokenize) {
2231
2261
  return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
@@ -2243,7 +2273,7 @@ var require_parser = __commonJS({
2243
2273
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2244
2274
  }
2245
2275
  }
2246
- var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
2276
+ var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
2247
2277
  function NameSpaceImport(state) {
2248
2278
  if (state.verbose)
2249
2279
  console.log("ENTER:", "NameSpaceImport");
@@ -2263,7 +2293,7 @@ var require_parser = __commonJS({
2263
2293
  return NamedImports$0(state);
2264
2294
  }
2265
2295
  }
2266
- var FromClause$0 = $S($EXPECT($L111, fail, 'FromClause "from"'), __, ModuleSpecifier);
2296
+ var FromClause$0 = $S($EXPECT($L113, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
2267
2297
  function FromClause(state) {
2268
2298
  if (state.verbose)
2269
2299
  console.log("ENTER:", "FromClause");
@@ -2273,7 +2303,7 @@ var require_parser = __commonJS({
2273
2303
  return FromClause$0(state);
2274
2304
  }
2275
2305
  }
2276
- var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
2306
+ var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
2277
2307
  var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
2278
2308
  function ImportSpecifier(state) {
2279
2309
  if (state.tokenize) {
@@ -2311,9 +2341,9 @@ var require_parser = __commonJS({
2311
2341
  return ImportedBinding$0(state);
2312
2342
  }
2313
2343
  }
2314
- var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2315
- var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
2316
- var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
2344
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2345
+ var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2346
+ var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2317
2347
  function ExportDeclaration(state) {
2318
2348
  if (state.tokenize) {
2319
2349
  return $TOKEN("ExportDeclaration", state, ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state));
@@ -2321,7 +2351,27 @@ var require_parser = __commonJS({
2321
2351
  return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
2322
2352
  }
2323
2353
  }
2324
- var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
2354
+ var As$0 = $S($EXPECT($L4, fail, 'As "as"'), NonIdContinue);
2355
+ function As(state) {
2356
+ if (state.verbose)
2357
+ console.log("ENTER:", "As");
2358
+ if (state.tokenize) {
2359
+ return $TOKEN("As", state, As$0(state));
2360
+ } else {
2361
+ return As$0(state);
2362
+ }
2363
+ }
2364
+ var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
2365
+ function Export(state) {
2366
+ if (state.verbose)
2367
+ console.log("ENTER:", "Export");
2368
+ if (state.tokenize) {
2369
+ return $TOKEN("Export", state, Export$0(state));
2370
+ } else {
2371
+ return Export$0(state);
2372
+ }
2373
+ }
2374
+ var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
2325
2375
  var ExportFromClause$1 = NamedExports;
2326
2376
  function ExportFromClause(state) {
2327
2377
  if (state.tokenize) {
@@ -2371,8 +2421,8 @@ var require_parser = __commonJS({
2371
2421
  return HoistableDeclaration$0(state);
2372
2422
  }
2373
2423
  }
2374
- var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2375
- 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) {
2376
2426
  var bind = value[0];
2377
2427
  var suffix = value[1];
2378
2428
  var ws = value[2];
@@ -2395,7 +2445,7 @@ var require_parser = __commonJS({
2395
2445
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2396
2446
  }
2397
2447
  }
2398
- var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2448
+ var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2399
2449
  function Initializer(state) {
2400
2450
  if (state.verbose)
2401
2451
  console.log("ENTER:", "Initializer");
@@ -2405,7 +2455,7 @@ var require_parser = __commonJS({
2405
2455
  return Initializer$0(state);
2406
2456
  }
2407
2457
  }
2408
- var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2458
+ var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2409
2459
  function VariableStatement(state) {
2410
2460
  if (state.verbose)
2411
2461
  console.log("ENTER:", "VariableStatement");
@@ -2496,11 +2546,11 @@ var require_parser = __commonJS({
2496
2546
  return HexLiteral$0(state);
2497
2547
  }
2498
2548
  }
2499
- 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) {
2500
2550
  return ["`", value[1], "`"];
2501
2551
  });
2502
- var StringLiteral$1 = $S($EXPECT($L115, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\""'));
2503
- 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 "\\\\'"`));
2504
2554
  function StringLiteral(state) {
2505
2555
  if (state.tokenize) {
2506
2556
  return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
@@ -2536,7 +2586,7 @@ var require_parser = __commonJS({
2536
2586
  return TripleDoubleStringCharacter$0(state);
2537
2587
  }
2538
2588
  }
2539
- 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 /./")));
2540
2590
  function EscapeSequence(state) {
2541
2591
  if (state.verbose)
2542
2592
  console.log("ENTER:", "EscapeSequence");
@@ -2546,7 +2596,7 @@ var require_parser = __commonJS({
2546
2596
  return EscapeSequence$0(state);
2547
2597
  }
2548
2598
  }
2549
- 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);
2550
2600
  function RegularExpressionLiteral(state) {
2551
2601
  if (state.verbose)
2552
2602
  console.log("ENTER:", "RegularExpressionLiteral");
@@ -2585,7 +2635,7 @@ var require_parser = __commonJS({
2585
2635
  return RegularExpressionFlags$0(state);
2586
2636
  }
2587
2637
  }
2588
- 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 "`"'));
2589
2639
  function TemplateLiteral(state) {
2590
2640
  if (state.verbose)
2591
2641
  console.log("ENTER:", "TemplateLiteral");
@@ -2595,7 +2645,7 @@ var require_parser = __commonJS({
2595
2645
  return TemplateLiteral$0(state);
2596
2646
  }
2597
2647
  }
2598
- 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 "}"'));
2599
2649
  function TemplateSubstitution(state) {
2600
2650
  if (state.verbose)
2601
2651
  console.log("ENTER:", "TemplateSubstitution");
@@ -2652,7 +2702,7 @@ var require_parser = __commonJS({
2652
2702
  return MultiLineComment$0(state) || MultiLineComment$1(state);
2653
2703
  }
2654
2704
  }
2655
- 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 "*/"'));
2656
2706
  function JSMultiLineComment(state) {
2657
2707
  if (state.verbose)
2658
2708
  console.log("ENTER:", "JSMultiLineComment");
@@ -2676,7 +2726,7 @@ var require_parser = __commonJS({
2676
2726
  return CoffeeSingleLineComment$0(state);
2677
2727
  }
2678
2728
  }
2679
- 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) {
2680
2730
  return ["/*", value[1], "*/"];
2681
2731
  });
2682
2732
  function CoffeeMultiLineComment(state) {
@@ -2688,7 +2738,7 @@ var require_parser = __commonJS({
2688
2738
  return CoffeeMultiLineComment$0(state);
2689
2739
  }
2690
2740
  }
2691
- 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 "*/"'));
2692
2742
  function InlineComment(state) {
2693
2743
  if (state.verbose)
2694
2744
  console.log("ENTER:", "InlineComment");
@@ -2738,7 +2788,7 @@ var require_parser = __commonJS({
2738
2788
  return __$0(state);
2739
2789
  }
2740
2790
  }
2741
- 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));
2742
2792
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
2743
2793
  return [";", value];
2744
2794
  });
@@ -2773,7 +2823,7 @@ var require_parser = __commonJS({
2773
2823
  return JSXElement$0(state) || JSXElement$1(state);
2774
2824
  }
2775
2825
  }
2776
- 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 "/>"'));
2777
2827
  function JSXSelfClosingElement(state) {
2778
2828
  if (state.verbose)
2779
2829
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -2783,7 +2833,7 @@ var require_parser = __commonJS({
2783
2833
  return JSXSelfClosingElement$0(state);
2784
2834
  }
2785
2835
  }
2786
- 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 ">"'));
2787
2837
  function JSXOpeningElement(state) {
2788
2838
  if (state.verbose)
2789
2839
  console.log("ENTER:", "JSXOpeningElement");
@@ -2793,7 +2843,7 @@ var require_parser = __commonJS({
2793
2843
  return JSXOpeningElement$0(state);
2794
2844
  }
2795
2845
  }
2796
- 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 ">"'));
2797
2847
  function JSXClosingElement(state) {
2798
2848
  if (state.verbose)
2799
2849
  console.log("ENTER:", "JSXClosingElement");
@@ -2803,7 +2853,7 @@ var require_parser = __commonJS({
2803
2853
  return JSXClosingElement$0(state);
2804
2854
  }
2805
2855
  }
2806
- 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 "</>"'));
2807
2857
  function JSXFragment(state) {
2808
2858
  if (state.verbose)
2809
2859
  console.log("ENTER:", "JSXFragment");
@@ -2843,7 +2893,7 @@ var require_parser = __commonJS({
2843
2893
  return JSXAttributes$0(state);
2844
2894
  }
2845
2895
  }
2846
- 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 "}"'));
2847
2897
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
2848
2898
  function JSXAttribute(state) {
2849
2899
  if (state.tokenize) {
@@ -2862,7 +2912,7 @@ var require_parser = __commonJS({
2862
2912
  return JSXAttributeName$0(state);
2863
2913
  }
2864
2914
  }
2865
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2915
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2866
2916
  function JSXAttributeInitializer(state) {
2867
2917
  if (state.verbose)
2868
2918
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -2915,7 +2965,7 @@ var require_parser = __commonJS({
2915
2965
  return JSXText$0(state);
2916
2966
  }
2917
2967
  }
2918
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2968
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L32, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2919
2969
  function JSXChildExpression(state) {
2920
2970
  if (state.verbose)
2921
2971
  console.log("ENTER:", "JSXChildExpression");
@@ -2925,7 +2975,7 @@ var require_parser = __commonJS({
2925
2975
  return JSXChildExpression$0(state);
2926
2976
  }
2927
2977
  }
2928
- 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) {
2929
2979
  return { "ts": true, "children": value };
2930
2980
  });
2931
2981
  var TypeDeclaration$1 = $T($S($EXPECT($R28, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
@@ -2983,7 +3033,7 @@ var require_parser = __commonJS({
2983
3033
  return InterfaceProperty$0(state);
2984
3034
  }
2985
3035
  }
2986
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
3036
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
2987
3037
  var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
2988
3038
  var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
2989
3039
  return ";";
@@ -2998,7 +3048,7 @@ var require_parser = __commonJS({
2998
3048
  return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
2999
3049
  }
3000
3050
  }
3001
- 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 "?"'))));
3002
3052
  function TypeIndexSignature(state) {
3003
3053
  if (state.verbose)
3004
3054
  console.log("ENTER:", "TypeIndexSignature");
@@ -3009,7 +3059,7 @@ var require_parser = __commonJS({
3009
3059
  }
3010
3060
  }
3011
3061
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3012
- 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)));
3013
3063
  function TypeIndex(state) {
3014
3064
  if (state.tokenize) {
3015
3065
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3029,7 +3079,7 @@ var require_parser = __commonJS({
3029
3079
  return TypeSuffix$0(state);
3030
3080
  }
3031
3081
  }
3032
- 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) {
3033
3083
  return { "ts": true, "children": value };
3034
3084
  });
3035
3085
  function ReturnTypeSuffix(state) {
@@ -3041,7 +3091,7 @@ var require_parser = __commonJS({
3041
3091
  return ReturnTypeSuffix$0(state);
3042
3092
  }
3043
3093
  }
3044
- 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)));
3045
3095
  function TypePredicate(state) {
3046
3096
  if (state.verbose)
3047
3097
  console.log("ENTER:", "TypePredicate");
@@ -3091,9 +3141,9 @@ var require_parser = __commonJS({
3091
3141
  return TypeUnarySuffix$0(state);
3092
3142
  }
3093
3143
  }
3094
- var TypeUnaryOp$0 = $EXPECT($L129, fail, 'TypeUnaryOp "keyof"');
3095
- var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
3096
- 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"');
3097
3147
  function TypeUnaryOp(state) {
3098
3148
  if (state.tokenize) {
3099
3149
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3134,8 +3184,8 @@ var require_parser = __commonJS({
3134
3184
  }
3135
3185
  }
3136
3186
  var TypeLiteral$0 = Literal;
3137
- var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3138
- var TypeLiteral$2 = $EXPECT($L131, fail, 'TypeLiteral "[]"');
3187
+ var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3188
+ var TypeLiteral$2 = $EXPECT($L133, fail, 'TypeLiteral "[]"');
3139
3189
  function TypeLiteral(state) {
3140
3190
  if (state.tokenize) {
3141
3191
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3143,8 +3193,8 @@ var require_parser = __commonJS({
3143
3193
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3144
3194
  }
3145
3195
  }
3146
- var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3147
- var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3196
+ var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3197
+ var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3148
3198
  function TypeBinaryOp(state) {
3149
3199
  if (state.tokenize) {
3150
3200
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3162,7 +3212,7 @@ var require_parser = __commonJS({
3162
3212
  return FunctionType$0(state);
3163
3213
  }
3164
3214
  }
3165
- 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 ">"'));
3166
3216
  function TypeArguments(state) {
3167
3217
  if (state.verbose)
3168
3218
  console.log("ENTER:", "TypeArguments");
@@ -3172,7 +3222,7 @@ var require_parser = __commonJS({
3172
3222
  return TypeArguments$0(state);
3173
3223
  }
3174
3224
  }
3175
- 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 ">"'));
3176
3226
  function TypeParameters(state) {
3177
3227
  if (state.verbose)
3178
3228
  console.log("ENTER:", "TypeParameters");
@@ -3203,8 +3253,8 @@ var require_parser = __commonJS({
3203
3253
  }
3204
3254
  }
3205
3255
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3206
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
3207
- 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) {
3208
3258
  return ",";
3209
3259
  });
3210
3260
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3269,7 +3319,7 @@ var require_parser = __commonJS({
3269
3319
  return EOF$0(state);
3270
3320
  }
3271
3321
  }
3272
- var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
3322
+ var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
3273
3323
  return "(";
3274
3324
  });
3275
3325
  function InsertOpenParen(state) {
@@ -3281,7 +3331,7 @@ var require_parser = __commonJS({
3281
3331
  return InsertOpenParen$0(state);
3282
3332
  }
3283
3333
  }
3284
- var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
3334
+ var InsertCloseParen$0 = $T($EXPECT($L31, fail, 'InsertCloseParen ""'), function(value) {
3285
3335
  return ")";
3286
3336
  });
3287
3337
  function InsertCloseParen(state) {
@@ -3293,7 +3343,7 @@ var require_parser = __commonJS({
3293
3343
  return InsertCloseParen$0(state);
3294
3344
  }
3295
3345
  }
3296
- var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
3346
+ var InsertOpenBrace$0 = $T($EXPECT($L31, fail, 'InsertOpenBrace ""'), function(value) {
3297
3347
  return " {";
3298
3348
  });
3299
3349
  function InsertOpenBrace(state) {
@@ -3305,7 +3355,7 @@ var require_parser = __commonJS({
3305
3355
  return InsertOpenBrace$0(state);
3306
3356
  }
3307
3357
  }
3308
- var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
3358
+ var InsertCloseBrace$0 = $T($EXPECT($L31, fail, 'InsertCloseBrace ""'), function(value) {
3309
3359
  return "}";
3310
3360
  });
3311
3361
  function InsertCloseBrace(state) {
@@ -3317,7 +3367,7 @@ var require_parser = __commonJS({
3317
3367
  return InsertCloseBrace$0(state);
3318
3368
  }
3319
3369
  }
3320
- 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) {
3321
3371
  return "\n";
3322
3372
  });
3323
3373
  function InsertNewline(state) {
@@ -3329,7 +3379,7 @@ var require_parser = __commonJS({
3329
3379
  return InsertNewline$0(state);
3330
3380
  }
3331
3381
  }
3332
- 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) {
3333
3383
  return "".padStart(global.currentIndent * 2);
3334
3384
  });
3335
3385
  function InsertIndent(state) {
@@ -3341,7 +3391,7 @@ var require_parser = __commonJS({
3341
3391
  return InsertIndent$0(state);
3342
3392
  }
3343
3393
  }
3344
- var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
3394
+ var InsertSpace$0 = $T($EXPECT($L31, fail, 'InsertSpace ""'), function(value) {
3345
3395
  return " ";
3346
3396
  });
3347
3397
  function InsertSpace(state) {
@@ -3353,7 +3403,7 @@ var require_parser = __commonJS({
3353
3403
  return InsertSpace$0(state);
3354
3404
  }
3355
3405
  }
3356
- var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
3406
+ var InsertDot$0 = $T($EXPECT($L31, fail, 'InsertDot ""'), function(value) {
3357
3407
  return ".";
3358
3408
  });
3359
3409
  function InsertDot(state) {
@@ -3365,7 +3415,7 @@ var require_parser = __commonJS({
3365
3415
  return InsertDot$0(state);
3366
3416
  }
3367
3417
  }
3368
- var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
3418
+ var InsertBreak$0 = $T($EXPECT($L31, fail, 'InsertBreak ""'), function(value) {
3369
3419
  return "break;";
3370
3420
  });
3371
3421
  function InsertBreak(state) {
@@ -3377,7 +3427,7 @@ var require_parser = __commonJS({
3377
3427
  return InsertBreak$0(state);
3378
3428
  }
3379
3429
  }
3380
- 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) {
3381
3431
  var directives = $2;
3382
3432
  global.currentIndent = 0;
3383
3433
  global.indentLevels = [0];
@@ -3397,7 +3447,7 @@ var require_parser = __commonJS({
3397
3447
  return Init$0(state);
3398
3448
  }
3399
3449
  }
3400
- 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) {
3401
3451
  return $1.length;
3402
3452
  });
3403
3453
  function Indent(state) {
@@ -3409,7 +3459,7 @@ var require_parser = __commonJS({
3409
3459
  return Indent$0(state);
3410
3460
  }
3411
3461
  }
3412
- 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) {
3413
3463
  global.currentIndent++;
3414
3464
  if (global.verbose) {
3415
3465
  console.log("pushing indent", global.currentIndent);
@@ -3426,7 +3476,7 @@ var require_parser = __commonJS({
3426
3476
  return PushIndent$0(state);
3427
3477
  }
3428
3478
  }
3429
- 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) {
3430
3480
  if (global.verbose) {
3431
3481
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3432
3482
  }