@danielx/civet 0.2.16 → 0.3.2

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 (10) hide show
  1. package/README.md +6 -4
  2. package/dist/browser.js +299 -272
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +10 -10
  5. package/dist/cli.js.map +3 -3
  6. package/{esbuild-plugin.js → dist/esbuild-plugin.js} +0 -0
  7. package/dist/esm.mjs +61 -0
  8. package/dist/main.js +299 -272
  9. package/package.json +12 -5
  10. package/register.mjs +26 -11
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,
@@ -547,6 +548,7 @@ var Civet = (() => {
547
548
  MaybeNestedExpression,
548
549
  Return,
549
550
  ImportDeclaration,
551
+ ImpliedImport,
550
552
  Import,
551
553
  ImportClause,
552
554
  NameSpaceImport,
@@ -678,93 +680,93 @@ var Civet = (() => {
678
680
  var $L5 = $L("++");
679
681
  var $L6 = $L("--");
680
682
  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");
683
+ var $L8 = $L("await");
684
+ var $L9 = $L("yield");
685
+ var $L10 = $L("*");
686
+ var $L11 = $L("=>");
687
+ var $L12 = $L("{");
688
+ var $L13 = $L(":");
689
+ var $L14 = $L("class");
690
+ var $L15 = $L("<");
691
+ var $L16 = $L("extends");
692
+ var $L17 = $L("}");
693
+ var $L18 = $L("static");
694
+ var $L19 = $L("this");
695
+ var $L20 = $L("#");
696
+ var $L21 = $L("@");
697
+ var $L22 = $L("new");
698
+ var $L23 = $L("super");
699
+ var $L24 = $L("import");
700
+ var $L25 = $L(".");
701
+ var $L26 = $L("[");
702
+ var $L27 = $L("]");
703
+ var $L28 = $L("::");
704
+ var $L29 = $L("super[");
705
+ var $L30 = $L("new.target");
706
+ var $L31 = $L("import.meta");
707
+ var $L32 = $L("");
708
+ var $L33 = $L("...");
709
+ var $L34 = $L("function");
710
+ var $L35 = $L("->");
711
+ var $L36 = $L("null");
712
+ var $L37 = $L("true");
713
+ var $L38 = $L("false");
714
+ var $L39 = $L("get");
715
+ var $L40 = $L("set");
716
+ var $L41 = $L("**=");
717
+ var $L42 = $L("*=");
718
+ var $L43 = $L("/=");
719
+ var $L44 = $L("%=");
720
+ var $L45 = $L("+=");
721
+ var $L46 = $L("-=");
722
+ var $L47 = $L("<<=");
723
+ var $L48 = $L(">>>=");
724
+ var $L49 = $L(">>=");
725
+ var $L50 = $L("&&=");
726
+ var $L51 = $L("&=");
727
+ var $L52 = $L("^=");
728
+ var $L53 = $L("||=");
729
+ var $L54 = $L("|=");
730
+ var $L55 = $L("??=");
731
+ var $L56 = $L("=");
732
+ var $L57 = $L("**");
733
+ var $L58 = $L("/");
734
+ var $L59 = $L("%");
735
+ var $L60 = $L("+");
736
+ var $L61 = $L("-");
737
+ var $L62 = $L("<=");
738
+ var $L63 = $L(">=");
739
+ var $L64 = $L("<<");
740
+ var $L65 = $L(">>>");
741
+ var $L66 = $L(">>");
742
+ var $L67 = $L(">");
743
+ var $L68 = $L("!==");
744
+ var $L69 = $L("!=");
745
+ var $L70 = $L("is");
746
+ var $L71 = $L("===");
747
+ var $L72 = $L("==");
748
+ var $L73 = $L("and");
749
+ var $L74 = $L("&&");
750
+ var $L75 = $L("or");
751
+ var $L76 = $L("||");
752
+ var $L77 = $L("??");
753
+ var $L78 = $L("instanceof");
754
+ var $L79 = $L("in");
755
+ var $L80 = $L("&");
756
+ var $L81 = $L("^");
757
+ var $L82 = $L("|");
758
+ var $L83 = $L("delete");
759
+ var $L84 = $L("void");
760
+ var $L85 = $L("typeof");
761
+ var $L86 = $L("if");
762
+ var $L87 = $L("unless");
763
+ var $L88 = $L(";");
764
+ var $L89 = $L("else");
765
+ var $L90 = $L("loop");
766
+ var $L91 = $L("do");
767
+ var $L92 = $L("while");
768
+ var $L93 = $L("until");
769
+ var $L94 = $L("var");
768
770
  var $L95 = $L("of");
769
771
  var $L96 = $L("for");
770
772
  var $L97 = $L("let");
@@ -994,18 +996,29 @@ var Civet = (() => {
994
996
  return AssignmentExpression$0(state) || AssignmentExpression$1(state);
995
997
  }
996
998
  }
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;
999
+ var AssignmentExpressionRest$0 = AwaitExpression;
1000
+ var AssignmentExpressionRest$1 = YieldExpression;
1001
+ var AssignmentExpressionRest$2 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
1002
+ var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
1003
+ var AssignmentExpressionRest$4 = ConditionalExpression;
1001
1004
  function AssignmentExpressionRest(state) {
1002
1005
  if (state.tokenize) {
1003
- return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state));
1006
+ return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state));
1004
1007
  } else {
1005
- return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
1008
+ return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
1006
1009
  }
1007
1010
  }
