@danielx/civet 0.3.6 → 0.3.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/README.md +13 -2
  2. package/dist/browser.js +311 -283
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +7 -7
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +311 -283
  7. package/package.json +2 -1
package/dist/browser.js CHANGED
@@ -446,6 +446,7 @@ var Civet = (() => {
446
446
  CallExpression,
447
447
  CallExpressionRest,
448
448
  OptionalShorthand,
449
+ NonNullAssertion,
449
450
  SpacedApplication,
450
451
  ApplicationStart,
451
452
  AdditionalReservedWords,
@@ -708,119 +709,120 @@ var Civet = (() => {
708
709
  var $L23 = $L("super");
709
710
  var $L24 = $L("import");
710
711
  var $L25 = $L(".");
711
- var $L26 = $L("[");
712
- var $L27 = $L("]");
713
- var $L28 = $L("::");
714
- var $L29 = $L("super[");
715
- var $L30 = $L("new.target");
716
- var $L31 = $L("import.meta");
717
- var $L32 = $L("");
718
- var $L33 = $L("...");
719
- var $L34 = $L("function");
720
- var $L35 = $L("->");
721
- var $L36 = $L("null");
722
- var $L37 = $L("true");
723
- var $L38 = $L("false");
724
- var $L39 = $L("get");
725
- var $L40 = $L("set");
726
- var $L41 = $L("**=");
727
- var $L42 = $L("*=");
728
- var $L43 = $L("/=");
729
- var $L44 = $L("%=");
730
- var $L45 = $L("+=");
731
- var $L46 = $L("-=");
732
- var $L47 = $L("<<=");
733
- var $L48 = $L(">>>=");
734
- var $L49 = $L(">>=");
735
- var $L50 = $L("&&=");
736
- var $L51 = $L("&=");
737
- var $L52 = $L("^=");
738
- var $L53 = $L("||=");
739
- var $L54 = $L("|=");
740
- var $L55 = $L("??=");
741
- var $L56 = $L("=");
742
- var $L57 = $L("**");
743
- var $L58 = $L("/");
744
- var $L59 = $L("%");
745
- var $L60 = $L("+");
746
- var $L61 = $L("-");
747
- var $L62 = $L("<=");
748
- var $L63 = $L(">=");
749
- var $L64 = $L("<<");
750
- var $L65 = $L(">>>");
751
- var $L66 = $L(">>");
752
- var $L67 = $L(">");
753
- var $L68 = $L("!==");
754
- var $L69 = $L("!=");
755
- var $L70 = $L("is");
756
- var $L71 = $L("===");
757
- var $L72 = $L("==");
758
- var $L73 = $L("and");
759
- var $L74 = $L("&&");
760
- var $L75 = $L("or");
761
- var $L76 = $L("||");
762
- var $L77 = $L("??");
763
- var $L78 = $L("instanceof");
764
- var $L79 = $L("in");
765
- var $L80 = $L("&");
766
- var $L81 = $L("^");
767
- var $L82 = $L("|");
768
- var $L83 = $L("delete");
769
- var $L84 = $L("void");
770
- var $L85 = $L("typeof");
771
- var $L86 = $L("if");
772
- var $L87 = $L("unless");
773
- var $L88 = $L(";");
774
- var $L89 = $L("else");
775
- var $L90 = $L("loop");
776
- var $L91 = $L("do");
777
- var $L92 = $L("while");
778
- var $L93 = $L("until");
779
- var $L94 = $L("var");
780
- var $L95 = $L("of");
781
- var $L96 = $L("for");
782
- var $L97 = $L("let");
783
- var $L98 = $L("const");
784
- var $L99 = $L("switch");
785
- var $L100 = $L("case");
786
- var $L101 = $L("default");
787
- var $L102 = $L("when");
788
- var $L103 = $L("try");
789
- var $L104 = $L("catch");
790
- var $L105 = $L("finally");
791
- var $L106 = $L("break");
792
- var $L107 = $L("continue");
793
- var $L108 = $L("debugger");
794
- var $L109 = $L("throw");
795
- var $L110 = $L("return");
796
- var $L111 = $L("import type");
797
- var $L112 = $L("from");
798
- var $L113 = $L("export");
799
- var $L114 = $L(":=");
800
- var $L115 = $L('"""');
801
- var $L116 = $L("'''");
802
- var $L117 = $L('"');
803
- var $L118 = $L("'");
804
- var $L119 = $L("`");
805
- var $L120 = $L("${");
806
- var $L121 = $L("/*");
807
- var $L122 = $L("*/");
808
- var $L123 = $L("###");
809
- var $L124 = $L("/>");
810
- var $L125 = $L("</");
811
- var $L126 = $L("<>");
812
- var $L127 = $L("</>");
813
- var $L128 = $L("declare");
814
- var $L129 = $L("type");
815
- var $L130 = $L("interface");
816
- var $L131 = $L("namespace");
817
- var $L132 = $L("readonly");
818
- var $L133 = $L("asserts");
819
- var $L134 = $L("keyof");
820
- var $L135 = $L("infer");
821
- var $L136 = $L("[]");
822
- var $L137 = $L(" ");
823
- var $L138 = $L(" ");
712
+ var $L26 = $L("!");
713
+ var $L27 = $L("[");
714
+ var $L28 = $L("]");
715
+ var $L29 = $L("::");
716
+ var $L30 = $L("super[");
717
+ var $L31 = $L("new.target");
718
+ var $L32 = $L("import.meta");
719
+ var $L33 = $L("");
720
+ var $L34 = $L("...");
721
+ var $L35 = $L("function");
722
+ var $L36 = $L("->");
723
+ var $L37 = $L("null");
724
+ var $L38 = $L("true");
725
+ var $L39 = $L("false");
726
+ var $L40 = $L("get");
727
+ var $L41 = $L("set");
728
+ var $L42 = $L("**=");
729
+ var $L43 = $L("*=");
730
+ var $L44 = $L("/=");
731
+ var $L45 = $L("%=");
732
+ var $L46 = $L("+=");
733
+ var $L47 = $L("-=");
734
+ var $L48 = $L("<<=");
735
+ var $L49 = $L(">>>=");
736
+ var $L50 = $L(">>=");
737
+ var $L51 = $L("&&=");
738
+ var $L52 = $L("&=");
739
+ var $L53 = $L("^=");
740
+ var $L54 = $L("||=");
741
+ var $L55 = $L("|=");
742
+ var $L56 = $L("??=");
743
+ var $L57 = $L("=");
744
+ var $L58 = $L("**");
745
+ var $L59 = $L("/");
746
+ var $L60 = $L("%");
747
+ var $L61 = $L("+");
748
+ var $L62 = $L("-");
749
+ var $L63 = $L("<=");
750
+ var $L64 = $L(">=");
751
+ var $L65 = $L("<<");
752
+ var $L66 = $L(">>>");
753
+ var $L67 = $L(">>");
754
+ var $L68 = $L(">");
755
+ var $L69 = $L("!==");
756
+ var $L70 = $L("!=");
757
+ var $L71 = $L("is");
758
+ var $L72 = $L("===");
759
+ var $L73 = $L("==");
760
+ var $L74 = $L("and");
761
+ var $L75 = $L("&&");
762
+ var $L76 = $L("or");
763
+ var $L77 = $L("||");
764
+ var $L78 = $L("??");
765
+ var $L79 = $L("instanceof");
766
+ var $L80 = $L("in");
767
+ var $L81 = $L("&");
768
+ var $L82 = $L("^");
769
+ var $L83 = $L("|");
770
+ var $L84 = $L("delete");
771
+ var $L85 = $L("void");
772
+ var $L86 = $L("typeof");
773
+ var $L87 = $L("if");
774
+ var $L88 = $L("unless");
775
+ var $L89 = $L(";");
776
+ var $L90 = $L("else");
777
+ var $L91 = $L("loop");
778
+ var $L92 = $L("do");
779
+ var $L93 = $L("while");
780
+ var $L94 = $L("until");
781
+ var $L95 = $L("var");
782
+ var $L96 = $L("of");
783
+ var $L97 = $L("for");
784
+ var $L98 = $L("let");
785
+ var $L99 = $L("const");
786
+ var $L100 = $L("switch");
787
+ var $L101 = $L("case");
788
+ var $L102 = $L("default");
789
+ var $L103 = $L("when");
790
+ var $L104 = $L("try");
791
+ var $L105 = $L("catch");
792
+ var $L106 = $L("finally");
793
+ var $L107 = $L("break");
794
+ var $L108 = $L("continue");
795
+ var $L109 = $L("debugger");
796
+ var $L110 = $L("throw");
797
+ var $L111 = $L("return");
798
+ var $L112 = $L("import type");
799
+ var $L113 = $L("from");
800
+ var $L114 = $L("export");
801
+ var $L115 = $L(":=");
802
+ var $L116 = $L('"""');
803
+ var $L117 = $L("'''");
804
+ var $L118 = $L('"');
805
+ var $L119 = $L("'");
806
+ var $L120 = $L("`");
807
+ var $L121 = $L("${");
808
+ var $L122 = $L("/*");
809
+ var $L123 = $L("*/");
810
+ var $L124 = $L("###");
811
+ var $L125 = $L("/>");
812
+ var $L126 = $L("</");
813
+ var $L127 = $L("<>");
814
+ var $L128 = $L("</>");
815
+ var $L129 = $L("declare");
816
+ var $L130 = $L("type");
817
+ var $L131 = $L("interface");
818
+ var $L132 = $L("namespace");
819
+ var $L133 = $L("readonly");
820
+ var $L134 = $L("asserts");
821
+ var $L135 = $L("keyof");
822
+ var $L136 = $L("infer");
823
+ var $L137 = $L("[]");
824
+ var $L138 = $L(" ");
825
+ var $L139 = $L(" ");
824
826
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
825
827
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
826
828
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -839,7 +841,7 @@ var Civet = (() => {
839
841
  var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
840
842
  var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
841
843
  var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
842
- var $R18 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
844
+ var $R18 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
843
845
  var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
844
846
  var $R20 = $R(new RegExp(".", "suy"));
845
847
  var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
@@ -1214,8 +1216,8 @@ var Civet = (() => {
1214
1216
  return NestedClassElement$0(state);
1215
1217
  }
1216
1218
  }
1217
- var ClassElement$0 = $S(Static, BracedBlock);
1218
- var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
1219
+ var ClassElement$0 = $S($E($S(Static, $Q(TrailingComment))), $C(MethodDefinition, FieldDefinition));
1220
+ var ClassElement$1 = $S(Static, BracedBlock);
1219
1221
  function ClassElement(state) {
1220
1222
  if (state.tokenize) {
1221
1223
  return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
@@ -1224,7 +1226,7 @@ var Civet = (() => {
1224
1226
  }
1225
1227
  }
1226
1228
  var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
1227
- return { $loc, token: $0 };
1229
+ return { $loc, token: $1 };
1228
1230
  });
1229
1231
  function Static(state) {
1230
1232
  if (state.verbose)
@@ -1235,14 +1237,27 @@ var Civet = (() => {
1235
1237
  return Static$0(state);
1236
1238
  }
1237
1239
  }
1238
- var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
1240
+ var FieldDefinition$0 = $TS($S(ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
1241
+ var name = $1;
1242
+ var suffix = $2;
1243
+ var ws = $3;
1244
+ var ca = $4;
1245
+ var exp = $5;
1246
+ return [
1247
+ { ts: true, token: "readonly ", $loc: ca.$loc },
1248
+ name,
1249
+ suffix,
1250
+ ws,
1251
+ { token: "=", $loc: ca.$loc },
1252
+ exp
1253
+ ];
1254
+ });
1255
+ var FieldDefinition$1 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
1239
1256
  function FieldDefinition(state) {
1240
- if (state.verbose)
1241
- console.log("ENTER:", "FieldDefinition");
1242
1257
  if (state.tokenize) {
1243
- return $TOKEN("FieldDefinition", state, FieldDefinition$0(state));
1258
+ return $TOKEN("FieldDefinition", state, FieldDefinition$0(state) || FieldDefinition$1(state));
1244
1259
  } else {
1245
- return FieldDefinition$0(state);
1260
+ return FieldDefinition$0(state) || FieldDefinition$1(state);
1246
1261
  }
1247
1262
  }
1248
1263
  var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
@@ -1300,7 +1315,7 @@ var Civet = (() => {
1300
1315
  return CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
1301
1316
  }
1302
1317
  }
1303
- var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1318
+ var CallExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), Arguments);
1304
1319
  var CallExpressionRest$1 = MemberExpressionRest;
1305
1320
  var CallExpressionRest$2 = SpacedApplication;
1306
1321
  var CallExpressionRest$3 = TemplateLiteral;
@@ -1321,6 +1336,18 @@ var Civet = (() => {
1321
1336
  return OptionalShorthand$0(state);
1322
1337
  }
1323
1338
  }
1339
+ var NonNullAssertion$0 = $T($EXPECT($L26, fail, 'NonNullAssertion "!"'), function(value) {
1340
+ return { "ts": true, "children": value };
1341
+ });
1342
+ function NonNullAssertion(state) {
1343
+ if (state.verbose)
1344
+ console.log("ENTER:", "NonNullAssertion");
1345
+ if (state.tokenize) {
1346
+ return $TOKEN("NonNullAssertion", state, NonNullAssertion$0(state));
1347
+ } else {
1348
+ return NonNullAssertion$0(state);
1349
+ }
1350
+ }
1324
1351
  var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
1325
1352
  function SpacedApplication(state) {
1326
1353
  if (state.verbose)
@@ -1365,22 +1392,23 @@ var Civet = (() => {
1365
1392
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1366
1393
  }
1367
1394
  }
1368
- var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
1395
+ var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), $EXPECT($L27, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L28, fail, 'MemberExpressionRest "]"'));
1369
1396
  var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
1370
- var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1397
+ var MemberExpressionRest$2 = $TS($S($EXPECT($L29, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1371
1398
  var id = $2;
1372
1399
  if (id)
1373
1400
  return [".prototype.", id];
1374
1401
  return ".prototype";
1375
1402
  });
1403
+ var MemberExpressionRest$3 = NonNullAssertion;
1376
1404
  function MemberExpressionRest(state) {
1377
1405
  if (state.tokenize) {
1378
- return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
1406
+ return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state));
1379
1407
  } else {
1380
- return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
1408
+ return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
1381
1409
  }
1382
1410
  }
1383
- var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1411
+ var PropertyAccess$0 = $S($E($C($EXPECT($L3, fail, 'PropertyAccess "?"'), NonNullAssertion)), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1384
1412
  function PropertyAccess(state) {
1385
1413
  if (state.verbose)
1386
1414
  console.log("ENTER:", "PropertyAccess");
@@ -1390,7 +1418,7 @@ var Civet = (() => {
1390
1418
  return PropertyAccess$0(state);
1391
1419
  }
1392
1420
  }
1393
- var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
1421
+ var SuperProperty$0 = $S($EXPECT($L30, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L28, fail, 'SuperProperty "]"'));
1394
1422
  function SuperProperty(state) {
1395
1423
  if (state.verbose)
1396
1424
  console.log("ENTER:", "SuperProperty");
@@ -1400,8 +1428,8 @@ var Civet = (() => {
1400
1428
  return SuperProperty$0(state);
1401
1429
  }
1402
1430
  }
1403
- var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
1404
- var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
1431
+ var MetaProperty$0 = $EXPECT($L31, fail, 'MetaProperty "new.target"');
1432
+ var MetaProperty$1 = $EXPECT($L32, fail, 'MetaProperty "import.meta"');
1405
1433
  function MetaProperty(state) {
1406
1434
  if (state.tokenize) {
1407
1435
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1410,7 +1438,7 @@ var Civet = (() => {
1410
1438
  }
1411
1439
  }
1412
1440
  var Parameters$0 = $S($E(TypeParameters), $EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1413
- var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
1441
+ var Parameters$1 = $T($EXPECT($L33, fail, 'Parameters ""'), function(value) {
1414
1442
  return "()";
1415
1443
  });
1416
1444
  function Parameters(state) {
@@ -1474,7 +1502,7 @@ var Civet = (() => {
1474
1502
  return ObjectBindingPattern$0(state);
1475
1503
  }
1476
1504
  }
1477
- var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
1505
+ var ArrayBindingPattern$0 = $S($EXPECT($L27, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L28, fail, 'ArrayBindingPattern "]"'));
1478
1506
  function ArrayBindingPattern(state) {
1479
1507
  if (state.verbose)
1480
1508
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1493,7 +1521,7 @@ var Civet = (() => {
1493
1521
  return BindingProperty$0(state) || BindingProperty$1(state);
1494
1522
  }
1495
1523
  }
1496
- var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1524
+ var BindingRestProperty$0 = $S($EXPECT($L34, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1497
1525
  function BindingRestProperty(state) {
1498
1526
  if (state.verbose)
1499
1527
  console.log("ENTER:", "BindingRestProperty");
@@ -1513,7 +1541,7 @@ var Civet = (() => {
1513
1541
  return BindingElement$0(state);
1514
1542
  }
1515
1543
  }
1516
- var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1544
+ var BindingRestElement$0 = $S($EXPECT($L34, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1517
1545
  function BindingRestElement(state) {
1518
1546
  if (state.verbose)
1519
1547
  console.log("ENTER:", "BindingRestElement");
@@ -1534,7 +1562,7 @@ var Civet = (() => {
1534
1562
  }
1535
1563
  }
1536
1564
  var FunctionExpression$0 = ThinArrowFunction;
1537
- var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L34, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1565
+ var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L35, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1538
1566
  function FunctionExpression(state) {
1539
1567
  if (state.tokenize) {
1540
1568
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1563,7 +1591,7 @@ var Civet = (() => {
1563
1591
  return ThinArrowFunction$0(state);
1564
1592
  }
1565
1593
  }
1566
- var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1594
+ var Arrow$0 = $TV($EXPECT($L36, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1567
1595
  return { $loc, token: $1 };
1568
1596
  });
1569
1597
  function Arrow(state) {
@@ -1656,7 +1684,7 @@ var Civet = (() => {
1656
1684
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1657
1685
  }
1658
1686
  }
1659
- var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1687
+ var NullLiteral$0 = $TV($EXPECT($L37, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1660
1688
  return { $loc, token: $1 };
1661
1689
  });
1662
1690
  function NullLiteral(state) {
@@ -1668,7 +1696,7 @@ var Civet = (() => {
1668
1696
  return NullLiteral$0(state);
1669
1697
  }
1670
1698
  }
1671
- var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1699
+ var BooleanLiteral$0 = $TV($C($EXPECT($L38, fail, 'BooleanLiteral "true"'), $EXPECT($L39, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1672
1700
  return { $loc, token: $1 };
1673
1701
  });
1674
1702
  function BooleanLiteral(state) {
@@ -1725,8 +1753,8 @@ var Civet = (() => {
1725
1753
  return IdentifierReference$0(state);
1726
1754
  }
1727
1755
  }
1728
- var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1729
- var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1756
+ var ArrayLiteral$0 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1757
+ var ArrayLiteral$1 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1730
1758
  function ArrayLiteral(state) {
1731
1759
  if (state.tokenize) {
1732
1760
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1760,8 +1788,8 @@ var Civet = (() => {
1760
1788
  }
1761
1789
  }
1762
1790
  var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1763
- var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
1764
- var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1791
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L28, fail, 'ArrayElementDelimiter "]"')));
1792
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L28, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1765
1793
  return ",";
1766
1794
  });
1767
1795
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1794,7 +1822,7 @@ var Civet = (() => {
1794
1822
  return InlineElementList$0(state);
1795
1823
  }
1796
1824
  }
1797
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1825
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L34, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1798
1826
  function ArrayElementExpression(state) {
1799
1827
  if (state.verbose)
1800
1828
  console.log("ENTER:", "ArrayElementExpression");
@@ -1877,7 +1905,7 @@ var Civet = (() => {
1877
1905
  }
1878
1906
  var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L14, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1879
1907
  var PropertyDefinition$1 = MethodDefinition;
1880
- var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1908
+ var PropertyDefinition$2 = $S($EXPECT($L34, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1881
1909
  var PropertyDefinition$3 = IdentifierReference;
1882
1910
  function PropertyDefinition(state) {
1883
1911
  if (state.tokenize) {
@@ -1889,7 +1917,7 @@ var Civet = (() => {
1889
1917
  var PropertyName$0 = NumericLiteral;
1890
1918
  var PropertyName$1 = StringLiteral;
1891
1919
  var PropertyName$2 = IdentifierName;
1892
- var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
1920
+ var PropertyName$3 = $S($EXPECT($L27, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L28, fail, 'PropertyName "]"'));
1893
1921
  function PropertyName(state) {
1894
1922
  if (state.tokenize) {
1895
1923
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1897,8 +1925,8 @@ var Civet = (() => {
1897
1925
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1898
1926
  }
1899
1927
  }
1900
- var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1901
- var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1928
+ var MethodDefinition$0 = $S($EXPECT($L40, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1929
+ var MethodDefinition$1 = $S($EXPECT($L41, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1902
1930
  var MethodDefinition$2 = AsyncGeneratorMethod;
1903
1931
  var MethodDefinition$3 = AsyncMethod;
1904
1932
  var MethodDefinition$4 = GeneratorMethod;
@@ -1910,7 +1938,7 @@ var Civet = (() => {
1910
1938
  return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
1911
1939
  }
1912
1940
  }
1913
- var MethodModifier$0 = $S($C($EXPECT($L39, fail, 'MethodModifier "get"'), $EXPECT($L40, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
1941
+ var MethodModifier$0 = $S($C($EXPECT($L40, fail, 'MethodModifier "get"'), $EXPECT($L41, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
1914
1942
  function MethodModifier(state) {
1915
1943
  if (state.verbose)
1916
1944
  console.log("ENTER:", "MethodModifier");
@@ -2021,22 +2049,22 @@ var Civet = (() => {
2021
2049
  return AssignmentOp$0(state);
2022
2050
  }
2023
2051
  }
2024
- var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
2025
- var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
2026
- var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
2027
- var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
2028
- var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
2029
- var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
2030
- var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
2031
- var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
2032
- var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
2033
- var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
2034
- var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
2035
- var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
2036
- var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
2037
- var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
2038
- var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
2039
- var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
2052
+ var AssignmentOpSymbol$0 = $EXPECT($L42, fail, 'AssignmentOpSymbol "**="');
2053
+ var AssignmentOpSymbol$1 = $EXPECT($L43, fail, 'AssignmentOpSymbol "*="');
2054
+ var AssignmentOpSymbol$2 = $EXPECT($L44, fail, 'AssignmentOpSymbol "/="');
2055
+ var AssignmentOpSymbol$3 = $EXPECT($L45, fail, 'AssignmentOpSymbol "%="');
2056
+ var AssignmentOpSymbol$4 = $EXPECT($L46, fail, 'AssignmentOpSymbol "+="');
2057
+ var AssignmentOpSymbol$5 = $EXPECT($L47, fail, 'AssignmentOpSymbol "-="');
2058
+ var AssignmentOpSymbol$6 = $EXPECT($L48, fail, 'AssignmentOpSymbol "<<="');
2059
+ var AssignmentOpSymbol$7 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>>="');
2060
+ var AssignmentOpSymbol$8 = $EXPECT($L50, fail, 'AssignmentOpSymbol ">>="');
2061
+ var AssignmentOpSymbol$9 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&&="');
2062
+ var AssignmentOpSymbol$10 = $EXPECT($L52, fail, 'AssignmentOpSymbol "&="');
2063
+ var AssignmentOpSymbol$11 = $EXPECT($L53, fail, 'AssignmentOpSymbol "^="');
2064
+ var AssignmentOpSymbol$12 = $EXPECT($L54, fail, 'AssignmentOpSymbol "||="');
2065
+ var AssignmentOpSymbol$13 = $EXPECT($L55, fail, 'AssignmentOpSymbol "|="');
2066
+ var AssignmentOpSymbol$14 = $EXPECT($L56, fail, 'AssignmentOpSymbol "??="');
2067
+ var AssignmentOpSymbol$15 = $EXPECT($L57, fail, 'AssignmentOpSymbol "="');
2040
2068
  function AssignmentOpSymbol(state) {
2041
2069
  if (state.tokenize) {
2042
2070
  return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state));
@@ -2056,48 +2084,48 @@ var Civet = (() => {
2056
2084
  return BinaryOp$0(state);
2057
2085
  }
2058
2086
  }
2059
- var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
2087
+ var BinaryOpSymbol$0 = $EXPECT($L58, fail, 'BinaryOpSymbol "**"');
2060
2088
  var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
2061
- var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
2062
- var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
2063
- var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
2064
- var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
2065
- var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
2066
- var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
2067
- var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
2089
+ var BinaryOpSymbol$2 = $EXPECT($L59, fail, 'BinaryOpSymbol "/"');
2090
+ var BinaryOpSymbol$3 = $EXPECT($L60, fail, 'BinaryOpSymbol "%"');
2091
+ var BinaryOpSymbol$4 = $EXPECT($L61, fail, 'BinaryOpSymbol "+"');
2092
+ var BinaryOpSymbol$5 = $EXPECT($L62, fail, 'BinaryOpSymbol "-"');
2093
+ var BinaryOpSymbol$6 = $EXPECT($L63, fail, 'BinaryOpSymbol "<="');
2094
+ var BinaryOpSymbol$7 = $EXPECT($L64, fail, 'BinaryOpSymbol ">="');
2095
+ var BinaryOpSymbol$8 = $EXPECT($L65, fail, 'BinaryOpSymbol "<<"');
2068
2096
  var BinaryOpSymbol$9 = $EXPECT($L16, fail, 'BinaryOpSymbol "<"');
2069
- var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
2070
- var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
2071
- var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
2072
- var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
2073
- var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2097
+ var BinaryOpSymbol$10 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>>"');
2098
+ var BinaryOpSymbol$11 = $EXPECT($L67, fail, 'BinaryOpSymbol ">>"');
2099
+ var BinaryOpSymbol$12 = $EXPECT($L68, fail, 'BinaryOpSymbol ">"');
2100
+ var BinaryOpSymbol$13 = $EXPECT($L69, fail, 'BinaryOpSymbol "!=="');
2101
+ var BinaryOpSymbol$14 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2074
2102
  if (global.coffeeCompat)
2075
2103
  return "!==";
2076
2104
  return $1;
2077
2105
  });
2078
- var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2106
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2079
2107
  return "===";
2080
2108
  });
2081
- var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
2082
- var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2109
+ var BinaryOpSymbol$16 = $EXPECT($L72, fail, 'BinaryOpSymbol "==="');
2110
+ var BinaryOpSymbol$17 = $TV($EXPECT($L73, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2083
2111
  if (global.coffeeCompat)
2084
2112
  return "===";
2085
2113
  return $1;
2086
2114
  });
2087
- var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2115
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2088
2116
  return "&&";
2089
2117
  });
2090
- var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
2091
- var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2118
+ var BinaryOpSymbol$19 = $EXPECT($L75, fail, 'BinaryOpSymbol "&&"');
2119
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L76, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2092
2120
  return "||";
2093
2121
  });
2094
- var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
2095
- var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
2096
- var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2097
- var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2098
- var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
2099
- var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
2100
- var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
2122
+ var BinaryOpSymbol$21 = $EXPECT($L77, fail, 'BinaryOpSymbol "||"');
2123
+ var BinaryOpSymbol$22 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
2124
+ var BinaryOpSymbol$23 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2125
+ var BinaryOpSymbol$24 = $S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2126
+ var BinaryOpSymbol$25 = $EXPECT($L81, fail, 'BinaryOpSymbol "&"');
2127
+ var BinaryOpSymbol$26 = $EXPECT($L82, fail, 'BinaryOpSymbol "^"');
2128
+ var BinaryOpSymbol$27 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
2101
2129
  function BinaryOpSymbol(state) {
2102
2130
  if (state.tokenize) {
2103
2131
  return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
@@ -2106,7 +2134,7 @@ var Civet = (() => {
2106
2134
  }
2107
2135
  }
2108
2136
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2109
- var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2137
+ var UnaryOp$1 = $S($C($EXPECT($L84, fail, 'UnaryOp "delete"'), $EXPECT($L85, fail, 'UnaryOp "void"'), $EXPECT($L86, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2110
2138
  function UnaryOp(state) {
2111
2139
  if (state.tokenize) {
2112
2140
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2140,7 +2168,7 @@ var Civet = (() => {
2140
2168
  return StatementListItem$0(state);
2141
2169
  }
2142
2170
  }
2143
- 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) {
2171
+ var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L87, fail, 'PostfixConditional "if"'), $EXPECT($L88, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
2144
2172
  var ws = $1;
2145
2173
  var cond = $2;
2146
2174
  var exp = $4;
@@ -2173,7 +2201,7 @@ var Civet = (() => {
2173
2201
  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);
2174
2202
  }
2175
2203
  }
2176
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
2204
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L89, fail, 'EmptyStatement ";"')));
2177
2205
  function EmptyStatement(state) {
2178
2206
  if (state.verbose)
2179
2207
  console.log("ENTER:", "EmptyStatement");
@@ -2193,8 +2221,8 @@ var Civet = (() => {
2193
2221
  return BlockStatement$0(state);
2194
2222
  }
2195
2223
  }
2196
- var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
2197
- var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2224
+ var IfStatement$0 = $S($EXPECT($L87, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L90, fail, 'IfStatement "else"'), Block)));
2225
+ var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2198
2226
  var condition = $2;
2199
2227
  var block = $3;
2200
2228
  return ["if", condition.map((c) => {
@@ -2224,7 +2252,7 @@ var Civet = (() => {
2224
2252
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2225
2253
  }
2226
2254
  }
2227
- var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2255
+ var LoopStatement$0 = $TS($S($EXPECT($L91, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2228
2256
  var b = $3;
2229
2257
  return ["while(true)", b];
2230
2258
  });
@@ -2237,7 +2265,7 @@ var Civet = (() => {
2237
2265
  return LoopStatement$0(state);
2238
2266
  }
2239
2267
  }
2240
- var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2268
+ var DoWhileStatement$0 = $S($EXPECT($L92, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2241
2269
  function DoWhileStatement(state) {
2242
2270
  if (state.verbose)
2243
2271
  console.log("ENTER:", "DoWhileStatement");
@@ -2257,7 +2285,7 @@ var Civet = (() => {
2257
2285
  return WhileStatement$0(state);
2258
2286
  }
2259
2287
  }
2260
- 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) {
2288
+ var WhileClause$0 = $TS($S($C($EXPECT($L93, fail, 'WhileClause "while"'), $EXPECT($L94, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2261
2289
  var kind = $1;
2262
2290
  var cond = $3;
2263
2291
  if (kind === "until") {
@@ -2276,7 +2304,7 @@ var Civet = (() => {
2276
2304
  return WhileClause$0(state);
2277
2305
  }
2278
2306
  }
2279
- var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2307
+ var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L89, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L89, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2280
2308
  function ForStatement(state) {
2281
2309
  if (state.verbose)
2282
2310
  console.log("ENTER:", "ForStatement");
@@ -2286,10 +2314,10 @@ var Civet = (() => {
2286
2314
  return ForStatement$0(state);
2287
2315
  }
2288
2316
  }
2289
- var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2290
- var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2291
- var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2292
- var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2317
+ var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L80, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2318
+ var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L80, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2319
+ var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L96, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2320
+ var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L96, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2293
2321
  function ForInOfStatement(state) {
2294
2322
  if (state.tokenize) {
2295
2323
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2297,7 +2325,7 @@ var Civet = (() => {
2297
2325
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2298
2326
  }
2299
2327
  }
2300
- var For$0 = $TS($S($EXPECT($L96, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2328
+ var For$0 = $TS($S($EXPECT($L97, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2301
2329
  return { $loc, token: $1 };
2302
2330
  });
2303
2331
  function For(state) {
@@ -2319,7 +2347,7 @@ var Civet = (() => {
2319
2347
  return ForDeclaration$0(state);
2320
2348
  }
2321
2349
  }
2322
- var LetOrConst$0 = $TV($C($EXPECT($L97, fail, 'LetOrConst "let"'), $EXPECT($L98, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
2350
+ var LetOrConst$0 = $TV($C($EXPECT($L98, fail, 'LetOrConst "let"'), $EXPECT($L99, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
2323
2351
  return { $loc, token: $1 };
2324
2352
  });
2325
2353
  function LetOrConst(state) {
@@ -2340,7 +2368,7 @@ var Civet = (() => {
2340
2368
  return ForBinding$0(state) || ForBinding$1(state);
2341
2369
  }
2342
2370
  }
2343
- var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2371
+ var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2344
2372
  function SwitchStatement(state) {
2345
2373
  if (state.verbose)
2346
2374
  console.log("ENTER:", "SwitchStatement");
@@ -2384,9 +2412,9 @@ var Civet = (() => {
2384
2412
  return NestedCaseClause$0(state);
2385
2413
  }
2386
2414
  }
2387
- var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2415
+ var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2388
2416
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2389
- var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2417
+ var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2390
2418
  function CaseClause(state) {
2391
2419
  if (state.tokenize) {
2392
2420
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2394,7 +2422,7 @@ var Civet = (() => {
2394
2422
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2395
2423
  }
2396
2424
  }
2397
- var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
2425
+ var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
2398
2426
  return "case";
2399
2427
  });
2400
2428
  function When(state) {
@@ -2407,7 +2435,7 @@ var Civet = (() => {
2407
2435
  }
2408
2436
  }
2409
2437
  var ImpliedColon$0 = $S(__, $EXPECT($L14, fail, 'ImpliedColon ":"'));
2410
- var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
2438
+ var ImpliedColon$1 = $T($EXPECT($L33, fail, 'ImpliedColon ""'), function(value) {
2411
2439
  return ":";
2412
2440
  });
2413
2441
  function ImpliedColon(state) {
@@ -2417,7 +2445,7 @@ var Civet = (() => {
2417
2445
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2418
2446
  }
2419
2447
  }
2420
- var TryStatement$0 = $TS($S($EXPECT($L103, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2448
+ var TryStatement$0 = $TS($S($EXPECT($L104, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2421
2449
  var c = $3;
2422
2450
  var f = $4;
2423
2451
  if (!c && !f) {
@@ -2434,7 +2462,7 @@ var Civet = (() => {
2434
2462
  return TryStatement$0(state);
2435
2463
  }
2436
2464
  }
2437
- var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2465
+ var Catch$0 = $S(__, $EXPECT($L105, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2438
2466
  function Catch(state) {
2439
2467
  if (state.verbose)
2440
2468
  console.log("ENTER:", "Catch");
@@ -2453,7 +2481,7 @@ var Civet = (() => {
2453
2481
  return CatchBind$0(state) || CatchBind$1(state);
2454
2482
  }
2455
2483
  }
2456
- var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
2484
+ var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
2457
2485
  function Finally(state) {
2458
2486
  if (state.verbose)
2459
2487
  console.log("ENTER:", "Finally");
@@ -2491,11 +2519,11 @@ var Civet = (() => {
2491
2519
  return ExpressionStatement$0(state);
2492
2520
  }
2493
2521
  }
2494
- var KeywordStatement$0 = $S($EXPECT($L106, fail, 'KeywordStatement "break"'), NonIdContinue);
2495
- var KeywordStatement$1 = $S($EXPECT($L107, fail, 'KeywordStatement "continue"'), NonIdContinue);
2496
- var KeywordStatement$2 = $S($EXPECT($L108, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2522
+ var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
2523
+ var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
2524
+ var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2497
2525
  var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2498
- var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2526
+ var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2499
2527
  function KeywordStatement(state) {
2500
2528
  if (state.tokenize) {
2501
2529
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2512,7 +2540,7 @@ var Civet = (() => {
2512
2540
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2513
2541
  }
2514
2542
  }
2515
- var Return$0 = $TS($S($EXPECT($L110, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2543
+ var Return$0 = $TS($S($EXPECT($L111, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2516
2544
  return { $loc, token: $1 };
2517
2545
  });
2518
2546
  function Return(state) {
@@ -2524,7 +2552,7 @@ var Civet = (() => {
2524
2552
  return Return$0(state);
2525
2553
  }
2526
2554
  }
2527
- var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2555
+ var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2528
2556
  return { "ts": true, "children": value };
2529
2557
  });
2530
2558
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2537,7 +2565,7 @@ var Civet = (() => {
2537
2565
  return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
2538
2566
  }
2539
2567
  }
2540
- var ImpliedImport$0 = $T($EXPECT($L32, fail, 'ImpliedImport ""'), function(value) {
2568
+ var ImpliedImport$0 = $T($EXPECT($L33, fail, 'ImpliedImport ""'), function(value) {
2541
2569
  return "import ";
2542
2570
  });
2543
2571
  function ImpliedImport(state) {
@@ -2601,7 +2629,7 @@ var Civet = (() => {
2601
2629
  return FromClause$0(state);
2602
2630
  }
2603
2631
  }
2604
- var From$0 = $TS($S($EXPECT($L112, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2632
+ var From$0 = $TS($S($EXPECT($L113, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2605
2633
  return { $loc, token: $1 };
2606
2634
  });
2607
2635
  function From(state) {
@@ -2663,7 +2691,7 @@ var Civet = (() => {
2663
2691
  return ImportedBinding$0(state);
2664
2692
  }
2665
2693
  }
2666
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2694
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2667
2695
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2668
2696
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2669
2697
  function ExportDeclaration(state) {
@@ -2683,7 +2711,7 @@ var Civet = (() => {
2683
2711
  return As$0(state);
2684
2712
  }
2685
2713
  }
2686
- var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
2714
+ var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
2687
2715
  function Export(state) {
2688
2716
  if (state.verbose)
2689
2717
  console.log("ENTER:", "Export");
@@ -2767,7 +2795,7 @@ var Civet = (() => {
2767
2795
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
2768
2796
  }
2769
2797
  }
2770
- var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2798
+ var ConstAssignment$0 = $TV($EXPECT($L115, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2771
2799
  return { $loc, token: $0 };
2772
2800
  });
2773
2801
  function ConstAssignment(state) {
@@ -2788,7 +2816,7 @@ var Civet = (() => {
2788
2816
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2789
2817
  }
2790
2818
  }
2791
- var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2819
+ var Initializer$0 = $S(__, $EXPECT($L57, fail, 'Initializer "="'), AssignmentExpression);
2792
2820
  function Initializer(state) {
2793
2821
  if (state.verbose)
2794
2822
  console.log("ENTER:", "Initializer");
@@ -2798,7 +2826,7 @@ var Civet = (() => {
2798
2826
  return Initializer$0(state);
2799
2827
  }
2800
2828
  }
2801
- var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2829
+ var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2802
2830
  function VariableStatement(state) {
2803
2831
  if (state.verbose)
2804
2832
  console.log("ENTER:", "VariableStatement");
@@ -2901,18 +2929,18 @@ var Civet = (() => {
2901
2929
  return HexLiteral$0(state);
2902
2930
  }
2903
2931
  }
2904
- var StringLiteral$0 = $TS($S($EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
2932
+ var StringLiteral$0 = $TS($S($EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
2905
2933
  var str = $2;
2906
2934
  return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
2907
2935
  });
2908
- var StringLiteral$1 = $TS($S($EXPECT($L116, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
2936
+ var StringLiteral$1 = $TS($S($EXPECT($L117, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L117, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
2909
2937
  var str = $2;
2910
2938
  return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
2911
2939
  });
2912
- var StringLiteral$2 = $TV($TEXT($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2940
+ var StringLiteral$2 = $TV($TEXT($S($EXPECT($L118, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L118, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2913
2941
  return { $loc, token: $1 };
2914
2942
  });
2915
- var StringLiteral$3 = $TV($TEXT($S($EXPECT($L118, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L118, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2943
+ var StringLiteral$3 = $TV($TEXT($S($EXPECT($L119, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L119, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2916
2944
  return { $loc, token: $1 };
2917
2945
  });
2918
2946
  function StringLiteral(state) {
@@ -2962,7 +2990,7 @@ var Civet = (() => {
2962
2990
  return TripleSingleStringCharacter$0(state);
2963
2991
  }
2964
2992
  }
2965
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2993
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L59, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L59, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2966
2994
  return { $loc, token: $1 };
2967
2995
  });
2968
2996
  function RegularExpressionLiteral(state) {
@@ -3004,7 +3032,7 @@ var Civet = (() => {
3004
3032
  return RegularExpressionFlags$0(state);
3005
3033
  }
3006
3034
  }
3007
- var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
3035
+ var TemplateLiteral$0 = $S($EXPECT($L120, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L120, fail, 'TemplateLiteral "`"'));
3008
3036
  function TemplateLiteral(state) {
3009
3037
  if (state.verbose)
3010
3038
  console.log("ENTER:", "TemplateLiteral");
@@ -3014,7 +3042,7 @@ var Civet = (() => {
3014
3042
  return TemplateLiteral$0(state);
3015
3043
  }
3016
3044
  }
3017
- var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
3045
+ var TemplateSubstitution$0 = $S($EXPECT($L121, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
3018
3046
  function TemplateSubstitution(state) {
3019
3047
  if (state.verbose)
3020
3048
  console.log("ENTER:", "TemplateSubstitution");
@@ -3034,7 +3062,7 @@ var Civet = (() => {
3034
3062
  return TemplateCharacters$0(state);
3035
3063
  }
3036
3064
  }
3037
- var ReservedWord$0 = $R$0($EXPECT($R18, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3065
+ var ReservedWord$0 = $R$0($EXPECT($R18, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3038
3066
  function ReservedWord(state) {
3039
3067
  if (state.verbose)
3040
3068
  console.log("ENTER:", "ReservedWord");
@@ -3071,7 +3099,7 @@ var Civet = (() => {
3071
3099
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3072
3100
  }
3073
3101
  }
3074
- var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
3102
+ var JSMultiLineComment$0 = $S($EXPECT($L122, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L123, fail, 'JSMultiLineComment "*/"'));
3075
3103
  function JSMultiLineComment(state) {
3076
3104
  if (state.verbose)
3077
3105
  console.log("ENTER:", "JSMultiLineComment");
@@ -3095,7 +3123,7 @@ var Civet = (() => {
3095
3123
  return CoffeeSingleLineComment$0(state);
3096
3124
  }
3097
3125
  }
3098
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), function(value) {
3126
+ var CoffeeMultiLineComment$0 = $T($S($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), function(value) {
3099
3127
  return ["/*", value[1], "*/"];
3100
3128
  });
3101
3129
  function CoffeeMultiLineComment(state) {
@@ -3107,7 +3135,7 @@ var Civet = (() => {
3107
3135
  return CoffeeMultiLineComment$0(state);
3108
3136
  }
3109
3137
  }
3110
- var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L122, fail, 'InlineComment "*/"'));
3138
+ var InlineComment$0 = $S($EXPECT($L122, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L123, fail, 'InlineComment "*/"'));
3111
3139
  function InlineComment(state) {
3112
3140
  if (state.verbose)
3113
3141
  console.log("ENTER:", "InlineComment");
@@ -3157,7 +3185,7 @@ var Civet = (() => {
3157
3185
  return __$0(state);
3158
3186
  }
3159
3187
  }
3160
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3188
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L89, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3161
3189
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
3162
3190
  return [";", value];
3163
3191
  });
@@ -3192,7 +3220,7 @@ var Civet = (() => {
3192
3220
  return JSXElement$0(state) || JSXElement$1(state);
3193
3221
  }
3194
3222
  }
3195
- var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
3223
+ var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L125, fail, 'JSXSelfClosingElement "/>"'));
3196
3224
  function JSXSelfClosingElement(state) {
3197
3225
  if (state.verbose)
3198
3226
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3202,7 +3230,7 @@ var Civet = (() => {
3202
3230
  return JSXSelfClosingElement$0(state);
3203
3231
  }
3204
3232
  }
3205
- var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
3233
+ var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L68, fail, 'JSXOpeningElement ">"'));
3206
3234
  function JSXOpeningElement(state) {
3207
3235
  if (state.verbose)
3208
3236
  console.log("ENTER:", "JSXOpeningElement");
@@ -3212,7 +3240,7 @@ var Civet = (() => {
3212
3240
  return JSXOpeningElement$0(state);
3213
3241
  }
3214
3242
  }
3215
- var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
3243
+ var JSXClosingElement$0 = $S($EXPECT($L126, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L68, fail, 'JSXClosingElement ">"'));
3216
3244
  function JSXClosingElement(state) {
3217
3245
  if (state.verbose)
3218
3246
  console.log("ENTER:", "JSXClosingElement");
@@ -3222,7 +3250,7 @@ var Civet = (() => {
3222
3250
  return JSXClosingElement$0(state);
3223
3251
  }
3224
3252
  }
3225
- var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
3253
+ var JSXFragment$0 = $S($EXPECT($L127, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L128, fail, 'JSXFragment "</>"'));
3226
3254
  function JSXFragment(state) {
3227
3255
  if (state.verbose)
3228
3256
  console.log("ENTER:", "JSXFragment");
@@ -3262,7 +3290,7 @@ var Civet = (() => {
3262
3290
  return JSXAttributes$0(state);
3263
3291
  }
3264
3292
  }
3265
- var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
3293
+ var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L34, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
3266
3294
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3267
3295
  function JSXAttribute(state) {
3268
3296
  if (state.tokenize) {
@@ -3281,7 +3309,7 @@ var Civet = (() => {
3281
3309
  return JSXAttributeName$0(state);
3282
3310
  }
3283
3311
  }
3284
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3312
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L57, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3285
3313
  function JSXAttributeInitializer(state) {
3286
3314
  if (state.verbose)
3287
3315
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -3334,7 +3362,7 @@ var Civet = (() => {
3334
3362
  return JSXText$0(state);
3335
3363
  }
3336
3364
  }
3337
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3365
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L34, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3338
3366
  function JSXChildExpression(state) {
3339
3367
  if (state.verbose)
3340
3368
  console.log("ENTER:", "JSXChildExpression");
@@ -3356,8 +3384,8 @@ var Civet = (() => {
3356
3384
  return TypeDeclaration$0(state);
3357
3385
  }
3358
3386
  }
3359
- var TypeDeclarationModifier$0 = $S($EXPECT($L128, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
3360
- var TypeDeclarationModifier$1 = $S($EXPECT($L113, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
3387
+ var TypeDeclarationModifier$0 = $S($EXPECT($L129, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
3388
+ var TypeDeclarationModifier$1 = $S($EXPECT($L114, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
3361
3389
  function TypeDeclarationModifier(state) {
3362
3390
  if (state.tokenize) {
3363
3391
  return $TOKEN("TypeDeclarationModifier", state, TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state));
@@ -3365,7 +3393,7 @@ var Civet = (() => {
3365
3393
  return TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state);
3366
3394
  }
3367
3395
  }
3368
- var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclarationRest "="'), __, Type);
3396
+ var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L57, fail, 'TypeDeclarationRest "="'), __, Type);
3369
3397
  var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
3370
3398
  var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
3371
3399
  function TypeDeclarationRest(state) {
@@ -3375,7 +3403,7 @@ var Civet = (() => {
3375
3403
  return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
3376
3404
  }
3377
3405
  }
3378
- var TypeKeyword$0 = $S($EXPECT($L129, fail, 'TypeKeyword "type"'), NonIdContinue);
3406
+ var TypeKeyword$0 = $S($EXPECT($L130, fail, 'TypeKeyword "type"'), NonIdContinue);
3379
3407
  function TypeKeyword(state) {
3380
3408
  if (state.verbose)
3381
3409
  console.log("ENTER:", "TypeKeyword");
@@ -3385,7 +3413,7 @@ var Civet = (() => {
3385
3413
  return TypeKeyword$0(state);
3386
3414
  }
3387
3415
  }
3388
- var Interface$0 = $S($EXPECT($L130, fail, 'Interface "interface"'), NonIdContinue);
3416
+ var Interface$0 = $S($EXPECT($L131, fail, 'Interface "interface"'), NonIdContinue);
3389
3417
  function Interface(state) {
3390
3418
  if (state.verbose)
3391
3419
  console.log("ENTER:", "Interface");
@@ -3395,7 +3423,7 @@ var Civet = (() => {
3395
3423
  return Interface$0(state);
3396
3424
  }
3397
3425
  }
3398
- var Namespace$0 = $S($EXPECT($L131, fail, 'Namespace "namespace"'), NonIdContinue);
3426
+ var Namespace$0 = $S($EXPECT($L132, fail, 'Namespace "namespace"'), NonIdContinue);
3399
3427
  function Namespace(state) {
3400
3428
  if (state.verbose)
3401
3429
  console.log("ENTER:", "Namespace");
@@ -3449,7 +3477,7 @@ var Civet = (() => {
3449
3477
  return InterfaceProperty$0(state) || InterfaceProperty$1(state);
3450
3478
  }
3451
3479
  }
3452
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3480
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L89, fail, 'InterfacePropertyDelimiter ";"'));
3453
3481
  var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"')));
3454
3482
  var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3455
3483
  return ";";
@@ -3499,7 +3527,7 @@ var Civet = (() => {
3499
3527
  return NestedTypeDeclaration$0(state);
3500
3528
  }
3501
3529
  }
3502
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L132, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3530
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L133, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L27, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L28, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3503
3531
  function TypeIndexSignature(state) {
3504
3532
  if (state.verbose)
3505
3533
  console.log("ENTER:", "TypeIndexSignature");
@@ -3510,7 +3538,7 @@ var Civet = (() => {
3510
3538
  }
3511
3539
  }
3512
3540
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3513
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3541
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L80, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3514
3542
  function TypeIndex(state) {
3515
3543
  if (state.tokenize) {
3516
3544
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3530,7 +3558,7 @@ var Civet = (() => {
3530
3558
  return TypeSuffix$0(state);
3531
3559
  }
3532
3560
  }
3533
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L133, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3561
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L134, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3534
3562
  return { "ts": true, "children": value };
3535
3563
  });
3536
3564
  function ReturnTypeSuffix(state) {
@@ -3542,7 +3570,7 @@ var Civet = (() => {
3542
3570
  return ReturnTypeSuffix$0(state);
3543
3571
  }
3544
3572
  }
3545
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3573
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L71, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3546
3574
  function TypePredicate(state) {
3547
3575
  if (state.verbose)
3548
3576
  console.log("ENTER:", "TypePredicate");
@@ -3592,9 +3620,9 @@ var Civet = (() => {
3592
3620
  return TypeUnarySuffix$0(state);
3593
3621
  }
3594
3622
  }
3595
- var TypeUnaryOp$0 = $EXPECT($L134, fail, 'TypeUnaryOp "keyof"');
3596
- var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3597
- var TypeUnaryOp$2 = $EXPECT($L135, fail, 'TypeUnaryOp "infer"');
3623
+ var TypeUnaryOp$0 = $EXPECT($L135, fail, 'TypeUnaryOp "keyof"');
3624
+ var TypeUnaryOp$1 = $EXPECT($L86, fail, 'TypeUnaryOp "typeof"');
3625
+ var TypeUnaryOp$2 = $EXPECT($L136, fail, 'TypeUnaryOp "infer"');
3598
3626
  function TypeUnaryOp(state) {
3599
3627
  if (state.tokenize) {
3600
3628
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3602,7 +3630,7 @@ var Civet = (() => {
3602
3630
  return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3603
3631
  }
3604
3632
  }
3605
- var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
3633
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L27, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L28, fail, 'TypeIndexedAccess "]"'));
3606
3634
  function TypeIndexedAccess(state) {
3607
3635
  if (state.verbose)
3608
3636
  console.log("ENTER:", "TypeIndexedAccess");
@@ -3635,8 +3663,8 @@ var Civet = (() => {
3635
3663
  }
3636
3664
  }
3637
3665
  var TypeLiteral$0 = Literal;
3638
- var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3639
- var TypeLiteral$2 = $EXPECT($L136, fail, 'TypeLiteral "[]"');
3666
+ var TypeLiteral$1 = $EXPECT($L85, fail, 'TypeLiteral "void"');
3667
+ var TypeLiteral$2 = $EXPECT($L137, fail, 'TypeLiteral "[]"');
3640
3668
  function TypeLiteral(state) {
3641
3669
  if (state.tokenize) {
3642
3670
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3644,8 +3672,8 @@ var Civet = (() => {
3644
3672
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3645
3673
  }
3646
3674
  }
3647
- var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3648
- var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3675
+ var TypeBinaryOp$0 = $EXPECT($L83, fail, 'TypeBinaryOp "|"');
3676
+ var TypeBinaryOp$1 = $EXPECT($L81, fail, 'TypeBinaryOp "&"');
3649
3677
  function TypeBinaryOp(state) {
3650
3678
  if (state.tokenize) {
3651
3679
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3663,7 +3691,7 @@ var Civet = (() => {
3663
3691
  return FunctionType$0(state);
3664
3692
  }
3665
3693
  }
3666
- var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
3694
+ var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L68, fail, 'TypeArguments ">"'));
3667
3695
  function TypeArguments(state) {
3668
3696
  if (state.verbose)
3669
3697
  console.log("ENTER:", "TypeArguments");
@@ -3673,7 +3701,7 @@ var Civet = (() => {
3673
3701
  return TypeArguments$0(state);
3674
3702
  }
3675
3703
  }
3676
- var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
3704
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L68, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
3677
3705
  return { ts: true, children: $0 };
3678
3706
  });
3679
3707
  function TypeParameters(state) {
@@ -3706,8 +3734,8 @@ var Civet = (() => {
3706
3734
  }
3707
3735
  }
3708
3736
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3709
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3710
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3737
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L68, fail, 'TypeParameterDelimiter ">"')));
3738
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L68, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3711
3739
  return ",";
3712
3740
  });
3713
3741
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3772,7 +3800,7 @@ var Civet = (() => {
3772
3800
  return EOF$0(state);
3773
3801
  }
3774
3802
  }
3775
- var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3803
+ var Debugger$0 = $TV($EXPECT($L33, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3776
3804
  debugger;
3777
3805
  });
3778
3806
  function Debugger(state) {
@@ -3784,7 +3812,7 @@ var Civet = (() => {
3784
3812
  return Debugger$0(state);
3785
3813
  }
3786
3814
  }
3787
- var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
3815
+ var InsertOpenParen$0 = $T($EXPECT($L33, fail, 'InsertOpenParen ""'), function(value) {
3788
3816
  return "(";
3789
3817
  });
3790
3818
  function InsertOpenParen(state) {
@@ -3796,7 +3824,7 @@ var Civet = (() => {
3796
3824
  return InsertOpenParen$0(state);
3797
3825
  }
3798
3826
  }
3799
- var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
3827
+ var InsertCloseParen$0 = $T($EXPECT($L33, fail, 'InsertCloseParen ""'), function(value) {
3800
3828
  return ")";
3801
3829
  });
3802
3830
  function InsertCloseParen(state) {
@@ -3808,7 +3836,7 @@ var Civet = (() => {
3808
3836
  return InsertCloseParen$0(state);
3809
3837
  }
3810
3838
  }
3811
- var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
3839
+ var InsertOpenBrace$0 = $T($EXPECT($L33, fail, 'InsertOpenBrace ""'), function(value) {
3812
3840
  return " {";
3813
3841
  });
3814
3842
  function InsertOpenBrace(state) {
@@ -3820,7 +3848,7 @@ var Civet = (() => {
3820
3848
  return InsertOpenBrace$0(state);
3821
3849
  }
3822
3850
  }
3823
- var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
3851
+ var InsertCloseBrace$0 = $T($EXPECT($L33, fail, 'InsertCloseBrace ""'), function(value) {
3824
3852
  return "}";
3825
3853
  });
3826
3854
  function InsertCloseBrace(state) {
@@ -3832,7 +3860,7 @@ var Civet = (() => {
3832
3860
  return InsertCloseBrace$0(state);
3833
3861
  }
3834
3862
  }
3835
- var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3863
+ var InsertNewline$0 = $TV($EXPECT($L33, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3836
3864
  return "\n";
3837
3865
  });
3838
3866
  function InsertNewline(state) {
@@ -3844,7 +3872,7 @@ var Civet = (() => {
3844
3872
  return InsertNewline$0(state);
3845
3873
  }
3846
3874
  }
3847
- var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3875
+ var InsertIndent$0 = $TV($EXPECT($L33, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3848
3876
  return "".padStart(global.currentIndent * 2);
3849
3877
  });
3850
3878
  function InsertIndent(state) {
@@ -3856,7 +3884,7 @@ var Civet = (() => {
3856
3884
  return InsertIndent$0(state);
3857
3885
  }
3858
3886
  }
3859
- var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
3887
+ var InsertSpace$0 = $T($EXPECT($L33, fail, 'InsertSpace ""'), function(value) {
3860
3888
  return " ";
3861
3889
  });
3862
3890
  function InsertSpace(state) {
@@ -3868,7 +3896,7 @@ var Civet = (() => {
3868
3896
  return InsertSpace$0(state);
3869
3897
  }
3870
3898
  }
3871
- var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
3899
+ var InsertDot$0 = $T($EXPECT($L33, fail, 'InsertDot ""'), function(value) {
3872
3900
  return ".";
3873
3901
  });
3874
3902
  function InsertDot(state) {
@@ -3880,7 +3908,7 @@ var Civet = (() => {
3880
3908
  return InsertDot$0(state);
3881
3909
  }
3882
3910
  }
3883
- var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
3911
+ var InsertBreak$0 = $T($EXPECT($L33, fail, 'InsertBreak ""'), function(value) {
3884
3912
  return "break;";
3885
3913
  });
3886
3914
  function InsertBreak(state) {
@@ -3892,7 +3920,7 @@ var Civet = (() => {
3892
3920
  return InsertBreak$0(state);
3893
3921
  }
3894
3922
  }
3895
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3923
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L33, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3896
3924
  var directives = $2;
3897
3925
  global.currentIndent = 0;
3898
3926
  global.indentLevels = [0];
@@ -3920,7 +3948,7 @@ var Civet = (() => {
3920
3948
  return Init$0(state);
3921
3949
  }
3922
3950
  }
3923
- var Indent$0 = $TV($Q($C($EXPECT($L137, fail, 'Indent " "'), $EXPECT($L138, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3951
+ var Indent$0 = $TV($Q($C($EXPECT($L138, fail, 'Indent " "'), $EXPECT($L139, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3924
3952
  return $1.length;
3925
3953
  });
3926
3954
  function Indent(state) {
@@ -3932,7 +3960,7 @@ var Civet = (() => {
3932
3960
  return Indent$0(state);
3933
3961
  }
3934
3962
  }
3935
- var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3963
+ var PushIndent$0 = $TV($EXPECT($L33, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3936
3964
  global.currentIndent++;
3937
3965
  if (global.verbose) {
3938
3966
  console.log("pushing indent", global.currentIndent);
@@ -3949,7 +3977,7 @@ var Civet = (() => {
3949
3977
  return PushIndent$0(state);
3950
3978
  }
3951
3979
  }
3952
- var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3980
+ var PopIndent$0 = $TV($EXPECT($L33, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3953
3981
  if (global.verbose) {
3954
3982
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3955
3983
  }