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