@danielx/civet 0.4.3 → 0.4.5

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 (4) hide show
  1. package/README.md +5 -2
  2. package/dist/browser.js +550 -382
  3. package/dist/main.js +550 -382
  4. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -504,7 +504,6 @@ var require_parser = __commonJS({
504
504
  PropertyName,
505
505
  MethodDefinition,
506
506
  MethodModifier,
507
- ConstructorShorthand,
508
507
  MethodSignature,
509
508
  ClassElementName,
510
509
  PrivateIdentifier,
@@ -534,6 +533,7 @@ var require_parser = __commonJS({
534
533
  NestedCaseClauses,
535
534
  NestedCaseClause,
536
535
  CaseClause,
536
+ CaseExpressionList,
537
537
  ImpliedColon,
538
538
  TryStatement,
539
539
  CatchClause,
@@ -579,12 +579,12 @@ var require_parser = __commonJS({
579
579
  OctalIntegerLiteral,
580
580
  HexLiteral,
581
581
  StringLiteral,
582
- DoubleStringCharacter,
583
- SingleStringCharacter,
582
+ BasicStringLiteral,
583
+ DoubleStringCharacters,
584
+ SingleStringCharacters,
584
585
  TripleDoubleStringCharacters,
585
586
  TripleSingleStringCharacters,
586
587
  CoffeeStringSubstitution,
587
- CoffeeSubstitutionStart,
588
588
  RegularExpressionLiteral,
589
589
  RegularExpressionBody,
590
590
  RegExpCharacter,
@@ -592,6 +592,7 @@ var require_parser = __commonJS({
592
592
  TemplateLiteral,
593
593
  TemplateSubstitution,
594
594
  TemplateCharacters,
595
+ TemplateBlockCharacters,
595
596
  ReservedWord,
596
597
  Comment,
597
598
  SingleLineComment,
@@ -612,13 +613,18 @@ var require_parser = __commonJS({
612
613
  As,
613
614
  Async,
614
615
  Await,
616
+ Case,
615
617
  Catch,
616
618
  Class,
617
619
  CloseBrace,
618
620
  CloseBracket,
619
621
  CloseParen,
622
+ CoffeeSubstitutionStart,
620
623
  Colon,
624
+ ConstructorShorthand,
625
+ Default,
621
626
  Dot,
627
+ DoubleQuote,
622
628
  Else,
623
629
  Equals,
624
630
  Export,
@@ -639,7 +645,10 @@ var require_parser = __commonJS({
639
645
  QuestionMark,
640
646
  Return,
641
647
  Semicolon,
648
+ SingleQuote,
649
+ Star,
642
650
  Static,
651
+ SubstitutionStart,
643
652
  Switch,
644
653
  Target,
645
654
  TripleDoubleQuote,
@@ -649,6 +658,7 @@ var require_parser = __commonJS({
649
658
  Unless,
650
659
  Var,
651
660
  When,
661
+ Yield,
652
662
  JSXElement,
653
663
  JSXSelfClosingElement,
654
664
  JSXOpeningElement,
@@ -730,130 +740,130 @@ var require_parser = __commonJS({
730
740
  var $L1 = $L("");
731
741
  var $L2 = $L("++");
732
742
  var $L3 = $L("--");
733
- var $L4 = $L("yield");
734
- var $L5 = $L("*");
735
- var $L6 = $L("=>");
736
- var $L7 = $L("<");
737
- var $L8 = $L("extends");
738
- var $L9 = $L("this");
739
- var $L10 = $L("#");
740
- var $L11 = $L("@");
741
- var $L12 = $L("super");
742
- var $L13 = $L("import");
743
- var $L14 = $L("!");
744
- var $L15 = $L("::");
745
- var $L16 = $L("super[");
746
- var $L17 = $L("import.meta");
747
- var $L18 = $L(")");
748
- var $L19 = $L("...");
749
- var $L20 = $L("->");
750
- var $L21 = $L("null");
751
- var $L22 = $L("true");
752
- var $L23 = $L("false");
753
- var $L24 = $L(",");
754
- var $L25 = $L("]");
755
- var $L26 = $L("}");
756
- var $L27 = $L("**=");
757
- var $L28 = $L("*=");
758
- var $L29 = $L("/=");
759
- var $L30 = $L("%=");
760
- var $L31 = $L("+=");
761
- var $L32 = $L("-=");
762
- var $L33 = $L("<<=");
763
- var $L34 = $L(">>>=");
764
- var $L35 = $L(">>=");
765
- var $L36 = $L("&&=");
766
- var $L37 = $L("&=");
767
- var $L38 = $L("^=");
768
- var $L39 = $L("||=");
769
- var $L40 = $L("|=");
770
- var $L41 = $L("??=");
771
- var $L42 = $L("?=");
772
- var $L43 = $L("=");
773
- var $L44 = $L("**");
774
- var $L45 = $L("/");
775
- var $L46 = $L("%");
776
- var $L47 = $L("+");
777
- var $L48 = $L("-");
778
- var $L49 = $L("<=");
779
- var $L50 = $L(">=");
780
- var $L51 = $L("<<");
781
- var $L52 = $L(">>>");
782
- var $L53 = $L(">>");
783
- var $L54 = $L(">");
784
- var $L55 = $L("!==");
785
- var $L56 = $L("!=");
786
- var $L57 = $L("is");
787
- var $L58 = $L("===");
788
- var $L59 = $L("==");
789
- var $L60 = $L("and");
790
- var $L61 = $L("&&");
791
- var $L62 = $L("or");
792
- var $L63 = $L("||");
793
- var $L64 = $L("??");
794
- var $L65 = $L("instanceof");
795
- var $L66 = $L("in");
796
- var $L67 = $L("&");
797
- var $L68 = $L("^");
798
- var $L69 = $L("|");
799
- var $L70 = $L("delete");
800
- var $L71 = $L("void");
801
- var $L72 = $L("typeof");
802
- var $L73 = $L(";");
803
- var $L74 = $L("do");
804
- var $L75 = $L("while");
805
- var $L76 = $L("until");
806
- var $L77 = $L("case");
807
- var $L78 = $L("default");
808
- var $L79 = $L("finally");
809
- var $L80 = $L("break");
810
- var $L81 = $L("continue");
811
- var $L82 = $L("debugger");
812
- var $L83 = $L("throw");
813
- var $L84 = $L("import type");
814
- var $L85 = $L(":=");
815
- var $L86 = $L('"');
816
- var $L87 = $L("'");
817
- var $L88 = $L("#{");
818
- var $L89 = $L("${");
819
- var $L90 = $L("/*");
820
- var $L91 = $L("*/");
821
- var $L92 = $L("###");
822
- var $L93 = $L("as");
823
- var $L94 = $L("async");
824
- var $L95 = $L("await");
825
- var $L96 = $L("catch");
826
- var $L97 = $L("class");
827
- var $L98 = $L(":");
828
- var $L99 = $L(".");
829
- var $L100 = $L("else");
830
- var $L101 = $L("export");
831
- var $L102 = $L("for");
832
- var $L103 = $L("from");
833
- var $L104 = $L("function");
834
- var $L105 = $L("get");
835
- var $L106 = $L("set");
836
- var $L107 = $L("if");
837
- var $L108 = $L("let");
838
- var $L109 = $L("const");
839
- var $L110 = $L("loop");
840
- var $L111 = $L("new");
841
- var $L112 = $L("of");
842
- var $L113 = $L("{");
843
- var $L114 = $L("[");
844
- var $L115 = $L("(");
845
- var $L116 = $L("?");
846
- var $L117 = $L("return");
847
- var $L118 = $L("static");
848
- var $L119 = $L("switch");
849
- var $L120 = $L("target");
850
- var $L121 = $L('"""');
851
- var $L122 = $L("'''");
852
- var $L123 = $L("```");
853
- var $L124 = $L("try");
854
- var $L125 = $L("unless");
855
- var $L126 = $L("var");
856
- var $L127 = $L("when");
743
+ var $L4 = $L("=>");
744
+ var $L5 = $L("<");
745
+ var $L6 = $L("extends");
746
+ var $L7 = $L("this");
747
+ var $L8 = $L("#");
748
+ var $L9 = $L("@");
749
+ var $L10 = $L("super");
750
+ var $L11 = $L("import");
751
+ var $L12 = $L("!");
752
+ var $L13 = $L("::");
753
+ var $L14 = $L("super[");
754
+ var $L15 = $L("import.meta");
755
+ var $L16 = $L(")");
756
+ var $L17 = $L("...");
757
+ var $L18 = $L("->");
758
+ var $L19 = $L("null");
759
+ var $L20 = $L("true");
760
+ var $L21 = $L("false");
761
+ var $L22 = $L(",");
762
+ var $L23 = $L("]");
763
+ var $L24 = $L("}");
764
+ var $L25 = $L("**=");
765
+ var $L26 = $L("*=");
766
+ var $L27 = $L("/=");
767
+ var $L28 = $L("%=");
768
+ var $L29 = $L("+=");
769
+ var $L30 = $L("-=");
770
+ var $L31 = $L("<<=");
771
+ var $L32 = $L(">>>=");
772
+ var $L33 = $L(">>=");
773
+ var $L34 = $L("&&=");
774
+ var $L35 = $L("&=");
775
+ var $L36 = $L("^=");
776
+ var $L37 = $L("||=");
777
+ var $L38 = $L("|=");
778
+ var $L39 = $L("??=");
779
+ var $L40 = $L("?=");
780
+ var $L41 = $L("=");
781
+ var $L42 = $L("**");
782
+ var $L43 = $L("*");
783
+ var $L44 = $L("/");
784
+ var $L45 = $L("%");
785
+ var $L46 = $L("+");
786
+ var $L47 = $L("-");
787
+ var $L48 = $L("<=");
788
+ var $L49 = $L(">=");
789
+ var $L50 = $L("<<");
790
+ var $L51 = $L(">>>");
791
+ var $L52 = $L(">>");
792
+ var $L53 = $L(">");
793
+ var $L54 = $L("!==");
794
+ var $L55 = $L("!=");
795
+ var $L56 = $L("is");
796
+ var $L57 = $L("===");
797
+ var $L58 = $L("==");
798
+ var $L59 = $L("and");
799
+ var $L60 = $L("&&");
800
+ var $L61 = $L("or");
801
+ var $L62 = $L("||");
802
+ var $L63 = $L("??");
803
+ var $L64 = $L("instanceof");
804
+ var $L65 = $L("in");
805
+ var $L66 = $L("&");
806
+ var $L67 = $L("^");
807
+ var $L68 = $L("|");
808
+ var $L69 = $L("delete");
809
+ var $L70 = $L("void");
810
+ var $L71 = $L("typeof");
811
+ var $L72 = $L(";");
812
+ var $L73 = $L("do");
813
+ var $L74 = $L("while");
814
+ var $L75 = $L("until");
815
+ var $L76 = $L("finally");
816
+ var $L77 = $L("break");
817
+ var $L78 = $L("continue");
818
+ var $L79 = $L("debugger");
819
+ var $L80 = $L("throw");
820
+ var $L81 = $L("import type");
821
+ var $L82 = $L("default");
822
+ var $L83 = $L(":=");
823
+ var $L84 = $L("/*");
824
+ var $L85 = $L("*/");
825
+ var $L86 = $L("###");
826
+ var $L87 = $L("as");
827
+ var $L88 = $L("async");
828
+ var $L89 = $L("await");
829
+ var $L90 = $L("case");
830
+ var $L91 = $L("catch");
831
+ var $L92 = $L("class");
832
+ var $L93 = $L("#{");
833
+ var $L94 = $L(":");
834
+ var $L95 = $L(".");
835
+ var $L96 = $L('"');
836
+ var $L97 = $L("else");
837
+ var $L98 = $L("export");
838
+ var $L99 = $L("for");
839
+ var $L100 = $L("from");
840
+ var $L101 = $L("function");
841
+ var $L102 = $L("get");
842
+ var $L103 = $L("set");
843
+ var $L104 = $L("if");
844
+ var $L105 = $L("let");
845
+ var $L106 = $L("const");
846
+ var $L107 = $L("loop");
847
+ var $L108 = $L("new");
848
+ var $L109 = $L("of");
849
+ var $L110 = $L("{");
850
+ var $L111 = $L("[");
851
+ var $L112 = $L("(");
852
+ var $L113 = $L("?");
853
+ var $L114 = $L("return");
854
+ var $L115 = $L("'");
855
+ var $L116 = $L("static");
856
+ var $L117 = $L("${");
857
+ var $L118 = $L("switch");
858
+ var $L119 = $L("target");
859
+ var $L120 = $L('"""');
860
+ var $L121 = $L("'''");
861
+ var $L122 = $L("```");
862
+ var $L123 = $L("try");
863
+ var $L124 = $L("unless");
864
+ var $L125 = $L("var");
865
+ var $L126 = $L("when");
866
+ var $L127 = $L("yield");
857
867
  var $L128 = $L("/>");
858
868
  var $L129 = $L("</");
859
869
  var $L130 = $L("<>");
@@ -878,21 +888,21 @@ var require_parser = __commonJS({
878
888
  var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
879
889
  var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
880
890
  var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
881
- var $R9 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
882
- var $R10 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
891
+ var $R9 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
892
+ var $R10 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
883
893
  var $R11 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
884
894
  var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
885
895
  var $R13 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
886
896
  var $R14 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
887
897
  var $R15 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
888
898
  var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
889
- var $R17 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
890
- var $R18 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
891
- var $R19 = $R(new RegExp(".", "suy"));
892
- var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
893
- var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
894
- var $R22 = $R(new RegExp("[ \\t]+", "suy"));
895
- var $R23 = $R(new RegExp("[\\t ]+", "suy"));
899
+ var $R17 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
900
+ var $R18 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
901
+ var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
902
+ var $R20 = $R(new RegExp(".", "suy"));
903
+ var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
904
+ var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
905
+ var $R23 = $R(new RegExp("[ \\t]+", "suy"));
896
906
  var $R24 = $R(new RegExp("[\\s]+", "suy"));
897
907
  var $R25 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
898
908
  var $R26 = $R(new RegExp("\\s", "suy"));
@@ -1005,8 +1015,7 @@ var require_parser = __commonJS({
1005
1015
  }
1006
1016
  var ApplicationStart$0 = $TS($S($N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
1007
1017
  var spacing = $2;
1008
- spacing[0].token = spacing[0].token.replace(/^ ?/, "(");
1009
- return spacing;
1018
+ return module2.insertTrimmingSpace(spacing, "(");
1010
1019
  });
1011
1020
  var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen);
1012
1021
  function ApplicationStart(state) {
@@ -1131,7 +1140,7 @@ var require_parser = __commonJS({
1131
1140
  return AwaitExpression$0(state);
1132
1141
  }
1133
1142
  }
1134
- var YieldExpression$0 = $S($EXPECT($L4, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L5, fail, 'YieldExpression "*"'))), AssignmentExpression);
1143
+ var YieldExpression$0 = $S(Yield, $E($S($Q(TrailingComment), Star)), AssignmentExpression);
1135
1144
  function YieldExpression(state) {
1136
1145
  if (state.verbose)
1137
1146
  console.log("ENTER:", "YieldExpression");
@@ -1150,7 +1159,7 @@ var require_parser = __commonJS({
1150
1159
  return ArrowFunction$0(state) || ArrowFunction$1(state);
1151
1160
  }
1152
1161
  }
1153
- var FatArrow$0 = $TS($S(__, $EXPECT($L6, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1162
+ var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1154
1163
  var ws = $1;
1155
1164
  if (!ws.length)
1156
1165
  return " =>";
@@ -1246,10 +1255,10 @@ var require_parser = __commonJS({
1246
1255
  return ClassHeritage$0(state);
1247
1256
  }
1248
1257
  }
1249
- var ExtendsToken$0 = $TV($EXPECT($L7, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1258
+ var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1250
1259
  return { $loc, token: "extends" };
1251
1260
  });
1252
- var ExtendsToken$1 = $TV($EXPECT($L8, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1261
+ var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1253
1262
  return { $loc, token: $1 };
1254
1263
  });
1255
1264
  function ExtendsToken(state) {
@@ -1319,11 +1328,11 @@ var require_parser = __commonJS({
1319
1328
  return FieldDefinition$0(state) || FieldDefinition$1(state);
1320
1329
  }
1321
1330
  }
1322
- var This$0 = $TV($EXPECT($L9, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1331
+ var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1323
1332
  return { $loc, token: $1 };
1324
1333
  });
1325
- var This$1 = $S(AtAccessor, $S($E($EXPECT($L10, fail, 'This "#"')), IdentifierName));
1326
- var This$2 = $TV($EXPECT($L11, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1334
+ var This$1 = $S(AtAccessor, $S($E($EXPECT($L8, fail, 'This "#"')), IdentifierName));
1335
+ var This$2 = $TV($EXPECT($L9, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1327
1336
  return { $loc, token: "this" };
1328
1337
  });
1329
1338
  function This(state) {
@@ -1333,7 +1342,7 @@ var require_parser = __commonJS({
1333
1342
  return This$0(state) || This$1(state) || This$2(state);
1334
1343
  }
1335
1344
  }
1336
- var AtAccessor$0 = $TV($EXPECT($L11, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1345
+ var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1337
1346
  return { $loc, token: "this." };
1338
1347
  });
1339
1348
  function AtAccessor(state) {
@@ -1364,8 +1373,8 @@ var require_parser = __commonJS({
1364
1373
  return NewExpression$0(state);
1365
1374
  }
1366
1375
  }
1367
- var CallExpression$0 = $S($EXPECT($L12, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1368
- var CallExpression$1 = $S($EXPECT($L13, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1376
+ var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1377
+ var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1369
1378
  var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
1370
1379
  function CallExpression(state) {
1371
1380
  if (state.tokenize) {
@@ -1394,7 +1403,7 @@ var require_parser = __commonJS({
1394
1403
  return OptionalShorthand$0(state);
1395
1404
  }
1396
1405
  }
1397
- var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
1406
+ var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
1398
1407
  return { "ts": true, "children": value };
1399
1408
  });
1400
1409
  function NonNullAssertion(state) {
@@ -1428,7 +1437,7 @@ var require_parser = __commonJS({
1428
1437
  }
1429
1438
  var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
1430
1439
  var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
1431
- var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L15, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1440
+ var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1432
1441
  var id = $3;
1433
1442
  if (id)
1434
1443
  return [".prototype.", id];
@@ -1452,7 +1461,7 @@ var require_parser = __commonJS({
1452
1461
  return PropertyAccess$0(state);
1453
1462
  }
1454
1463
  }
1455
- var SuperProperty$0 = $S($EXPECT($L16, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1464
+ var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1456
1465
  function SuperProperty(state) {
1457
1466
  if (state.verbose)
1458
1467
  console.log("ENTER:", "SuperProperty");
@@ -1463,7 +1472,7 @@ var require_parser = __commonJS({
1463
1472
  }
1464
1473
  }
1465
1474
  var MetaProperty$0 = $S(New, Dot, Target);
1466
- var MetaProperty$1 = $TV($EXPECT($L17, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1475
+ var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1467
1476
  return { $loc, token: $1 };
1468
1477
  });
1469
1478
  function MetaProperty(state) {
@@ -1495,8 +1504,8 @@ var require_parser = __commonJS({
1495
1504
  }
1496
1505
  }
1497
1506
  var ParameterElementDelimiter$0 = $S($Q(_), Comma);
1498
- var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L18, fail, 'ParameterElementDelimiter ")"')));
1499
- var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L18, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
1507
+ var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
1508
+ var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
1500
1509
  return { $loc, token: "," };
1501
1510
  });
1502
1511
  var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -1583,7 +1592,7 @@ var require_parser = __commonJS({
1583
1592
  return BindingProperty$0(state) || BindingProperty$1(state);
1584
1593
  }
1585
1594
  }
1586
- var BindingRestProperty$0 = $S($EXPECT($L19, fail, 'BindingRestProperty "..."'), BindingIdentifier);
1595
+ var BindingRestProperty$0 = $S($EXPECT($L17, fail, 'BindingRestProperty "..."'), BindingIdentifier);
1587
1596
  function BindingRestProperty(state) {
1588
1597
  if (state.verbose)
1589
1598
  console.log("ENTER:", "BindingRestProperty");
@@ -1631,7 +1640,7 @@ var require_parser = __commonJS({
1631
1640
  return BindingElement$0(state);
1632
1641
  }
1633
1642
  }
1634
- var BindingRestElement$0 = $S($EXPECT($L19, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1643
+ var BindingRestElement$0 = $S($EXPECT($L17, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1635
1644
  function BindingRestElement(state) {
1636
1645
  if (state.verbose)
1637
1646
  console.log("ENTER:", "BindingRestElement");
@@ -1652,7 +1661,7 @@ var require_parser = __commonJS({
1652
1661
  }
1653
1662
  }
1654
1663
  var FunctionExpression$0 = ThinArrowFunction;
1655
- var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S($EXPECT($L5, fail, 'FunctionExpression "*"'), __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1664
+ var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1656
1665
  function FunctionExpression(state) {
1657
1666
  if (state.tokenize) {
1658
1667
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1681,7 +1690,7 @@ var require_parser = __commonJS({
1681
1690
  return ThinArrowFunction$0(state);
1682
1691
  }
1683
1692
  }
1684
- var Arrow$0 = $TV($EXPECT($L20, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1693
+ var Arrow$0 = $TV($EXPECT($L18, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1685
1694
  return { $loc, token: $1 };
1686
1695
  });
1687
1696
  function Arrow(state) {
@@ -1774,7 +1783,7 @@ var require_parser = __commonJS({
1774
1783
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1775
1784
  }
1776
1785
  }
1777
- var NullLiteral$0 = $TV($EXPECT($L21, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1786
+ var NullLiteral$0 = $TV($EXPECT($L19, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1778
1787
  return { $loc, token: $1 };
1779
1788
  });
1780
1789
  function NullLiteral(state) {
@@ -1786,7 +1795,7 @@ var require_parser = __commonJS({
1786
1795
  return NullLiteral$0(state);
1787
1796
  }
1788
1797
  }
1789
- var BooleanLiteral$0 = $TV($C($EXPECT($L22, fail, 'BooleanLiteral "true"'), $EXPECT($L23, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1798
+ var BooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'BooleanLiteral "true"'), $EXPECT($L21, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1790
1799
  return { $loc, token: $1 };
1791
1800
  });
1792
1801
  function BooleanLiteral(state) {
@@ -1798,7 +1807,7 @@ var require_parser = __commonJS({
1798
1807
  return BooleanLiteral$0(state);
1799
1808
  }
1800
1809
  }
1801
- var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
1810
+ var Comma$0 = $TV($EXPECT($L22, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
1802
1811
  return { $loc, token: $1 };
1803
1812
  });
1804
1813
  function Comma(state) {
@@ -1880,7 +1889,7 @@ var require_parser = __commonJS({
1880
1889
  }
1881
1890
  }
1882
1891
  var ArrayElementDelimiter$0 = $S($Q(_), Comma);
1883
- var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
1892
+ var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L23, fail, 'ArrayElementDelimiter "]"')));
1884
1893
  var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1885
1894
  return { $loc, token: "," };
1886
1895
  });
@@ -1911,7 +1920,7 @@ var require_parser = __commonJS({
1911
1920
  return InlineElementList$0(state);
1912
1921
  }
1913
1922
  }
1914
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L19, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1923
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L17, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1915
1924
  function ArrayElementExpression(state) {
1916
1925
  if (state.verbose)
1917
1926
  console.log("ENTER:", "ArrayElementExpression");
@@ -1978,7 +1987,7 @@ var require_parser = __commonJS({
1978
1987
  }
1979
1988
  }
1980
1989
  var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
1981
- var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
1990
+ var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ObjectPropertyDelimiter "}"')));
1982
1991
  var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1983
1992
  return { $loc, token: "," };
1984
1993
  });
@@ -2001,7 +2010,7 @@ var require_parser = __commonJS({
2001
2010
  }
2002
2011
  var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
2003
2012
  var PropertyDefinition$1 = MethodDefinition;
2004
- var PropertyDefinition$2 = $S($EXPECT($L19, fail, 'PropertyDefinition "..."'), AssignmentExpression);
2013
+ var PropertyDefinition$2 = $S($EXPECT($L17, fail, 'PropertyDefinition "..."'), AssignmentExpression);
2005
2014
  var PropertyDefinition$3 = IdentifierReference;
2006
2015
  function PropertyDefinition(state) {
2007
2016
  if (state.tokenize) {
@@ -2013,7 +2022,7 @@ var require_parser = __commonJS({
2013
2022
  var PropertyName$0 = NumericLiteral;
2014
2023
  var PropertyName$1 = StringLiteral;
2015
2024
  var PropertyName$2 = IdentifierName;
2016
- var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
2025
+ var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L23, fail, 'PropertyName "]"'));
2017
2026
  function PropertyName(state) {
2018
2027
  if (state.tokenize) {
2019
2028
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -2032,8 +2041,8 @@ var require_parser = __commonJS({
2032
2041
  }
2033
2042
  }
2034
2043
  var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
2035
- var MethodModifier$1 = $S($S(Async, __), $E($S($EXPECT($L5, fail, 'MethodModifier "*"'), __)));
2036
- var MethodModifier$2 = $S($EXPECT($L5, fail, 'MethodModifier "*"'), __);
2044
+ var MethodModifier$1 = $S($S(Async, __), $E($S(Star, __)));
2045
+ var MethodModifier$2 = $S(Star, __);
2037
2046
  var MethodModifier$3 = $S(Async, __);
2038
2047
  function MethodModifier(state) {
2039
2048
  if (state.tokenize) {
@@ -2042,18 +2051,6 @@ var require_parser = __commonJS({
2042
2051
  return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
2043
2052
  }
2044
2053
  }
2045
- var ConstructorShorthand$0 = $TV($EXPECT($L11, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
2046
- return { $loc, token: "constructor" };
2047
- });
2048
- function ConstructorShorthand(state) {
2049
- if (state.verbose)
2050
- console.log("ENTER:", "ConstructorShorthand");
2051
- if (state.tokenize) {
2052
- return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
2053
- } else {
2054
- return ConstructorShorthand$0(state);
2055
- }
2056
- }
2057
2054
  var MethodSignature$0 = $S(ConstructorShorthand, Parameters);
2058
2055
  var MethodSignature$1 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
2059
2056
  function MethodSignature(state) {
@@ -2072,7 +2069,7 @@ var require_parser = __commonJS({
2072
2069
  return ClassElementName$0(state) || ClassElementName$1(state);
2073
2070
  }
2074
2071
  }
2075
- var PrivateIdentifier$0 = $S($EXPECT($L10, fail, 'PrivateIdentifier "#"'), IdentifierName);
2072
+ var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
2076
2073
  function PrivateIdentifier(state) {
2077
2074
  if (state.verbose)
2078
2075
  console.log("ENTER:", "PrivateIdentifier");
@@ -2094,25 +2091,25 @@ var require_parser = __commonJS({
2094
2091
  return AssignmentOp$0(state);
2095
2092
  }
2096
2093
  }
2097
- var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
2098
- var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
2099
- var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
2100
- var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
2101
- var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
2102
- var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
2103
- var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
2104
- var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
2105
- var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
2106
- var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
2107
- var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
2108
- var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
2109
- var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
2110
- var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
2111
- var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
2112
- var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
2094
+ var AssignmentOpSymbol$0 = $EXPECT($L25, fail, 'AssignmentOpSymbol "**="');
2095
+ var AssignmentOpSymbol$1 = $EXPECT($L26, fail, 'AssignmentOpSymbol "*="');
2096
+ var AssignmentOpSymbol$2 = $EXPECT($L27, fail, 'AssignmentOpSymbol "/="');
2097
+ var AssignmentOpSymbol$3 = $EXPECT($L28, fail, 'AssignmentOpSymbol "%="');
2098
+ var AssignmentOpSymbol$4 = $EXPECT($L29, fail, 'AssignmentOpSymbol "+="');
2099
+ var AssignmentOpSymbol$5 = $EXPECT($L30, fail, 'AssignmentOpSymbol "-="');
2100
+ var AssignmentOpSymbol$6 = $EXPECT($L31, fail, 'AssignmentOpSymbol "<<="');
2101
+ var AssignmentOpSymbol$7 = $EXPECT($L32, fail, 'AssignmentOpSymbol ">>>="');
2102
+ var AssignmentOpSymbol$8 = $EXPECT($L33, fail, 'AssignmentOpSymbol ">>="');
2103
+ var AssignmentOpSymbol$9 = $EXPECT($L34, fail, 'AssignmentOpSymbol "&&="');
2104
+ var AssignmentOpSymbol$10 = $EXPECT($L35, fail, 'AssignmentOpSymbol "&="');
2105
+ var AssignmentOpSymbol$11 = $EXPECT($L36, fail, 'AssignmentOpSymbol "^="');
2106
+ var AssignmentOpSymbol$12 = $EXPECT($L37, fail, 'AssignmentOpSymbol "||="');
2107
+ var AssignmentOpSymbol$13 = $EXPECT($L38, fail, 'AssignmentOpSymbol "|="');
2108
+ var AssignmentOpSymbol$14 = $EXPECT($L39, fail, 'AssignmentOpSymbol "??="');
2109
+ var AssignmentOpSymbol$15 = $T($EXPECT($L40, fail, 'AssignmentOpSymbol "?="'), function(value) {
2113
2110
  return "??=";
2114
2111
  });
2115
- var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
2112
+ var AssignmentOpSymbol$16 = $EXPECT($L41, fail, 'AssignmentOpSymbol "="');
2116
2113
  function AssignmentOpSymbol(state) {
2117
2114
  if (state.tokenize) {
2118
2115
  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) || AssignmentOpSymbol$16(state));
@@ -2132,52 +2129,52 @@ var require_parser = __commonJS({
2132
2129
  return BinaryOp$0(state);
2133
2130
  }
2134
2131
  }
2135
- var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
2136
- var BinaryOpSymbol$1 = $EXPECT($L5, fail, 'BinaryOpSymbol "*"');
2137
- var BinaryOpSymbol$2 = $EXPECT($L45, fail, 'BinaryOpSymbol "/"');
2138
- var BinaryOpSymbol$3 = $EXPECT($L46, fail, 'BinaryOpSymbol "%"');
2139
- var BinaryOpSymbol$4 = $EXPECT($L47, fail, 'BinaryOpSymbol "+"');
2140
- var BinaryOpSymbol$5 = $EXPECT($L48, fail, 'BinaryOpSymbol "-"');
2141
- var BinaryOpSymbol$6 = $EXPECT($L49, fail, 'BinaryOpSymbol "<="');
2142
- var BinaryOpSymbol$7 = $EXPECT($L50, fail, 'BinaryOpSymbol ">="');
2143
- var BinaryOpSymbol$8 = $EXPECT($L51, fail, 'BinaryOpSymbol "<<"');
2144
- var BinaryOpSymbol$9 = $EXPECT($L7, fail, 'BinaryOpSymbol "<"');
2145
- var BinaryOpSymbol$10 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>>"');
2146
- var BinaryOpSymbol$11 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>"');
2147
- var BinaryOpSymbol$12 = $EXPECT($L54, fail, 'BinaryOpSymbol ">"');
2148
- var BinaryOpSymbol$13 = $EXPECT($L55, fail, 'BinaryOpSymbol "!=="');
2149
- var BinaryOpSymbol$14 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2132
+ var BinaryOpSymbol$0 = $EXPECT($L42, fail, 'BinaryOpSymbol "**"');
2133
+ var BinaryOpSymbol$1 = $EXPECT($L43, fail, 'BinaryOpSymbol "*"');
2134
+ var BinaryOpSymbol$2 = $EXPECT($L44, fail, 'BinaryOpSymbol "/"');
2135
+ var BinaryOpSymbol$3 = $EXPECT($L45, fail, 'BinaryOpSymbol "%"');
2136
+ var BinaryOpSymbol$4 = $EXPECT($L46, fail, 'BinaryOpSymbol "+"');
2137
+ var BinaryOpSymbol$5 = $EXPECT($L47, fail, 'BinaryOpSymbol "-"');
2138
+ var BinaryOpSymbol$6 = $EXPECT($L48, fail, 'BinaryOpSymbol "<="');
2139
+ var BinaryOpSymbol$7 = $EXPECT($L49, fail, 'BinaryOpSymbol ">="');
2140
+ var BinaryOpSymbol$8 = $EXPECT($L50, fail, 'BinaryOpSymbol "<<"');
2141
+ var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
2142
+ var BinaryOpSymbol$10 = $EXPECT($L51, fail, 'BinaryOpSymbol ">>>"');
2143
+ var BinaryOpSymbol$11 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>"');
2144
+ var BinaryOpSymbol$12 = $EXPECT($L53, fail, 'BinaryOpSymbol ">"');
2145
+ var BinaryOpSymbol$13 = $EXPECT($L54, fail, 'BinaryOpSymbol "!=="');
2146
+ var BinaryOpSymbol$14 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2150
2147
  if (module2.coffeeCompat)
2151
2148
  return "!==";
2152
2149
  return $1;
2153
2150
  });
2154
- var BinaryOpSymbol$15 = $T($S($EXPECT($L57, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2151
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L56, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2155
2152
  return "===";
2156
2153
  });
2157
- var BinaryOpSymbol$16 = $EXPECT($L58, fail, 'BinaryOpSymbol "==="');
2158
- var BinaryOpSymbol$17 = $TV($EXPECT($L59, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2154
+ var BinaryOpSymbol$16 = $EXPECT($L57, fail, 'BinaryOpSymbol "==="');
2155
+ var BinaryOpSymbol$17 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2159
2156
  if (module2.coffeeCompat)
2160
2157
  return "===";
2161
2158
  return $1;
2162
2159
  });
2163
- var BinaryOpSymbol$18 = $T($S($EXPECT($L60, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2160
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2164
2161
  return "&&";
2165
2162
  });
2166
- var BinaryOpSymbol$19 = $EXPECT($L61, fail, 'BinaryOpSymbol "&&"');
2167
- var BinaryOpSymbol$20 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2163
+ var BinaryOpSymbol$19 = $EXPECT($L60, fail, 'BinaryOpSymbol "&&"');
2164
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2168
2165
  return "||";
2169
2166
  });
2170
- var BinaryOpSymbol$21 = $EXPECT($L63, fail, 'BinaryOpSymbol "||"');
2171
- var BinaryOpSymbol$22 = $EXPECT($L64, fail, 'BinaryOpSymbol "??"');
2172
- var BinaryOpSymbol$23 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2167
+ var BinaryOpSymbol$21 = $EXPECT($L62, fail, 'BinaryOpSymbol "||"');
2168
+ var BinaryOpSymbol$22 = $EXPECT($L63, fail, 'BinaryOpSymbol "??"');
2169
+ var BinaryOpSymbol$23 = $TS($S($EXPECT($L64, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2173
2170
  return $1;
2174
2171
  });
2175
- var BinaryOpSymbol$24 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2172
+ var BinaryOpSymbol$24 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2176
2173
  return $1;
2177
2174
  });
2178
- var BinaryOpSymbol$25 = $EXPECT($L67, fail, 'BinaryOpSymbol "&"');
2179
- var BinaryOpSymbol$26 = $EXPECT($L68, fail, 'BinaryOpSymbol "^"');
2180
- var BinaryOpSymbol$27 = $EXPECT($L69, fail, 'BinaryOpSymbol "|"');
2175
+ var BinaryOpSymbol$25 = $EXPECT($L66, fail, 'BinaryOpSymbol "&"');
2176
+ var BinaryOpSymbol$26 = $EXPECT($L67, fail, 'BinaryOpSymbol "^"');
2177
+ var BinaryOpSymbol$27 = $EXPECT($L68, fail, 'BinaryOpSymbol "|"');
2181
2178
  function BinaryOpSymbol(state) {
2182
2179
  if (state.tokenize) {
2183
2180
  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));
@@ -2186,7 +2183,7 @@ var require_parser = __commonJS({
2186
2183
  }
2187
2184
  }
2188
2185
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2189
- var UnaryOp$1 = $S($C($EXPECT($L70, fail, 'UnaryOp "delete"'), $EXPECT($L71, fail, 'UnaryOp "void"'), $EXPECT($L72, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2186
+ var UnaryOp$1 = $S($C($EXPECT($L69, fail, 'UnaryOp "delete"'), $EXPECT($L70, fail, 'UnaryOp "void"'), $EXPECT($L71, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2190
2187
  function UnaryOp(state) {
2191
2188
  if (state.tokenize) {
2192
2189
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2266,7 +2263,7 @@ var require_parser = __commonJS({
2266
2263
  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);
2267
2264
  }
2268
2265
  }
2269
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L73, fail, 'EmptyStatement ";"')));
2266
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L72, fail, 'EmptyStatement ";"')));
2270
2267
  function EmptyStatement(state) {
2271
2268
  if (state.verbose)
2272
2269
  console.log("ENTER:", "EmptyStatement");
@@ -2331,7 +2328,7 @@ var require_parser = __commonJS({
2331
2328
  return LoopStatement$0(state);
2332
2329
  }
2333
2330
  }
2334
- var DoWhileStatement$0 = $S($EXPECT($L74, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2331
+ var DoWhileStatement$0 = $S($EXPECT($L73, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2335
2332
  function DoWhileStatement(state) {
2336
2333
  if (state.verbose)
2337
2334
  console.log("ENTER:", "DoWhileStatement");
@@ -2351,7 +2348,7 @@ var require_parser = __commonJS({
2351
2348
  return WhileStatement$0(state);
2352
2349
  }
2353
2350
  }
2354
- var WhileClause$0 = $TS($S($C($EXPECT($L75, fail, 'WhileClause "while"'), $EXPECT($L76, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2351
+ var WhileClause$0 = $TS($S($C($EXPECT($L74, fail, 'WhileClause "while"'), $EXPECT($L75, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2355
2352
  var kind = $1;
2356
2353
  var cond = $3;
2357
2354
  if (kind === "until") {
@@ -2410,7 +2407,7 @@ var require_parser = __commonJS({
2410
2407
  return ForBinding$0(state) || ForBinding$1(state);
2411
2408
  }
2412
2409
  }
2413
- var SwitchStatement$0 = $S(Switch, NonIdContinue, Condition, CaseBlock);
2410
+ var SwitchStatement$0 = $S(Switch, Condition, CaseBlock);
2414
2411
  function SwitchStatement(state) {
2415
2412
  if (state.verbose)
2416
2413
  console.log("ENTER:", "SwitchStatement");
@@ -2454,9 +2451,9 @@ var require_parser = __commonJS({
2454
2451
  return NestedCaseClause$0(state);
2455
2452
  }
2456
2453
  }
2457
- var CaseClause$0 = $S($EXPECT($L77, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions);
2458
- var CaseClause$1 = $S(When, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions, InsertBreak);
2459
- var CaseClause$2 = $S($EXPECT($L78, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2454
+ var CaseClause$0 = $S(Case, CaseExpressionList, NestedBlockExpressions);
2455
+ var CaseClause$1 = $S(When, CaseExpressionList, NestedBlockExpressions, InsertBreak);
2456
+ var CaseClause$2 = $S(Default, ImpliedColon, NestedBlockExpressions);
2460
2457
  function CaseClause(state) {
2461
2458
  if (state.tokenize) {
2462
2459
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2464,6 +2461,25 @@ var require_parser = __commonJS({
2464
2461
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2465
2462
  }
2466
2463
  }
2464
+ var CaseExpressionList$0 = $TS($S($S($Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon), $Q($S(__, Comma, ExpressionWithIndentedApplicationSuppressed, ImpliedColon))), function($skip, $loc, $0, $1, $2) {
2465
+ const result = $2.map(([ws, _comma, exp, col]) => {
2466
+ module2.insertTrimmingSpace(exp, "");
2467
+ if (ws.length)
2468
+ return [module2.insertTrimmingSpace("case ", ws), exp, col];
2469
+ return ["case ", exp, col];
2470
+ });
2471
+ result.unshift($1);
2472
+ return result;
2473
+ });
2474
+ function CaseExpressionList(state) {
2475
+ if (state.verbose)
2476
+ console.log("ENTER:", "CaseExpressionList");
2477
+ if (state.tokenize) {
2478
+ return $TOKEN("CaseExpressionList", state, CaseExpressionList$0(state));
2479
+ } else {
2480
+ return CaseExpressionList$0(state);
2481
+ }
2482
+ }
2467
2483
  var ImpliedColon$0 = $S(__, Colon);
2468
2484
  var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
2469
2485
  return { $loc, token: ":" };
@@ -2511,7 +2527,7 @@ var require_parser = __commonJS({
2511
2527
  return CatchBind$0(state) || CatchBind$1(state);
2512
2528
  }
2513
2529
  }
2514
- var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
2530
+ var Finally$0 = $S(__, $EXPECT($L76, fail, 'Finally "finally"'), BracedBlock);
2515
2531
  function Finally(state) {
2516
2532
  if (state.verbose)
2517
2533
  console.log("ENTER:", "Finally");
@@ -2539,7 +2555,7 @@ var require_parser = __commonJS({
2539
2555
  return Condition$0(state) || Condition$1(state);
2540
2556
  }
2541
2557
  }
2542
- var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(Expression)), function($skip, $loc, $0, $1, $2) {
2558
+ var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(AssignmentExpression)), function($skip, $loc, $0, $1, $2) {
2543
2559
  var exp = $2;
2544
2560
  module2.suppressIndentedApplication = false;
2545
2561
  if (exp)
@@ -2577,11 +2593,11 @@ var require_parser = __commonJS({
2577
2593
  return ExpressionStatement$0(state);
2578
2594
  }
2579
2595
  }
2580
- var KeywordStatement$0 = $S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue);
2581
- var KeywordStatement$1 = $S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue);
2582
- var KeywordStatement$2 = $S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2596
+ var KeywordStatement$0 = $S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue);
2597
+ var KeywordStatement$1 = $S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue);
2598
+ var KeywordStatement$2 = $S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2583
2599
  var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2584
- var KeywordStatement$4 = $S($EXPECT($L83, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2600
+ var KeywordStatement$4 = $S($EXPECT($L80, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2585
2601
  function KeywordStatement(state) {
2586
2602
  if (state.tokenize) {
2587
2603
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2598,7 +2614,7 @@ var require_parser = __commonJS({
2598
2614
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2599
2615
  }
2600
2616
  }
2601
- var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2617
+ var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2602
2618
  return { "ts": true, "children": value };
2603
2619
  });
2604
2620
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2643,7 +2659,7 @@ var require_parser = __commonJS({
2643
2659
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2644
2660
  }
2645
2661
  }
2646
- var NameSpaceImport$0 = $S($EXPECT($L5, fail, 'NameSpaceImport "*"'), __, As, NonIdContinue, __, ImportedBinding);
2662
+ var NameSpaceImport$0 = $S(Star, __, As, NonIdContinue, __, ImportedBinding);
2647
2663
  function NameSpaceImport(state) {
2648
2664
  if (state.verbose)
2649
2665
  console.log("ENTER:", "NameSpaceImport");
@@ -2704,7 +2720,7 @@ var require_parser = __commonJS({
2704
2720
  return ModuleSpecifier$0(state);
2705
2721
  }
2706
2722
  }
2707
- var UnprocessedModuleSpecifier$0 = StringLiteral;
2723
+ var UnprocessedModuleSpecifier$0 = BasicStringLiteral;
2708
2724
  var UnprocessedModuleSpecifier$1 = UnquotedSpecifier;
2709
2725
  function UnprocessedModuleSpecifier(state) {
2710
2726
  if (state.tokenize) {
@@ -2736,7 +2752,7 @@ var require_parser = __commonJS({
2736
2752
  return ImportedBinding$0(state);
2737
2753
  }
2738
2754
  }
2739
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L78, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2755
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2740
2756
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2741
2757
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2742
2758
  function ExportDeclaration(state) {
@@ -2746,7 +2762,7 @@ var require_parser = __commonJS({
2746
2762
  return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
2747
2763
  }
2748
2764
  }
2749
- var ExportFromClause$0 = $S($EXPECT($L5, fail, 'ExportFromClause "*"'), $E($S(__, As, NonIdContinue, __, ModuleExportName)));
2765
+ var ExportFromClause$0 = $S(Star, $E($S(__, As, NonIdContinue, __, ModuleExportName)));
2750
2766
  var ExportFromClause$1 = NamedExports;
2751
2767
  function ExportFromClause(state) {
2752
2768
  if (state.tokenize) {
@@ -2813,7 +2829,7 @@ var require_parser = __commonJS({
2813
2829
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
2814
2830
  }
2815
2831
  }
2816
- var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2832
+ var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2817
2833
  return { $loc, token: "=" };
2818
2834
  });
2819
2835
  function ConstAssignment(state) {
@@ -2948,37 +2964,7 @@ var require_parser = __commonJS({
2948
2964
  }
2949
2965
  }
2950
2966
  var StringLiteral$0 = $TS($S(TripleDoubleQuote, $Q($C(TripleDoubleStringCharacters, CoffeeStringSubstitution)), TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
2951
- var s = $1;
2952
- var strWithSubstitutions = $2;
2953
- var e = $3;
2954
- if (strWithSubstitutions.length === 0) {
2955
- return $0;
2956
- }
2957
- let initialSpacing, i = 0, l = strWithSubstitutions.length, results = [s];
2958
- const { token } = strWithSubstitutions[0];
2959
- if (token) {
2960
- initialSpacing = token.match(/^(\r?\n|\n)\s+/);
2961
- } else {
2962
- initialSpacing = false;
2963
- }
2964
- while (i < l) {
2965
- let segment = strWithSubstitutions[i];
2966
- if (segment.token) {
2967
- segment = module2.dedentBlockString(segment, initialSpacing, false);
2968
- if (i === 0) {
2969
- segment.token = segment.token.replace(/^(\r?\n|\n)/, "");
2970
- }
2971
- if (i === l - 1) {
2972
- segment.token = segment.token.replace(/(\r?\n|\n)[ \t]*$/, "");
2973
- }
2974
- results.push(segment);
2975
- } else {
2976
- results.push(segment);
2977
- }
2978
- i++;
2979
- }
2980
- results.push(e);
2981
- return results;
2967
+ return module2.dedentBlockSubstitutions($0);
2982
2968
  });
2983
2969
  var StringLiteral$1 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
2984
2970
  var s = $1;
@@ -2986,37 +2972,57 @@ var require_parser = __commonJS({
2986
2972
  var e = $3;
2987
2973
  return [s, module2.dedentBlockString(str), e];
2988
2974
  });
2989
- var StringLiteral$2 = $TV($TEXT($S($EXPECT($L86, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L86, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2990
- return { $loc, token: $1 };
2975
+ var StringLiteral$2 = BasicStringLiteral;
2976
+ function StringLiteral(state) {
2977
+ if (state.tokenize) {
2978
+ return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
2979
+ } else {
2980
+ return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
2981
+ }
2982
+ }
2983
+ var BasicStringLiteral$0 = $TS($S(DoubleQuote, DoubleStringCharacters, DoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
2984
+ var str = $2;
2985
+ return {
2986
+ token: `"${module2.modifyString(str.token)}"`,
2987
+ $loc
2988
+ };
2991
2989
  });
2992
- var StringLiteral$3 = $TV($TEXT($S($EXPECT($L87, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L87, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2993
- return { $loc, token: $1 };
2990
+ var BasicStringLiteral$1 = $TS($S(SingleQuote, SingleStringCharacters, SingleQuote), function($skip, $loc, $0, $1, $2, $3) {
2991
+ var str = $2;
2992
+ return {
2993
+ token: `'${module2.modifyString(str.token)}'`,
2994
+ $loc
2995
+ };
2994
2996
  });
2995
- function StringLiteral(state) {
2997
+ function BasicStringLiteral(state) {
2996
2998
  if (state.tokenize) {
2997
- return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
2999
+ return $TOKEN("BasicStringLiteral", state, BasicStringLiteral$0(state) || BasicStringLiteral$1(state));
2998
3000
  } else {
2999
- return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
3001
+ return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
3000
3002
  }
3001
3003
  }
3002
- var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
3003
- function DoubleStringCharacter(state) {
3004
+ var DoubleStringCharacters$0 = $TR($EXPECT($R9, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3005
+ return { $loc, token: $0 };
3006
+ });
3007
+ function DoubleStringCharacters(state) {
3004
3008
  if (state.verbose)
3005
- console.log("ENTER:", "DoubleStringCharacter");
3009
+ console.log("ENTER:", "DoubleStringCharacters");
3006
3010
  if (state.tokenize) {
3007
- return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
3011
+ return $TOKEN("DoubleStringCharacters", state, DoubleStringCharacters$0(state));
3008
3012
  } else {
3009
- return DoubleStringCharacter$0(state);
3013
+ return DoubleStringCharacters$0(state);
3010
3014
  }
3011
3015
  }
3012
- var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
3013
- function SingleStringCharacter(state) {
3016
+ var SingleStringCharacters$0 = $TR($EXPECT($R10, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3017
+ return { $loc, token: $0 };
3018
+ });
3019
+ function SingleStringCharacters(state) {
3014
3020
  if (state.verbose)
3015
- console.log("ENTER:", "SingleStringCharacter");
3021
+ console.log("ENTER:", "SingleStringCharacters");
3016
3022
  if (state.tokenize) {
3017
- return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
3023
+ return $TOKEN("SingleStringCharacters", state, SingleStringCharacters$0(state));
3018
3024
  } else {
3019
- return SingleStringCharacter$0(state);
3025
+ return SingleStringCharacters$0(state);
3020
3026
  }
3021
3027
  }
3022
3028
  var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
@@ -3053,19 +3059,7 @@ var require_parser = __commonJS({
3053
3059
  return CoffeeStringSubstitution$0(state);
3054
3060
  }
3055
3061
  }
3056
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L88, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3057
- return { $loc, token: "${" };
3058
- });
3059
- function CoffeeSubstitutionStart(state) {
3060
- if (state.verbose)
3061
- console.log("ENTER:", "CoffeeSubstitutionStart");
3062
- if (state.tokenize) {
3063
- return $TOKEN("CoffeeSubstitutionStart", state, CoffeeSubstitutionStart$0(state));
3064
- } else {
3065
- return CoffeeSubstitutionStart$0(state);
3066
- }
3067
- }
3068
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3062
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3069
3063
  return { $loc, token: $1 };
3070
3064
  });
3071
3065
  function RegularExpressionLiteral(state) {
@@ -3107,17 +3101,18 @@ var require_parser = __commonJS({
3107
3101
  return RegularExpressionFlags$0(state);
3108
3102
  }
3109
3103
  }
3110
- var TemplateLiteral$0 = $S($EXPECT($L0, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L0, fail, 'TemplateLiteral "`"'));
3104
+ var TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
3105
+ return module2.dedentBlockSubstitutions($0);
3106
+ });
3107
+ var TemplateLiteral$1 = $S($EXPECT($L0, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L0, fail, 'TemplateLiteral "`"'));
3111
3108
  function TemplateLiteral(state) {
3112
- if (state.verbose)
3113
- console.log("ENTER:", "TemplateLiteral");
3114
3109
  if (state.tokenize) {
3115
- return $TOKEN("TemplateLiteral", state, TemplateLiteral$0(state));
3110
+ return $TOKEN("TemplateLiteral", state, TemplateLiteral$0(state) || TemplateLiteral$1(state));
3116
3111
  } else {
3117
- return TemplateLiteral$0(state);
3112
+ return TemplateLiteral$0(state) || TemplateLiteral$1(state);
3118
3113
  }
3119
3114
  }
3120
- var TemplateSubstitution$0 = $S($EXPECT($L89, fail, 'TemplateSubstitution "${"'), Expression, __, CloseBrace);
3115
+ var TemplateSubstitution$0 = $S(SubstitutionStart, Expression, __, CloseBrace);
3121
3116
  function TemplateSubstitution(state) {
3122
3117
  if (state.verbose)
3123
3118
  console.log("ENTER:", "TemplateSubstitution");
@@ -3127,7 +3122,9 @@ var require_parser = __commonJS({
3127
3122
  return TemplateSubstitution$0(state);
3128
3123
  }
3129
3124
  }
3130
- var TemplateCharacters$0 = $R$0($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
3125
+ var TemplateCharacters$0 = $TR($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3126
+ return { $loc, token: $0 };
3127
+ });
3131
3128
  function TemplateCharacters(state) {
3132
3129
  if (state.verbose)
3133
3130
  console.log("ENTER:", "TemplateCharacters");
@@ -3137,7 +3134,19 @@ var require_parser = __commonJS({
3137
3134
  return TemplateCharacters$0(state);
3138
3135
  }
3139
3136
  }
3140
- var ReservedWord$0 = $R$0($EXPECT($R17, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3137
+ var TemplateBlockCharacters$0 = $TR($EXPECT($R17, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3138
+ return { $loc, token: $0 };
3139
+ });
3140
+ function TemplateBlockCharacters(state) {
3141
+ if (state.verbose)
3142
+ console.log("ENTER:", "TemplateBlockCharacters");
3143
+ if (state.tokenize) {
3144
+ return $TOKEN("TemplateBlockCharacters", state, TemplateBlockCharacters$0(state));
3145
+ } else {
3146
+ return TemplateBlockCharacters$0(state);
3147
+ }
3148
+ }
3149
+ var ReservedWord$0 = $R$0($EXPECT($R18, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3141
3150
  function ReservedWord(state) {
3142
3151
  if (state.verbose)
3143
3152
  console.log("ENTER:", "ReservedWord");
@@ -3156,7 +3165,7 @@ var require_parser = __commonJS({
3156
3165
  return Comment$0(state) || Comment$1(state);
3157
3166
  }
3158
3167
  }
3159
- var SingleLineComment$0 = $TR($EXPECT($R18, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3168
+ var SingleLineComment$0 = $TR($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3160
3169
  return { $loc, token: $0 };
3161
3170
  });
3162
3171
  var SingleLineComment$1 = CoffeeSingleLineComment;
@@ -3176,7 +3185,7 @@ var require_parser = __commonJS({
3176
3185
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3177
3186
  }
3178
3187
  }
3179
- var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L90, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L91, fail, 'JSMultiLineComment "*/"')), $EXPECT($R19, fail, "JSMultiLineComment /./"))), $EXPECT($L91, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3188
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3180
3189
  return { $loc, token: $1 };
3181
3190
  });
3182
3191
  function JSMultiLineComment(state) {
@@ -3188,7 +3197,7 @@ var require_parser = __commonJS({
3188
3197
  return JSMultiLineComment$0(state);
3189
3198
  }
3190
3199
  }
3191
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3200
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R21, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3192
3201
  if (!module2.coffeeCompat)
3193
3202
  return $skip;
3194
3203
  return { $loc, token: `//${$1}` };
@@ -3202,7 +3211,7 @@ var require_parser = __commonJS({
3202
3211
  return CoffeeSingleLineComment$0(state);
3203
3212
  }
3204
3213
  }
3205
- var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L92, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L92, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L91, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R19, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L92, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3214
+ var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3206
3215
  return { $loc, token: `/*${$2}*/` };
3207
3216
  });
3208
3217
  function CoffeeMultiLineComment(state) {
@@ -3214,7 +3223,7 @@ var require_parser = __commonJS({
3214
3223
  return CoffeeMultiLineComment$0(state);
3215
3224
  }
3216
3225
  }
3217
- var InlineComment$0 = $TV($TEXT($S($EXPECT($L90, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L91, fail, 'InlineComment "*/"')), $EXPECT($R21, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L91, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3226
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3218
3227
  return { $loc, token: $1 };
3219
3228
  });
3220
3229
  function InlineComment(state) {
@@ -3226,7 +3235,7 @@ var require_parser = __commonJS({
3226
3235
  return InlineComment$0(state);
3227
3236
  }
3228
3237
  }
3229
- var RestOfLine$0 = $S($Q($C($R$0($EXPECT($R22, fail, "RestOfLine /[ \\t]+/")), SingleLineComment, MultiLineComment)), EOL);
3238
+ var RestOfLine$0 = $S($Q($C(NonNewlineWhitespace, SingleLineComment, MultiLineComment)), EOL);
3230
3239
  function RestOfLine(state) {
3231
3240
  if (state.verbose)
3232
3241
  console.log("ENTER:", "RestOfLine");
@@ -3236,7 +3245,7 @@ var require_parser = __commonJS({
3236
3245
  return RestOfLine$0(state);
3237
3246
  }
3238
3247
  }
3239
- var TrailingComment$0 = $R$0($EXPECT($R23, fail, "TrailingComment /[\\t ]+/"));
3248
+ var TrailingComment$0 = NonNewlineWhitespace;
3240
3249
  var TrailingComment$1 = InlineComment;
3241
3250
  var TrailingComment$2 = SingleLineComment;
3242
3251
  function TrailingComment(state) {
@@ -3256,7 +3265,7 @@ var require_parser = __commonJS({
3256
3265
  return _$0(state);
3257
3266
  }
3258
3267
  }
3259
- var NonNewlineWhitespace$0 = $TR($EXPECT($R22, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3268
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R23, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3260
3269
  return { $loc, token: $0 };
3261
3270
  });
3262
3271
  function NonNewlineWhitespace(state) {
@@ -3323,7 +3332,7 @@ var require_parser = __commonJS({
3323
3332
  return Loc$0(state);
3324
3333
  }
3325
3334
  }
3326
- var As$0 = $TS($S($EXPECT($L93, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3335
+ var As$0 = $TS($S($EXPECT($L87, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3327
3336
  return { $loc, token: $1 };
3328
3337
  });
3329
3338
  function As(state) {
@@ -3335,7 +3344,7 @@ var require_parser = __commonJS({
3335
3344
  return As$0(state);
3336
3345
  }
3337
3346
  }
3338
- var Async$0 = $TV($EXPECT($L94, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3347
+ var Async$0 = $TV($EXPECT($L88, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3339
3348
  return { $loc, token: $1 };
3340
3349
  });
3341
3350
  function Async(state) {
@@ -3347,7 +3356,7 @@ var require_parser = __commonJS({
3347
3356
  return Async$0(state);
3348
3357
  }
3349
3358
  }
3350
- var Await$0 = $TS($S($EXPECT($L95, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3359
+ var Await$0 = $TS($S($EXPECT($L89, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3351
3360
  return { $loc, token: $1 };
3352
3361
  });
3353
3362
  function Await(state) {
@@ -3359,7 +3368,19 @@ var require_parser = __commonJS({
3359
3368
  return Await$0(state);
3360
3369
  }
3361
3370
  }
3362
- var Catch$0 = $TV($EXPECT($L96, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3371
+ var Case$0 = $TS($S($EXPECT($L90, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3372
+ return { $loc, token: $1 };
3373
+ });
3374
+ function Case(state) {
3375
+ if (state.verbose)
3376
+ console.log("ENTER:", "Case");
3377
+ if (state.tokenize) {
3378
+ return $TOKEN("Case", state, Case$0(state));
3379
+ } else {
3380
+ return Case$0(state);
3381
+ }
3382
+ }
3383
+ var Catch$0 = $TV($EXPECT($L91, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3363
3384
  return { $loc, token: $1 };
3364
3385
  });
3365
3386
  function Catch(state) {
@@ -3371,7 +3392,7 @@ var require_parser = __commonJS({
3371
3392
  return Catch$0(state);
3372
3393
  }
3373
3394
  }
3374
- var Class$0 = $TV($EXPECT($L97, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3395
+ var Class$0 = $TV($EXPECT($L92, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3375
3396
  return { $loc, token: $1 };
3376
3397
  });
3377
3398
  function Class(state) {
@@ -3383,7 +3404,7 @@ var require_parser = __commonJS({
3383
3404
  return Class$0(state);
3384
3405
  }
3385
3406
  }
3386
- var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3407
+ var CloseBrace$0 = $TV($EXPECT($L24, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3387
3408
  return { $loc, token: $1 };
3388
3409
  });
3389
3410
  function CloseBrace(state) {
@@ -3395,7 +3416,7 @@ var require_parser = __commonJS({
3395
3416
  return CloseBrace$0(state);
3396
3417
  }
3397
3418
  }
3398
- var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3419
+ var CloseBracket$0 = $TV($EXPECT($L23, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3399
3420
  return { $loc, token: $1 };
3400
3421
  });
3401
3422
  function CloseBracket(state) {
@@ -3407,7 +3428,7 @@ var require_parser = __commonJS({
3407
3428
  return CloseBracket$0(state);
3408
3429
  }
3409
3430
  }
3410
- var CloseParen$0 = $TV($EXPECT($L18, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3431
+ var CloseParen$0 = $TV($EXPECT($L16, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3411
3432
  return { $loc, token: $1 };
3412
3433
  });
3413
3434
  function CloseParen(state) {
@@ -3419,7 +3440,19 @@ var require_parser = __commonJS({
3419
3440
  return CloseParen$0(state);
3420
3441
  }
3421
3442
  }
3422
- var Colon$0 = $TV($EXPECT($L98, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3443
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L93, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3444
+ return { $loc, token: "${" };
3445
+ });
3446
+ function CoffeeSubstitutionStart(state) {
3447
+ if (state.verbose)
3448
+ console.log("ENTER:", "CoffeeSubstitutionStart");
3449
+ if (state.tokenize) {
3450
+ return $TOKEN("CoffeeSubstitutionStart", state, CoffeeSubstitutionStart$0(state));
3451
+ } else {
3452
+ return CoffeeSubstitutionStart$0(state);
3453
+ }
3454
+ }
3455
+ var Colon$0 = $TV($EXPECT($L94, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3423
3456
  return { $loc, token: $1 };
3424
3457
  });
3425
3458
  function Colon(state) {
@@ -3431,7 +3464,31 @@ var require_parser = __commonJS({
3431
3464
  return Colon$0(state);
3432
3465
  }
3433
3466
  }
3434
- var Dot$0 = $TV($EXPECT($L99, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3467
+ var ConstructorShorthand$0 = $TV($EXPECT($L9, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
3468
+ return { $loc, token: "constructor" };
3469
+ });
3470
+ function ConstructorShorthand(state) {
3471
+ if (state.verbose)
3472
+ console.log("ENTER:", "ConstructorShorthand");
3473
+ if (state.tokenize) {
3474
+ return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
3475
+ } else {
3476
+ return ConstructorShorthand$0(state);
3477
+ }
3478
+ }
3479
+ var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3480
+ return { $loc, token: $1 };
3481
+ });
3482
+ function Default(state) {
3483
+ if (state.verbose)
3484
+ console.log("ENTER:", "Default");
3485
+ if (state.tokenize) {
3486
+ return $TOKEN("Default", state, Default$0(state));
3487
+ } else {
3488
+ return Default$0(state);
3489
+ }
3490
+ }
3491
+ var Dot$0 = $TV($EXPECT($L95, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3435
3492
  return { $loc, token: $1 };
3436
3493
  });
3437
3494
  function Dot(state) {
@@ -3443,7 +3500,19 @@ var require_parser = __commonJS({
3443
3500
  return Dot$0(state);
3444
3501
  }
3445
3502
  }
3446
- var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3503
+ var DoubleQuote$0 = $TV($EXPECT($L96, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3504
+ return { $loc, token: $1 };
3505
+ });
3506
+ function DoubleQuote(state) {
3507
+ if (state.verbose)
3508
+ console.log("ENTER:", "DoubleQuote");
3509
+ if (state.tokenize) {
3510
+ return $TOKEN("DoubleQuote", state, DoubleQuote$0(state));
3511
+ } else {
3512
+ return DoubleQuote$0(state);
3513
+ }
3514
+ }
3515
+ var Else$0 = $TV($EXPECT($L97, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3447
3516
  return { $loc, token: $1 };
3448
3517
  });
3449
3518
  function Else(state) {
@@ -3455,7 +3524,7 @@ var require_parser = __commonJS({
3455
3524
  return Else$0(state);
3456
3525
  }
3457
3526
  }
3458
- var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3527
+ var Equals$0 = $TV($EXPECT($L41, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3459
3528
  return { $loc, token: $1 };
3460
3529
  });
3461
3530
  function Equals(state) {
@@ -3467,7 +3536,7 @@ var require_parser = __commonJS({
3467
3536
  return Equals$0(state);
3468
3537
  }
3469
3538
  }
3470
- var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3539
+ var Export$0 = $TS($S($EXPECT($L98, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3471
3540
  return { $loc, token: $1 };
3472
3541
  });
3473
3542
  function Export(state) {
@@ -3479,7 +3548,7 @@ var require_parser = __commonJS({
3479
3548
  return Export$0(state);
3480
3549
  }
3481
3550
  }
3482
- var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3551
+ var For$0 = $TS($S($EXPECT($L99, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3483
3552
  return { $loc, token: $1 };
3484
3553
  });
3485
3554
  function For(state) {
@@ -3491,7 +3560,7 @@ var require_parser = __commonJS({
3491
3560
  return For$0(state);
3492
3561
  }
3493
3562
  }
3494
- var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3563
+ var From$0 = $TS($S($EXPECT($L100, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3495
3564
  return { $loc, token: $1 };
3496
3565
  });
3497
3566
  function From(state) {
@@ -3503,7 +3572,7 @@ var require_parser = __commonJS({
3503
3572
  return From$0(state);
3504
3573
  }
3505
3574
  }
3506
- var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3575
+ var Function$0 = $TV($EXPECT($L101, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3507
3576
  return { $loc, token: $1 };
3508
3577
  });
3509
3578
  function Function(state) {
@@ -3515,7 +3584,7 @@ var require_parser = __commonJS({
3515
3584
  return Function$0(state);
3516
3585
  }
3517
3586
  }
3518
- var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3587
+ var GetOrSet$0 = $TS($S($C($EXPECT($L102, fail, 'GetOrSet "get"'), $EXPECT($L103, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3519
3588
  return { $loc, token: $1 };
3520
3589
  });
3521
3590
  function GetOrSet(state) {
@@ -3527,7 +3596,7 @@ var require_parser = __commonJS({
3527
3596
  return GetOrSet$0(state);
3528
3597
  }
3529
3598
  }
3530
- var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3599
+ var If$0 = $TV($EXPECT($L104, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3531
3600
  return { $loc, token: $1 };
3532
3601
  });
3533
3602
  function If(state) {
@@ -3539,7 +3608,7 @@ var require_parser = __commonJS({
3539
3608
  return If$0(state);
3540
3609
  }
3541
3610
  }
3542
- var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3611
+ var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3543
3612
  return { $loc, token: $1 };
3544
3613
  });
3545
3614
  function Import(state) {
@@ -3551,7 +3620,7 @@ var require_parser = __commonJS({
3551
3620
  return Import$0(state);
3552
3621
  }
3553
3622
  }
3554
- var In$0 = $TV($EXPECT($L66, fail, 'In "in"'), function($skip, $loc, $0, $1) {
3623
+ var In$0 = $TV($EXPECT($L65, fail, 'In "in"'), function($skip, $loc, $0, $1) {
3555
3624
  return { $loc, token: $1 };
3556
3625
  });
3557
3626
  function In(state) {
@@ -3563,7 +3632,7 @@ var require_parser = __commonJS({
3563
3632
  return In$0(state);
3564
3633
  }
3565
3634
  }
3566
- var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
3635
+ var LetOrConst$0 = $TV($C($EXPECT($L105, fail, 'LetOrConst "let"'), $EXPECT($L106, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
3567
3636
  return { $loc, token: $1 };
3568
3637
  });
3569
3638
  function LetOrConst(state) {
@@ -3575,7 +3644,7 @@ var require_parser = __commonJS({
3575
3644
  return LetOrConst$0(state);
3576
3645
  }
3577
3646
  }
3578
- var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3647
+ var Loop$0 = $TS($S($EXPECT($L107, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3579
3648
  return { $loc, token: "while(true)" };
3580
3649
  });
3581
3650
  function Loop(state) {
@@ -3587,7 +3656,7 @@ var require_parser = __commonJS({
3587
3656
  return Loop$0(state);
3588
3657
  }
3589
3658
  }
3590
- var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
3659
+ var New$0 = $TV($EXPECT($L108, fail, 'New "new"'), function($skip, $loc, $0, $1) {
3591
3660
  return { $loc, token: $1 };
3592
3661
  });
3593
3662
  function New(state) {
@@ -3599,7 +3668,7 @@ var require_parser = __commonJS({
3599
3668
  return New$0(state);
3600
3669
  }
3601
3670
  }
3602
- var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
3671
+ var Of$0 = $TV($EXPECT($L109, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
3603
3672
  return { $loc, token: $1 };
3604
3673
  });
3605
3674
  function Of(state) {
@@ -3611,7 +3680,7 @@ var require_parser = __commonJS({
3611
3680
  return Of$0(state);
3612
3681
  }
3613
3682
  }
3614
- var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
3683
+ var OpenBrace$0 = $TV($EXPECT($L110, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
3615
3684
  return { $loc, token: $1 };
3616
3685
  });
3617
3686
  function OpenBrace(state) {
@@ -3623,7 +3692,7 @@ var require_parser = __commonJS({
3623
3692
  return OpenBrace$0(state);
3624
3693
  }
3625
3694
  }
3626
- var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
3695
+ var OpenBracket$0 = $TV($EXPECT($L111, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
3627
3696
  return { $loc, token: $1 };
3628
3697
  });
3629
3698
  function OpenBracket(state) {
@@ -3635,7 +3704,7 @@ var require_parser = __commonJS({
3635
3704
  return OpenBracket$0(state);
3636
3705
  }
3637
3706
  }
3638
- var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
3707
+ var OpenParen$0 = $TV($EXPECT($L112, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
3639
3708
  return { $loc, token: $1 };
3640
3709
  });
3641
3710
  function OpenParen(state) {
@@ -3647,7 +3716,7 @@ var require_parser = __commonJS({
3647
3716
  return OpenParen$0(state);
3648
3717
  }
3649
3718
  }
3650
- var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
3719
+ var QuestionMark$0 = $TV($EXPECT($L113, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
3651
3720
  return { $loc, token: $1 };
3652
3721
  });
3653
3722
  function QuestionMark(state) {
@@ -3659,7 +3728,7 @@ var require_parser = __commonJS({
3659
3728
  return QuestionMark$0(state);
3660
3729
  }
3661
3730
  }
3662
- var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3731
+ var Return$0 = $TS($S($EXPECT($L114, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3663
3732
  return { $loc, token: $1 };
3664
3733
  });
3665
3734
  function Return(state) {
@@ -3671,7 +3740,7 @@ var require_parser = __commonJS({
3671
3740
  return Return$0(state);
3672
3741
  }
3673
3742
  }
3674
- var Semicolon$0 = $TV($EXPECT($L73, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
3743
+ var Semicolon$0 = $TV($EXPECT($L72, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
3675
3744
  return { $loc, token: $1 };
3676
3745
  });
3677
3746
  function Semicolon(state) {
@@ -3683,10 +3752,34 @@ var require_parser = __commonJS({
3683
3752
  return Semicolon$0(state);
3684
3753
  }
3685
3754
  }
3686
- var Static$0 = $TV($EXPECT($L118, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
3755
+ var SingleQuote$0 = $TV($EXPECT($L115, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
3756
+ return { $loc, token: $1 };
3757
+ });
3758
+ function SingleQuote(state) {
3759
+ if (state.verbose)
3760
+ console.log("ENTER:", "SingleQuote");
3761
+ if (state.tokenize) {
3762
+ return $TOKEN("SingleQuote", state, SingleQuote$0(state));
3763
+ } else {
3764
+ return SingleQuote$0(state);
3765
+ }
3766
+ }
3767
+ var Star$0 = $TV($EXPECT($L43, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
3768
+ return { $loc, token: $1 };
3769
+ });
3770
+ function Star(state) {
3771
+ if (state.verbose)
3772
+ console.log("ENTER:", "Star");
3773
+ if (state.tokenize) {
3774
+ return $TOKEN("Star", state, Star$0(state));
3775
+ } else {
3776
+ return Star$0(state);
3777
+ }
3778
+ }
3779
+ var Static$0 = $TV($EXPECT($L116, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
3687
3780
  return { $loc, token: $1 };
3688
3781
  });
3689
- var Static$1 = $TS($S($EXPECT($L11, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
3782
+ var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L112, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
3690
3783
  return { $loc, token: "static " };
3691
3784
  });
3692
3785
  function Static(state) {
@@ -3696,7 +3789,19 @@ var require_parser = __commonJS({
3696
3789
  return Static$0(state) || Static$1(state);
3697
3790
  }
3698
3791
  }
3699
- var Switch$0 = $TV($EXPECT($L119, fail, 'Switch "switch"'), function($skip, $loc, $0, $1) {
3792
+ var SubstitutionStart$0 = $TV($EXPECT($L117, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
3793
+ return { $loc, token: $1 };
3794
+ });
3795
+ function SubstitutionStart(state) {
3796
+ if (state.verbose)
3797
+ console.log("ENTER:", "SubstitutionStart");
3798
+ if (state.tokenize) {
3799
+ return $TOKEN("SubstitutionStart", state, SubstitutionStart$0(state));
3800
+ } else {
3801
+ return SubstitutionStart$0(state);
3802
+ }
3803
+ }
3804
+ var Switch$0 = $TS($S($EXPECT($L118, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3700
3805
  return { $loc, token: $1 };
3701
3806
  });
3702
3807
  function Switch(state) {
@@ -3708,7 +3813,7 @@ var require_parser = __commonJS({
3708
3813
  return Switch$0(state);
3709
3814
  }
3710
3815
  }
3711
- var Target$0 = $TV($EXPECT($L120, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
3816
+ var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
3712
3817
  return { $loc, token: $1 };
3713
3818
  });
3714
3819
  function Target(state) {
@@ -3720,7 +3825,7 @@ var require_parser = __commonJS({
3720
3825
  return Target$0(state);
3721
3826
  }
3722
3827
  }
3723
- var TripleDoubleQuote$0 = $TV($EXPECT($L121, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
3828
+ var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
3724
3829
  return { $loc, token: "`" };
3725
3830
  });
3726
3831
  function TripleDoubleQuote(state) {
@@ -3732,7 +3837,7 @@ var require_parser = __commonJS({
3732
3837
  return TripleDoubleQuote$0(state);
3733
3838
  }
3734
3839
  }
3735
- var TripleSingleQuote$0 = $TV($EXPECT($L122, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
3840
+ var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
3736
3841
  return { $loc, token: "`" };
3737
3842
  });
3738
3843
  function TripleSingleQuote(state) {
@@ -3744,7 +3849,7 @@ var require_parser = __commonJS({
3744
3849
  return TripleSingleQuote$0(state);
3745
3850
  }
3746
3851
  }
3747
- var TripleTick$0 = $TV($EXPECT($L123, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
3852
+ var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
3748
3853
  return { $loc, token: "`" };
3749
3854
  });
3750
3855
  function TripleTick(state) {
@@ -3756,7 +3861,7 @@ var require_parser = __commonJS({
3756
3861
  return TripleTick$0(state);
3757
3862
  }
3758
3863
  }
3759
- var Try$0 = $TV($EXPECT($L124, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
3864
+ var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
3760
3865
  return { $loc, token: $1 };
3761
3866
  });
3762
3867
  function Try(state) {
@@ -3768,7 +3873,7 @@ var require_parser = __commonJS({
3768
3873
  return Try$0(state);
3769
3874
  }
3770
3875
  }
3771
- var Unless$0 = $TV($EXPECT($L125, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
3876
+ var Unless$0 = $TV($EXPECT($L124, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
3772
3877
  return { $loc, token: $1 };
3773
3878
  });
3774
3879
  function Unless(state) {
@@ -3780,7 +3885,7 @@ var require_parser = __commonJS({
3780
3885
  return Unless$0(state);
3781
3886
  }
3782
3887
  }
3783
- var Var$0 = $TV($EXPECT($L126, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
3888
+ var Var$0 = $TV($EXPECT($L125, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
3784
3889
  return { $loc, token: $1 };
3785
3890
  });
3786
3891
  function Var(state) {
@@ -3792,7 +3897,7 @@ var require_parser = __commonJS({
3792
3897
  return Var$0(state);
3793
3898
  }
3794
3899
  }
3795
- var When$0 = $TS($S($EXPECT($L127, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3900
+ var When$0 = $TS($S($EXPECT($L126, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3796
3901
  return { $loc, token: "case" };
3797
3902
  });
3798
3903
  function When(state) {
@@ -3804,6 +3909,18 @@ var require_parser = __commonJS({
3804
3909
  return When$0(state);
3805
3910
  }
3806
3911
  }
3912
+ var Yield$0 = $TS($S($EXPECT($L127, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3913
+ return { $loc, token: $1 };
3914
+ });
3915
+ function Yield(state) {
3916
+ if (state.verbose)
3917
+ console.log("ENTER:", "Yield");
3918
+ if (state.tokenize) {
3919
+ return $TOKEN("Yield", state, Yield$0(state));
3920
+ } else {
3921
+ return Yield$0(state);
3922
+ }
3923
+ }
3807
3924
  var JSXElement$0 = JSXSelfClosingElement;
3808
3925
  var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
3809
3926
  if ($1[1] !== $4[2]) {
@@ -3818,7 +3935,7 @@ var require_parser = __commonJS({
3818
3935
  return JSXElement$0(state) || JSXElement$1(state);
3819
3936
  }
3820
3937
  }
3821
- var JSXSelfClosingElement$0 = $S($EXPECT($L7, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
3938
+ var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
3822
3939
  function JSXSelfClosingElement(state) {
3823
3940
  if (state.verbose)
3824
3941
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3828,7 +3945,7 @@ var require_parser = __commonJS({
3828
3945
  return JSXSelfClosingElement$0(state);
3829
3946
  }
3830
3947
  }
3831
- var JSXOpeningElement$0 = $S($EXPECT($L7, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L54, fail, 'JSXOpeningElement ">"'));
3948
+ var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L53, fail, 'JSXOpeningElement ">"'));
3832
3949
  function JSXOpeningElement(state) {
3833
3950
  if (state.verbose)
3834
3951
  console.log("ENTER:", "JSXOpeningElement");
@@ -3838,7 +3955,7 @@ var require_parser = __commonJS({
3838
3955
  return JSXOpeningElement$0(state);
3839
3956
  }
3840
3957
  }
3841
- var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L54, fail, 'JSXClosingElement ">"'));
3958
+ var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L53, fail, 'JSXClosingElement ">"'));
3842
3959
  function JSXClosingElement(state) {
3843
3960
  if (state.verbose)
3844
3961
  console.log("ENTER:", "JSXClosingElement");
@@ -3888,7 +4005,7 @@ var require_parser = __commonJS({
3888
4005
  return JSXAttributes$0(state);
3889
4006
  }
3890
4007
  }
3891
- var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L19, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
4008
+ var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L17, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
3892
4009
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3893
4010
  function JSXAttribute(state) {
3894
4011
  if (state.tokenize) {
@@ -3960,7 +4077,7 @@ var require_parser = __commonJS({
3960
4077
  return JSXText$0(state);
3961
4078
  }
3962
4079
  }
3963
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L19, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
4080
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L17, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3964
4081
  function JSXChildExpression(state) {
3965
4082
  if (state.verbose)
3966
4083
  console.log("ENTER:", "JSXChildExpression");
@@ -4168,7 +4285,7 @@ var require_parser = __commonJS({
4168
4285
  return ReturnTypeSuffix$0(state);
4169
4286
  }
4170
4287
  }
4171
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L57, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
4288
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
4172
4289
  function TypePredicate(state) {
4173
4290
  if (state.verbose)
4174
4291
  console.log("ENTER:", "TypePredicate");
@@ -4219,7 +4336,7 @@ var require_parser = __commonJS({
4219
4336
  }
4220
4337
  }
4221
4338
  var TypeUnaryOp$0 = $EXPECT($L138, fail, 'TypeUnaryOp "keyof"');
4222
- var TypeUnaryOp$1 = $EXPECT($L72, fail, 'TypeUnaryOp "typeof"');
4339
+ var TypeUnaryOp$1 = $EXPECT($L71, fail, 'TypeUnaryOp "typeof"');
4223
4340
  var TypeUnaryOp$2 = $EXPECT($L139, fail, 'TypeUnaryOp "infer"');
4224
4341
  function TypeUnaryOp(state) {
4225
4342
  if (state.tokenize) {
@@ -4250,7 +4367,7 @@ var require_parser = __commonJS({
4250
4367
  return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
4251
4368
  }
4252
4369
  }
4253
- var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L8, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
4370
+ var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
4254
4371
  function TypeConditional(state) {
4255
4372
  if (state.verbose)
4256
4373
  console.log("ENTER:", "TypeConditional");
@@ -4261,7 +4378,7 @@ var require_parser = __commonJS({
4261
4378
  }
4262
4379
  }
4263
4380
  var TypeLiteral$0 = Literal;
4264
- var TypeLiteral$1 = $EXPECT($L71, fail, 'TypeLiteral "void"');
4381
+ var TypeLiteral$1 = $EXPECT($L70, fail, 'TypeLiteral "void"');
4265
4382
  var TypeLiteral$2 = $EXPECT($L140, fail, 'TypeLiteral "[]"');
4266
4383
  function TypeLiteral(state) {
4267
4384
  if (state.tokenize) {
@@ -4270,8 +4387,8 @@ var require_parser = __commonJS({
4270
4387
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
4271
4388
  }
4272
4389
  }
4273
- var TypeBinaryOp$0 = $EXPECT($L69, fail, 'TypeBinaryOp "|"');
4274
- var TypeBinaryOp$1 = $EXPECT($L67, fail, 'TypeBinaryOp "&"');
4390
+ var TypeBinaryOp$0 = $EXPECT($L68, fail, 'TypeBinaryOp "|"');
4391
+ var TypeBinaryOp$1 = $EXPECT($L66, fail, 'TypeBinaryOp "&"');
4275
4392
  function TypeBinaryOp(state) {
4276
4393
  if (state.tokenize) {
4277
4394
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -4279,7 +4396,7 @@ var require_parser = __commonJS({
4279
4396
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
4280
4397
  }
4281
4398
  }
4282
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L6, fail, 'FunctionType "=>"'), Type);
4399
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
4283
4400
  function FunctionType(state) {
4284
4401
  if (state.verbose)
4285
4402
  console.log("ENTER:", "FunctionType");
@@ -4289,7 +4406,7 @@ var require_parser = __commonJS({
4289
4406
  return FunctionType$0(state);
4290
4407
  }
4291
4408
  }
4292
- var TypeArguments$0 = $S(__, $EXPECT($L7, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeArguments ">"'));
4409
+ var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeArguments ">"'));
4293
4410
  function TypeArguments(state) {
4294
4411
  if (state.verbose)
4295
4412
  console.log("ENTER:", "TypeArguments");
@@ -4299,7 +4416,7 @@ var require_parser = __commonJS({
4299
4416
  return TypeArguments$0(state);
4300
4417
  }
4301
4418
  }
4302
- var TypeParameters$0 = $TS($S(__, $EXPECT($L7, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
4419
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
4303
4420
  return { ts: true, children: $0 };
4304
4421
  });
4305
4422
  function TypeParameters(state) {
@@ -4321,7 +4438,7 @@ var require_parser = __commonJS({
4321
4438
  return TypeParameter$0(state);
4322
4439
  }
4323
4440
  }
4324
- var TypeConstraint$0 = $S(__, $EXPECT($L8, fail, 'TypeConstraint "extends"'), Type);
4441
+ var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
4325
4442
  function TypeConstraint(state) {
4326
4443
  if (state.verbose)
4327
4444
  console.log("ENTER:", "TypeConstraint");
@@ -4332,8 +4449,8 @@ var require_parser = __commonJS({
4332
4449
  }
4333
4450
  }
4334
4451
  var TypeParameterDelimiter$0 = $S($Q(_), Comma);
4335
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L54, fail, 'TypeParameterDelimiter ">"')));
4336
- var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L54, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4452
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L53, fail, 'TypeParameterDelimiter ">"')));
4453
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L53, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4337
4454
  return { $loc, token: "," };
4338
4455
  });
4339
4456
  var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -4549,6 +4666,57 @@ var require_parser = __commonJS({
4549
4666
  const compatRe = /use coffee-compat/;
4550
4667
  module2.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
4551
4668
  }
4669
+ module2.parsePosition = function() {
4670
+ let s = Error().stack.split(/\n at /);
4671
+ s.shift();
4672
+ s = s.filter((e) => !e.match(/^eval/)).map((e) => e.split(" ")[0]);
4673
+ s = s.slice(1, s.indexOf("Program") + 1);
4674
+ return s;
4675
+ };
4676
+ module2.insertTrimmingSpace = function(spacing, c) {
4677
+ let target = spacing;
4678
+ while (Array.isArray(target)) {
4679
+ target = target[0];
4680
+ }
4681
+ if (target.token) {
4682
+ target.token = target.token.replace(/^ ?/, c);
4683
+ }
4684
+ return spacing;
4685
+ };
4686
+ module2.modifyString = function(str) {
4687
+ return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
4688
+ };
4689
+ module2.dedentBlockSubstitutions = function($02) {
4690
+ const [s, strWithSubstitutions, e] = $02;
4691
+ if (strWithSubstitutions.length === 0) {
4692
+ return $02;
4693
+ }
4694
+ let initialSpacing, i = 0, l = strWithSubstitutions.length, results = [s];
4695
+ const { token } = strWithSubstitutions[0];
4696
+ if (token) {
4697
+ initialSpacing = token.match(/^(\r?\n|\n)\s+/);
4698
+ } else {
4699
+ initialSpacing = false;
4700
+ }
4701
+ while (i < l) {
4702
+ let segment = strWithSubstitutions[i];
4703
+ if (segment.token) {
4704
+ segment = module2.dedentBlockString(segment, initialSpacing, false);
4705
+ if (i === 0) {
4706
+ segment.token = segment.token.replace(/^(\r?\n|\n)/, "");
4707
+ }
4708
+ if (i === l - 1) {
4709
+ segment.token = segment.token.replace(/(\r?\n|\n)[ \t]*$/, "");
4710
+ }
4711
+ results.push(segment);
4712
+ } else {
4713
+ results.push(segment);
4714
+ }
4715
+ i++;
4716
+ }
4717
+ results.push(e);
4718
+ return results;
4719
+ };
4552
4720
  module2.dedentBlockString = function({ $loc: $loc2, token: str }, spacing, trim = true) {
4553
4721
  if (spacing == null)
4554
4722
  spacing = str.match(/^(\r?\n|\n)[ \t]+/);