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