@danielx/civet 0.3.0 → 0.3.1

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 +3 -2
  2. package/dist/browser.js +276 -264
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +6 -6
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +276 -264
  7. package/package.json +1 -1
package/dist/browser.js CHANGED
@@ -420,6 +420,7 @@ var Civet = (() => {
420
420
  UpdateExpressionSymbol,
421
421
  AssignmentExpression,
422
422
  AssignmentExpressionRest,
423
+ AwaitExpression,
423
424
  YieldExpression,
424
425
  ArrowFunction,
425
426
  FatArrow,
@@ -678,93 +679,93 @@ var Civet = (() => {
678
679
  var $L5 = $L("++");
679
680
  var $L6 = $L("--");
680
681
  var $L7 = $L("async");
681
- var $L8 = $L("yield");
682
- var $L9 = $L("*");
683
- var $L10 = $L("=>");
684
- var $L11 = $L("{");
685
- var $L12 = $L(":");
686
- var $L13 = $L("class");
687
- var $L14 = $L("<");
688
- var $L15 = $L("extends");
689
- var $L16 = $L("}");
690
- var $L17 = $L("static");
691
- var $L18 = $L("this");
692
- var $L19 = $L("#");
693
- var $L20 = $L("@");
694
- var $L21 = $L("new");
695
- var $L22 = $L("super");
696
- var $L23 = $L("import");
697
- var $L24 = $L(".");
698
- var $L25 = $L("[");
699
- var $L26 = $L("]");
700
- var $L27 = $L("::");
701
- var $L28 = $L("super[");
702
- var $L29 = $L("new.target");
703
- var $L30 = $L("import.meta");
704
- var $L31 = $L("");
705
- var $L32 = $L("...");
706
- var $L33 = $L("function");
707
- var $L34 = $L("->");
708
- var $L35 = $L("null");
709
- var $L36 = $L("true");
710
- var $L37 = $L("false");
711
- var $L38 = $L("get");
712
- var $L39 = $L("set");
713
- var $L40 = $L("**=");
714
- var $L41 = $L("*=");
715
- var $L42 = $L("/=");
716
- var $L43 = $L("%=");
717
- var $L44 = $L("+=");
718
- var $L45 = $L("-=");
719
- var $L46 = $L("<<=");
720
- var $L47 = $L(">>>=");
721
- var $L48 = $L(">>=");
722
- var $L49 = $L("&&=");
723
- var $L50 = $L("&=");
724
- var $L51 = $L("^=");
725
- var $L52 = $L("||=");
726
- var $L53 = $L("|=");
727
- var $L54 = $L("??=");
728
- var $L55 = $L("=");
729
- var $L56 = $L("**");
730
- var $L57 = $L("/");
731
- var $L58 = $L("%");
732
- var $L59 = $L("+");
733
- var $L60 = $L("-");
734
- var $L61 = $L("<=");
735
- var $L62 = $L(">=");
736
- var $L63 = $L("<<");
737
- var $L64 = $L(">>>");
738
- var $L65 = $L(">>");
739
- var $L66 = $L(">");
740
- var $L67 = $L("!==");
741
- var $L68 = $L("!=");
742
- var $L69 = $L("is");
743
- var $L70 = $L("===");
744
- var $L71 = $L("==");
745
- var $L72 = $L("and");
746
- var $L73 = $L("&&");
747
- var $L74 = $L("or");
748
- var $L75 = $L("||");
749
- var $L76 = $L("??");
750
- var $L77 = $L("instanceof");
751
- var $L78 = $L("in");
752
- var $L79 = $L("&");
753
- var $L80 = $L("^");
754
- var $L81 = $L("|");
755
- var $L82 = $L("delete");
756
- var $L83 = $L("void");
757
- var $L84 = $L("typeof");
758
- var $L85 = $L("if");
759
- var $L86 = $L("unless");
760
- var $L87 = $L(";");
761
- var $L88 = $L("else");
762
- var $L89 = $L("loop");
763
- var $L90 = $L("do");
764
- var $L91 = $L("while");
765
- var $L92 = $L("until");
766
- var $L93 = $L("var");
767
- var $L94 = $L("await");
682
+ var $L8 = $L("await");
683
+ var $L9 = $L("yield");
684
+ var $L10 = $L("*");
685
+ var $L11 = $L("=>");
686
+ var $L12 = $L("{");
687
+ var $L13 = $L(":");
688
+ var $L14 = $L("class");
689
+ var $L15 = $L("<");
690
+ var $L16 = $L("extends");
691
+ var $L17 = $L("}");
692
+ var $L18 = $L("static");
693
+ var $L19 = $L("this");
694
+ var $L20 = $L("#");
695
+ var $L21 = $L("@");
696
+ var $L22 = $L("new");
697
+ var $L23 = $L("super");
698
+ var $L24 = $L("import");
699
+ var $L25 = $L(".");
700
+ var $L26 = $L("[");
701
+ var $L27 = $L("]");
702
+ var $L28 = $L("::");
703
+ var $L29 = $L("super[");
704
+ var $L30 = $L("new.target");
705
+ var $L31 = $L("import.meta");
706
+ var $L32 = $L("");
707
+ var $L33 = $L("...");
708
+ var $L34 = $L("function");
709
+ var $L35 = $L("->");
710
+ var $L36 = $L("null");
711
+ var $L37 = $L("true");
712
+ var $L38 = $L("false");
713
+ var $L39 = $L("get");
714
+ var $L40 = $L("set");
715
+ var $L41 = $L("**=");
716
+ var $L42 = $L("*=");
717
+ var $L43 = $L("/=");
718
+ var $L44 = $L("%=");
719
+ var $L45 = $L("+=");
720
+ var $L46 = $L("-=");
721
+ var $L47 = $L("<<=");
722
+ var $L48 = $L(">>>=");
723
+ var $L49 = $L(">>=");
724
+ var $L50 = $L("&&=");
725
+ var $L51 = $L("&=");
726
+ var $L52 = $L("^=");
727
+ var $L53 = $L("||=");
728
+ var $L54 = $L("|=");
729
+ var $L55 = $L("??=");
730
+ var $L56 = $L("=");
731
+ var $L57 = $L("**");
732
+ var $L58 = $L("/");
733
+ var $L59 = $L("%");
734
+ var $L60 = $L("+");
735
+ var $L61 = $L("-");
736
+ var $L62 = $L("<=");
737
+ var $L63 = $L(">=");
738
+ var $L64 = $L("<<");
739
+ var $L65 = $L(">>>");
740
+ var $L66 = $L(">>");
741
+ var $L67 = $L(">");
742
+ var $L68 = $L("!==");
743
+ var $L69 = $L("!=");
744
+ var $L70 = $L("is");
745
+ var $L71 = $L("===");
746
+ var $L72 = $L("==");
747
+ var $L73 = $L("and");
748
+ var $L74 = $L("&&");
749
+ var $L75 = $L("or");
750
+ var $L76 = $L("||");
751
+ var $L77 = $L("??");
752
+ var $L78 = $L("instanceof");
753
+ var $L79 = $L("in");
754
+ var $L80 = $L("&");
755
+ var $L81 = $L("^");
756
+ var $L82 = $L("|");
757
+ var $L83 = $L("delete");
758
+ var $L84 = $L("void");
759
+ var $L85 = $L("typeof");
760
+ var $L86 = $L("if");
761
+ var $L87 = $L("unless");
762
+ var $L88 = $L(";");
763
+ var $L89 = $L("else");
764
+ var $L90 = $L("loop");
765
+ var $L91 = $L("do");
766
+ var $L92 = $L("while");
767
+ var $L93 = $L("until");
768
+ var $L94 = $L("var");
768
769
  var $L95 = $L("of");
769
770
  var $L96 = $L("for");
770
771
  var $L97 = $L("let");
@@ -994,18 +995,29 @@ var Civet = (() => {
994
995
  return AssignmentExpression$0(state) || AssignmentExpression$1(state);
995
996
  }
996
997
  }
997
- var AssignmentExpressionRest$0 = YieldExpression;
998
- var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
999
- var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
1000
- var AssignmentExpressionRest$3 = ConditionalExpression;
998
+ var AssignmentExpressionRest$0 = AwaitExpression;
999
+ var AssignmentExpressionRest$1 = YieldExpression;
1000
+ var AssignmentExpressionRest$2 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
1001
+ var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
1002
+ var AssignmentExpressionRest$4 = ConditionalExpression;
1001
1003
  function AssignmentExpressionRest(state) {
1002
1004
  if (state.tokenize) {
1003
- return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state));
1005
+ return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state));
1004
1006
  } else {
1005
- return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
1007
+ return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
1006
1008
  }
1007
1009
  }
