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