@danielx/civet 0.2.11 → 0.2.14

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 (9) hide show
  1. package/README.md +25 -8
  2. package/dist/browser.js +488 -292
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +12 -11
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +488 -292
  7. package/dist/types.d.ts +1 -0
  8. package/esbuild-plugin.js +27 -0
  9. package/package.json +2 -1
package/dist/main.js CHANGED
@@ -444,6 +444,8 @@ var require_parser = __commonJS({
444
444
  ApplicationStart,
445
445
  AdditionalReservedWords,
446
446
  MemberExpression,
447
+ MemberExpressionRest,
448
+ PropertyAccess,
447
449
  SuperProperty,
448
450
  MetaProperty,
449
451
  Parameters,
@@ -462,7 +464,8 @@ var require_parser = __commonJS({
462
464
  ThinArrowFunction,
463
465
  Block,
464
466
  BracedBlock,
465
- SingleNestedBlockExpression,
467
+ SingleNestedExpression,
468
+ SingleNestedBlockStatement,
466
469
  NestedBlockExpressions,
467
470
  BlockExpression,
468
471
  Literal,
@@ -508,6 +511,7 @@ var require_parser = __commonJS({
508
511
  LoopStatement,
509
512
  DoWhileStatement,
510
513
  WhileStatement,
514
+ WhileClause,
511
515
  ForStatement,
512
516
  ForInOfStatement,
513
517
  ForDeclaration,
@@ -527,6 +531,8 @@ var require_parser = __commonJS({
527
531
  Condition,
528
532
  ExpressionStatement,
529
533
  KeywordStatement,
534
+ MaybeNestedExpression,
535
+ Return,
530
536
  ImportDeclaration,
531
537
  ImportClause,
532
538
  NameSpaceImport,
@@ -545,6 +551,7 @@ var require_parser = __commonJS({
545
551
  Declaration,
546
552
  HoistableDeclaration,
547
553
  LexicalDeclaration,
554
+ ConstAssignment,
548
555
  LexicalBinding,
549
556
  Initializer,
550
557
  VariableStatement,
@@ -630,6 +637,7 @@ var require_parser = __commonJS({
630
637
  EOS,
631
638
  EOL,
632
639
  EOF,
640
+ Debugger,
633
641
  InsertOpenParen,
634
642
  InsertCloseParen,
635
643
  InsertOpenBrace,
@@ -643,7 +651,8 @@ var require_parser = __commonJS({
643
651
  Indent,
644
652
  PushIndent,
645
653
  PopIndent,
646
- Nested
654
+ Nested,
655
+ NestedFurther
647
656
  });
648
657
  var $L0 = $L(",");
649
658
  var $L1 = $L("(");
@@ -669,116 +678,118 @@ var require_parser = __commonJS({
669
678
  var $L21 = $L("new");
670
679
  var $L22 = $L("super");
671
680
  var $L23 = $L("import");
672
- var $L24 = $L("[");
673
- var $L25 = $L("]");
674
- var $L26 = $L(".");
675
- var $L27 = $L("super[");
676
- var $L28 = $L("new.target");
677
- var $L29 = $L("import.meta");
678
- var $L30 = $L("");
679
- var $L31 = $L("...");
680
- var $L32 = $L("function");
681
- var $L33 = $L("->");
682
- var $L34 = $L("true");
683
- var $L35 = $L("false");
684
- var $L36 = $L("null");
685
- var $L37 = $L("undefined");
686
- var $L38 = $L("get");
687
- var $L39 = $L("set");
688
- var $L40 = $L("**=");
689
- var $L41 = $L("*=");
690
- var $L42 = $L("/=");
691
- var $L43 = $L("%=");
692
- var $L44 = $L("+=");
693
- var $L45 = $L("-=");
694
- var $L46 = $L("<<=");
695
- var $L47 = $L(">>>=");
696
- var $L48 = $L(">>=");
697
- var $L49 = $L("&&=");
698
- var $L50 = $L("&=");
699
- var $L51 = $L("^=");
700
- var $L52 = $L("||=");
701
- var $L53 = $L("|=");
702
- var $L54 = $L("??=");
703
- var $L55 = $L("=");
704
- var $L56 = $L("**");
705
- var $L57 = $L("/");
706
- var $L58 = $L("%");
707
- var $L59 = $L("+");
708
- var $L60 = $L("-");
709
- var $L61 = $L("<=");
710
- var $L62 = $L(">=");
711
- var $L63 = $L("<<");
712
- var $L64 = $L(">>>");
713
- var $L65 = $L(">>");
714
- var $L66 = $L(">");
715
- var $L67 = $L("!==");
716
- var $L68 = $L("!=");
717
- var $L69 = $L("is");
718
- var $L70 = $L("===");
719
- var $L71 = $L("==");
720
- var $L72 = $L("and");
721
- var $L73 = $L("&&");
722
- var $L74 = $L("or");
723
- var $L75 = $L("||");
724
- var $L76 = $L("??");
725
- var $L77 = $L("instanceof");
726
- var $L78 = $L("in");
727
- var $L79 = $L("&");
728
- var $L80 = $L("^");
729
- var $L81 = $L("|");
730
- var $L82 = $L("delete");
731
- var $L83 = $L("void");
732
- var $L84 = $L("typeof");
733
- var $L85 = $L("if");
734
- var $L86 = $L("unless");
735
- var $L87 = $L(";");
736
- var $L88 = $L("else");
737
- var $L89 = $L("loop");
738
- var $L90 = $L("do");
739
- var $L91 = $L("while");
740
- var $L92 = $L("for");
741
- var $L93 = $L("var");
742
- var $L94 = $L("await");
743
- var $L95 = $L("of");
744
- var $L96 = $L("let");
745
- var $L97 = $L("const");
746
- var $L98 = $L("switch");
747
- var $L99 = $L("case");
748
- var $L100 = $L("default");
749
- var $L101 = $L("when");
750
- var $L102 = $L("try");
751
- var $L103 = $L("catch");
752
- var $L104 = $L("finally");
753
- var $L105 = $L("break");
754
- var $L106 = $L("continue");
755
- var $L107 = $L("debugger");
756
- var $L108 = $L("return");
757
- var $L109 = $L("throw");
758
- var $L110 = $L("import type");
759
- var $L111 = $L("from");
760
- var $L112 = $L("export");
761
- var $L113 = $L(":=");
762
- var $L114 = $L('"""');
763
- var $L115 = $L('"');
764
- var $L116 = $L("'");
765
- var $L117 = $L("\\");
766
- var $L118 = $L("`");
767
- var $L119 = $L("${");
768
- var $L120 = $L("/*");
769
- var $L121 = $L("*/");
770
- var $L122 = $L("###");
771
- var $L123 = $L("/>");
772
- var $L124 = $L("</");
773
- var $L125 = $L("<>");
774
- var $L126 = $L("</>");
775
- var $L127 = $L("readonly");
776
- var $L128 = $L("asserts");
777
- var $L129 = $L("keyof");
778
- var $L130 = $L("infer");
779
- var $L131 = $L("[]");
780
- var $L132 = $L(" ");
781
- var $L133 = $L(" ");
681
+ var $L24 = $L(".");
682
+ var $L25 = $L("[");
683
+ var $L26 = $L("]");
684
+ var $L27 = $L("::");
685
+ var $L28 = $L("super[");
686
+ var $L29 = $L("new.target");
687
+ var $L30 = $L("import.meta");
688
+ var $L31 = $L("");
689
+ var $L32 = $L("...");
690
+ var $L33 = $L("function");
691
+ var $L34 = $L("->");
692
+ var $L35 = $L("true");
693
+ var $L36 = $L("false");
694
+ var $L37 = $L("null");
695
+ var $L38 = $L("undefined");
696
+ var $L39 = $L("get");
697
+ var $L40 = $L("set");
698
+ var $L41 = $L("**=");
699
+ var $L42 = $L("*=");
700
+ var $L43 = $L("/=");
701
+ var $L44 = $L("%=");
702
+ var $L45 = $L("+=");
703
+ var $L46 = $L("-=");
704
+ var $L47 = $L("<<=");
705
+ var $L48 = $L(">>>=");
706
+ var $L49 = $L(">>=");
707
+ var $L50 = $L("&&=");
708
+ var $L51 = $L("&=");
709
+ var $L52 = $L("^=");
710
+ var $L53 = $L("||=");
711
+ var $L54 = $L("|=");
712
+ var $L55 = $L("??=");
713
+ var $L56 = $L("=");
714
+ var $L57 = $L("**");
715
+ var $L58 = $L("/");
716
+ var $L59 = $L("%");
717
+ var $L60 = $L("+");
718
+ var $L61 = $L("-");
719
+ var $L62 = $L("<=");
720
+ var $L63 = $L(">=");
721
+ var $L64 = $L("<<");
722
+ var $L65 = $L(">>>");
723
+ var $L66 = $L(">>");
724
+ var $L67 = $L(">");
725
+ var $L68 = $L("!==");
726
+ var $L69 = $L("!=");
727
+ var $L70 = $L("is");
728
+ var $L71 = $L("===");
729
+ var $L72 = $L("==");
730
+ var $L73 = $L("and");
731
+ var $L74 = $L("&&");
732
+ var $L75 = $L("or");
733
+ var $L76 = $L("||");
734
+ var $L77 = $L("??");
735
+ var $L78 = $L("instanceof");
736
+ var $L79 = $L("in");
737
+ var $L80 = $L("&");
738
+ var $L81 = $L("^");
739
+ var $L82 = $L("|");
740
+ var $L83 = $L("delete");
741
+ var $L84 = $L("void");
742
+ var $L85 = $L("typeof");
743
+ var $L86 = $L("if");
744
+ var $L87 = $L("unless");
745
+ var $L88 = $L(";");
746
+ var $L89 = $L("else");
747
+ var $L90 = $L("loop");
748
+ var $L91 = $L("do");
749
+ var $L92 = $L("while");
750
+ var $L93 = $L("until");
751
+ var $L94 = $L("for");
752
+ var $L95 = $L("var");
753
+ var $L96 = $L("await");
754
+ var $L97 = $L("of");
755
+ var $L98 = $L("let");
756
+ var $L99 = $L("const");
757
+ var $L100 = $L("switch");
758
+ var $L101 = $L("case");
759
+ var $L102 = $L("default");
760
+ var $L103 = $L("when");
761
+ var $L104 = $L("try");
762
+ var $L105 = $L("catch");
763
+ var $L106 = $L("finally");
764
+ var $L107 = $L("break");
765
+ var $L108 = $L("continue");
766
+ var $L109 = $L("debugger");
767
+ var $L110 = $L("throw");
768
+ var $L111 = $L("return");
769
+ var $L112 = $L("import type");
770
+ var $L113 = $L("from");
771
+ var $L114 = $L("export");
772
+ var $L115 = $L(":=");
773
+ var $L116 = $L('"""');
774
+ var $L117 = $L('"');
775
+ var $L118 = $L("'");
776
+ var $L119 = $L("\\");
777
+ var $L120 = $L("`");
778
+ var $L121 = $L("${");
779
+ var $L122 = $L("/*");
780
+ var $L123 = $L("*/");
781
+ var $L124 = $L("###");
782
+ var $L125 = $L("/>");
783
+ var $L126 = $L("</");
784
+ var $L127 = $L("<>");
785
+ var $L128 = $L("</>");
786
+ var $L129 = $L("readonly");
787
+ var $L130 = $L("asserts");
788
+ var $L131 = $L("keyof");
789
+ var $L132 = $L("infer");
790
+ var $L133 = $L("[]");
791
+ var $L134 = $L(" ");
792
+ var $L135 = $L(" ");
782
793
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
783
794
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
784
795
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -998,7 +1009,7 @@ var require_parser = __commonJS({
998
1009
  return FatArrow$0(state);
999
1010
  }
1000
1011
  }
1001
- var ConciseBody$0 = $S(EOS, SingleNestedBlockExpression);
1012
+ var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
1002
1013
  var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
1003
1014
  var ConciseBody$2 = BracedBlock;
1004
1015
  function ConciseBody(state) {
@@ -1067,7 +1078,7 @@ var require_parser = __commonJS({
1067
1078
  return ClassExpression$0(state);
1068
1079
  }
1069
1080
  }
1070
- var ClassHeritage$0 = $S(ExtendsToken, __, $S(MemberExpression, $Q(CallExpressionRest)));
1081
+ var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
1071
1082
  function ClassHeritage(state) {
1072
1083
  if (state.verbose)
1073
1084
  console.log("ENTER:", "ClassHeritage");
@@ -1146,8 +1157,8 @@ var require_parser = __commonJS({
1146
1157
  var ref = value[1];
1147
1158
  return ["this.", ref];
1148
1159
  });
1149
- var This$2 = $T($EXPECT($L19, fail, 'This "@"'), function(value) {
1150
- return "this";
1160
+ var This$2 = $TV($EXPECT($L19, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1161
+ return { $loc, token: "this" };
1151
1162
  });
1152
1163
  function This(state) {
1153
1164
  if (state.tokenize) {
@@ -1165,7 +1176,7 @@ var require_parser = __commonJS({
1165
1176
  return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
1166
1177
  }
1167
1178
  }
1168
- var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), MemberExpression);
1179
+ var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), CallExpression);
1169
1180
  function NewExpression(state) {
1170
1181
  if (state.verbose)
1171
1182
  console.log("ENTER:", "NewExpression");
@@ -1177,7 +1188,7 @@ var require_parser = __commonJS({
1177
1188
  }
1178
1189
  var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
1179
1190
  var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1180
- var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
1191
+ var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
1181
1192
  function CallExpression(state) {
1182
1193
  if (state.tokenize) {
1183
1194
  return $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
@@ -1186,8 +1197,8 @@ var require_parser = __commonJS({
1186
1197
  }
1187
1198
  }
1188
1199
  var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1189
- var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
1190
- var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1200
+ var CallExpressionRest$1 = MemberExpressionRest;
1201
+ var CallExpressionRest$2 = SpacedApplication;
1191
1202
  var CallExpressionRest$3 = TemplateLiteral;
1192
1203
  function CallExpressionRest(state) {
1193
1204
  if (state.tokenize) {
@@ -1196,7 +1207,7 @@ var require_parser = __commonJS({
1196
1207
  return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1197
1208
  }
1198
1209
  }
1199
- var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
1210
+ var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L24, fail, 'OptionalShorthand "."'), InsertDot));
1200
1211
  function OptionalShorthand(state) {
1201
1212
  if (state.verbose)
1202
1213
  console.log("ENTER:", "OptionalShorthand");
@@ -1206,7 +1217,7 @@ var require_parser = __commonJS({
1206
1217
  return OptionalShorthand$0(state);
1207
1218
  }
1208
1219
  }
1209
- var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
1220
+ var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
1210
1221
  function SpacedApplication(state) {
1211
1222
  if (state.verbose)
1212
1223
  console.log("ENTER:", "SpacedApplication");
@@ -1240,7 +1251,7 @@ var require_parser = __commonJS({
1240
1251
  return AdditionalReservedWords$0(state);
1241
1252
  }
1242
1253
  }
1243
- var MemberExpression$0 = $S(PrimaryExpression, $Q(CallExpressionRest));
1254
+ var MemberExpression$0 = $S(PrimaryExpression, $Q(MemberExpressionRest));
1244
1255
  var MemberExpression$1 = $S($Q(TrailingComment), SuperProperty);
1245
1256
  var MemberExpression$2 = $S($Q(TrailingComment), MetaProperty);
1246
1257
  function MemberExpression(state) {
@@ -1250,7 +1261,32 @@ var require_parser = __commonJS({
1250
1261
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1251
1262
  }
1252
1263
  }
1253
- var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
1264
+ var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L25, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L26, fail, 'MemberExpressionRest "]"'));
1265
+ var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
1266
+ var MemberExpressionRest$2 = $TS($S($EXPECT($L27, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1267
+ var id = $2;
1268
+ if (id)
1269
+ return [".prototype.", id];
1270
+ return ".prototype";
1271
+ });
1272
+ function MemberExpressionRest(state) {
1273
+ if (state.tokenize) {
1274
+ return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
1275
+ } else {
1276
+ return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
1277
+ }
1278
+ }
1279
+ var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L24, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1280
+ function PropertyAccess(state) {
1281
+ if (state.verbose)
1282
+ console.log("ENTER:", "PropertyAccess");
1283
+ if (state.tokenize) {
1284
+ return $TOKEN("PropertyAccess", state, PropertyAccess$0(state));
1285
+ } else {
1286
+ return PropertyAccess$0(state);
1287
+ }
1288
+ }
1289
+ var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L26, fail, 'SuperProperty "]"'));
1254
1290
  function SuperProperty(state) {
1255
1291
  if (state.verbose)
1256
1292
  console.log("ENTER:", "SuperProperty");
@@ -1260,8 +1296,8 @@ var require_parser = __commonJS({
1260
1296
  return SuperProperty$0(state);
1261
1297
  }
1262
1298
  }
1263
- var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
1264
- var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
1299
+ var MetaProperty$0 = $EXPECT($L29, fail, 'MetaProperty "new.target"');
1300
+ var MetaProperty$1 = $EXPECT($L30, fail, 'MetaProperty "import.meta"');
1265
1301
  function MetaProperty(state) {
1266
1302
  if (state.tokenize) {
1267
1303
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1270,7 +1306,7 @@ var require_parser = __commonJS({
1270
1306
  }
1271
1307
  }
1272
1308
  var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1273
- var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
1309
+ var Parameters$1 = $T($EXPECT($L31, fail, 'Parameters ""'), function(value) {
1274
1310
  return "()";
1275
1311
  });
1276
1312
  function Parameters(state) {
@@ -1334,7 +1370,7 @@ var require_parser = __commonJS({
1334
1370
  return ObjectBindingPattern$0(state);
1335
1371
  }
1336
1372
  }
1337
- var ArrayBindingPattern$0 = $S($EXPECT($L24, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L25, fail, 'ArrayBindingPattern "]"'));
1373
+ var ArrayBindingPattern$0 = $S($EXPECT($L25, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L26, fail, 'ArrayBindingPattern "]"'));
1338
1374
  function ArrayBindingPattern(state) {
1339
1375
  if (state.verbose)
1340
1376
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1353,7 +1389,7 @@ var require_parser = __commonJS({
1353
1389
  return BindingProperty$0(state) || BindingProperty$1(state);
1354
1390
  }
1355
1391
  }
1356
- var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1392
+ var BindingRestProperty$0 = $S($EXPECT($L32, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1357
1393
  function BindingRestProperty(state) {
1358
1394
  if (state.verbose)
1359
1395
  console.log("ENTER:", "BindingRestProperty");
@@ -1373,7 +1409,7 @@ var require_parser = __commonJS({
1373
1409
  return BindingElement$0(state);
1374
1410
  }
1375
1411
  }
1376
- var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1412
+ var BindingRestElement$0 = $S($EXPECT($L32, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1377
1413
  function BindingRestElement(state) {
1378
1414
  if (state.verbose)
1379
1415
  console.log("ENTER:", "BindingRestElement");
@@ -1394,7 +1430,7 @@ var require_parser = __commonJS({
1394
1430
  }
1395
1431
  }
1396
1432
  var FunctionExpression$0 = ThinArrowFunction;
1397
- var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L32, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1433
+ 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);
1398
1434
  function FunctionExpression(state) {
1399
1435
  if (state.tokenize) {
1400
1436
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1402,7 +1438,7 @@ var require_parser = __commonJS({
1402
1438
  return FunctionExpression$0(state) || FunctionExpression$1(state);
1403
1439
  }
1404
1440
  }
1405
- var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1441
+ var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L34, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1406
1442
  var params = value[0];
1407
1443
  var suffix = value[1];
1408
1444
  var block = value[4];
@@ -1438,19 +1474,34 @@ var require_parser = __commonJS({
1438
1474
  return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
1439
1475
  }
1440
1476
  }
1441
- var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), $S(PopIndent, $N($EXPECT($L30, fail, 'SingleNestedBlockExpression ""')))), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
1477
+ var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
1442
1478
  var exp = $2;
1443
1479
  if (exp)
1444
1480
  return exp;
1445
1481
  return $skip;
1446
1482
  });
1447
- function SingleNestedBlockExpression(state) {
1483
+ function SingleNestedExpression(state) {
1448
1484
  if (state.verbose)
1449
- console.log("ENTER:", "SingleNestedBlockExpression");
1485
+ console.log("ENTER:", "SingleNestedExpression");
1450
1486
  if (state.tokenize) {
1451
- return $TOKEN("SingleNestedBlockExpression", state, SingleNestedBlockExpression$0(state));
1487
+ return $TOKEN("SingleNestedExpression", state, SingleNestedExpression$0(state));
1452
1488
  } else {
1453
- return SingleNestedBlockExpression$0(state);
1489
+ return SingleNestedExpression$0(state);
1490
+ }
1491
+ }
1492
+ var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
1493
+ var exp = $2;
1494
+ if (exp)
1495
+ return exp;
1496
+ return $skip;
1497
+ });
1498
+ function SingleNestedBlockStatement(state) {
1499
+ if (state.verbose)
1500
+ console.log("ENTER:", "SingleNestedBlockStatement");
1501
+ if (state.tokenize) {
1502
+ return $TOKEN("SingleNestedBlockStatement", state, SingleNestedBlockStatement$0(state));
1503
+ } else {
1504
+ return SingleNestedBlockStatement$0(state);
1454
1505
  }
1455
1506
  }
1456
1507
  var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(BlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
@@ -1480,10 +1531,10 @@ var require_parser = __commonJS({
1480
1531
  }
1481
1532
  var Literal$0 = StringLiteral;
1482
1533
  var Literal$1 = NumericLiteral;
1483
- var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
1484
- var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
1485
- var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
1486
- var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
1534
+ var Literal$2 = $EXPECT($L35, fail, 'Literal "true"');
1535
+ var Literal$3 = $EXPECT($L36, fail, 'Literal "false"');
1536
+ var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
1537
+ var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
1487
1538
  function Literal(state) {
1488
1539
  if (state.tokenize) {
1489
1540
  return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
@@ -1511,7 +1562,12 @@ var require_parser = __commonJS({
1511
1562
  return Identifier$0(state);
1512
1563
  }
1513
1564
  }
1514
- var IdentifierName$0 = $R$0($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
1565
+ var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
1566
+ return {
1567
+ $loc,
1568
+ token: $0
1569
+ };
1570
+ });
1515
1571
  function IdentifierName(state) {
1516
1572
  if (state.verbose)
1517
1573
  console.log("ENTER:", "IdentifierName");
@@ -1531,8 +1587,8 @@ var require_parser = __commonJS({
1531
1587
  return IdentifierReference$0(state);
1532
1588
  }
1533
1589
  }
1534
- var ArrayLiteral$0 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
1535
- var ArrayLiteral$1 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
1590
+ var ArrayLiteral$0 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
1591
+ var ArrayLiteral$1 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
1536
1592
  function ArrayLiteral(state) {
1537
1593
  if (state.tokenize) {
1538
1594
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1566,8 +1622,8 @@ var require_parser = __commonJS({
1566
1622
  }
1567
1623
  }
1568
1624
  var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1569
- var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
1570
- var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1625
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
1626
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1571
1627
  return ",";
1572
1628
  });
1573
1629
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1600,7 +1656,7 @@ var require_parser = __commonJS({
1600
1656
  return InlineElementList$0(state);
1601
1657
  }
1602
1658
  }
1603
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1659
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L32, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1604
1660
  function ArrayElementExpression(state) {
1605
1661
  if (state.verbose)
1606
1662
  console.log("ENTER:", "ArrayElementExpression");
@@ -1683,7 +1739,7 @@ var require_parser = __commonJS({
1683
1739
  }
1684
1740
  var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1685
1741
  var PropertyDefinition$1 = MethodDefinition;
1686
- var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1742
+ var PropertyDefinition$2 = $S($EXPECT($L32, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1687
1743
  var PropertyDefinition$3 = IdentifierReference;
1688
1744
  function PropertyDefinition(state) {
1689
1745
  if (state.tokenize) {
@@ -1695,7 +1751,7 @@ var require_parser = __commonJS({
1695
1751
  var PropertyName$0 = NumericLiteral;
1696
1752
  var PropertyName$1 = StringLiteral;
1697
1753
  var PropertyName$2 = IdentifierName;
1698
- var PropertyName$3 = $S($EXPECT($L24, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
1754
+ var PropertyName$3 = $S($EXPECT($L25, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
1699
1755
  function PropertyName(state) {
1700
1756
  if (state.tokenize) {
1701
1757
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1703,8 +1759,8 @@ var require_parser = __commonJS({
1703
1759
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1704
1760
  }
1705
1761
  }
1706
- var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1707
- var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1762
+ var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1763
+ var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1708
1764
  var MethodDefinition$2 = AsyncGeneratorMethod;
1709
1765
  var MethodDefinition$3 = AsyncMethod;
1710
1766
  var MethodDefinition$4 = GeneratorMethod;
@@ -1795,22 +1851,22 @@ var require_parser = __commonJS({
1795
1851
  return AsyncGeneratorBody$0(state);
1796
1852
  }
1797
1853
  }
1798
- var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
1799
- var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
1800
- var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
1801
- var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
1802
- var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
1803
- var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
1804
- var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
1805
- var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
1806
- var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
1807
- var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
1808
- var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
1809
- var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
1810
- var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
1811
- var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
1812
- var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
1813
- var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
1854
+ var AssignmentOp$0 = $EXPECT($L41, fail, 'AssignmentOp "**="');
1855
+ var AssignmentOp$1 = $EXPECT($L42, fail, 'AssignmentOp "*="');
1856
+ var AssignmentOp$2 = $EXPECT($L43, fail, 'AssignmentOp "/="');
1857
+ var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
1858
+ var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
1859
+ var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
1860
+ var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
1861
+ var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
1862
+ var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
1863
+ var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
1864
+ var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
1865
+ var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
1866
+ var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
1867
+ var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
1868
+ var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
1869
+ var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
1814
1870
  function AssignmentOp(state) {
1815
1871
  if (state.tokenize) {
1816
1872
  return $TOKEN("AssignmentOp", state, AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state));
@@ -1818,48 +1874,48 @@ var require_parser = __commonJS({
1818
1874
  return AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state);
1819
1875
  }
1820
1876
  }
1821
- var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
1877
+ var BinaryOp$0 = $EXPECT($L57, fail, 'BinaryOp "**"');
1822
1878
  var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
1823
- var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
1824
- var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
1825
- var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
1826
- var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
1827
- var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
1828
- var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
1829
- var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
1879
+ var BinaryOp$2 = $EXPECT($L58, fail, 'BinaryOp "/"');
1880
+ var BinaryOp$3 = $EXPECT($L59, fail, 'BinaryOp "%"');
1881
+ var BinaryOp$4 = $EXPECT($L60, fail, 'BinaryOp "+"');
1882
+ var BinaryOp$5 = $EXPECT($L61, fail, 'BinaryOp "-"');
1883
+ var BinaryOp$6 = $EXPECT($L62, fail, 'BinaryOp "<="');
1884
+ var BinaryOp$7 = $EXPECT($L63, fail, 'BinaryOp ">="');
1885
+ var BinaryOp$8 = $EXPECT($L64, fail, 'BinaryOp "<<"');
1830
1886
  var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
1831
- var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
1832
- var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
1833
- var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
1834
- var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
1835
- var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1887
+ var BinaryOp$10 = $EXPECT($L65, fail, 'BinaryOp ">>>"');
1888
+ var BinaryOp$11 = $EXPECT($L66, fail, 'BinaryOp ">>"');
1889
+ var BinaryOp$12 = $EXPECT($L67, fail, 'BinaryOp ">"');
1890
+ var BinaryOp$13 = $EXPECT($L68, fail, 'BinaryOp "!=="');
1891
+ var BinaryOp$14 = $TV($EXPECT($L69, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1836
1892
  if (global.coffeeCompat)
1837
1893
  return "!==";
1838
1894
  return $1;
1839
1895
  });
1840
- var BinaryOp$15 = $T($S($EXPECT($L69, fail, 'BinaryOp "is"'), NonIdContinue), function(value) {
1896
+ var BinaryOp$15 = $T($S($EXPECT($L70, fail, 'BinaryOp "is"'), NonIdContinue), function(value) {
1841
1897
  return "===";
1842
1898
  });
1843
- var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
1844
- var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1899
+ var BinaryOp$16 = $EXPECT($L71, fail, 'BinaryOp "==="');
1900
+ var BinaryOp$17 = $TV($EXPECT($L72, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1845
1901
  if (global.coffeeCompat)
1846
1902
  return "===";
1847
1903
  return $1;
1848
1904
  });
1849
- var BinaryOp$18 = $T($S($EXPECT($L72, fail, 'BinaryOp "and"'), NonIdContinue), function(value) {
1905
+ var BinaryOp$18 = $T($S($EXPECT($L73, fail, 'BinaryOp "and"'), NonIdContinue), function(value) {
1850
1906
  return "&&";
1851
1907
  });
1852
- var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
1853
- var BinaryOp$20 = $T($S($EXPECT($L74, fail, 'BinaryOp "or"'), NonIdContinue), function(value) {
1908
+ var BinaryOp$19 = $EXPECT($L74, fail, 'BinaryOp "&&"');
1909
+ var BinaryOp$20 = $T($S($EXPECT($L75, fail, 'BinaryOp "or"'), NonIdContinue), function(value) {
1854
1910
  return "||";
1855
1911
  });
1856
- var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
1857
- var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
1858
- var BinaryOp$23 = $S($EXPECT($L77, fail, 'BinaryOp "instanceof"'), NonIdContinue);
1859
- var BinaryOp$24 = $S($EXPECT($L78, fail, 'BinaryOp "in"'), NonIdContinue);
1860
- var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
1861
- var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
1862
- var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
1912
+ var BinaryOp$21 = $EXPECT($L76, fail, 'BinaryOp "||"');
1913
+ var BinaryOp$22 = $EXPECT($L77, fail, 'BinaryOp "??"');
1914
+ var BinaryOp$23 = $S($EXPECT($L78, fail, 'BinaryOp "instanceof"'), NonIdContinue);
1915
+ var BinaryOp$24 = $S($EXPECT($L79, fail, 'BinaryOp "in"'), NonIdContinue);
1916
+ var BinaryOp$25 = $EXPECT($L80, fail, 'BinaryOp "&"');
1917
+ var BinaryOp$26 = $EXPECT($L81, fail, 'BinaryOp "^"');
1918
+ var BinaryOp$27 = $EXPECT($L82, fail, 'BinaryOp "|"');
1863
1919
  function BinaryOp(state) {
1864
1920
  if (state.tokenize) {
1865
1921
  return $TOKEN("BinaryOp", state, BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state));
@@ -1868,7 +1924,7 @@ var require_parser = __commonJS({
1868
1924
  }
1869
1925
  }
1870
1926
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
1871
- var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
1927
+ var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
1872
1928
  function UnaryOp(state) {
1873
1929
  if (state.tokenize) {
1874
1930
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -1902,7 +1958,7 @@ var require_parser = __commonJS({
1902
1958
  return StatementListItem$0(state);
1903
1959
  }
1904
1960
  }
1905
- 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) {
1961
+ 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) {
1906
1962
  var ws = $1;
1907
1963
  var cond = $2;
1908
1964
  var exp = $4;
@@ -1935,7 +1991,7 @@ var require_parser = __commonJS({
1935
1991
  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);
1936
1992
  }
1937
1993
  }
1938
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
1994
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
1939
1995
  function EmptyStatement(state) {
1940
1996
  if (state.verbose)
1941
1997
  console.log("ENTER:", "EmptyStatement");
@@ -1955,8 +2011,8 @@ var require_parser = __commonJS({
1955
2011
  return BlockStatement$0(state);
1956
2012
  }
1957
2013
  }
1958
- var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
1959
- var IfStatement$1 = $TS($S($EXPECT($L86, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2014
+ var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
2015
+ var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1960
2016
  var condition = $2;
1961
2017
  var block = $3;
1962
2018
  return ["if", condition.map((c) => {
@@ -1986,7 +2042,7 @@ var require_parser = __commonJS({
1986
2042
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
1987
2043
  }
1988
2044
  }
1989
- var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2045
+ var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
1990
2046
  var b = $3;
1991
2047
  return ["while(true)", b];
1992
2048
  });
@@ -1999,7 +2055,7 @@ var require_parser = __commonJS({
1999
2055
  return LoopStatement$0(state);
2000
2056
  }
2001
2057
  }
2002
- var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
2058
+ var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2003
2059
  function DoWhileStatement(state) {
2004
2060
  if (state.verbose)
2005
2061
  console.log("ENTER:", "DoWhileStatement");
@@ -2009,7 +2065,7 @@ var require_parser = __commonJS({
2009
2065
  return DoWhileStatement$0(state);
2010
2066
  }
2011
2067
  }
2012
- var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), NonIdContinue, Condition, Block);
2068
+ var WhileStatement$0 = $S(WhileClause, Block);
2013
2069
  function WhileStatement(state) {
2014
2070
  if (state.verbose)
2015
2071
  console.log("ENTER:", "WhileStatement");
@@ -2019,7 +2075,26 @@ var require_parser = __commonJS({
2019
2075
  return WhileStatement$0(state);
2020
2076
  }
2021
2077
  }
2022
- var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), NonIdContinue, __, $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);
2078
+ 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) {
2079
+ var kind = $1;
2080
+ var cond = $3;
2081
+ if (kind === "until") {
2082
+ cond[1] = "(!(";
2083
+ cond[5] = "))";
2084
+ return ["while", cond];
2085
+ }
2086
+ return $0;
2087
+ });
2088
+ function WhileClause(state) {
2089
+ if (state.verbose)
2090
+ console.log("ENTER:", "WhileClause");
2091
+ if (state.tokenize) {
2092
+ return $TOKEN("WhileClause", state, WhileClause$0(state));
2093
+ } else {
2094
+ return WhileClause$0(state);
2095
+ }
2096
+ }
2097
+ var ForStatement$0 = $S($EXPECT($L94, fail, 'ForStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2023
2098
  function ForStatement(state) {
2024
2099
  if (state.verbose)
2025
2100
  console.log("ENTER:", "ForStatement");
@@ -2029,10 +2104,10 @@ var require_parser = __commonJS({
2029
2104
  return ForStatement$0(state);
2030
2105
  }
2031
2106
  }
2032
- var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $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);
2033
- var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2034
- var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $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);
2035
- var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $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);
2107
+ var ForInOfStatement$0 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2108
+ var ForInOfStatement$1 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2109
+ var ForInOfStatement$2 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2110
+ var ForInOfStatement$3 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2036
2111
  function ForInOfStatement(state) {
2037
2112
  if (state.tokenize) {
2038
2113
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2040,7 +2115,7 @@ var require_parser = __commonJS({
2040
2115
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2041
2116
  }
2042
2117
  }
2043
- var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
2118
+ var ForDeclaration$0 = $S($C($EXPECT($L98, fail, 'ForDeclaration "let"'), $EXPECT($L99, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
2044
2119
  function ForDeclaration(state) {
2045
2120
  if (state.verbose)
2046
2121
  console.log("ENTER:", "ForDeclaration");
@@ -2059,7 +2134,7 @@ var require_parser = __commonJS({
2059
2134
  return ForBinding$0(state) || ForBinding$1(state);
2060
2135
  }
2061
2136
  }
2062
- var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2137
+ var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2063
2138
  function SwitchStatement(state) {
2064
2139
  if (state.verbose)
2065
2140
  console.log("ENTER:", "SwitchStatement");
@@ -2103,9 +2178,9 @@ var require_parser = __commonJS({
2103
2178
  return NestedCaseClause$0(state);
2104
2179
  }
2105
2180
  }
2106
- var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2181
+ var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2107
2182
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2108
- var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2183
+ var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2109
2184
  function CaseClause(state) {
2110
2185
  if (state.tokenize) {
2111
2186
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2113,7 +2188,7 @@ var require_parser = __commonJS({
2113
2188
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2114
2189
  }
2115
2190
  }
2116
- var When$0 = $T($S($EXPECT($L101, fail, 'When "when"'), NonIdContinue), function(value) {
2191
+ var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
2117
2192
  return "case";
2118
2193
  });
2119
2194
  function When(state) {
@@ -2126,7 +2201,7 @@ var require_parser = __commonJS({
2126
2201
  }
2127
2202
  }
2128
2203
  var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2129
- var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
2204
+ var ImpliedColon$1 = $T($EXPECT($L31, fail, 'ImpliedColon ""'), function(value) {
2130
2205
  return ":";
2131
2206
  });
2132
2207
  function ImpliedColon(state) {
@@ -2136,7 +2211,7 @@ var require_parser = __commonJS({
2136
2211
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2137
2212
  }
2138
2213
  }
2139
- var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2214
+ var TryStatement$0 = $TS($S($EXPECT($L104, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2140
2215
  var c = $3;
2141
2216
  var f = $4;
2142
2217
  if (!c && !f) {
@@ -2153,7 +2228,7 @@ var require_parser = __commonJS({
2153
2228
  return TryStatement$0(state);
2154
2229
  }
2155
2230
  }
2156
- var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2231
+ var Catch$0 = $S(__, $EXPECT($L105, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2157
2232
  function Catch(state) {
2158
2233
  if (state.verbose)
2159
2234
  console.log("ENTER:", "Catch");
@@ -2172,7 +2247,7 @@ var require_parser = __commonJS({
2172
2247
  return CatchBind$0(state) || CatchBind$1(state);
2173
2248
  }
2174
2249
  }
2175
- var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
2250
+ var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
2176
2251
  function Finally(state) {
2177
2252
  if (state.verbose)
2178
2253
  console.log("ENTER:", "Finally");
@@ -2210,20 +2285,38 @@ var require_parser = __commonJS({
2210
2285
  return ExpressionStatement$0(state);
2211
2286
  }
2212
2287
  }
2213
- var KeywordStatement$0 = $S($EXPECT($L105, fail, 'KeywordStatement "break"'), NonIdContinue);
2214
- var KeywordStatement$1 = $S($EXPECT($L106, fail, 'KeywordStatement "continue"'), NonIdContinue);
2215
- var KeywordStatement$2 = $S($EXPECT($L107, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2216
- var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue, Expression);
2217
- var KeywordStatement$4 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue);
2218
- var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2288
+ var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
2289
+ var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
2290
+ var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2291
+ var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2292
+ var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2219
2293
  function KeywordStatement(state) {
2220
2294
  if (state.tokenize) {
2221
- return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
2295
+ return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
2296
+ } else {
2297
+ return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
2298
+ }
2299
+ }
2300
+ var MaybeNestedExpression$0 = $S($N(EOS), $Q(TrailingComment), Expression);
2301
+ var MaybeNestedExpression$1 = $S($Y(EOS), ObjectLiteral);
2302
+ function MaybeNestedExpression(state) {
2303
+ if (state.tokenize) {
2304
+ return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state));
2222
2305
  } else {
2223
- return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
2306
+ return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2224
2307
  }
2225
2308
  }
2226
- var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2309
+ var Return$0 = $S($EXPECT($L111, fail, 'Return "return"'), NonIdContinue);
2310
+ function Return(state) {
2311
+ if (state.verbose)
2312
+ console.log("ENTER:", "Return");
2313
+ if (state.tokenize) {
2314
+ return $TOKEN("Return", state, Return$0(state));
2315
+ } else {
2316
+ return Return$0(state);
2317
+ }
2318
+ }
2319
+ var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2227
2320
  return { "ts": true, "children": value };
2228
2321
  });
2229
2322
  var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ImportClause, __, FromClause);
@@ -2265,7 +2358,7 @@ var require_parser = __commonJS({
2265
2358
  return NamedImports$0(state);
2266
2359
  }
2267
2360
  }
2268
- var FromClause$0 = $S($EXPECT($L111, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
2361
+ var FromClause$0 = $S($EXPECT($L113, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
2269
2362
  function FromClause(state) {
2270
2363
  if (state.verbose)
2271
2364
  console.log("ENTER:", "FromClause");
@@ -2313,7 +2406,7 @@ var require_parser = __commonJS({
2313
2406
  return ImportedBinding$0(state);
2314
2407
  }
2315
2408
  }
2316
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2409
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2317
2410
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2318
2411
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2319
2412
  function ExportDeclaration(state) {
@@ -2333,7 +2426,7 @@ var require_parser = __commonJS({
2333
2426
  return As$0(state);
2334
2427
  }
2335
2428
  }
2336
- var Export$0 = $S($EXPECT($L112, fail, 'Export "export"'), NonIdContinue);
2429
+ var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
2337
2430
  function Export(state) {
2338
2431
  if (state.verbose)
2339
2432
  console.log("ENTER:", "Export");
@@ -2393,13 +2486,22 @@ var require_parser = __commonJS({
2393
2486
  return HoistableDeclaration$0(state);
2394
2487
  }
2395
2488
  }
2396
- var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2397
- var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
2398
- var bind = value[0];
2399
- var suffix = value[1];
2400
- var ws = value[2];
2401
- var exp = value[4];
2402
- return ["const ", bind, suffix, ws, "=", exp];
2489
+ var LexicalDeclaration$0 = $S($C($EXPECT($L98, fail, 'LexicalDeclaration "let"'), $EXPECT($L99, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2490
+ var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
2491
+ var bind = $1;
2492
+ var suffix = $2;
2493
+ var ws = $3;
2494
+ var ca = $4;
2495
+ var exp = $5;
2496
+ return [
2497
+ { token: "const", $loc: ca.$loc },
2498
+ " ",
2499
+ bind,
2500
+ suffix,
2501
+ ws,
2502
+ { token: "=", $loc: ca.$loc },
2503
+ exp
2504
+ ];
2403
2505
  });
2404
2506
  function LexicalDeclaration(state) {
2405
2507
  if (state.tokenize) {
@@ -2408,6 +2510,18 @@ var require_parser = __commonJS({
2408
2510
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
2409
2511
  }
2410
2512
  }
2513
+ var ConstAssignment$0 = $TV($EXPECT($L115, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2514
+ return { $loc, token: $0 };
2515
+ });
2516
+ function ConstAssignment(state) {
2517
+ if (state.verbose)
2518
+ console.log("ENTER:", "ConstAssignment");
2519
+ if (state.tokenize) {
2520
+ return $TOKEN("ConstAssignment", state, ConstAssignment$0(state));
2521
+ } else {
2522
+ return ConstAssignment$0(state);
2523
+ }
2524
+ }
2411
2525
  var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
2412
2526
  var LexicalBinding$1 = $S(BindingIdentifier, $E(TypeSuffix), $E(Initializer));
2413
2527
  function LexicalBinding(state) {
@@ -2417,7 +2531,7 @@ var require_parser = __commonJS({
2417
2531
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2418
2532
  }
2419
2533
  }
2420
- var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2534
+ var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2421
2535
  function Initializer(state) {
2422
2536
  if (state.verbose)
2423
2537
  console.log("ENTER:", "Initializer");
@@ -2427,7 +2541,7 @@ var require_parser = __commonJS({
2427
2541
  return Initializer$0(state);
2428
2542
  }
2429
2543
  }
2430
- var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2544
+ var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2431
2545
  function VariableStatement(state) {
2432
2546
  if (state.verbose)
2433
2547
  console.log("ENTER:", "VariableStatement");
@@ -2518,11 +2632,11 @@ var require_parser = __commonJS({
2518
2632
  return HexLiteral$0(state);
2519
2633
  }
2520
2634
  }
2521
- var StringLiteral$0 = $T($S($EXPECT($L114, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L114, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
2635
+ var StringLiteral$0 = $T($S($EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
2522
2636
  return ["`", value[1], "`"];
2523
2637
  });
2524
- var StringLiteral$1 = $S($EXPECT($L115, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\""'));
2525
- var StringLiteral$2 = $S($EXPECT($L116, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "\\\\'"`));
2638
+ var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
2639
+ var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
2526
2640
  function StringLiteral(state) {
2527
2641
  if (state.tokenize) {
2528
2642
  return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
@@ -2558,7 +2672,7 @@ var require_parser = __commonJS({
2558
2672
  return TripleDoubleStringCharacter$0(state);
2559
2673
  }
2560
2674
  }
2561
- var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R11, fail, "EscapeSequence /./")));
2675
+ var EscapeSequence$0 = $TEXT($S($EXPECT($L119, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R11, fail, "EscapeSequence /./")));
2562
2676
  function EscapeSequence(state) {
2563
2677
  if (state.verbose)
2564
2678
  console.log("ENTER:", "EscapeSequence");
@@ -2568,7 +2682,7 @@ var require_parser = __commonJS({
2568
2682
  return EscapeSequence$0(state);
2569
2683
  }
2570
2684
  }
2571
- var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2685
+ var RegularExpressionLiteral$0 = $S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2572
2686
  function RegularExpressionLiteral(state) {
2573
2687
  if (state.verbose)
2574
2688
  console.log("ENTER:", "RegularExpressionLiteral");
@@ -2607,7 +2721,7 @@ var require_parser = __commonJS({
2607
2721
  return RegularExpressionFlags$0(state);
2608
2722
  }
2609
2723
  }
2610
- var TemplateLiteral$0 = $S($EXPECT($L118, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L118, fail, 'TemplateLiteral "`"'));
2724
+ var TemplateLiteral$0 = $S($EXPECT($L120, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L120, fail, 'TemplateLiteral "`"'));
2611
2725
  function TemplateLiteral(state) {
2612
2726
  if (state.verbose)
2613
2727
  console.log("ENTER:", "TemplateLiteral");
@@ -2617,7 +2731,7 @@ var require_parser = __commonJS({
2617
2731
  return TemplateLiteral$0(state);
2618
2732
  }
2619
2733
  }
2620
- var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2734
+ var TemplateSubstitution$0 = $S($EXPECT($L121, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2621
2735
  function TemplateSubstitution(state) {
2622
2736
  if (state.verbose)
2623
2737
  console.log("ENTER:", "TemplateSubstitution");
@@ -2674,7 +2788,7 @@ var require_parser = __commonJS({
2674
2788
  return MultiLineComment$0(state) || MultiLineComment$1(state);
2675
2789
  }
2676
2790
  }
2677
- var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R11, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
2791
+ var JSMultiLineComment$0 = $S($EXPECT($L122, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'JSMultiLineComment "*/"')), $EXPECT($R11, fail, "JSMultiLineComment /./")))), $EXPECT($L123, fail, 'JSMultiLineComment "*/"'));
2678
2792
  function JSMultiLineComment(state) {
2679
2793
  if (state.verbose)
2680
2794
  console.log("ENTER:", "JSMultiLineComment");
@@ -2698,7 +2812,7 @@ var require_parser = __commonJS({
2698
2812
  return CoffeeSingleLineComment$0(state);
2699
2813
  }
2700
2814
  }
2701
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R11, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2815
+ var CoffeeMultiLineComment$0 = $T($S($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R11, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2702
2816
  return ["/*", value[1], "*/"];
2703
2817
  });
2704
2818
  function CoffeeMultiLineComment(state) {
@@ -2710,7 +2824,7 @@ var require_parser = __commonJS({
2710
2824
  return CoffeeMultiLineComment$0(state);
2711
2825
  }
2712
2826
  }
2713
- var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($R19, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L121, fail, 'InlineComment "*/"'));
2827
+ var InlineComment$0 = $S($EXPECT($L122, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'InlineComment "*/"')), $EXPECT($R19, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L123, fail, 'InlineComment "*/"'));
2714
2828
  function InlineComment(state) {
2715
2829
  if (state.verbose)
2716
2830
  console.log("ENTER:", "InlineComment");
@@ -2760,7 +2874,7 @@ var require_parser = __commonJS({
2760
2874
  return __$0(state);
2761
2875
  }
2762
2876
  }
2763
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2877
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2764
2878
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
2765
2879
  return [";", value];
2766
2880
  });
@@ -2795,7 +2909,7 @@ var require_parser = __commonJS({
2795
2909
  return JSXElement$0(state) || JSXElement$1(state);
2796
2910
  }
2797
2911
  }
2798
- var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
2912
+ var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L125, fail, 'JSXSelfClosingElement "/>"'));
2799
2913
  function JSXSelfClosingElement(state) {
2800
2914
  if (state.verbose)
2801
2915
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -2805,7 +2919,7 @@ var require_parser = __commonJS({
2805
2919
  return JSXSelfClosingElement$0(state);
2806
2920
  }
2807
2921
  }
2808
- var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
2922
+ var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
2809
2923
  function JSXOpeningElement(state) {
2810
2924
  if (state.verbose)
2811
2925
  console.log("ENTER:", "JSXOpeningElement");
@@ -2815,7 +2929,7 @@ var require_parser = __commonJS({
2815
2929
  return JSXOpeningElement$0(state);
2816
2930
  }
2817
2931
  }
2818
- var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
2932
+ var JSXClosingElement$0 = $S($EXPECT($L126, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
2819
2933
  function JSXClosingElement(state) {
2820
2934
  if (state.verbose)
2821
2935
  console.log("ENTER:", "JSXClosingElement");
@@ -2825,7 +2939,7 @@ var require_parser = __commonJS({
2825
2939
  return JSXClosingElement$0(state);
2826
2940
  }
2827
2941
  }
2828
- var JSXFragment$0 = $S($EXPECT($L125, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L126, fail, 'JSXFragment "</>"'));
2942
+ var JSXFragment$0 = $S($EXPECT($L127, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L128, fail, 'JSXFragment "</>"'));
2829
2943
  function JSXFragment(state) {
2830
2944
  if (state.verbose)
2831
2945
  console.log("ENTER:", "JSXFragment");
@@ -2835,7 +2949,7 @@ var require_parser = __commonJS({
2835
2949
  return JSXFragment$0(state);
2836
2950
  }
2837
2951
  }
2838
- var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L26, fail, 'JSXElementName "."'), JSXIdentifierName))));
2952
+ var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L24, fail, 'JSXElementName "."'), JSXIdentifierName))));
2839
2953
  function JSXElementName(state) {
2840
2954
  if (state.verbose)
2841
2955
  console.log("ENTER:", "JSXElementName");
@@ -2865,7 +2979,7 @@ var require_parser = __commonJS({
2865
2979
  return JSXAttributes$0(state);
2866
2980
  }
2867
2981
  }
2868
- var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2982
+ var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L32, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2869
2983
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
2870
2984
  function JSXAttribute(state) {
2871
2985
  if (state.tokenize) {
@@ -2884,7 +2998,7 @@ var require_parser = __commonJS({
2884
2998
  return JSXAttributeName$0(state);
2885
2999
  }
2886
3000
  }
2887
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3001
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2888
3002
  function JSXAttributeInitializer(state) {
2889
3003
  if (state.verbose)
2890
3004
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -2937,7 +3051,7 @@ var require_parser = __commonJS({
2937
3051
  return JSXText$0(state);
2938
3052
  }
2939
3053
  }
2940
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3054
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L32, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2941
3055
  function JSXChildExpression(state) {
2942
3056
  if (state.verbose)
2943
3057
  console.log("ENTER:", "JSXChildExpression");
@@ -2947,7 +3061,7 @@ var require_parser = __commonJS({
2947
3061
  return JSXChildExpression$0(state);
2948
3062
  }
2949
3063
  }
2950
- var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
3064
+ var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
2951
3065
  return { "ts": true, "children": value };
2952
3066
  });
2953
3067
  var TypeDeclaration$1 = $T($S($EXPECT($R28, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
@@ -3005,7 +3119,7 @@ var require_parser = __commonJS({
3005
3119
  return InterfaceProperty$0(state);
3006
3120
  }
3007
3121
  }
3008
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
3122
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3009
3123
  var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
3010
3124
  var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3011
3125
  return ";";
@@ -3020,7 +3134,7 @@ var require_parser = __commonJS({
3020
3134
  return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
3021
3135
  }
3022
3136
  }
3023
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L127, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3137
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L129, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L25, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L26, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3024
3138
  function TypeIndexSignature(state) {
3025
3139
  if (state.verbose)
3026
3140
  console.log("ENTER:", "TypeIndexSignature");
@@ -3031,7 +3145,7 @@ var require_parser = __commonJS({
3031
3145
  }
3032
3146
  }
3033
3147
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3034
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3148
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3035
3149
  function TypeIndex(state) {
3036
3150
  if (state.tokenize) {
3037
3151
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3051,7 +3165,7 @@ var require_parser = __commonJS({
3051
3165
  return TypeSuffix$0(state);
3052
3166
  }
3053
3167
  }
3054
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L128, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3168
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L130, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3055
3169
  return { "ts": true, "children": value };
3056
3170
  });
3057
3171
  function ReturnTypeSuffix(state) {
@@ -3063,7 +3177,7 @@ var require_parser = __commonJS({
3063
3177
  return ReturnTypeSuffix$0(state);
3064
3178
  }
3065
3179
  }
3066
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3180
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3067
3181
  function TypePredicate(state) {
3068
3182
  if (state.verbose)
3069
3183
  console.log("ENTER:", "TypePredicate");
@@ -3113,9 +3227,9 @@ var require_parser = __commonJS({
3113
3227
  return TypeUnarySuffix$0(state);
3114
3228
  }
3115
3229
  }
3116
- var TypeUnaryOp$0 = $EXPECT($L129, fail, 'TypeUnaryOp "keyof"');
3117
- var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
3118
- var TypeUnaryOp$2 = $EXPECT($L130, fail, 'TypeUnaryOp "infer"');
3230
+ var TypeUnaryOp$0 = $EXPECT($L131, fail, 'TypeUnaryOp "keyof"');
3231
+ var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3232
+ var TypeUnaryOp$2 = $EXPECT($L132, fail, 'TypeUnaryOp "infer"');
3119
3233
  function TypeUnaryOp(state) {
3120
3234
  if (state.tokenize) {
3121
3235
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3123,7 +3237,7 @@ var require_parser = __commonJS({
3123
3237
  return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3124
3238
  }
3125
3239
  }
3126
- var TypeIndexedAccess$0 = $S(__, $EXPECT($L24, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L25, fail, 'TypeIndexedAccess "]"'));
3240
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L25, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L26, fail, 'TypeIndexedAccess "]"'));
3127
3241
  function TypeIndexedAccess(state) {
3128
3242
  if (state.verbose)
3129
3243
  console.log("ENTER:", "TypeIndexedAccess");
@@ -3136,7 +3250,7 @@ var require_parser = __commonJS({
3136
3250
  var TypePrimary$0 = InterfaceBlock;
3137
3251
  var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
3138
3252
  var TypePrimary$2 = $S($Q(_), FunctionType);
3139
- var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L26, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
3253
+ var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L24, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
3140
3254
  var TypePrimary$4 = $S($Q(_), TypeLiteral);
3141
3255
  function TypePrimary(state) {
3142
3256
  if (state.tokenize) {
@@ -3156,8 +3270,8 @@ var require_parser = __commonJS({
3156
3270
  }
3157
3271
  }
3158
3272
  var TypeLiteral$0 = Literal;
3159
- var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3160
- var TypeLiteral$2 = $EXPECT($L131, fail, 'TypeLiteral "[]"');
3273
+ var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3274
+ var TypeLiteral$2 = $EXPECT($L133, fail, 'TypeLiteral "[]"');
3161
3275
  function TypeLiteral(state) {
3162
3276
  if (state.tokenize) {
3163
3277
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3165,8 +3279,8 @@ var require_parser = __commonJS({
3165
3279
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3166
3280
  }
3167
3281
  }
3168
- var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3169
- var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3282
+ var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3283
+ var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3170
3284
  function TypeBinaryOp(state) {
3171
3285
  if (state.tokenize) {
3172
3286
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3184,7 +3298,7 @@ var require_parser = __commonJS({
3184
3298
  return FunctionType$0(state);
3185
3299
  }
3186
3300
  }
3187
- 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 ">"'));
3301
+ var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
3188
3302
  function TypeArguments(state) {
3189
3303
  if (state.verbose)
3190
3304
  console.log("ENTER:", "TypeArguments");
@@ -3194,7 +3308,7 @@ var require_parser = __commonJS({
3194
3308
  return TypeArguments$0(state);
3195
3309
  }
3196
3310
  }
3197
- 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 ">"'));
3311
+ var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
3198
3312
  function TypeParameters(state) {
3199
3313
  if (state.verbose)
3200
3314
  console.log("ENTER:", "TypeParameters");
@@ -3225,8 +3339,8 @@ var require_parser = __commonJS({
3225
3339
  }
3226
3340
  }
3227
3341
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3228
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
3229
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3342
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3343
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3230
3344
  return ",";
3231
3345
  });
3232
3346
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3291,7 +3405,19 @@ var require_parser = __commonJS({
3291
3405
  return EOF$0(state);
3292
3406
  }
3293
3407
  }
3294
- var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
3408
+ var Debugger$0 = $TV($EXPECT($L31, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3409
+ debugger;
3410
+ });
3411
+ function Debugger(state) {
3412
+ if (state.verbose)
3413
+ console.log("ENTER:", "Debugger");
3414
+ if (state.tokenize) {
3415
+ return $TOKEN("Debugger", state, Debugger$0(state));
3416
+ } else {
3417
+ return Debugger$0(state);
3418
+ }
3419
+ }
3420
+ var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
3295
3421
  return "(";
3296
3422
  });
3297
3423
  function InsertOpenParen(state) {
@@ -3303,7 +3429,7 @@ var require_parser = __commonJS({
3303
3429
  return InsertOpenParen$0(state);
3304
3430
  }
3305
3431
  }
3306
- var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
3432
+ var InsertCloseParen$0 = $T($EXPECT($L31, fail, 'InsertCloseParen ""'), function(value) {
3307
3433
  return ")";
3308
3434
  });
3309
3435
  function InsertCloseParen(state) {
@@ -3315,7 +3441,7 @@ var require_parser = __commonJS({
3315
3441
  return InsertCloseParen$0(state);
3316
3442
  }
3317
3443
  }
3318
- var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
3444
+ var InsertOpenBrace$0 = $T($EXPECT($L31, fail, 'InsertOpenBrace ""'), function(value) {
3319
3445
  return " {";
3320
3446
  });
3321
3447
  function InsertOpenBrace(state) {
@@ -3327,7 +3453,7 @@ var require_parser = __commonJS({
3327
3453
  return InsertOpenBrace$0(state);
3328
3454
  }
3329
3455
  }
3330
- var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
3456
+ var InsertCloseBrace$0 = $T($EXPECT($L31, fail, 'InsertCloseBrace ""'), function(value) {
3331
3457
  return "}";
3332
3458
  });
3333
3459
  function InsertCloseBrace(state) {
@@ -3339,7 +3465,7 @@ var require_parser = __commonJS({
3339
3465
  return InsertCloseBrace$0(state);
3340
3466
  }
3341
3467
  }
3342
- var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3468
+ var InsertNewline$0 = $TV($EXPECT($L31, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3343
3469
  return "\n";
3344
3470
  });
3345
3471
  function InsertNewline(state) {
@@ -3351,7 +3477,7 @@ var require_parser = __commonJS({
3351
3477
  return InsertNewline$0(state);
3352
3478
  }
3353
3479
  }
3354
- var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3480
+ var InsertIndent$0 = $TV($EXPECT($L31, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3355
3481
  return "".padStart(global.currentIndent * 2);
3356
3482
  });
3357
3483
  function InsertIndent(state) {
@@ -3363,7 +3489,7 @@ var require_parser = __commonJS({
3363
3489
  return InsertIndent$0(state);
3364
3490
  }
3365
3491
  }
3366
- var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
3492
+ var InsertSpace$0 = $T($EXPECT($L31, fail, 'InsertSpace ""'), function(value) {
3367
3493
  return " ";
3368
3494
  });
3369
3495
  function InsertSpace(state) {
@@ -3375,7 +3501,7 @@ var require_parser = __commonJS({
3375
3501
  return InsertSpace$0(state);
3376
3502
  }
3377
3503
  }
3378
- var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
3504
+ var InsertDot$0 = $T($EXPECT($L31, fail, 'InsertDot ""'), function(value) {
3379
3505
  return ".";
3380
3506
  });
3381
3507
  function InsertDot(state) {
@@ -3387,7 +3513,7 @@ var require_parser = __commonJS({
3387
3513
  return InsertDot$0(state);
3388
3514
  }
3389
3515
  }
3390
- var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
3516
+ var InsertBreak$0 = $T($EXPECT($L31, fail, 'InsertBreak ""'), function(value) {
3391
3517
  return "break;";
3392
3518
  });
3393
3519
  function InsertBreak(state) {
@@ -3399,7 +3525,7 @@ var require_parser = __commonJS({
3399
3525
  return InsertBreak$0(state);
3400
3526
  }
3401
3527
  }
3402
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3528
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L31, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3403
3529
  var directives = $2;
3404
3530
  global.currentIndent = 0;
3405
3531
  global.indentLevels = [0];
@@ -3419,7 +3545,7 @@ var require_parser = __commonJS({
3419
3545
  return Init$0(state);
3420
3546
  }
3421
3547
  }
3422
- var Indent$0 = $TV($Q($C($EXPECT($L132, fail, 'Indent " "'), $EXPECT($L133, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3548
+ var Indent$0 = $TV($Q($C($EXPECT($L134, fail, 'Indent " "'), $EXPECT($L135, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3423
3549
  return $1.length;
3424
3550
  });
3425
3551
  function Indent(state) {
@@ -3431,7 +3557,7 @@ var require_parser = __commonJS({
3431
3557
  return Indent$0(state);
3432
3558
  }
3433
3559
  }
3434
- var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3560
+ var PushIndent$0 = $TV($EXPECT($L31, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3435
3561
  global.currentIndent++;
3436
3562
  if (global.verbose) {
3437
3563
  console.log("pushing indent", global.currentIndent);
@@ -3448,7 +3574,7 @@ var require_parser = __commonJS({
3448
3574
  return PushIndent$0(state);
3449
3575
  }
3450
3576
  }
3451
- var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3577
+ var PopIndent$0 = $TV($EXPECT($L31, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3452
3578
  if (global.verbose) {
3453
3579
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3454
3580
  }
@@ -3490,6 +3616,31 @@ var require_parser = __commonJS({
3490
3616
  return Nested$0(state);
3491
3617
  }
3492
3618
  }
3619
+ var NestedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
3620
+ var eos = $1;
3621
+ var indent = $2;
3622
+ const currentIndent = global.indentLevels[global.indentLevels.length - 1];
3623
+ if (global.verbose) {
3624
+ console.log("global indent", global.currentIndent);
3625
+ console.log("Indented", indent, currentIndent);
3626
+ }
3627
+ if (indent !== currentIndent + 1) {
3628
+ if (global.verbose) {
3629
+ console.log("skipped nested");
3630
+ }
3631
+ return $skip;
3632
+ }
3633
+ return [eos, "".padStart(indent * 2)];
3634
+ });
3635
+ function NestedFurther(state) {
3636
+ if (state.verbose)
3637
+ console.log("ENTER:", "NestedFurther");
3638
+ if (state.tokenize) {
3639
+ return $TOKEN("NestedFurther", state, NestedFurther$0(state));
3640
+ } else {
3641
+ return NestedFurther$0(state);
3642
+ }
3643
+ }
3493
3644
  module2.exports = {
3494
3645
  parse: parse2
3495
3646
  };
@@ -3500,11 +3651,18 @@ var require_parser = __commonJS({
3500
3651
  var require_generate = __commonJS({
3501
3652
  "source/generate.coffee"(exports2, module2) {
3502
3653
  var gen2;
3654
+ var prune;
3503
3655
  gen2 = function(node, options) {
3656
+ var $loc, token;
3504
3657
  if (node === null || node === void 0) {
3505
3658
  return "";
3506
3659
  }
3507
3660
  if (typeof node === "string") {
3661
+ if (options != null) {
3662
+ if (typeof options.updateSourceMap === "function") {
3663
+ options.updateSourceMap(node);
3664
+ }
3665
+ }
3508
3666
  return node;
3509
3667
  }
3510
3668
  if (Array.isArray(node)) {
@@ -3513,19 +3671,55 @@ var require_generate = __commonJS({
3513
3671
  }).join("");
3514
3672
  }
3515
3673
  if (typeof node === "object") {
3516
- if ((options != null ? options.js : void 0) && node.ts) {
3674
+ if (options.js && node.ts) {
3517
3675
  return "";
3518
3676
  }
3677
+ if (node.$loc != null) {
3678
+ ({ token, $loc } = node);
3679
+ if (options != null) {
3680
+ if (typeof options.updateSourceMap === "function") {
3681
+ options.updateSourceMap(token, $loc.pos);
3682
+ }
3683
+ }
3684
+ return token;
3685
+ }
3519
3686
  if (!node.children) {
3520
3687
  throw new Error("Unknown node", JSON.stringify(node));
3521
3688
  }
3522
- return node.children.map(function(child) {
3523
- return gen2(child, options);
3524
- }).join("");
3689
+ return gen2(node.children, options);
3525
3690
  }
3526
3691
  throw new Error("Unknown node", JSON.stringify(node));
3527
3692
  };
3528
3693
  module2.exports = gen2;
3694
+ prune = function(node) {
3695
+ var a;
3696
+ if (node === null || node === void 0) {
3697
+ return;
3698
+ }
3699
+ if (node.length === 0) {
3700
+ return;
3701
+ }
3702
+ if (Array.isArray(node)) {
3703
+ a = node.map(function(n) {
3704
+ return prune(n);
3705
+ }).filter(function(n) {
3706
+ return !!n;
3707
+ });
3708
+ if (a.length > 1) {
3709
+ return a;
3710
+ }
3711
+ if (a.length === 1) {
3712
+ return a[0];
3713
+ }
3714
+ return;
3715
+ }
3716
+ if (node.children != null) {
3717
+ node.children = prune(node.children);
3718
+ return node;
3719
+ }
3720
+ return node;
3721
+ };
3722
+ gen2.prune = prune;
3529
3723
  }
3530
3724
  });
3531
3725
 
@@ -3537,7 +3731,9 @@ gen = require_generate();
3537
3731
  module.exports = {
3538
3732
  parse,
3539
3733
  compile: function(src, options) {
3540
- return gen(parse(src), options);
3734
+ return gen(parse(src, {
3735
+ filename: options != null ? options.filename : void 0
3736
+ }), options);
3541
3737
  },
3542
3738
  generate: gen
3543
3739
  };