1008
- var YieldExpression$0 = $S($EXPECT($L8, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L9, fail, 'YieldExpression "*"'))), AssignmentExpression);
1010
+ var AwaitExpression$0 = $S($EXPECT($L8, fail, 'AwaitExpression "await"'), NonIdContinue, $Q(TrailingComment), AssignmentExpression);
1011
+ function AwaitExpression(state) {
1012
+ if (state.verbose)
1013
+ console.log("ENTER:", "AwaitExpression");
1014
+ if (state.tokenize) {
1015
+ return $TOKEN("AwaitExpression", state, AwaitExpression$0(state));
1016
+ } else {
1017
+ return AwaitExpression$0(state);
1018
+ }
1019
+ }
1020
+ var YieldExpression$0 = $S($EXPECT($L9, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L10, fail, 'YieldExpression "*"'))), AssignmentExpression);
1009
1021
  function YieldExpression(state) {
1010
1022
  if (state.verbose)
1011
1023
  console.log("ENTER:", "YieldExpression");
@@ -1024,7 +1036,7 @@ var Civet = (() => {
1024
1036
  return ArrowFunction$0(state) || ArrowFunction$1(state);
1025
1037
  }
1026
1038
  }
1027
- var FatArrow$0 = $TS($S(__, $EXPECT($L10, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1039
+ var FatArrow$0 = $TS($S(__, $EXPECT($L11, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1028
1040
  var ws = $1;
1029
1041
  if (!ws.length)
1030
1042
  return " =>";
@@ -1040,7 +1052,7 @@ var Civet = (() => {
1040
1052
  }
1041
1053
  }
1042
1054
  var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
1043
- var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
1055
+ var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L12, fail, 'ConciseBody "{"'))), AssignmentExpression);
1044
1056
  var ConciseBody$2 = BracedBlock;
1045
1057
  function ConciseBody(state) {
1046
1058
  if (state.tokenize) {
@@ -1049,7 +1061,7 @@ var Civet = (() => {
1049
1061
  return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
1050
1062
  }
1051
1063
  }
1052
- var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L12, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
1064
+ var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L13, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
1053
1065
  function ConditionalExpression(state) {
1054
1066
  if (state.verbose)
1055
1067
  console.log("ENTER:", "ConditionalExpression");
@@ -1108,7 +1120,7 @@ var Civet = (() => {
1108
1120
  return ClassExpression$0(state);
1109
1121
  }
1110
1122
  }
1111
- var Class$0 = $TV($EXPECT($L13, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
1123
+ var Class$0 = $TV($EXPECT($L14, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
1112
1124
  return { $loc, token: $0 };
1113
1125
  });
1114
1126
  function Class(state) {
@@ -1130,10 +1142,10 @@ var Civet = (() => {
1130
1142
  return ClassHeritage$0(state);
1131
1143
  }
1132
1144
  }
1133
- var ExtendsToken$0 = $TV($EXPECT($L14, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1145
+ var ExtendsToken$0 = $TV($EXPECT($L15, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1134
1146
  return { $loc, token: "extends" };
1135
1147
  });
1136
- var ExtendsToken$1 = $TV($EXPECT($L15, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1148
+ var ExtendsToken$1 = $TV($EXPECT($L16, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1137
1149
  return { $loc, token: $1 };
1138
1150
  });
1139
1151
  function ExtendsToken(state) {
@@ -1143,7 +1155,7 @@ var Civet = (() => {
1143
1155
  return ExtendsToken$0(state) || ExtendsToken$1(state);
1144
1156
  }
1145
1157
  }
1146
- var ClassBody$0 = $S(__, $EXPECT($L11, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L16, fail, 'ClassBody "}"'));
1158
+ var ClassBody$0 = $S(__, $EXPECT($L12, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L17, fail, 'ClassBody "}"'));
1147
1159
  var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
1148
1160
  function ClassBody(state) {
1149
1161
  if (state.tokenize) {
@@ -1186,7 +1198,7 @@ var Civet = (() => {
1186
1198
  return ClassElement$0(state) || ClassElement$1(state);
1187
1199
  }
1188
1200
  }
1189
- var Static$0 = $TV($EXPECT($L17, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
1201
+ var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
1190
1202
  return { $loc, token: $0 };
1191
1203
  });
1192
1204
  function Static(state) {
@@ -1208,11 +1220,11 @@ var Civet = (() => {
1208
1220
  return FieldDefinition$0(state);
1209
1221
  }
1210
1222
  }
1211
- var This$0 = $TV($EXPECT($L18, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1223
+ var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1212
1224
  return { $loc, token: $0 };
1213
1225
  });
1214
- var This$1 = $S(AtAccessor, $S($E($EXPECT($L19, fail, 'This "#"')), IdentifierName));
1215
- var This$2 = $TV($EXPECT($L20, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1226
+ var This$1 = $S(AtAccessor, $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName));
1227
+ var This$2 = $TV($EXPECT($L21, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1216
1228
  return { $loc, token: "this" };
1217
1229
  });
1218
1230
  function This(state) {
@@ -1222,7 +1234,7 @@ var Civet = (() => {
1222
1234
  return This$0(state) || This$1(state) || This$2(state);
1223
1235
  }
1224
1236
  }
1225
- var AtAccessor$0 = $TV($EXPECT($L20, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1237
+ var AtAccessor$0 = $TV($EXPECT($L21, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1226
1238
  return { $loc, token: "this." };
1227
1239
  });
1228
1240
  function AtAccessor(state) {
@@ -1243,7 +1255,7 @@ var Civet = (() => {
1243
1255
  return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
1244
1256
  }
1245
1257
  }
1246
- var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), CallExpression);
1258
+ var NewExpression$0 = $S($P($S($EXPECT($L22, fail, 'NewExpression "new"'), __)), CallExpression);
1247
1259
  function NewExpression(state) {
1248
1260
  if (state.verbose)
1249
1261
  console.log("ENTER:", "NewExpression");
@@ -1253,8 +1265,8 @@ var Civet = (() => {
1253
1265
  return NewExpression$0(state);
1254
1266
  }
1255
1267
  }
1256
- var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
1257
- var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1268
+ var CallExpression$0 = $S($EXPECT($L23, fail, 'CallExpression "super"'), __, Arguments);
1269
+ var CallExpression$1 = $S($EXPECT($L24, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1258
1270
  var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
1259
1271
  function CallExpression(state) {
1260
1272
  if (state.tokenize) {
@@ -1274,7 +1286,7 @@ var Civet = (() => {
1274
1286
  return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1275
1287
  }
1276
1288
  }
1277
- var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L24, fail, 'OptionalShorthand "."'), InsertDot));
1289
+ var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
1278
1290
  function OptionalShorthand(state) {
1279
1291
  if (state.verbose)
1280
1292
  console.log("ENTER:", "OptionalShorthand");
@@ -1328,9 +1340,9 @@ var Civet = (() => {
1328
1340
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1329
1341
  }
1330
1342
  }
1331
- var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L25, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L26, fail, 'MemberExpressionRest "]"'));
1343
+ var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
1332
1344
  var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
1333
- var MemberExpressionRest$2 = $TS($S($EXPECT($L27, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1345
+ var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1334
1346
  var id = $2;
1335
1347
  if (id)
1336
1348
  return [".prototype.", id];
@@ -1343,7 +1355,7 @@ var Civet = (() => {
1343
1355
  return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
1344
1356
  }
1345
1357
  }
1346
- var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L24, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1358
+ var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1347
1359
  function PropertyAccess(state) {
1348
1360
  if (state.verbose)
1349
1361
  console.log("ENTER:", "PropertyAccess");
@@ -1353,7 +1365,7 @@ var Civet = (() => {
1353
1365
  return PropertyAccess$0(state);
1354
1366
  }
1355
1367
  }
1356
- var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L26, fail, 'SuperProperty "]"'));
1368
+ var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
1357
1369
  function SuperProperty(state) {
1358
1370
  if (state.verbose)
1359
1371
  console.log("ENTER:", "SuperProperty");
@@ -1363,8 +1375,8 @@ var Civet = (() => {
1363
1375
  return SuperProperty$0(state);
1364
1376
  }
1365
1377
  }
1366
- var MetaProperty$0 = $EXPECT($L29, fail, 'MetaProperty "new.target"');
1367
- var MetaProperty$1 = $EXPECT($L30, fail, 'MetaProperty "import.meta"');
1378
+ var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
1379
+ var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
1368
1380
  function MetaProperty(state) {
1369
1381
  if (state.tokenize) {
1370
1382
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1373,7 +1385,7 @@ var Civet = (() => {
1373
1385
  }
1374
1386
  }
1375
1387
  var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1376
- var Parameters$1 = $T($EXPECT($L31, fail, 'Parameters ""'), function(value) {
1388
+ var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
1377
1389
  return "()";
1378
1390
  });
1379
1391
  function Parameters(state) {
@@ -1427,7 +1439,7 @@ var Civet = (() => {
1427
1439
  return BindingPattern$0(state) || BindingPattern$1(state);
1428
1440
  }
1429
1441
  }
1430
- var ObjectBindingPattern$0 = $S($EXPECT($L11, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L16, fail, 'ObjectBindingPattern "}"'));
1442
+ var ObjectBindingPattern$0 = $S($EXPECT($L12, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L17, fail, 'ObjectBindingPattern "}"'));
1431
1443
  function ObjectBindingPattern(state) {
1432
1444
  if (state.verbose)
1433
1445
  console.log("ENTER:", "ObjectBindingPattern");
@@ -1437,7 +1449,7 @@ var Civet = (() => {
1437
1449
  return ObjectBindingPattern$0(state);
1438
1450
  }
1439
1451
  }
1440
- var ArrayBindingPattern$0 = $S($EXPECT($L25, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L26, fail, 'ArrayBindingPattern "]"'));
1452
+ var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
1441
1453
  function ArrayBindingPattern(state) {
1442
1454
  if (state.verbose)
1443
1455
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1447,7 +1459,7 @@ var Civet = (() => {
1447
1459
  return ArrayBindingPattern$0(state);
1448
1460
  }
1449
1461
  }
1450
- var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L12, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1462
+ var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L13, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1451
1463
  var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
1452
1464
  function BindingProperty(state) {
1453
1465
  if (state.tokenize) {
@@ -1456,7 +1468,7 @@ var Civet = (() => {
1456
1468
  return BindingProperty$0(state) || BindingProperty$1(state);
1457
1469
  }
1458
1470
  }
1459
- var BindingRestProperty$0 = $S($EXPECT($L32, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1471
+ var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1460
1472
  function BindingRestProperty(state) {
1461
1473
  if (state.verbose)
1462
1474
  console.log("ENTER:", "BindingRestProperty");
@@ -1476,7 +1488,7 @@ var Civet = (() => {
1476
1488
  return BindingElement$0(state);
1477
1489
  }
1478
1490
  }
1479
- var BindingRestElement$0 = $S($EXPECT($L32, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1491
+ var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1480
1492
  function BindingRestElement(state) {
1481
1493
  if (state.verbose)
1482
1494
  console.log("ENTER:", "BindingRestElement");
@@ -1497,7 +1509,7 @@ var Civet = (() => {
1497
1509
  }
1498
1510
  }
1499
1511
  var FunctionExpression$0 = ThinArrowFunction;
1500
- 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);
1512
+ 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);
1501
1513
  function FunctionExpression(state) {
1502
1514
  if (state.tokenize) {
1503
1515
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1526,7 +1538,7 @@ var Civet = (() => {
1526
1538
  return ThinArrowFunction$0(state);
1527
1539
  }
1528
1540
  }
1529
- var Arrow$0 = $TV($EXPECT($L34, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1541
+ var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1530
1542
  return { $loc, token: $1 };
1531
1543
  });
1532
1544
  function Arrow(state) {
@@ -1538,7 +1550,7 @@ var Civet = (() => {
1538
1550
  return Arrow$0(state);
1539
1551
  }
1540
1552
  }
1541
- var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
1553
+ var Block$0 = $S(__, $EXPECT($L12, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'Block "}"'));
1542
1554
  var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1543
1555
  var Block$2 = Statement;
1544
1556
  var Block$3 = $S(__, Statement);
@@ -1558,7 +1570,7 @@ var Civet = (() => {
1558
1570
  return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
1559
1571
  }
1560
1572
  }
1561
- var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
1573
+ var BracedBlock$0 = $S(__, $EXPECT($L12, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BracedBlock "}"'));
1562
1574
  var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1563
1575
  var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
1564
1576
  function BracedBlock(state) {
@@ -1634,7 +1646,7 @@ var Civet = (() => {
1634
1646
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1635
1647
  }
1636
1648
  }
1637
- var NullLiteral$0 = $TV($EXPECT($L35, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1649
+ var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1638
1650
  return { $loc, token: $1 };
1639
1651
  });
1640
1652
  function NullLiteral(state) {
@@ -1646,7 +1658,7 @@ var Civet = (() => {
1646
1658
  return NullLiteral$0(state);
1647
1659
  }
1648
1660
  }
1649
- var BooleanLiteral$0 = $TV($C($EXPECT($L36, fail, 'BooleanLiteral "true"'), $EXPECT($L37, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1661
+ var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1650
1662
  return { $loc, token: $1 };
1651
1663
  });
1652
1664
  function BooleanLiteral(state) {
@@ -1703,8 +1715,8 @@ var Civet = (() => {
1703
1715
  return IdentifierReference$0(state);
1704
1716
  }
1705
1717
  }
1706
- var ArrayLiteral$0 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
1707
- var ArrayLiteral$1 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
1718
+ var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1719
+ var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1708
1720
  function ArrayLiteral(state) {
1709
1721
  if (state.tokenize) {
1710
1722
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1738,8 +1750,8 @@ var Civet = (() => {
1738
1750
  }
1739
1751
  }
1740
1752
  var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1741
- var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
1742
- var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1753
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
1754
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1743
1755
  return ",";
1744
1756
  });
1745
1757
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1772,7 +1784,7 @@ var Civet = (() => {
1772
1784
  return InlineElementList$0(state);
1773
1785
  }
1774
1786
  }
1775
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L32, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1787
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1776
1788
  function ArrayElementExpression(state) {
1777
1789
  if (state.verbose)
1778
1790
  console.log("ENTER:", "ArrayElementExpression");
@@ -1792,9 +1804,9 @@ var Civet = (() => {
1792
1804
  return Elision$0(state);
1793
1805
  }
1794
1806
  }
1795
- var ObjectLiteral$0 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1796
- var ObjectLiteral$1 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1797
- var ObjectLiteral$2 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1807
+ var ObjectLiteral$0 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
1808
+ var ObjectLiteral$1 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L17, fail, 'ObjectLiteral "}"'));
1809
+ var ObjectLiteral$2 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
1798
1810
  var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
1799
1811
  function ObjectLiteral(state) {
1800
1812
  if (state.tokenize) {
@@ -1829,8 +1841,8 @@ var Civet = (() => {
1829
1841
  }
1830
1842
  }
1831
1843
  var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
1832
- var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
1833
- var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1844
+ var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"')));
1845
+ var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1834
1846
  return ",";
1835
1847
  });
1836
1848
  var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1853,9 +1865,9 @@ var Civet = (() => {
1853
1865
  return PropertyDefinitionList$0(state);
1854
1866
  }
1855
1867
  }
1856
- var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1868
+ var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L13, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1857
1869
  var PropertyDefinition$1 = MethodDefinition;
1858
- var PropertyDefinition$2 = $S($EXPECT($L32, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1870
+ var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1859
1871
  var PropertyDefinition$3 = IdentifierReference;
1860
1872
  function PropertyDefinition(state) {
1861
1873
  if (state.tokenize) {
@@ -1867,7 +1879,7 @@ var Civet = (() => {
1867
1879
  var PropertyName$0 = NumericLiteral;
1868
1880
  var PropertyName$1 = StringLiteral;
1869
1881
  var PropertyName$2 = IdentifierName;
1870
- var PropertyName$3 = $S($EXPECT($L25, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
1882
+ var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
1871
1883
  function PropertyName(state) {
1872
1884
  if (state.tokenize) {
1873
1885
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1875,8 +1887,8 @@ var Civet = (() => {
1875
1887
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1876
1888
  }
1877
1889
  }
1878
- var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1879
- var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1890
+ var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1891
+ var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1880
1892
  var MethodDefinition$2 = AsyncGeneratorMethod;
1881
1893
  var MethodDefinition$3 = AsyncMethod;
1882
1894
  var MethodDefinition$4 = GeneratorMethod;
@@ -1897,7 +1909,7 @@ var Civet = (() => {
1897
1909
  return ClassElementName$0(state) || ClassElementName$1(state);
1898
1910
  }
1899
1911
  }
1900
- var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
1912
+ var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
1901
1913
  function PrivateIdentifier(state) {
1902
1914
  if (state.verbose)
1903
1915
  console.log("ENTER:", "PrivateIdentifier");
@@ -1907,7 +1919,7 @@ var Civet = (() => {
1907
1919
  return PrivateIdentifier$0(state);
1908
1920
  }
1909
1921
  }
1910
- var GeneratorMethod$0 = $S($EXPECT($L9, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1922
+ var GeneratorMethod$0 = $S($EXPECT($L10, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1911
1923
  function GeneratorMethod(state) {
1912
1924
  if (state.verbose)
1913
1925
  console.log("ENTER:", "GeneratorMethod");
@@ -1947,7 +1959,7 @@ var Civet = (() => {
1947
1959
  return AsyncFunctionBody$0(state);
1948
1960
  }
1949
1961
  }
1950
- var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L9, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1962
+ var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L10, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1951
1963
  function AsyncGeneratorMethod(state) {
1952
1964
  if (state.verbose)
1953
1965
  console.log("ENTER:", "AsyncGeneratorMethod");
@@ -1979,22 +1991,22 @@ var Civet = (() => {
1979
1991
  return AssignmentOp$0(state);
1980
1992
  }
1981
1993
  }
1982
- var AssignmentOpSymbol$0 = $EXPECT($L40, fail, 'AssignmentOpSymbol "**="');
1983
- var AssignmentOpSymbol$1 = $EXPECT($L41, fail, 'AssignmentOpSymbol "*="');
1984
- var AssignmentOpSymbol$2 = $EXPECT($L42, fail, 'AssignmentOpSymbol "/="');
1985
- var AssignmentOpSymbol$3 = $EXPECT($L43, fail, 'AssignmentOpSymbol "%="');
1986
- var AssignmentOpSymbol$4 = $EXPECT($L44, fail, 'AssignmentOpSymbol "+="');
1987
- var AssignmentOpSymbol$5 = $EXPECT($L45, fail, 'AssignmentOpSymbol "-="');
1988
- var AssignmentOpSymbol$6 = $EXPECT($L46, fail, 'AssignmentOpSymbol "<<="');
1989
- var AssignmentOpSymbol$7 = $EXPECT($L47, fail, 'AssignmentOpSymbol ">>>="');
1990
- var AssignmentOpSymbol$8 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>="');
1991
- var AssignmentOpSymbol$9 = $EXPECT($L49, fail, 'AssignmentOpSymbol "&&="');
1992
- var AssignmentOpSymbol$10 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&="');
1993
- var AssignmentOpSymbol$11 = $EXPECT($L51, fail, 'AssignmentOpSymbol "^="');
1994
- var AssignmentOpSymbol$12 = $EXPECT($L52, fail, 'AssignmentOpSymbol "||="');
1995
- var AssignmentOpSymbol$13 = $EXPECT($L53, fail, 'AssignmentOpSymbol "|="');
1996
- var AssignmentOpSymbol$14 = $EXPECT($L54, fail, 'AssignmentOpSymbol "??="');
1997
- var AssignmentOpSymbol$15 = $EXPECT($L55, fail, 'AssignmentOpSymbol "="');
1994
+ var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
1995
+ var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
1996
+ var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
1997
+ var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
1998
+ var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
1999
+ var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
2000
+ var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
2001
+ var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
2002
+ var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
2003
+ var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
2004
+ var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
2005
+ var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
2006
+ var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
2007
+ var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
2008
+ var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
2009
+ var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
1998
2010
  function AssignmentOpSymbol(state) {
1999
2011
  if (state.tokenize) {
2000
2012
  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));
@@ -2014,48 +2026,48 @@ var Civet = (() => {
2014
2026
  return BinaryOp$0(state);
2015
2027
  }
2016
2028
  }
2017
- var BinaryOpSymbol$0 = $EXPECT($L56, fail, 'BinaryOpSymbol "**"');
2018
- var BinaryOpSymbol$1 = $EXPECT($L9, fail, 'BinaryOpSymbol "*"');
2019
- var BinaryOpSymbol$2 = $EXPECT($L57, fail, 'BinaryOpSymbol "/"');
2020
- var BinaryOpSymbol$3 = $EXPECT($L58, fail, 'BinaryOpSymbol "%"');
2021
- var BinaryOpSymbol$4 = $EXPECT($L59, fail, 'BinaryOpSymbol "+"');
2022
- var BinaryOpSymbol$5 = $EXPECT($L60, fail, 'BinaryOpSymbol "-"');
2023
- var BinaryOpSymbol$6 = $EXPECT($L61, fail, 'BinaryOpSymbol "<="');
2024
- var BinaryOpSymbol$7 = $EXPECT($L62, fail, 'BinaryOpSymbol ">="');
2025
- var BinaryOpSymbol$8 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
2026
- var BinaryOpSymbol$9 = $EXPECT($L14, fail, 'BinaryOpSymbol "<"');
2027
- var BinaryOpSymbol$10 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
2028
- var BinaryOpSymbol$11 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
2029
- var BinaryOpSymbol$12 = $EXPECT($L66, fail, 'BinaryOpSymbol ">"');
2030
- var BinaryOpSymbol$13 = $EXPECT($L67, fail, 'BinaryOpSymbol "!=="');
2031
- var BinaryOpSymbol$14 = $TV($EXPECT($L68, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2029
+ var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
2030
+ var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
2031
+ var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
2032
+ var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
2033
+ var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
2034
+ var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
2035
+ var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
2036
+ var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
2037
+ var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
2038
+ var BinaryOpSymbol$9 = $EXPECT($L15, fail, 'BinaryOpSymbol "<"');
2039
+ var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
2040
+ var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
2041
+ var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
2042
+ var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
2043
+ var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2032
2044
  if (global.coffeeCompat)
2033
2045
  return "!==";
2034
2046
  return $1;
2035
2047
  });
2036
- var BinaryOpSymbol$15 = $T($S($EXPECT($L69, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2048
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2037
2049
  return "===";
2038
2050
  });
2039
- var BinaryOpSymbol$16 = $EXPECT($L70, fail, 'BinaryOpSymbol "==="');
2040
- var BinaryOpSymbol$17 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2051
+ var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
2052
+ var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2041
2053
  if (global.coffeeCompat)
2042
2054
  return "===";
2043
2055
  return $1;
2044
2056
  });
2045
- var BinaryOpSymbol$18 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2057
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2046
2058
  return "&&";
2047
2059
  });
2048
- var BinaryOpSymbol$19 = $EXPECT($L73, fail, 'BinaryOpSymbol "&&"');
2049
- var BinaryOpSymbol$20 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2060
+ var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
2061
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2050
2062
  return "||";
2051
2063
  });
2052
- var BinaryOpSymbol$21 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
2053
- var BinaryOpSymbol$22 = $EXPECT($L76, fail, 'BinaryOpSymbol "??"');
2054
- var BinaryOpSymbol$23 = $S($EXPECT($L77, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2055
- var BinaryOpSymbol$24 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2056
- var BinaryOpSymbol$25 = $EXPECT($L79, fail, 'BinaryOpSymbol "&"');
2057
- var BinaryOpSymbol$26 = $EXPECT($L80, fail, 'BinaryOpSymbol "^"');
2058
- var BinaryOpSymbol$27 = $EXPECT($L81, fail, 'BinaryOpSymbol "|"');
2064
+ var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
2065
+ var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
2066
+ var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2067
+ var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2068
+ var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
2069
+ var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
2070
+ var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
2059
2071
  function BinaryOpSymbol(state) {
2060
2072
  if (state.tokenize) {
2061
2073
  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));
@@ -2064,7 +2076,7 @@ var Civet = (() => {
2064
2076
  }
2065
2077
  }
2066
2078
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2067
- var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2079
+ var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2068
2080
  function UnaryOp(state) {
2069
2081
  if (state.tokenize) {
2070
2082
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2098,7 +2110,7 @@ var Civet = (() => {
2098
2110
  return StatementListItem$0(state);
2099
2111
  }
2100
2112
  }
2101
- 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) {
2113
+ 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) {
2102
2114
  var ws = $1;
2103
2115
  var cond = $2;
2104
2116
  var exp = $4;
@@ -2131,7 +2143,7 @@ var Civet = (() => {
2131
2143
  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);
2132
2144
  }
2133
2145
  }
2134
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
2146
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
2135
2147
  function EmptyStatement(state) {
2136
2148
  if (state.verbose)
2137
2149
  console.log("ENTER:", "EmptyStatement");
@@ -2141,7 +2153,7 @@ var Civet = (() => {
2141
2153
  return EmptyStatement$0(state);
2142
2154
  }
2143
2155
  }
2144
- var BlockStatement$0 = $S(__, $EXPECT($L11, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BlockStatement "}"'));
2156
+ var BlockStatement$0 = $S(__, $EXPECT($L12, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BlockStatement "}"'));
2145
2157
  function BlockStatement(state) {
2146
2158
  if (state.verbose)
2147
2159
  console.log("ENTER:", "BlockStatement");
@@ -2151,8 +2163,8 @@ var Civet = (() => {
2151
2163
  return BlockStatement$0(state);
2152
2164
  }
2153
2165
  }
2154
- var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
2155
- var IfStatement$1 = $TS($S($EXPECT($L86, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2166
+ var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
2167
+ var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2156
2168
  var condition = $2;
2157
2169
  var block = $3;
2158
2170
  return ["if", condition.map((c) => {
@@ -2182,7 +2194,7 @@ var Civet = (() => {
2182
2194
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2183
2195
  }
2184
2196
  }
2185
- var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2197
+ var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2186
2198
  var b = $3;
2187
2199
  return ["while(true)", b];
2188
2200
  });
@@ -2195,7 +2207,7 @@ var Civet = (() => {
2195
2207
  return LoopStatement$0(state);
2196
2208
  }
2197
2209
  }
2198
- var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2210
+ var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2199
2211
  function DoWhileStatement(state) {
2200
2212
  if (state.verbose)
2201
2213
  console.log("ENTER:", "DoWhileStatement");
@@ -2215,7 +2227,7 @@ var Civet = (() => {
2215
2227
  return WhileStatement$0(state);
2216
2228
  }
2217
2229
  }
2218
- var WhileClause$0 = $TS($S($C($EXPECT($L91, fail, 'WhileClause "while"'), $EXPECT($L92, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2230
+ 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) {
2219
2231
  var kind = $1;
2220
2232
  var cond = $3;
2221
2233
  if (kind === "until") {
@@ -2234,7 +2246,7 @@ var Civet = (() => {
2234
2246
  return WhileClause$0(state);
2235
2247
  }
2236
2248
  }
2237
- var ForStatement$0 = $S(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);
2249
+ 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);
2238
2250
  function ForStatement(state) {
2239
2251
  if (state.verbose)
2240
2252
  console.log("ENTER:", "ForStatement");
@@ -2244,10 +2256,10 @@ var Civet = (() => {
2244
2256
  return ForStatement$0(state);
2245
2257
  }
2246
2258
  }
2247
- var ForInOfStatement$0 = $S(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);
2248
- var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2249
- var ForInOfStatement$2 = $S(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);
2250
- var ForInOfStatement$3 = $S(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);
2259
+ 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);
2260
+ var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2261
+ 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);
2262
+ 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);
2251
2263
  function ForInOfStatement(state) {
2252
2264
  if (state.tokenize) {
2253
2265
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2308,7 +2320,7 @@ var Civet = (() => {
2308
2320
  return SwitchStatement$0(state);
2309
2321
  }
2310
2322
  }
2311
- var CaseBlock$0 = $S(__, $EXPECT($L11, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L16, fail, 'CaseBlock "}"'));
2323
+ var CaseBlock$0 = $S(__, $EXPECT($L12, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L17, fail, 'CaseBlock "}"'));
2312
2324
  var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
2313
2325
  function CaseBlock(state) {
2314
2326
  if (state.tokenize) {
@@ -2364,8 +2376,8 @@ var Civet = (() => {
2364
2376
  return When$0(state);
2365
2377
  }
2366
2378
  }
2367
- var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2368
- var ImpliedColon$1 = $T($EXPECT($L31, fail, 'ImpliedColon ""'), function(value) {
2379
+ var ImpliedColon$0 = $S(__, $EXPECT($L13, fail, 'ImpliedColon ":"'));
2380
+ var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
2369
2381
  return ":";
2370
2382
  });
2371
2383
  function ImpliedColon(state) {
@@ -2494,7 +2506,7 @@ var Civet = (() => {
2494
2506
  return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
2495
2507
  }
2496
2508
  }
2497
- var Import$0 = $TS($S($EXPECT($L23, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2509
+ var Import$0 = $TS($S($EXPECT($L24, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2498
2510
  return { $loc, token: $1 };
2499
2511
  });
2500
2512
  function Import(state) {
@@ -2516,7 +2528,7 @@ var Civet = (() => {
2516
2528
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2517
2529
  }
2518
2530
  }
2519
- var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
2531
+ var NameSpaceImport$0 = $S($EXPECT($L10, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
2520
2532
  function NameSpaceImport(state) {
2521
2533
  if (state.verbose)
2522
2534
  console.log("ENTER:", "NameSpaceImport");
@@ -2526,7 +2538,7 @@ var Civet = (() => {
2526
2538
  return NameSpaceImport$0(state);
2527
2539
  }
2528
2540
  }
2529
- var NamedImports$0 = $S($EXPECT($L11, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L16, fail, 'NamedImports "}"'));
2541
+ var NamedImports$0 = $S($EXPECT($L12, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L17, fail, 'NamedImports "}"'));
2530
2542
  function NamedImports(state) {
2531
2543
  if (state.verbose)
2532
2544
  console.log("ENTER:", "NamedImports");
@@ -2626,7 +2638,7 @@ var Civet = (() => {
2626
2638
  return Export$0(state);
2627
2639
  }
2628
2640
  }
2629
- var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
2641
+ var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
2630
2642
  var ExportFromClause$1 = NamedExports;
2631
2643
  function ExportFromClause(state) {
2632
2644
  if (state.tokenize) {
@@ -2635,7 +2647,7 @@ var Civet = (() => {
2635
2647
  return ExportFromClause$0(state) || ExportFromClause$1(state);
2636
2648
  }
2637
2649
  }
2638
- var NamedExports$0 = $S($EXPECT($L11, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L16, fail, 'NamedExports "}"'));
2650
+ var NamedExports$0 = $S($EXPECT($L12, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L17, fail, 'NamedExports "}"'));
2639
2651
  function NamedExports(state) {
2640
2652
  if (state.verbose)
2641
2653
  console.log("ENTER:", "NamedExports");
@@ -2721,7 +2733,7 @@ var Civet = (() => {
2721
2733
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2722
2734
  }
2723
2735
  }
2724
- var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2736
+ var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2725
2737
  function Initializer(state) {
2726
2738
  if (state.verbose)
2727
2739
  console.log("ENTER:", "Initializer");
@@ -2731,7 +2743,7 @@ var Civet = (() => {
2731
2743
  return Initializer$0(state);
2732
2744
  }
2733
2745
  }
2734
- var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2746
+ var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2735
2747
  function VariableStatement(state) {
2736
2748
  if (state.verbose)
2737
2749
  console.log("ENTER:", "VariableStatement");
@@ -2895,7 +2907,7 @@ var Civet = (() => {
2895
2907
  return TripleSingleStringCharacter$0(state);
2896
2908
  }
2897
2909
  }
2898
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2910
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2899
2911
  return { $loc, token: $1 };
2900
2912
  });
2901
2913
  function RegularExpressionLiteral(state) {
@@ -2947,7 +2959,7 @@ var Civet = (() => {
2947
2959
  return TemplateLiteral$0(state);
2948
2960
  }
2949
2961
  }
2950
- var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2962
+ var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L17, fail, 'TemplateSubstitution "}"'));
2951
2963
  function TemplateSubstitution(state) {
2952
2964
  if (state.verbose)
2953
2965
  console.log("ENTER:", "TemplateSubstitution");
@@ -3090,7 +3102,7 @@ var Civet = (() => {
3090
3102
  return __$0(state);
3091
3103
  }
3092
3104
  }
3093
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3105
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3094
3106
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
3095
3107
  return [";", value];
3096
3108
  });
@@ -3125,7 +3137,7 @@ var Civet = (() => {
3125
3137
  return JSXElement$0(state) || JSXElement$1(state);
3126
3138
  }
3127
3139
  }
3128
- var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
3140
+ var JSXSelfClosingElement$0 = $S($EXPECT($L15, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
3129
3141
  function JSXSelfClosingElement(state) {
3130
3142
  if (state.verbose)
3131
3143
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3135,7 +3147,7 @@ var Civet = (() => {
3135
3147
  return JSXSelfClosingElement$0(state);
3136
3148
  }
3137
3149
  }
3138
- var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
3150
+ var JSXOpeningElement$0 = $S($EXPECT($L15, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
3139
3151
  function JSXOpeningElement(state) {
3140
3152
  if (state.verbose)
3141
3153
  console.log("ENTER:", "JSXOpeningElement");
@@ -3145,7 +3157,7 @@ var Civet = (() => {
3145
3157
  return JSXOpeningElement$0(state);
3146
3158
  }
3147
3159
  }
3148
- var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
3160
+ var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
3149
3161
  function JSXClosingElement(state) {
3150
3162
  if (state.verbose)
3151
3163
  console.log("ENTER:", "JSXClosingElement");
@@ -3165,7 +3177,7 @@ var Civet = (() => {
3165
3177
  return JSXFragment$0(state);
3166
3178
  }
3167
3179
  }
3168
- var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L24, fail, 'JSXElementName "."'), JSXIdentifierName))));
3180
+ var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L13, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
3169
3181
  function JSXElementName(state) {
3170
3182
  if (state.verbose)
3171
3183
  console.log("ENTER:", "JSXElementName");
@@ -3195,7 +3207,7 @@ var Civet = (() => {
3195
3207
  return JSXAttributes$0(state);
3196
3208
  }
3197
3209
  }
3198
- var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L32, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
3210
+ var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttribute "}"'));
3199
3211
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3200
3212
  function JSXAttribute(state) {
3201
3213
  if (state.tokenize) {
@@ -3204,7 +3216,7 @@ var Civet = (() => {
3204
3216
  return JSXAttribute$0(state) || JSXAttribute$1(state);
3205
3217
  }
3206
3218
  }
3207
- var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L12, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
3219
+ var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L13, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
3208
3220
  function JSXAttributeName(state) {
3209
3221
  if (state.verbose)
3210
3222
  console.log("ENTER:", "JSXAttributeName");
@@ -3214,7 +3226,7 @@ var Civet = (() => {
3214
3226
  return JSXAttributeName$0(state);
3215
3227
  }
3216
3228
  }
3217
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3229
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3218
3230
  function JSXAttributeInitializer(state) {
3219
3231
  if (state.verbose)
3220
3232
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -3226,7 +3238,7 @@ var Civet = (() => {
3226
3238
  }
3227
3239
  var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
3228
3240
  var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
3229
- var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
3241
+ var JSXAttributeValue$2 = $S($EXPECT($L12, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttributeValue "}"'));
3230
3242
  var JSXAttributeValue$3 = JSXElement;
3231
3243
  var JSXAttributeValue$4 = JSXFragment;
3232
3244
  function JSXAttributeValue(state) {
@@ -3249,7 +3261,7 @@ var Civet = (() => {
3249
3261
  var JSXChild$0 = JSXText;
3250
3262
  var JSXChild$1 = JSXElement;
3251
3263
  var JSXChild$2 = JSXFragment;
3252
- var JSXChild$3 = $S($EXPECT($L11, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L16, fail, 'JSXChild "}"'));
3264
+ var JSXChild$3 = $S($EXPECT($L12, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L17, fail, 'JSXChild "}"'));
3253
3265
  function JSXChild(state) {
3254
3266
  if (state.tokenize) {
3255
3267
  return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
@@ -3267,7 +3279,7 @@ var Civet = (() => {
3267
3279
  return JSXText$0(state);
3268
3280
  }
3269
3281
  }
3270
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L32, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3282
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3271
3283
  function JSXChildExpression(state) {
3272
3284
  if (state.verbose)
3273
3285
  console.log("ENTER:", "JSXChildExpression");
@@ -3277,7 +3289,7 @@ var Civet = (() => {
3277
3289
  return JSXChildExpression$0(state);
3278
3290
  }
3279
3291
  }
3280
- var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
3292
+ var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
3281
3293
  return { "ts": true, "children": value };
3282
3294
  });
3283
3295
  var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
@@ -3290,8 +3302,8 @@ var Civet = (() => {
3290
3302
  return TypeDeclaration$0(state) || TypeDeclaration$1(state);
3291
3303
  }
3292
3304
  }
3293
- var InterfaceBlock$0 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
3294
- var InterfaceBlock$1 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
3305
+ var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
3306
+ var InterfaceBlock$1 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
3295
3307
  var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
3296
3308
  function InterfaceBlock(state) {
3297
3309
  if (state.tokenize) {
@@ -3335,9 +3347,9 @@ var Civet = (() => {
3335
3347
  return InterfaceProperty$0(state);
3336
3348
  }
3337
3349
  }
3338
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
3339
- var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
3340
- var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3350
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3351
+ var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"')));
3352
+ var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3341
3353
  return ";";
3342
3354
  });
3343
3355
  var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3350,7 +3362,7 @@ var Civet = (() => {
3350
3362
  return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
3351
3363
  }
3352
3364
  }
3353
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L25, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L26, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3365
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3354
3366
  function TypeIndexSignature(state) {
3355
3367
  if (state.verbose)
3356
3368
  console.log("ENTER:", "TypeIndexSignature");
@@ -3361,7 +3373,7 @@ var Civet = (() => {
3361
3373
  }
3362
3374
  }
3363
3375
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3364
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3376
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3365
3377
  function TypeIndex(state) {
3366
3378
  if (state.tokenize) {
3367
3379
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3369,7 +3381,7 @@ var Civet = (() => {
3369
3381
  return TypeIndex$0(state) || TypeIndex$1(state);
3370
3382
  }
3371
3383
  }
3372
- var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L12, fail, 'TypeSuffix ":"'), Type), function(value) {
3384
+ var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L13, fail, 'TypeSuffix ":"'), Type), function(value) {
3373
3385
  return { "ts": true, "children": value };
3374
3386
  });
3375
3387
  function TypeSuffix(state) {
@@ -3381,7 +3393,7 @@ var Civet = (() => {
3381
3393
  return TypeSuffix$0(state);
3382
3394
  }
3383
3395
  }
3384
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3396
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L13, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3385
3397
  return { "ts": true, "children": value };
3386
3398
  });
3387
3399
  function ReturnTypeSuffix(state) {
@@ -3393,7 +3405,7 @@ var Civet = (() => {
3393
3405
  return ReturnTypeSuffix$0(state);
3394
3406
  }
3395
3407
  }
3396
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3408
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3397
3409
  function TypePredicate(state) {
3398
3410
  if (state.verbose)
3399
3411
  console.log("ENTER:", "TypePredicate");
@@ -3444,7 +3456,7 @@ var Civet = (() => {
3444
3456
  }
3445
3457
  }
3446
3458
  var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
3447
- var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
3459
+ var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3448
3460
  var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
3449
3461
  function TypeUnaryOp(state) {
3450
3462
  if (state.tokenize) {
@@ -3453,7 +3465,7 @@ var Civet = (() => {
3453
3465
  return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3454
3466
  }
3455
3467
  }
3456
- var TypeIndexedAccess$0 = $S(__, $EXPECT($L25, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L26, fail, 'TypeIndexedAccess "]"'));
3468
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
3457
3469
  function TypeIndexedAccess(state) {
3458
3470
  if (state.verbose)
3459
3471
  console.log("ENTER:", "TypeIndexedAccess");
@@ -3466,7 +3478,7 @@ var Civet = (() => {
3466
3478
  var TypePrimary$0 = InterfaceBlock;
3467
3479
  var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
3468
3480
  var TypePrimary$2 = $S($Q(_), FunctionType);
3469
- var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L24, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
3481
+ var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
3470
3482
  var TypePrimary$4 = $S($Q(_), TypeLiteral);
3471
3483
  function TypePrimary(state) {
3472
3484
  if (state.tokenize) {
@@ -3475,7 +3487,7 @@ var Civet = (() => {
3475
3487
  return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
3476
3488
  }
3477
3489
  }
3478
- var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L15, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L12, fail, 'TypeConditional ":"'), Type)))));
3490
+ var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L16, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L13, fail, 'TypeConditional ":"'), Type)))));
3479
3491
  function TypeConditional(state) {
3480
3492
  if (state.verbose)
3481
3493
  console.log("ENTER:", "TypeConditional");
@@ -3486,7 +3498,7 @@ var Civet = (() => {
3486
3498
  }
3487
3499
  }
3488
3500
  var TypeLiteral$0 = Literal;
3489
- var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3501
+ var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3490
3502
  var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
3491
3503
  function TypeLiteral(state) {
3492
3504
  if (state.tokenize) {
@@ -3495,8 +3507,8 @@ var Civet = (() => {
3495
3507
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3496
3508
  }
3497
3509
  }
3498
- var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3499
- var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3510
+ var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3511
+ var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3500
3512
  function TypeBinaryOp(state) {
3501
3513
  if (state.tokenize) {
3502
3514
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3504,7 +3516,7 @@ var Civet = (() => {
3504
3516
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
3505
3517
  }
3506
3518
  }
3507
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L10, fail, 'FunctionType "=>"'), Type);
3519
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L11, fail, 'FunctionType "=>"'), Type);
3508
3520
  function FunctionType(state) {
3509
3521
  if (state.verbose)
3510
3522
  console.log("ENTER:", "FunctionType");
@@ -3514,7 +3526,7 @@ var Civet = (() => {
3514
3526
  return FunctionType$0(state);
3515
3527
  }
3516
3528
  }
3517
- 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 ">"'));
3529
+ var TypeArguments$0 = $S(__, $EXPECT($L15, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
3518
3530
  function TypeArguments(state) {
3519
3531
  if (state.verbose)
3520
3532
  console.log("ENTER:", "TypeArguments");
@@ -3524,7 +3536,7 @@ var Civet = (() => {
3524
3536
  return TypeArguments$0(state);
3525
3537
  }
3526
3538
  }
3527
- 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 ">"'));
3539
+ var TypeParameters$0 = $S(__, $EXPECT($L15, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
3528
3540
  function TypeParameters(state) {
3529
3541
  if (state.verbose)
3530
3542
  console.log("ENTER:", "TypeParameters");
@@ -3544,7 +3556,7 @@ var Civet = (() => {
3544
3556
  return TypeParameter$0(state);
3545
3557
  }
3546
3558
  }
3547
- var TypeConstraint$0 = $S(__, $EXPECT($L15, fail, 'TypeConstraint "extends"'), Type);
3559
+ var TypeConstraint$0 = $S(__, $EXPECT($L16, fail, 'TypeConstraint "extends"'), Type);
3548
3560
  function TypeConstraint(state) {
3549
3561
  if (state.verbose)
3550
3562
  console.log("ENTER:", "TypeConstraint");
@@ -3555,8 +3567,8 @@ var Civet = (() => {
3555
3567
  }
3556
3568
  }
3557
3569
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3558
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
3559
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3570
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3571
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3560
3572
  return ",";
3561
3573
  });
3562
3574
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3621,7 +3633,7 @@ var Civet = (() => {
3621
3633
  return EOF$0(state);
3622
3634
  }
3623
3635
  }
3624
- var Debugger$0 = $TV($EXPECT($L31, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3636
+ var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3625
3637
  debugger;
3626
3638
  });
3627
3639
  function Debugger(state) {
@@ -3633,7 +3645,7 @@ var Civet = (() => {
3633
3645
  return Debugger$0(state);
3634
3646
  }
3635
3647
  }
3636
- var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
3648
+ var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
3637
3649
  return "(";
3638
3650
  });
3639
3651
  function InsertOpenParen(state) {
@@ -3645,7 +3657,7 @@ var Civet = (() => {
3645
3657
  return InsertOpenParen$0(state);
3646
3658
  }
3647
3659
  }
3648
- var InsertCloseParen$0 = $T($EXPECT($L31, fail, 'InsertCloseParen ""'), function(value) {
3660
+ var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
3649
3661
  return ")";
3650
3662
  });
3651
3663
  function InsertCloseParen(state) {
@@ -3657,7 +3669,7 @@ var Civet = (() => {
3657
3669
  return InsertCloseParen$0(state);
3658
3670
  }
3659
3671
  }
3660
- var InsertOpenBrace$0 = $T($EXPECT($L31, fail, 'InsertOpenBrace ""'), function(value) {
3672
+ var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
3661
3673
  return " {";
3662
3674
  });
3663
3675
  function InsertOpenBrace(state) {
@@ -3669,7 +3681,7 @@ var Civet = (() => {
3669
3681
  return InsertOpenBrace$0(state);
3670
3682
  }
3671
3683
  }
3672
- var InsertCloseBrace$0 = $T($EXPECT($L31, fail, 'InsertCloseBrace ""'), function(value) {
3684
+ var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
3673
3685
  return "}";
3674
3686
  });
3675
3687
  function InsertCloseBrace(state) {
@@ -3681,7 +3693,7 @@ var Civet = (() => {
3681
3693
  return InsertCloseBrace$0(state);
3682
3694
  }
3683
3695
  }
3684
- var InsertNewline$0 = $TV($EXPECT($L31, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3696
+ var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3685
3697
  return "\n";
3686
3698
  });
3687
3699
  function InsertNewline(state) {
@@ -3693,7 +3705,7 @@ var Civet = (() => {
3693
3705
  return InsertNewline$0(state);
3694
3706
  }
3695
3707
  }
3696
- var InsertIndent$0 = $TV($EXPECT($L31, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3708
+ var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3697
3709
  return "".padStart(global.currentIndent * 2);
3698
3710
  });
3699
3711
  function InsertIndent(state) {
@@ -3705,7 +3717,7 @@ var Civet = (() => {
3705
3717
  return InsertIndent$0(state);
3706
3718
  }
3707
3719
  }
3708
- var InsertSpace$0 = $T($EXPECT($L31, fail, 'InsertSpace ""'), function(value) {
3720
+ var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
3709
3721
  return " ";
3710
3722
  });
3711
3723
  function InsertSpace(state) {
@@ -3717,7 +3729,7 @@ var Civet = (() => {
3717
3729
  return InsertSpace$0(state);
3718
3730
  }
3719
3731
  }
3720
- var InsertDot$0 = $T($EXPECT($L31, fail, 'InsertDot ""'), function(value) {
3732
+ var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
3721
3733
  return ".";
3722
3734
  });
3723
3735
  function InsertDot(state) {
@@ -3729,7 +3741,7 @@ var Civet = (() => {
3729
3741
  return InsertDot$0(state);
3730
3742
  }
3731
3743
  }
3732
- var InsertBreak$0 = $T($EXPECT($L31, fail, 'InsertBreak ""'), function(value) {
3744
+ var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
3733
3745
  return "break;";
3734
3746
  });
3735
3747
  function InsertBreak(state) {
@@ -3741,7 +3753,7 @@ var Civet = (() => {
3741
3753
  return InsertBreak$0(state);
3742
3754
  }
3743
3755
  }
3744
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L31, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3756
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3745
3757
  var directives = $2;
3746
3758
  global.currentIndent = 0;
3747
3759
  global.indentLevels = [0];
@@ -3782,7 +3794,7 @@ var Civet = (() => {
3782
3794
  return Indent$0(state);
3783
3795
  }
3784
3796
  }
3785
- var PushIndent$0 = $TV($EXPECT($L31, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3797
+ var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3786
3798
  global.currentIndent++;
3787
3799
  if (global.verbose) {
3788
3800
  console.log("pushing indent", global.currentIndent);
@@ -3799,7 +3811,7 @@ var Civet = (() => {
3799
3811
  return PushIndent$0(state);
3800
3812
  }
3801
3813
  }
3802
- var PopIndent$0 = $TV($EXPECT($L31, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3814
+ var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3803
3815
  if (global.verbose) {
3804
3816
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3805
3817
  }