1008
- var YieldExpression$0 = $S($EXPECT($L8, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L9, fail, 'YieldExpression "*"'))), AssignmentExpression);
1011
+ var AwaitExpression$0 = $S($EXPECT($L8, fail, 'AwaitExpression "await"'), NonIdContinue, $Q(TrailingComment), AssignmentExpression);
1012
+ function AwaitExpression(state) {
1013
+ if (state.verbose)
1014
+ console.log("ENTER:", "AwaitExpression");
1015
+ if (state.tokenize) {
1016
+ return $TOKEN("AwaitExpression", state, AwaitExpression$0(state));
1017
+ } else {
1018
+ return AwaitExpression$0(state);
1019
+ }
1020
+ }
1021
+ var YieldExpression$0 = $S($EXPECT($L9, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L10, fail, 'YieldExpression "*"'))), AssignmentExpression);
1009
1022
  function YieldExpression(state) {
1010
1023
  if (state.verbose)
1011
1024
  console.log("ENTER:", "YieldExpression");
@@ -1024,7 +1037,7 @@ var Civet = (() => {
1024
1037
  return ArrowFunction$0(state) || ArrowFunction$1(state);
1025
1038
  }
1026
1039
  }
1027
- var FatArrow$0 = $TS($S(__, $EXPECT($L10, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1040
+ var FatArrow$0 = $TS($S(__, $EXPECT($L11, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1028
1041
  var ws = $1;
1029
1042
  if (!ws.length)
1030
1043
  return " =>";
@@ -1040,7 +1053,7 @@ var Civet = (() => {
1040
1053
  }
1041
1054
  }
1042
1055
  var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
1043
- var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
1056
+ var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L12, fail, 'ConciseBody "{"'))), AssignmentExpression);
1044
1057
  var ConciseBody$2 = BracedBlock;
1045
1058
  function ConciseBody(state) {
1046
1059
  if (state.tokenize) {
@@ -1049,7 +1062,7 @@ var Civet = (() => {
1049
1062
  return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
1050
1063
  }
1051
1064
  }
1052
- var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L12, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
1065
+ var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L13, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
1053
1066
  function ConditionalExpression(state) {
1054
1067
  if (state.verbose)
1055
1068
  console.log("ENTER:", "ConditionalExpression");
@@ -1108,7 +1121,7 @@ var Civet = (() => {
1108
1121
  return ClassExpression$0(state);
1109
1122
  }
1110
1123
  }
1111
- var Class$0 = $TV($EXPECT($L13, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
1124
+ var Class$0 = $TV($EXPECT($L14, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
1112
1125
  return { $loc, token: $0 };
1113
1126
  });
1114
1127
  function Class(state) {
@@ -1130,10 +1143,10 @@ var Civet = (() => {
1130
1143
  return ClassHeritage$0(state);
1131
1144
  }
1132
1145
  }
1133
- var ExtendsToken$0 = $TV($EXPECT($L14, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1146
+ var ExtendsToken$0 = $TV($EXPECT($L15, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1134
1147
  return { $loc, token: "extends" };
1135
1148
  });
1136
- var ExtendsToken$1 = $TV($EXPECT($L15, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1149
+ var ExtendsToken$1 = $TV($EXPECT($L16, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1137
1150
  return { $loc, token: $1 };
1138
1151
  });
1139
1152
  function ExtendsToken(state) {
@@ -1143,7 +1156,7 @@ var Civet = (() => {
1143
1156
  return ExtendsToken$0(state) || ExtendsToken$1(state);
1144
1157
  }
1145
1158
  }
1146
- var ClassBody$0 = $S(__, $EXPECT($L11, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L16, fail, 'ClassBody "}"'));
1159
+ var ClassBody$0 = $S(__, $EXPECT($L12, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L17, fail, 'ClassBody "}"'));
1147
1160
  var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
1148
1161
  function ClassBody(state) {
1149
1162
  if (state.tokenize) {
@@ -1186,7 +1199,7 @@ var Civet = (() => {
1186
1199
  return ClassElement$0(state) || ClassElement$1(state);
1187
1200
  }
1188
1201
  }
1189
- var Static$0 = $TV($EXPECT($L17, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
1202
+ var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
1190
1203
  return { $loc, token: $0 };
1191
1204
  });
1192
1205
  function Static(state) {
@@ -1208,11 +1221,11 @@ var Civet = (() => {
1208
1221
  return FieldDefinition$0(state);
1209
1222
  }
1210
1223
  }
1211
- var This$0 = $TV($EXPECT($L18, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1224
+ var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1212
1225
  return { $loc, token: $0 };
1213
1226
  });
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) {
1227
+ var This$1 = $S(AtAccessor, $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName));
1228
+ var This$2 = $TV($EXPECT($L21, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1216
1229
  return { $loc, token: "this" };
1217
1230
  });
1218
1231
  function This(state) {
@@ -1222,7 +1235,7 @@ var Civet = (() => {
1222
1235
  return This$0(state) || This$1(state) || This$2(state);
1223
1236
  }
1224
1237
  }
1225
- var AtAccessor$0 = $TV($EXPECT($L20, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1238
+ var AtAccessor$0 = $TV($EXPECT($L21, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1226
1239
  return { $loc, token: "this." };
1227
1240
  });
1228
1241
  function AtAccessor(state) {
@@ -1243,7 +1256,7 @@ var Civet = (() => {
1243
1256
  return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
1244
1257
  }
1245
1258
  }
1246
- var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), CallExpression);
1259
+ var NewExpression$0 = $S($P($S($EXPECT($L22, fail, 'NewExpression "new"'), __)), CallExpression);
1247
1260
  function NewExpression(state) {
1248
1261
  if (state.verbose)
1249
1262
  console.log("ENTER:", "NewExpression");
@@ -1253,8 +1266,8 @@ var Civet = (() => {
1253
1266
  return NewExpression$0(state);
1254
1267
  }
1255
1268
  }
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 ")"'));
1269
+ var CallExpression$0 = $S($EXPECT($L23, fail, 'CallExpression "super"'), __, Arguments);
1270
+ var CallExpression$1 = $S($EXPECT($L24, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1258
1271
  var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
1259
1272
  function CallExpression(state) {
1260
1273
  if (state.tokenize) {
@@ -1274,7 +1287,7 @@ var Civet = (() => {
1274
1287
  return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1275
1288
  }
1276
1289
  }
1277
- var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L24, fail, 'OptionalShorthand "."'), InsertDot));
1290
+ var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
1278
1291
  function OptionalShorthand(state) {
1279
1292
  if (state.verbose)
1280
1293
  console.log("ENTER:", "OptionalShorthand");
@@ -1294,9 +1307,9 @@ var Civet = (() => {
1294
1307
  return SpacedApplication$0(state);
1295
1308
  }
1296
1309
  }
1297
- var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $TEXT($P(_)), $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
1310
+ var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $N(EOS), $TEXT($P(_)), $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3, $4) {
1298
1311
  var opt = $1;
1299
- var spacing = $2;
1312
+ var spacing = $3;
1300
1313
  return [opt, "(", spacing.replace(/^ /, "")];
1301
1314
  });
1302
1315
  function ApplicationStart(state) {
@@ -1328,9 +1341,9 @@ var Civet = (() => {
1328
1341
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1329
1342
  }
1330
1343
  }
1331
- var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L25, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L26, fail, 'MemberExpressionRest "]"'));
1344
+ var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
1332
1345
  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) {
1346
+ var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1334
1347
  var id = $2;
1335
1348
  if (id)
1336
1349
  return [".prototype.", id];
@@ -1343,7 +1356,7 @@ var Civet = (() => {
1343
1356
  return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
1344
1357
  }
1345
1358
  }
1346
- var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L24, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1359
+ var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1347
1360
  function PropertyAccess(state) {
1348
1361
  if (state.verbose)
1349
1362
  console.log("ENTER:", "PropertyAccess");
@@ -1353,7 +1366,7 @@ var Civet = (() => {
1353
1366
  return PropertyAccess$0(state);
1354
1367
  }
1355
1368
  }
1356
- var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L26, fail, 'SuperProperty "]"'));
1369
+ var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
1357
1370
  function SuperProperty(state) {
1358
1371
  if (state.verbose)
1359
1372
  console.log("ENTER:", "SuperProperty");
@@ -1363,8 +1376,8 @@ var Civet = (() => {
1363
1376
  return SuperProperty$0(state);
1364
1377
  }
1365
1378
  }
1366
- var MetaProperty$0 = $EXPECT($L29, fail, 'MetaProperty "new.target"');
1367
- var MetaProperty$1 = $EXPECT($L30, fail, 'MetaProperty "import.meta"');
1379
+ var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
1380
+ var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
1368
1381
  function MetaProperty(state) {
1369
1382
  if (state.tokenize) {
1370
1383
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1373,7 +1386,7 @@ var Civet = (() => {
1373
1386
  }
1374
1387
  }
1375
1388
  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) {
1389
+ var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
1377
1390
  return "()";
1378
1391
  });
1379
1392
  function Parameters(state) {
@@ -1427,7 +1440,7 @@ var Civet = (() => {
1427
1440
  return BindingPattern$0(state) || BindingPattern$1(state);
1428
1441
  }
1429
1442
  }
1430
- var ObjectBindingPattern$0 = $S($EXPECT($L11, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L16, fail, 'ObjectBindingPattern "}"'));
1443
+ var ObjectBindingPattern$0 = $S($EXPECT($L12, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L17, fail, 'ObjectBindingPattern "}"'));
1431
1444
  function ObjectBindingPattern(state) {
1432
1445
  if (state.verbose)
1433
1446
  console.log("ENTER:", "ObjectBindingPattern");
@@ -1437,7 +1450,7 @@ var Civet = (() => {
1437
1450
  return ObjectBindingPattern$0(state);
1438
1451
  }
1439
1452
  }
1440
- var ArrayBindingPattern$0 = $S($EXPECT($L25, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L26, fail, 'ArrayBindingPattern "]"'));
1453
+ var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
1441
1454
  function ArrayBindingPattern(state) {
1442
1455
  if (state.verbose)
1443
1456
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1447,7 +1460,7 @@ var Civet = (() => {
1447
1460
  return ArrayBindingPattern$0(state);
1448
1461
  }
1449
1462
  }
1450
- var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L12, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1463
+ var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L13, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1451
1464
  var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
1452
1465
  function BindingProperty(state) {
1453
1466
  if (state.tokenize) {
@@ -1456,7 +1469,7 @@ var Civet = (() => {
1456
1469
  return BindingProperty$0(state) || BindingProperty$1(state);
1457
1470
  }
1458
1471
  }
1459
- var BindingRestProperty$0 = $S($EXPECT($L32, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1472
+ var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1460
1473
  function BindingRestProperty(state) {
1461
1474
  if (state.verbose)
1462
1475
  console.log("ENTER:", "BindingRestProperty");
@@ -1476,7 +1489,7 @@ var Civet = (() => {
1476
1489
  return BindingElement$0(state);
1477
1490
  }
1478
1491
  }
1479
- var BindingRestElement$0 = $S($EXPECT($L32, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1492
+ var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1480
1493
  function BindingRestElement(state) {
1481
1494
  if (state.verbose)
1482
1495
  console.log("ENTER:", "BindingRestElement");
@@ -1497,7 +1510,7 @@ var Civet = (() => {
1497
1510
  }
1498
1511
  }
1499
1512
  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);
1513
+ 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
1514
  function FunctionExpression(state) {
1502
1515
  if (state.tokenize) {
1503
1516
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1526,7 +1539,7 @@ var Civet = (() => {
1526
1539
  return ThinArrowFunction$0(state);
1527
1540
  }
1528
1541
  }
1529
- var Arrow$0 = $TV($EXPECT($L34, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1542
+ var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1530
1543
  return { $loc, token: $1 };
1531
1544
  });
1532
1545
  function Arrow(state) {
@@ -1538,7 +1551,7 @@ var Civet = (() => {
1538
1551
  return Arrow$0(state);
1539
1552
  }
1540
1553
  }
1541
- var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
1554
+ var Block$0 = $S(__, $EXPECT($L12, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'Block "}"'));
1542
1555
  var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1543
1556
  var Block$2 = Statement;
1544
1557
  var Block$3 = $S(__, Statement);
@@ -1558,7 +1571,7 @@ var Civet = (() => {
1558
1571
  return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
1559
1572
  }
1560
1573
  }
1561
- var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
1574
+ var BracedBlock$0 = $S(__, $EXPECT($L12, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BracedBlock "}"'));
1562
1575
  var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1563
1576
  var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
1564
1577
  function BracedBlock(state) {
@@ -1634,7 +1647,7 @@ var Civet = (() => {
1634
1647
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1635
1648
  }
1636
1649
  }
1637
- var NullLiteral$0 = $TV($EXPECT($L35, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1650
+ var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1638
1651
  return { $loc, token: $1 };
1639
1652
  });
1640
1653
  function NullLiteral(state) {
@@ -1646,7 +1659,7 @@ var Civet = (() => {
1646
1659
  return NullLiteral$0(state);
1647
1660
  }
1648
1661
  }
1649
- var BooleanLiteral$0 = $TV($C($EXPECT($L36, fail, 'BooleanLiteral "true"'), $EXPECT($L37, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1662
+ var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1650
1663
  return { $loc, token: $1 };
1651
1664
  });
1652
1665
  function BooleanLiteral(state) {
@@ -1703,8 +1716,8 @@ var Civet = (() => {
1703
1716
  return IdentifierReference$0(state);
1704
1717
  }
1705
1718
  }
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 "]"'));
1719
+ var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1720
+ var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1708
1721
  function ArrayLiteral(state) {
1709
1722
  if (state.tokenize) {
1710
1723
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1738,8 +1751,8 @@ var Civet = (() => {
1738
1751
  }
1739
1752
  }
1740
1753
  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) {
1754
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
1755
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1743
1756
  return ",";
1744
1757
  });
1745
1758
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1772,7 +1785,7 @@ var Civet = (() => {
1772
1785
  return InlineElementList$0(state);
1773
1786
  }
1774
1787
  }
1775
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L32, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1788
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1776
1789
  function ArrayElementExpression(state) {
1777
1790
  if (state.verbose)
1778
1791
  console.log("ENTER:", "ArrayElementExpression");
@@ -1792,9 +1805,9 @@ var Civet = (() => {
1792
1805
  return Elision$0(state);
1793
1806
  }
1794
1807
  }
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 "}"'));
1808
+ var ObjectLiteral$0 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
1809
+ var ObjectLiteral$1 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L17, fail, 'ObjectLiteral "}"'));
1810
+ var ObjectLiteral$2 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
1798
1811
  var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
1799
1812
  function ObjectLiteral(state) {
1800
1813
  if (state.tokenize) {
@@ -1829,8 +1842,8 @@ var Civet = (() => {
1829
1842
  }
1830
1843
  }
1831
1844
  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) {
1845
+ var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"')));
1846
+ var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1834
1847
  return ",";
1835
1848
  });
1836
1849
  var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1853,9 +1866,9 @@ var Civet = (() => {
1853
1866
  return PropertyDefinitionList$0(state);
1854
1867
  }
1855
1868
  }
1856
- var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1869
+ var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L13, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1857
1870
  var PropertyDefinition$1 = MethodDefinition;
1858
- var PropertyDefinition$2 = $S($EXPECT($L32, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1871
+ var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1859
1872
  var PropertyDefinition$3 = IdentifierReference;
1860
1873
  function PropertyDefinition(state) {
1861
1874
  if (state.tokenize) {
@@ -1867,7 +1880,7 @@ var Civet = (() => {
1867
1880
  var PropertyName$0 = NumericLiteral;
1868
1881
  var PropertyName$1 = StringLiteral;
1869
1882
  var PropertyName$2 = IdentifierName;
1870
- var PropertyName$3 = $S($EXPECT($L25, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
1883
+ var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
1871
1884
  function PropertyName(state) {
1872
1885
  if (state.tokenize) {
1873
1886
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1875,8 +1888,8 @@ var Civet = (() => {
1875
1888
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1876
1889
  }
1877
1890
  }
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);
1891
+ var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1892
+ var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1880
1893
  var MethodDefinition$2 = AsyncGeneratorMethod;
1881
1894
  var MethodDefinition$3 = AsyncMethod;
1882
1895
  var MethodDefinition$4 = GeneratorMethod;
@@ -1897,7 +1910,7 @@ var Civet = (() => {
1897
1910
  return ClassElementName$0(state) || ClassElementName$1(state);
1898
1911
  }
1899
1912
  }
1900
- var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
1913
+ var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
1901
1914
  function PrivateIdentifier(state) {
1902
1915
  if (state.verbose)
1903
1916
  console.log("ENTER:", "PrivateIdentifier");
@@ -1907,7 +1920,7 @@ var Civet = (() => {
1907
1920
  return PrivateIdentifier$0(state);
1908
1921
  }
1909
1922
  }
1910
- var GeneratorMethod$0 = $S($EXPECT($L9, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1923
+ var GeneratorMethod$0 = $S($EXPECT($L10, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1911
1924
  function GeneratorMethod(state) {
1912
1925
  if (state.verbose)
1913
1926
  console.log("ENTER:", "GeneratorMethod");
@@ -1947,7 +1960,7 @@ var Civet = (() => {
1947
1960
  return AsyncFunctionBody$0(state);
1948
1961
  }
1949
1962
  }
1950
- var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L9, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1963
+ var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L10, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1951
1964
  function AsyncGeneratorMethod(state) {
1952
1965
  if (state.verbose)
1953
1966
  console.log("ENTER:", "AsyncGeneratorMethod");
@@ -1979,22 +1992,22 @@ var Civet = (() => {
1979
1992
  return AssignmentOp$0(state);
1980
1993
  }
1981
1994
  }
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 "="');
1995
+ var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
1996
+ var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
1997
+ var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
1998
+ var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
1999
+ var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
2000
+ var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
2001
+ var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
2002
+ var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
2003
+ var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
2004
+ var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
2005
+ var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
2006
+ var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
2007
+ var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
2008
+ var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
2009
+ var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
2010
+ var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
1998
2011
  function AssignmentOpSymbol(state) {
1999
2012
  if (state.tokenize) {
2000
2013
  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 +2027,48 @@ var Civet = (() => {
2014
2027
  return BinaryOp$0(state);
2015
2028
  }
2016
2029
  }
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) {
2030
+ var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
2031
+ var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
2032
+ var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
2033
+ var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
2034
+ var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
2035
+ var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
2036
+ var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
2037
+ var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
2038
+ var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
2039
+ var BinaryOpSymbol$9 = $EXPECT($L15, fail, 'BinaryOpSymbol "<"');
2040
+ var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
2041
+ var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
2042
+ var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
2043
+ var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
2044
+ var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2032
2045
  if (global.coffeeCompat)
2033
2046
  return "!==";
2034
2047
  return $1;
2035
2048
  });
2036
- var BinaryOpSymbol$15 = $T($S($EXPECT($L69, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2049
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2037
2050
  return "===";
2038
2051
  });
2039
- var BinaryOpSymbol$16 = $EXPECT($L70, fail, 'BinaryOpSymbol "==="');
2040
- var BinaryOpSymbol$17 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2052
+ var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
2053
+ var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2041
2054
  if (global.coffeeCompat)
2042
2055
  return "===";
2043
2056
  return $1;
2044
2057
  });
2045
- var BinaryOpSymbol$18 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2058
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2046
2059
  return "&&";
2047
2060
  });
2048
- var BinaryOpSymbol$19 = $EXPECT($L73, fail, 'BinaryOpSymbol "&&"');
2049
- var BinaryOpSymbol$20 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2061
+ var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
2062
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2050
2063
  return "||";
2051
2064
  });
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 "|"');
2065
+ var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
2066
+ var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
2067
+ var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2068
+ var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2069
+ var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
2070
+ var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
2071
+ var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
2059
2072
  function BinaryOpSymbol(state) {
2060
2073
  if (state.tokenize) {
2061
2074
  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 +2077,7 @@ var Civet = (() => {
2064
2077
  }
2065
2078
  }
2066
2079
  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, __);
2080
+ var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2068
2081
  function UnaryOp(state) {
2069
2082
  if (state.tokenize) {
2070
2083
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2098,7 +2111,7 @@ var Civet = (() => {
2098
2111
  return StatementListItem$0(state);
2099
2112
  }
2100
2113
  }
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) {
2114
+ 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
2115
  var ws = $1;
2103
2116
  var cond = $2;
2104
2117
  var exp = $4;
@@ -2131,7 +2144,7 @@ var Civet = (() => {
2131
2144
  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
2145
  }
2133
2146
  }
2134
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
2147
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
2135
2148
  function EmptyStatement(state) {
2136
2149
  if (state.verbose)
2137
2150
  console.log("ENTER:", "EmptyStatement");
@@ -2141,7 +2154,7 @@ var Civet = (() => {
2141
2154
  return EmptyStatement$0(state);
2142
2155
  }
2143
2156
  }
2144
- var BlockStatement$0 = $S(__, $EXPECT($L11, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BlockStatement "}"'));
2157
+ var BlockStatement$0 = $S(__, $EXPECT($L12, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BlockStatement "}"'));
2145
2158
  function BlockStatement(state) {
2146
2159
  if (state.verbose)
2147
2160
  console.log("ENTER:", "BlockStatement");
@@ -2151,8 +2164,8 @@ var Civet = (() => {
2151
2164
  return BlockStatement$0(state);
2152
2165
  }
2153
2166
  }
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) {
2167
+ var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
2168
+ var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2156
2169
  var condition = $2;
2157
2170
  var block = $3;
2158
2171
  return ["if", condition.map((c) => {
@@ -2182,7 +2195,7 @@ var Civet = (() => {
2182
2195
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2183
2196
  }
2184
2197
  }
2185
- var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2198
+ var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2186
2199
  var b = $3;
2187
2200
  return ["while(true)", b];
2188
2201
  });
@@ -2195,7 +2208,7 @@ var Civet = (() => {
2195
2208
  return LoopStatement$0(state);
2196
2209
  }
2197
2210
  }
2198
- var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2211
+ var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2199
2212
  function DoWhileStatement(state) {
2200
2213
  if (state.verbose)
2201
2214
  console.log("ENTER:", "DoWhileStatement");
@@ -2215,7 +2228,7 @@ var Civet = (() => {
2215
2228
  return WhileStatement$0(state);
2216
2229
  }
2217
2230
  }
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) {
2231
+ 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
2232
  var kind = $1;
2220
2233
  var cond = $3;
2221
2234
  if (kind === "until") {
@@ -2234,7 +2247,7 @@ var Civet = (() => {
2234
2247
  return WhileClause$0(state);
2235
2248
  }
2236
2249
  }
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);
2250
+ 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
2251
  function ForStatement(state) {
2239
2252
  if (state.verbose)
2240
2253
  console.log("ENTER:", "ForStatement");
@@ -2244,10 +2257,10 @@ var Civet = (() => {
2244
2257
  return ForStatement$0(state);
2245
2258
  }
2246
2259
  }
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);
2260
+ 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);
2261
+ var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2262
+ 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);
2263
+ 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
2264
  function ForInOfStatement(state) {
2252
2265
  if (state.tokenize) {
2253
2266
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2308,7 +2321,7 @@ var Civet = (() => {
2308
2321
  return SwitchStatement$0(state);
2309
2322
  }
2310
2323
  }
2311
- var CaseBlock$0 = $S(__, $EXPECT($L11, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L16, fail, 'CaseBlock "}"'));
2324
+ var CaseBlock$0 = $S(__, $EXPECT($L12, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L17, fail, 'CaseBlock "}"'));
2312
2325
  var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
2313
2326
  function CaseBlock(state) {
2314
2327
  if (state.tokenize) {
@@ -2364,8 +2377,8 @@ var Civet = (() => {
2364
2377
  return When$0(state);
2365
2378
  }
2366
2379
  }
2367
- var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2368
- var ImpliedColon$1 = $T($EXPECT($L31, fail, 'ImpliedColon ""'), function(value) {
2380
+ var ImpliedColon$0 = $S(__, $EXPECT($L13, fail, 'ImpliedColon ":"'));
2381
+ var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
2369
2382
  return ":";
2370
2383
  });
2371
2384
  function ImpliedColon(state) {
@@ -2487,14 +2500,27 @@ var Civet = (() => {
2487
2500
  });
2488
2501
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
2489
2502
  var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
2503
+ var ImportDeclaration$3 = $S(ImpliedImport, ImportClause, __, FromClause);
2490
2504
  function ImportDeclaration(state) {
2491
2505
  if (state.tokenize) {
2492
- return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
2506
+ return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state));
2507
+ } else {
2508
+ return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
2509
+ }
2510
+ }
2511
+ var ImpliedImport$0 = $T($EXPECT($L32, fail, 'ImpliedImport ""'), function(value) {
2512
+ return "import ";
2513
+ });
2514
+ function ImpliedImport(state) {
2515
+ if (state.verbose)
2516
+ console.log("ENTER:", "ImpliedImport");
2517
+ if (state.tokenize) {
2518
+ return $TOKEN("ImpliedImport", state, ImpliedImport$0(state));
2493
2519
  } else {
2494
- return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
2520
+ return ImpliedImport$0(state);
2495
2521
  }
2496
2522
  }
2497
- var Import$0 = $TS($S($EXPECT($L23, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2523
+ var Import$0 = $TS($S($EXPECT($L24, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2498
2524
  return { $loc, token: $1 };
2499
2525
  });
2500
2526
  function Import(state) {
@@ -2516,7 +2542,7 @@ var Civet = (() => {
2516
2542
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2517
2543
  }
2518
2544
  }
2519
- var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
2545
+ var NameSpaceImport$0 = $S($EXPECT($L10, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
2520
2546
  function NameSpaceImport(state) {
2521
2547
  if (state.verbose)
2522
2548
  console.log("ENTER:", "NameSpaceImport");
@@ -2526,7 +2552,7 @@ var Civet = (() => {
2526
2552
  return NameSpaceImport$0(state);
2527
2553
  }
2528
2554
  }
2529
- var NamedImports$0 = $S($EXPECT($L11, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L16, fail, 'NamedImports "}"'));
2555
+ var NamedImports$0 = $S($EXPECT($L12, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L17, fail, 'NamedImports "}"'));
2530
2556
  function NamedImports(state) {
2531
2557
  if (state.verbose)
2532
2558
  console.log("ENTER:", "NamedImports");
@@ -2626,7 +2652,7 @@ var Civet = (() => {
2626
2652
  return Export$0(state);
2627
2653
  }
2628
2654
  }
2629
- var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
2655
+ var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
2630
2656
  var ExportFromClause$1 = NamedExports;
2631
2657
  function ExportFromClause(state) {
2632
2658
  if (state.tokenize) {
@@ -2635,7 +2661,7 @@ var Civet = (() => {
2635
2661
  return ExportFromClause$0(state) || ExportFromClause$1(state);
2636
2662
  }
2637
2663
  }
2638
- var NamedExports$0 = $S($EXPECT($L11, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L16, fail, 'NamedExports "}"'));
2664
+ var NamedExports$0 = $S($EXPECT($L12, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L17, fail, 'NamedExports "}"'));
2639
2665
  function NamedExports(state) {
2640
2666
  if (state.verbose)
2641
2667
  console.log("ENTER:", "NamedExports");
@@ -2721,7 +2747,7 @@ var Civet = (() => {
2721
2747
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2722
2748
  }
2723
2749
  }
2724
- var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2750
+ var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2725
2751
  function Initializer(state) {
2726
2752
  if (state.verbose)
2727
2753
  console.log("ENTER:", "Initializer");
@@ -2731,7 +2757,7 @@ var Civet = (() => {
2731
2757
  return Initializer$0(state);
2732
2758
  }
2733
2759
  }
2734
- var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2760
+ var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2735
2761
  function VariableStatement(state) {
2736
2762
  if (state.verbose)
2737
2763
  console.log("ENTER:", "VariableStatement");
@@ -2895,7 +2921,7 @@ var Civet = (() => {
2895
2921
  return TripleSingleStringCharacter$0(state);
2896
2922
  }
2897
2923
  }
2898
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2924
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2899
2925
  return { $loc, token: $1 };
2900
2926
  });
2901
2927
  function RegularExpressionLiteral(state) {
@@ -2947,7 +2973,7 @@ var Civet = (() => {
2947
2973
  return TemplateLiteral$0(state);
2948
2974
  }
2949
2975
  }
2950
- var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2976
+ var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L17, fail, 'TemplateSubstitution "}"'));
2951
2977
  function TemplateSubstitution(state) {
2952
2978
  if (state.verbose)
2953
2979
  console.log("ENTER:", "TemplateSubstitution");
@@ -3090,7 +3116,7 @@ var Civet = (() => {
3090
3116
  return __$0(state);
3091
3117
  }
3092
3118
  }
3093
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3119
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3094
3120
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
3095
3121
  return [";", value];
3096
3122
  });
@@ -3125,7 +3151,7 @@ var Civet = (() => {
3125
3151
  return JSXElement$0(state) || JSXElement$1(state);
3126
3152
  }
3127
3153
  }
3128
- var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
3154
+ var JSXSelfClosingElement$0 = $S($EXPECT($L15, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
3129
3155
  function JSXSelfClosingElement(state) {
3130
3156
  if (state.verbose)
3131
3157
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3135,7 +3161,7 @@ var Civet = (() => {
3135
3161
  return JSXSelfClosingElement$0(state);
3136
3162
  }
3137
3163
  }
3138
- var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
3164
+ var JSXOpeningElement$0 = $S($EXPECT($L15, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
3139
3165
  function JSXOpeningElement(state) {
3140
3166
  if (state.verbose)
3141
3167
  console.log("ENTER:", "JSXOpeningElement");
@@ -3145,7 +3171,7 @@ var Civet = (() => {
3145
3171
  return JSXOpeningElement$0(state);
3146
3172
  }
3147
3173
  }
3148
- var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
3174
+ var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
3149
3175
  function JSXClosingElement(state) {
3150
3176
  if (state.verbose)
3151
3177
  console.log("ENTER:", "JSXClosingElement");
@@ -3165,7 +3191,7 @@ var Civet = (() => {
3165
3191
  return JSXFragment$0(state);
3166
3192
  }
3167
3193
  }
3168
- var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L24, fail, 'JSXElementName "."'), JSXIdentifierName))));
3194
+ var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L13, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
3169
3195
  function JSXElementName(state) {
3170
3196
  if (state.verbose)
3171
3197
  console.log("ENTER:", "JSXElementName");
@@ -3195,7 +3221,7 @@ var Civet = (() => {
3195
3221
  return JSXAttributes$0(state);
3196
3222
  }
3197
3223
  }
3198
- var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L32, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
3224
+ var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttribute "}"'));
3199
3225
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3200
3226
  function JSXAttribute(state) {
3201
3227
  if (state.tokenize) {
@@ -3204,7 +3230,7 @@ var Civet = (() => {
3204
3230
  return JSXAttribute$0(state) || JSXAttribute$1(state);
3205
3231
  }
3206
3232
  }
3207
- var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L12, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
3233
+ var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L13, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
3208
3234
  function JSXAttributeName(state) {
3209
3235
  if (state.verbose)
3210
3236
  console.log("ENTER:", "JSXAttributeName");
@@ -3214,7 +3240,7 @@ var Civet = (() => {
3214
3240
  return JSXAttributeName$0(state);
3215
3241
  }
3216
3242
  }
3217
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3243
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3218
3244
  function JSXAttributeInitializer(state) {
3219
3245
  if (state.verbose)
3220
3246
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -3226,7 +3252,7 @@ var Civet = (() => {
3226
3252
  }
3227
3253
  var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
3228
3254
  var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
3229
- var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
3255
+ var JSXAttributeValue$2 = $S($EXPECT($L12, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttributeValue "}"'));
3230
3256
  var JSXAttributeValue$3 = JSXElement;
3231
3257
  var JSXAttributeValue$4 = JSXFragment;
3232
3258
  function JSXAttributeValue(state) {
@@ -3249,7 +3275,7 @@ var Civet = (() => {
3249
3275
  var JSXChild$0 = JSXText;
3250
3276
  var JSXChild$1 = JSXElement;
3251
3277
  var JSXChild$2 = JSXFragment;
3252
- var JSXChild$3 = $S($EXPECT($L11, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L16, fail, 'JSXChild "}"'));
3278
+ var JSXChild$3 = $S($EXPECT($L12, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L17, fail, 'JSXChild "}"'));
3253
3279
  function JSXChild(state) {
3254
3280
  if (state.tokenize) {
3255
3281
  return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
@@ -3267,7 +3293,7 @@ var Civet = (() => {
3267
3293
  return JSXText$0(state);
3268
3294
  }
3269
3295
  }
3270
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L32, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3296
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3271
3297
  function JSXChildExpression(state) {
3272
3298
  if (state.verbose)
3273
3299
  console.log("ENTER:", "JSXChildExpression");
@@ -3277,7 +3303,7 @@ var Civet = (() => {
3277
3303
  return JSXChildExpression$0(state);
3278
3304
  }
3279
3305
  }
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) {
3306
+ 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
3307
  return { "ts": true, "children": value };
3282
3308
  });
3283
3309
  var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
@@ -3290,8 +3316,8 @@ var Civet = (() => {
3290
3316
  return TypeDeclaration$0(state) || TypeDeclaration$1(state);
3291
3317
  }
3292
3318
  }
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 "}"'));
3319
+ var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
3320
+ var InterfaceBlock$1 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
3295
3321
  var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
3296
3322
  function InterfaceBlock(state) {
3297
3323
  if (state.tokenize) {
@@ -3335,9 +3361,9 @@ var Civet = (() => {
3335
3361
  return InterfaceProperty$0(state);
3336
3362
  }
3337
3363
  }
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) {
3364
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3365
+ var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"')));
3366
+ var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3341
3367
  return ";";
3342
3368
  });
3343
3369
  var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3350,7 +3376,7 @@ var Civet = (() => {
3350
3376
  return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
3351
3377
  }
3352
3378
  }
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 "?"'))));
3379
+ 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
3380
  function TypeIndexSignature(state) {
3355
3381
  if (state.verbose)
3356
3382
  console.log("ENTER:", "TypeIndexSignature");
@@ -3361,7 +3387,7 @@ var Civet = (() => {
3361
3387
  }
3362
3388
  }
3363
3389
  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)));
3390
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3365
3391
  function TypeIndex(state) {
3366
3392
  if (state.tokenize) {
3367
3393
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3369,7 +3395,7 @@ var Civet = (() => {
3369
3395
  return TypeIndex$0(state) || TypeIndex$1(state);
3370
3396
  }
3371
3397
  }
3372
- var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L12, fail, 'TypeSuffix ":"'), Type), function(value) {
3398
+ var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L13, fail, 'TypeSuffix ":"'), Type), function(value) {
3373
3399
  return { "ts": true, "children": value };
3374
3400
  });
3375
3401
  function TypeSuffix(state) {
@@ -3381,7 +3407,7 @@ var Civet = (() => {
3381
3407
  return TypeSuffix$0(state);
3382
3408
  }
3383
3409
  }
3384
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3410
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L13, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3385
3411
  return { "ts": true, "children": value };
3386
3412
  });
3387
3413
  function ReturnTypeSuffix(state) {
@@ -3393,7 +3419,7 @@ var Civet = (() => {
3393
3419
  return ReturnTypeSuffix$0(state);
3394
3420
  }
3395
3421
  }
3396
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3422
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3397
3423
  function TypePredicate(state) {
3398
3424
  if (state.verbose)
3399
3425
  console.log("ENTER:", "TypePredicate");
@@ -3444,7 +3470,7 @@ var Civet = (() => {
3444
3470
  }
3445
3471
  }
3446
3472
  var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
3447
- var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
3473
+ var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3448
3474
  var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
3449
3475
  function TypeUnaryOp(state) {
3450
3476
  if (state.tokenize) {
@@ -3453,7 +3479,7 @@ var Civet = (() => {
3453
3479
  return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3454
3480
  }
3455
3481
  }
3456
- var TypeIndexedAccess$0 = $S(__, $EXPECT($L25, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L26, fail, 'TypeIndexedAccess "]"'));
3482
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
3457
3483
  function TypeIndexedAccess(state) {
3458
3484
  if (state.verbose)
3459
3485
  console.log("ENTER:", "TypeIndexedAccess");
@@ -3466,7 +3492,7 @@ var Civet = (() => {
3466
3492
  var TypePrimary$0 = InterfaceBlock;
3467
3493
  var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
3468
3494
  var TypePrimary$2 = $S($Q(_), FunctionType);
3469
- var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L24, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
3495
+ var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
3470
3496
  var TypePrimary$4 = $S($Q(_), TypeLiteral);
3471
3497
  function TypePrimary(state) {
3472
3498
  if (state.tokenize) {
@@ -3475,7 +3501,7 @@ var Civet = (() => {
3475
3501
  return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
3476
3502
  }
3477
3503
  }
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)))));
3504
+ 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
3505
  function TypeConditional(state) {
3480
3506
  if (state.verbose)
3481
3507
  console.log("ENTER:", "TypeConditional");
@@ -3486,7 +3512,7 @@ var Civet = (() => {
3486
3512
  }
3487
3513
  }
3488
3514
  var TypeLiteral$0 = Literal;
3489
- var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3515
+ var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3490
3516
  var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
3491
3517
  function TypeLiteral(state) {
3492
3518
  if (state.tokenize) {
@@ -3495,8 +3521,8 @@ var Civet = (() => {
3495
3521
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3496
3522
  }
3497
3523
  }
3498
- var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3499
- var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3524
+ var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3525
+ var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3500
3526
  function TypeBinaryOp(state) {
3501
3527
  if (state.tokenize) {
3502
3528
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3504,7 +3530,7 @@ var Civet = (() => {
3504
3530
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
3505
3531
  }
3506
3532
  }
3507
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L10, fail, 'FunctionType "=>"'), Type);
3533
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L11, fail, 'FunctionType "=>"'), Type);
3508
3534
  function FunctionType(state) {
3509
3535
  if (state.verbose)
3510
3536
  console.log("ENTER:", "FunctionType");
@@ -3514,7 +3540,7 @@ var Civet = (() => {
3514
3540
  return FunctionType$0(state);
3515
3541
  }
3516
3542
  }
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 ">"'));
3543
+ 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
3544
  function TypeArguments(state) {
3519
3545
  if (state.verbose)
3520
3546
  console.log("ENTER:", "TypeArguments");
@@ -3524,7 +3550,7 @@ var Civet = (() => {
3524
3550
  return TypeArguments$0(state);
3525
3551
  }
3526
3552
  }
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 ">"'));
3553
+ 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
3554
  function TypeParameters(state) {
3529
3555
  if (state.verbose)
3530
3556
  console.log("ENTER:", "TypeParameters");
@@ -3544,7 +3570,7 @@ var Civet = (() => {
3544
3570
  return TypeParameter$0(state);
3545
3571
  }
3546
3572
  }
3547
- var TypeConstraint$0 = $S(__, $EXPECT($L15, fail, 'TypeConstraint "extends"'), Type);
3573
+ var TypeConstraint$0 = $S(__, $EXPECT($L16, fail, 'TypeConstraint "extends"'), Type);
3548
3574
  function TypeConstraint(state) {
3549
3575
  if (state.verbose)
3550
3576
  console.log("ENTER:", "TypeConstraint");
@@ -3555,8 +3581,8 @@ var Civet = (() => {
3555
3581
  }
3556
3582
  }
3557
3583
  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) {
3584
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3585
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3560
3586
  return ",";
3561
3587
  });
3562
3588
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3621,7 +3647,7 @@ var Civet = (() => {
3621
3647
  return EOF$0(state);
3622
3648
  }
3623
3649
  }
3624
- var Debugger$0 = $TV($EXPECT($L31, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3650
+ var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3625
3651
  debugger;
3626
3652
  });
3627
3653
  function Debugger(state) {
@@ -3633,7 +3659,7 @@ var Civet = (() => {
3633
3659
  return Debugger$0(state);
3634
3660
  }
3635
3661
  }
3636
- var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
3662
+ var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
3637
3663
  return "(";
3638
3664
  });
3639
3665
  function InsertOpenParen(state) {
@@ -3645,7 +3671,7 @@ var Civet = (() => {
3645
3671
  return InsertOpenParen$0(state);
3646
3672
  }
3647
3673
  }
3648
- var InsertCloseParen$0 = $T($EXPECT($L31, fail, 'InsertCloseParen ""'), function(value) {
3674
+ var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
3649
3675
  return ")";
3650
3676
  });
3651
3677
  function InsertCloseParen(state) {
@@ -3657,7 +3683,7 @@ var Civet = (() => {
3657
3683
  return InsertCloseParen$0(state);
3658
3684
  }
3659
3685
  }
3660
- var InsertOpenBrace$0 = $T($EXPECT($L31, fail, 'InsertOpenBrace ""'), function(value) {
3686
+ var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
3661
3687
  return " {";
3662
3688
  });
3663
3689
  function InsertOpenBrace(state) {
@@ -3669,7 +3695,7 @@ var Civet = (() => {
3669
3695
  return InsertOpenBrace$0(state);
3670
3696
  }
3671
3697
  }
3672
- var InsertCloseBrace$0 = $T($EXPECT($L31, fail, 'InsertCloseBrace ""'), function(value) {
3698
+ var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
3673
3699
  return "}";
3674
3700
  });
3675
3701
  function InsertCloseBrace(state) {
@@ -3681,7 +3707,7 @@ var Civet = (() => {
3681
3707
  return InsertCloseBrace$0(state);
3682
3708
  }
3683
3709
  }
3684
- var InsertNewline$0 = $TV($EXPECT($L31, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3710
+ var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3685
3711
  return "\n";
3686
3712
  });
3687
3713
  function InsertNewline(state) {
@@ -3693,7 +3719,7 @@ var Civet = (() => {
3693
3719
  return InsertNewline$0(state);
3694
3720
  }
3695
3721
  }
3696
- var InsertIndent$0 = $TV($EXPECT($L31, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3722
+ var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3697
3723
  return "".padStart(global.currentIndent * 2);
3698
3724
  });
3699
3725
  function InsertIndent(state) {
@@ -3705,7 +3731,7 @@ var Civet = (() => {
3705
3731
  return InsertIndent$0(state);
3706
3732
  }
3707
3733
  }
3708
- var InsertSpace$0 = $T($EXPECT($L31, fail, 'InsertSpace ""'), function(value) {
3734
+ var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
3709
3735
  return " ";
3710
3736
  });
3711
3737
  function InsertSpace(state) {
@@ -3717,7 +3743,7 @@ var Civet = (() => {
3717
3743
  return InsertSpace$0(state);
3718
3744
  }
3719
3745
  }
3720
- var InsertDot$0 = $T($EXPECT($L31, fail, 'InsertDot ""'), function(value) {
3746
+ var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
3721
3747
  return ".";
3722
3748
  });
3723
3749
  function InsertDot(state) {
@@ -3729,7 +3755,7 @@ var Civet = (() => {
3729
3755
  return InsertDot$0(state);
3730
3756
  }
3731
3757
  }
3732
- var InsertBreak$0 = $T($EXPECT($L31, fail, 'InsertBreak ""'), function(value) {
3758
+ var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
3733
3759
  return "break;";
3734
3760
  });
3735
3761
  function InsertBreak(state) {
@@ -3741,7 +3767,7 @@ var Civet = (() => {
3741
3767
  return InsertBreak$0(state);
3742
3768
  }
3743
3769
  }
3744
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L31, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3770
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3745
3771
  var directives = $2;
3746
3772
  global.currentIndent = 0;
3747
3773
  global.indentLevels = [0];
@@ -3755,8 +3781,7 @@ var Civet = (() => {
3755
3781
  if (spacing) {
3756
3782
  str = str.replaceAll(spacing[0], "\n");
3757
3783
  }
3758
- str = str.replace(/^(\r?\n|\n)/, "");
3759
- str = str.replace(/(\r?\n|\n)$/, "");
3784
+ str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "").replace(/(`|\$)/g, "\\$1");
3760
3785
  return str;
3761
3786
  };
3762
3787
  return $0;
@@ -3782,7 +3807,7 @@ var Civet = (() => {
3782
3807
  return Indent$0(state);
3783
3808
  }
3784
3809
  }
3785
- var PushIndent$0 = $TV($EXPECT($L31, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3810
+ var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3786
3811
  global.currentIndent++;
3787
3812
  if (global.verbose) {
3788
3813
  console.log("pushing indent", global.currentIndent);
@@ -3799,7 +3824,7 @@ var Civet = (() => {
3799
3824
  return PushIndent$0(state);
3800
3825
  }
3801
3826
  }
3802
- var PopIndent$0 = $TV($EXPECT($L31, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3827
+ var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3803
3828
  if (global.verbose) {
3804
3829
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3805
3830
  }
@@ -4080,6 +4105,7 @@ var Civet = (() => {
4080
4105
  var require_main = __commonJS({
4081
4106
  "source/main.coffee"(exports, module) {
4082
4107
  var SourceMap;
4108
+ var defaultOptions;
4083
4109
  var gen;
4084
4110
  var parse;
4085
4111
  var prune;
@@ -4087,12 +4113,13 @@ var Civet = (() => {
4087
4113
  ({ parse } = require_parser());
4088
4114
  ({ prune } = gen = require_generate());
4089
4115
  ({ SourceMap } = util = require_util());
4116
+ defaultOptions = {};
4090
4117
  module.exports = {
4091
4118
  parse,
4092
- compile: function(src, options) {
4119
+ compile: function(src, options = defaultOptions) {
4093
4120
  var ast, code, sm;
4094
4121
  ast = prune(parse(src, {
4095
- filename: options != null ? options.filename : void 0
4122
+ filename: options.filename
4096
4123
  }));
4097
4124
  if (options.sourceMap) {
4098
4125
  sm = SourceMap(src);