@danielx/civet 0.2.1 → 0.2.4

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 (6) hide show
  1. package/dist/browser.js +485 -453
  2. package/dist/browser.js.map +2 -2
  3. package/dist/civet +9 -9
  4. package/dist/cli.js.map +3 -3
  5. package/dist/main.js +485 -453
  6. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -486,16 +486,10 @@ var require_parser = __commonJS({
486
486
  MethodDefinition,
487
487
  ClassElementName,
488
488
  PrivateIdentifier,
489
- GeneratorDeclaration,
490
- GeneratorExpression,
491
489
  GeneratorMethod,
492
490
  GeneratorBody,
493
- AsyncFunctionDeclaration,
494
- AsyncFunctionExpression,
495
491
  AsyncMethod,
496
492
  AsyncFunctionBody,
497
- AsyncGeneratorDeclaration,
498
- AsyncGeneratorExpression,
499
493
  AsyncGeneratorMethod,
500
494
  AsyncGeneratorBody,
501
495
  AssignmentOp,
@@ -601,11 +595,19 @@ var require_parser = __commonJS({
601
595
  InterfaceBlock,
602
596
  NestedInterfaceProperties,
603
597
  NestedInterfaceProperty,
598
+ InterfaceProperty,
599
+ InterfacePropertyDelimiter,
600
+ TypeIndexSignature,
601
+ TypeIndex,
604
602
  TypeSuffix,
603
+ ReturnTypeSuffix,
604
+ TypePredicate,
605
605
  Type,
606
606
  TypeBinary,
607
607
  TypeUnary,
608
+ TypeUnarySuffix,
608
609
  TypeUnaryOp,
610
+ TypeIndexedAccess,
609
611
  TypePrimary,
610
612
  TypeConditional,
611
613
  TypeLiteral,
@@ -640,113 +642,113 @@ var require_parser = __commonJS({
640
642
  var $L1 = $L("(");
641
643
  var $L2 = $L(")");
642
644
  var $L3 = $L("?");
643
- var $L4 = $L("++");
644
- var $L5 = $L("--");
645
- var $L6 = $L("async");
646
- var $L7 = $L("yield");
647
- var $L8 = $L("*");
648
- var $L9 = $L("=>");
649
- var $L10 = $L("{");
650
- var $L11 = $L(":");
651
- var $L12 = $L("class");
652
- var $L13 = $L("<");
653
- var $L14 = $L("extends");
654
- var $L15 = $L("}");
655
- var $L16 = $L("static");
656
- var $L17 = $L("this");
657
- var $L18 = $L("@");
658
- var $L19 = $L("#");
659
- var $L20 = $L("new");
660
- var $L21 = $L("super");
661
- var $L22 = $L("import");
662
- var $L23 = $L("[");
663
- var $L24 = $L("]");
664
- var $L25 = $L(".");
665
- var $L26 = $L("super[");
666
- var $L27 = $L("new.target");
667
- var $L28 = $L("import.meta");
668
- var $L29 = $L("");
669
- var $L30 = $L("...");
670
- var $L31 = $L("function");
671
- var $L32 = $L("->");
672
- var $L33 = $L("true");
673
- var $L34 = $L("false");
674
- var $L35 = $L("null");
675
- var $L36 = $L("undefined");
676
- var $L37 = $L("get");
677
- var $L38 = $L("set");
678
- var $L39 = $L("**=");
679
- var $L40 = $L("*=");
680
- var $L41 = $L("/=");
681
- var $L42 = $L("%=");
682
- var $L43 = $L("+=");
683
- var $L44 = $L("-=");
684
- var $L45 = $L("<<=");
685
- var $L46 = $L(">>>=");
686
- var $L47 = $L(">>=");
687
- var $L48 = $L("&&=");
688
- var $L49 = $L("&=");
689
- var $L50 = $L("^=");
690
- var $L51 = $L("||=");
691
- var $L52 = $L("|=");
692
- var $L53 = $L("??=");
693
- var $L54 = $L("=");
694
- var $L55 = $L("**");
695
- var $L56 = $L("/");
696
- var $L57 = $L("%");
697
- var $L58 = $L("+");
698
- var $L59 = $L("-");
699
- var $L60 = $L("<=");
700
- var $L61 = $L(">=");
701
- var $L62 = $L("<<");
702
- var $L63 = $L(">>>");
703
- var $L64 = $L(">>");
704
- var $L65 = $L(">");
705
- var $L66 = $L("!==");
706
- var $L67 = $L("!=");
707
- var $L68 = $L("is");
708
- var $L69 = $L("===");
709
- var $L70 = $L("==");
710
- var $L71 = $L("and");
711
- var $L72 = $L("&&");
712
- var $L73 = $L("or");
713
- var $L74 = $L("||");
714
- var $L75 = $L("??");
715
- var $L76 = $L("instanceof");
716
- var $L77 = $L("in");
717
- var $L78 = $L("&");
718
- var $L79 = $L("^");
719
- var $L80 = $L("|");
720
- var $L81 = $L("delete");
721
- var $L82 = $L("void");
722
- var $L83 = $L("typeof");
723
- var $L84 = $L(";");
724
- var $L85 = $L("if");
725
- var $L86 = $L("else");
726
- var $L87 = $L("unless");
727
- var $L88 = $L("loop");
728
- var $L89 = $L("do");
729
- var $L90 = $L("while");
730
- var $L91 = $L("for");
731
- var $L92 = $L("var");
732
- var $L93 = $L("await");
733
- var $L94 = $L("of");
734
- var $L95 = $L("let");
735
- var $L96 = $L("const");
736
- var $L97 = $L("switch");
737
- var $L98 = $L("case");
738
- var $L99 = $L("default");
739
- var $L100 = $L("when");
740
- var $L101 = $L("try");
741
- var $L102 = $L("catch");
742
- var $L103 = $L("finally");
743
- var $L104 = $L("break");
744
- var $L105 = $L("continue");
745
- var $L106 = $L("debugger");
746
- var $L107 = $L("return");
747
- var $L108 = $L("throw");
748
- var $L109 = $L("import type");
749
- var $L110 = $L("as");
645
+ var $L4 = $L("as");
646
+ var $L5 = $L("++");
647
+ var $L6 = $L("--");
648
+ var $L7 = $L("async");
649
+ var $L8 = $L("yield");
650
+ var $L9 = $L("*");
651
+ var $L10 = $L("=>");
652
+ var $L11 = $L("{");
653
+ var $L12 = $L(":");
654
+ var $L13 = $L("class");
655
+ var $L14 = $L("<");
656
+ var $L15 = $L("extends");
657
+ var $L16 = $L("}");
658
+ var $L17 = $L("static");
659
+ var $L18 = $L("this");
660
+ var $L19 = $L("@");
661
+ var $L20 = $L("#");
662
+ var $L21 = $L("new");
663
+ var $L22 = $L("super");
664
+ var $L23 = $L("import");
665
+ var $L24 = $L("[");
666
+ var $L25 = $L("]");
667
+ var $L26 = $L(".");
668
+ var $L27 = $L("super[");
669
+ var $L28 = $L("new.target");
670
+ var $L29 = $L("import.meta");
671
+ var $L30 = $L("");
672
+ var $L31 = $L("...");
673
+ var $L32 = $L("function");
674
+ var $L33 = $L("->");
675
+ var $L34 = $L("true");
676
+ var $L35 = $L("false");
677
+ var $L36 = $L("null");
678
+ var $L37 = $L("undefined");
679
+ var $L38 = $L("get");
680
+ var $L39 = $L("set");
681
+ var $L40 = $L("**=");
682
+ var $L41 = $L("*=");
683
+ var $L42 = $L("/=");
684
+ var $L43 = $L("%=");
685
+ var $L44 = $L("+=");
686
+ var $L45 = $L("-=");
687
+ var $L46 = $L("<<=");
688
+ var $L47 = $L(">>>=");
689
+ var $L48 = $L(">>=");
690
+ var $L49 = $L("&&=");
691
+ var $L50 = $L("&=");
692
+ var $L51 = $L("^=");
693
+ var $L52 = $L("||=");
694
+ var $L53 = $L("|=");
695
+ var $L54 = $L("??=");
696
+ var $L55 = $L("=");
697
+ var $L56 = $L("**");
698
+ var $L57 = $L("/");
699
+ var $L58 = $L("%");
700
+ var $L59 = $L("+");
701
+ var $L60 = $L("-");
702
+ var $L61 = $L("<=");
703
+ var $L62 = $L(">=");
704
+ var $L63 = $L("<<");
705
+ var $L64 = $L(">>>");
706
+ var $L65 = $L(">>");
707
+ var $L66 = $L(">");
708
+ var $L67 = $L("!==");
709
+ var $L68 = $L("!=");
710
+ var $L69 = $L("is");
711
+ var $L70 = $L("===");
712
+ var $L71 = $L("==");
713
+ var $L72 = $L("and");
714
+ var $L73 = $L("&&");
715
+ var $L74 = $L("or");
716
+ var $L75 = $L("||");
717
+ var $L76 = $L("??");
718
+ var $L77 = $L("instanceof");
719
+ var $L78 = $L("in");
720
+ var $L79 = $L("&");
721
+ var $L80 = $L("^");
722
+ var $L81 = $L("|");
723
+ var $L82 = $L("delete");
724
+ var $L83 = $L("void");
725
+ var $L84 = $L("typeof");
726
+ var $L85 = $L(";");
727
+ var $L86 = $L("if");
728
+ var $L87 = $L("else");
729
+ var $L88 = $L("unless");
730
+ var $L89 = $L("loop");
731
+ var $L90 = $L("do");
732
+ var $L91 = $L("while");
733
+ var $L92 = $L("for");
734
+ var $L93 = $L("var");
735
+ var $L94 = $L("await");
736
+ var $L95 = $L("of");
737
+ var $L96 = $L("let");
738
+ var $L97 = $L("const");
739
+ var $L98 = $L("switch");
740
+ var $L99 = $L("case");
741
+ var $L100 = $L("default");
742
+ var $L101 = $L("when");
743
+ var $L102 = $L("try");
744
+ var $L103 = $L("catch");
745
+ var $L104 = $L("finally");
746
+ var $L105 = $L("break");
747
+ var $L106 = $L("continue");
748
+ var $L107 = $L("debugger");
749
+ var $L108 = $L("return");
750
+ var $L109 = $L("throw");
751
+ var $L110 = $L("import type");
750
752
  var $L111 = $L("from");
751
753
  var $L112 = $L("export");
752
754
  var $L113 = $L(":=");
@@ -763,44 +765,49 @@ var require_parser = __commonJS({
763
765
  var $L124 = $L("</");
764
766
  var $L125 = $L("<>");
765
767
  var $L126 = $L("</>");
766
- var $L127 = $L("infer");
767
- var $L128 = $L("[]");
768
- var $L129 = $L(" ");
769
- var $L130 = $L(" ");
770
- var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
771
- var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
772
- var $R2 = $R(new RegExp("\\p{ID_Continue}", "suy"));
773
- var $R3 = $R(new RegExp("[!~+-]", "suy"));
774
- var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
775
- var $R5 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
776
- var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
777
- var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
778
- var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
779
- var $R9 = $R(new RegExp('[^"\\\\]+', "suy"));
780
- var $R10 = $R(new RegExp("[^'\\\\]+", "suy"));
781
- var $R11 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
782
- var $R12 = $R(new RegExp(".", "suy"));
783
- var $R13 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
784
- var $R14 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
785
- var $R15 = $R(new RegExp("(:?\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
786
- var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
787
- var $R17 = $R(new RegExp("(?:and|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|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
788
- var $R18 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
789
- var $R19 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
790
- var $R20 = $R(new RegExp("[^\\r\\n]", "suy"));
791
- var $R21 = $R(new RegExp("[\\t ]+", "suy"));
792
- var $R22 = $R(new RegExp("[\\s]+", "suy"));
793
- var $R23 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
794
- var $R24 = $R(new RegExp('"[^"]*"', "suy"));
795
- var $R25 = $R(new RegExp("'[^']*'", "suy"));
796
- var $R26 = $R(new RegExp("[^{}<>]+", "suy"));
797
- var $R27 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
798
- var $R28 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
799
- var $R29 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
800
- var $R30 = $R(new RegExp("#![^\\r\\n]*", "suy"));
801
- var $R31 = $R(new RegExp("[\\t ]*", "suy"));
802
- var $R32 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
803
- var $R33 = $R(new RegExp("$", "suy"));
768
+ var $L127 = $L("readonly");
769
+ var $L128 = $L("asserts");
770
+ var $L129 = $L("keyof");
771
+ var $L130 = $L("infer");
772
+ var $L131 = $L("[]");
773
+ var $L132 = $L(" ");
774
+ var $L133 = $L(" ");
775
+ var $R0 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
776
+ var $R1 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
777
+ var $R2 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
778
+ var $R3 = $R(new RegExp("\\p{ID_Continue}", "suy"));
779
+ var $R4 = $R(new RegExp("[!~+-]", "suy"));
780
+ var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
781
+ var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
782
+ var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
783
+ var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
784
+ var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
785
+ var $R10 = $R(new RegExp('[^"\\\\]+', "suy"));
786
+ var $R11 = $R(new RegExp("[^'\\\\]+", "suy"));
787
+ var $R12 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
788
+ var $R13 = $R(new RegExp(".", "suy"));
789
+ var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
790
+ var $R15 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
791
+ var $R16 = $R(new RegExp("(:?\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
792
+ var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
793
+ 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|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
794
+ var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
795
+ var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
796
+ var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
797
+ var $R22 = $R(new RegExp("[\\t ]+", "suy"));
798
+ var $R23 = $R(new RegExp("[\\s]+", "suy"));
799
+ var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
800
+ var $R25 = $R(new RegExp('"[^"]*"', "suy"));
801
+ var $R26 = $R(new RegExp("'[^']*'", "suy"));
802
+ var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
803
+ var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
804
+ var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
805
+ var $R30 = $R(new RegExp("[+-]?", "suy"));
806
+ var $R31 = $R(new RegExp("[+-]", "suy"));
807
+ var $R32 = $R(new RegExp("#![^\\r\\n]*", "suy"));
808
+ var $R33 = $R(new RegExp("[\\t ]*", "suy"));
809
+ var $R34 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
810
+ var $R35 = $R(new RegExp("$", "suy"));
804
811
  var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
805
812
  function Program(state) {
806
813
  if (state.verbose)
@@ -899,10 +906,10 @@ var require_parser = __commonJS({
899
906
  var pre = $1;
900
907
  var exp = $2;
901
908
  var post = $3;
902
- if (post) {
909
+ if (post === "?") {
903
910
  return ["(", pre, , "(", exp, ") != null)"];
904
911
  }
905
- return [pre, exp];
912
+ return [pre, exp, post];
906
913
  });
907
914
  function UnaryExpression(state) {
908
915
  if (state.verbose)
@@ -914,17 +921,16 @@ var require_parser = __commonJS({
914
921
  }
915
922
  }
916
923
  var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
924
+ var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), $R$0($EXPECT($R0, fail, "UnaryPostfix /(?!\\p{ID_Continue})/")), Type);
917
925
  function UnaryPostfix(state) {
918
- if (state.verbose)
919
- console.log("ENTER:", "UnaryPostfix");
920
926
  if (state.tokenize) {
921
- return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state));
927
+ return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
922
928
  } else {
923
- return UnaryPostfix$0(state);
929
+ return UnaryPostfix$0(state) || UnaryPostfix$1(state);
924
930
  }
925
931
  }
926
- var UpdateExpression$0 = $S($C($EXPECT($L4, fail, 'UpdateExpression "++"'), $EXPECT($L5, fail, 'UpdateExpression "--"')), UnaryExpression);
927
- var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L4, fail, 'UpdateExpression "++"'), $EXPECT($L5, fail, 'UpdateExpression "--"'))));
932
+ var UpdateExpression$0 = $S($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"')), UnaryExpression);
933
+ var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"'))));
928
934
  function UpdateExpression(state) {
929
935
  if (state.tokenize) {
930
936
  return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
@@ -942,7 +948,7 @@ var require_parser = __commonJS({
942
948
  }
943
949
  }
944
950
  var AssignmentExpressionRest$0 = YieldExpression;
945
- var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L6, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
951
+ var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
946
952
  var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), $C($S($Q(_), Expression), $S(__, Expression)));
947
953
  var AssignmentExpressionRest$3 = ConditionalExpression;
948
954
  function AssignmentExpressionRest(state) {
@@ -952,7 +958,7 @@ var require_parser = __commonJS({
952
958
  return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
953
959
  }
954
960
  }
955
- var YieldExpression$0 = $S($EXPECT($L7, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L8, fail, 'YieldExpression "*"'))), AssignmentExpression);
961
+ var YieldExpression$0 = $S($EXPECT($L8, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L9, fail, 'YieldExpression "*"'))), AssignmentExpression);
956
962
  function YieldExpression(state) {
957
963
  if (state.verbose)
958
964
  console.log("ENTER:", "YieldExpression");
@@ -963,7 +969,7 @@ var require_parser = __commonJS({
963
969
  }
964
970
  }
965
971
  var ArrowFunction$0 = ThinArrowFunction;
966
- var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L9, fail, 'ArrowFunction "=>"'), ConciseBody);
972
+ var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L10, fail, 'ArrowFunction "=>"'), ConciseBody);
967
973
  function ArrowFunction(state) {
968
974
  if (state.tokenize) {
969
975
  return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
@@ -971,7 +977,7 @@ var require_parser = __commonJS({
971
977
  return ArrowFunction$0(state) || ArrowFunction$1(state);
972
978
  }
973
979
  }
974
- var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L10, fail, 'ConciseBody "{"'))), AssignmentExpression);
980
+ var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
975
981
  var ConciseBody$1 = $S(EOS, SingleNestedBlockExpression);
976
982
  var ConciseBody$2 = BracedBlock;
977
983
  function ConciseBody(state) {
@@ -981,7 +987,7 @@ var require_parser = __commonJS({
981
987
  return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
982
988
  }
983
989
  }
984
- var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L11, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
990
+ var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L12, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
985
991
  function ConditionalExpression(state) {
986
992
  if (state.verbose)
987
993
  console.log("ENTER:", "ConditionalExpression");
@@ -1030,7 +1036,7 @@ var require_parser = __commonJS({
1030
1036
  return ClassDeclaration$0(state);
1031
1037
  }
1032
1038
  }
1033
- var ClassExpression$0 = $S($EXPECT($L12, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
1039
+ var ClassExpression$0 = $S($EXPECT($L13, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
1034
1040
  function ClassExpression(state) {
1035
1041
  if (state.verbose)
1036
1042
  console.log("ENTER:", "ClassExpression");
@@ -1050,10 +1056,10 @@ var require_parser = __commonJS({
1050
1056
  return ClassHeritage$0(state);
1051
1057
  }
1052
1058
  }
1053
- var ExtendsToken$0 = $T($EXPECT($L13, fail, 'ExtendsToken "<"'), function(value) {
1059
+ var ExtendsToken$0 = $T($EXPECT($L14, fail, 'ExtendsToken "<"'), function(value) {
1054
1060
  return "extends";
1055
1061
  });
1056
- var ExtendsToken$1 = $EXPECT($L14, fail, 'ExtendsToken "extends"');
1062
+ var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
1057
1063
  function ExtendsToken(state) {
1058
1064
  if (state.tokenize) {
1059
1065
  return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
@@ -1061,7 +1067,7 @@ var require_parser = __commonJS({
1061
1067
  return ExtendsToken$0(state) || ExtendsToken$1(state);
1062
1068
  }
1063
1069
  }
1064
- var ClassBody$0 = $S(__, $EXPECT($L10, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L15, fail, 'ClassBody "}"'));
1070
+ var ClassBody$0 = $S(__, $EXPECT($L11, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L16, fail, 'ClassBody "}"'));
1065
1071
  var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
1066
1072
  function ClassBody(state) {
1067
1073
  if (state.tokenize) {
@@ -1095,8 +1101,8 @@ var require_parser = __commonJS({
1095
1101
  return NestedClassElement$0(state);
1096
1102
  }
1097
1103
  }
1098
- var ClassElement$0 = $S($EXPECT($L16, fail, 'ClassElement "static"'), BracedBlock);
1099
- var ClassElement$1 = $S($E($S($EXPECT($L16, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
1104
+ var ClassElement$0 = $S($EXPECT($L17, fail, 'ClassElement "static"'), BracedBlock);
1105
+ var ClassElement$1 = $S($E($S($EXPECT($L17, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
1100
1106
  function ClassElement(state) {
1101
1107
  if (state.tokenize) {
1102
1108
  return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
@@ -1114,12 +1120,12 @@ var require_parser = __commonJS({
1114
1120
  return FieldDefinition$0(state);
1115
1121
  }
1116
1122
  }
1117
- var This$0 = $EXPECT($L17, fail, 'This "this"');
1118
- var This$1 = $T($S($EXPECT($L18, fail, 'This "@"'), $S($E($EXPECT($L19, fail, 'This "#"')), IdentifierName)), function(value) {
1123
+ var This$0 = $EXPECT($L18, fail, 'This "this"');
1124
+ var This$1 = $T($S($EXPECT($L19, fail, 'This "@"'), $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName)), function(value) {
1119
1125
  var ref = value[1];
1120
1126
  return ["this.", ref];
1121
1127
  });
1122
- var This$2 = $T($EXPECT($L18, fail, 'This "@"'), function(value) {
1128
+ var This$2 = $T($EXPECT($L19, fail, 'This "@"'), function(value) {
1123
1129
  return "this";
1124
1130
  });
1125
1131
  function This(state) {
@@ -1138,7 +1144,7 @@ var require_parser = __commonJS({
1138
1144
  return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
1139
1145
  }
1140
1146
  }
1141
- var NewExpression$0 = $S($P($S($EXPECT($L20, fail, 'NewExpression "new"'), __)), MemberExpression);
1147
+ var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), MemberExpression);
1142
1148
  function NewExpression(state) {
1143
1149
  if (state.verbose)
1144
1150
  console.log("ENTER:", "NewExpression");
@@ -1148,8 +1154,8 @@ var require_parser = __commonJS({
1148
1154
  return NewExpression$0(state);
1149
1155
  }
1150
1156
  }
1151
- var CallExpression$0 = $S($EXPECT($L21, fail, 'CallExpression "super"'), __, Arguments);
1152
- var CallExpression$1 = $S($EXPECT($L22, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1157
+ var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
1158
+ var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1153
1159
  var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
1154
1160
  function CallExpression(state) {
1155
1161
  if (state.tokenize) {
@@ -1159,8 +1165,8 @@ var require_parser = __commonJS({
1159
1165
  }
1160
1166
  }
1161
1167
  var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1162
- var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L23, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L24, fail, 'CallExpressionRest "]"'));
1163
- var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L25, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1168
+ var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
1169
+ var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1164
1170
  var CallExpressionRest$3 = TemplateLiteral;
1165
1171
  function CallExpressionRest(state) {
1166
1172
  if (state.tokenize) {
@@ -1169,7 +1175,7 @@ var require_parser = __commonJS({
1169
1175
  return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1170
1176
  }
1171
1177
  }
1172
- var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
1178
+ var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
1173
1179
  function OptionalShorthand(state) {
1174
1180
  if (state.verbose)
1175
1181
  console.log("ENTER:", "OptionalShorthand");
@@ -1203,7 +1209,7 @@ var require_parser = __commonJS({
1203
1209
  return ApplicationStart$0(state);
1204
1210
  }
1205
1211
  }
1206
- var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
1212
+ var AdditionalReservedWords$0 = $R$0($EXPECT($R1, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
1207
1213
  function AdditionalReservedWords(state) {
1208
1214
  if (state.verbose)
1209
1215
  console.log("ENTER:", "AdditionalReservedWords");
@@ -1223,7 +1229,7 @@ var require_parser = __commonJS({
1223
1229
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1224
1230
  }
1225
1231
  }
1226
- var SuperProperty$0 = $S($EXPECT($L26, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L24, fail, 'SuperProperty "]"'));
1232
+ var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
1227
1233
  function SuperProperty(state) {
1228
1234
  if (state.verbose)
1229
1235
  console.log("ENTER:", "SuperProperty");
@@ -1233,8 +1239,8 @@ var require_parser = __commonJS({
1233
1239
  return SuperProperty$0(state);
1234
1240
  }
1235
1241
  }
1236
- var MetaProperty$0 = $EXPECT($L27, fail, 'MetaProperty "new.target"');
1237
- var MetaProperty$1 = $EXPECT($L28, fail, 'MetaProperty "import.meta"');
1242
+ var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
1243
+ var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
1238
1244
  function MetaProperty(state) {
1239
1245
  if (state.tokenize) {
1240
1246
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1243,7 +1249,7 @@ var require_parser = __commonJS({
1243
1249
  }
1244
1250
  }
1245
1251
  var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1246
- var Parameters$1 = $T($EXPECT($L29, fail, 'Parameters ""'), function(value) {
1252
+ var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
1247
1253
  return "()";
1248
1254
  });
1249
1255
  function Parameters(state) {
@@ -1297,7 +1303,7 @@ var require_parser = __commonJS({
1297
1303
  return BindingPattern$0(state) || BindingPattern$1(state);
1298
1304
  }
1299
1305
  }
1300
- var ObjectBindingPattern$0 = $S($EXPECT($L10, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L15, fail, 'ObjectBindingPattern "}"'));
1306
+ var ObjectBindingPattern$0 = $S($EXPECT($L11, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L16, fail, 'ObjectBindingPattern "}"'));
1301
1307
  function ObjectBindingPattern(state) {
1302
1308
  if (state.verbose)
1303
1309
  console.log("ENTER:", "ObjectBindingPattern");
@@ -1307,7 +1313,7 @@ var require_parser = __commonJS({
1307
1313
  return ObjectBindingPattern$0(state);
1308
1314
  }
1309
1315
  }
1310
- var ArrayBindingPattern$0 = $S($EXPECT($L23, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L24, fail, 'ArrayBindingPattern "]"'));
1316
+ var ArrayBindingPattern$0 = $S($EXPECT($L24, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L25, fail, 'ArrayBindingPattern "]"'));
1311
1317
  function ArrayBindingPattern(state) {
1312
1318
  if (state.verbose)
1313
1319
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1317,7 +1323,7 @@ var require_parser = __commonJS({
1317
1323
  return ArrayBindingPattern$0(state);
1318
1324
  }
1319
1325
  }
1320
- var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L11, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1326
+ var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L12, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1321
1327
  var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
1322
1328
  function BindingProperty(state) {
1323
1329
  if (state.tokenize) {
@@ -1326,7 +1332,7 @@ var require_parser = __commonJS({
1326
1332
  return BindingProperty$0(state) || BindingProperty$1(state);
1327
1333
  }
1328
1334
  }
1329
- var BindingRestProperty$0 = $S($EXPECT($L30, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1335
+ var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1330
1336
  function BindingRestProperty(state) {
1331
1337
  if (state.verbose)
1332
1338
  console.log("ENTER:", "BindingRestProperty");
@@ -1346,7 +1352,7 @@ var require_parser = __commonJS({
1346
1352
  return BindingElement$0(state);
1347
1353
  }
1348
1354
  }
1349
- var BindingRestElement$0 = $S($EXPECT($L30, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1355
+ var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1350
1356
  function BindingRestElement(state) {
1351
1357
  if (state.verbose)
1352
1358
  console.log("ENTER:", "BindingRestElement");
@@ -1367,7 +1373,7 @@ var require_parser = __commonJS({
1367
1373
  }
1368
1374
  }
1369
1375
  var FunctionExpression$0 = ThinArrowFunction;
1370
- var FunctionExpression$1 = $S($EXPECT($L31, fail, 'FunctionExpression "function"'), __, Parameters, BracedBlock);
1376
+ var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L32, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1371
1377
  function FunctionExpression(state) {
1372
1378
  if (state.tokenize) {
1373
1379
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1375,7 +1381,7 @@ var require_parser = __commonJS({
1375
1381
  return FunctionExpression$0(state) || FunctionExpression$1(state);
1376
1382
  }
1377
1383
  }
1378
- var ThinArrowFunction$0 = $T($S(Parameters, $E(TypeSuffix), __, $EXPECT($L32, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1384
+ var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1379
1385
  var params = value[0];
1380
1386
  var suffix = value[1];
1381
1387
  var block = value[4];
@@ -1390,7 +1396,7 @@ var require_parser = __commonJS({
1390
1396
  return ThinArrowFunction$0(state);
1391
1397
  }
1392
1398
  }
1393
- var Block$0 = $S(__, $EXPECT($L10, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'Block "}"'));
1399
+ var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
1394
1400
  var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1395
1401
  var Block$2 = Statement;
1396
1402
  var Block$3 = $S(__, Statement);
@@ -1401,7 +1407,7 @@ var require_parser = __commonJS({
1401
1407
  return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
1402
1408
  }
1403
1409
  }
1404
- var BracedBlock$0 = $S(__, $EXPECT($L10, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'BracedBlock "}"'));
1410
+ var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
1405
1411
  var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1406
1412
  var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
1407
1413
  function BracedBlock(state) {
@@ -1453,10 +1459,10 @@ var require_parser = __commonJS({
1453
1459
  }
1454
1460
  var Literal$0 = StringLiteral;
1455
1461
  var Literal$1 = NumericLiteral;
1456
- var Literal$2 = $EXPECT($L33, fail, 'Literal "true"');
1457
- var Literal$3 = $EXPECT($L34, fail, 'Literal "false"');
1458
- var Literal$4 = $EXPECT($L35, fail, 'Literal "null"');
1459
- var Literal$5 = $EXPECT($L36, fail, 'Literal "undefined"');
1462
+ var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
1463
+ var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
1464
+ var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
1465
+ var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
1460
1466
  function Literal(state) {
1461
1467
  if (state.tokenize) {
1462
1468
  return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
@@ -1484,7 +1490,7 @@ var require_parser = __commonJS({
1484
1490
  return Identifier$0(state);
1485
1491
  }
1486
1492
  }
1487
- var IdentifierName$0 = $R$0($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
1493
+ var IdentifierName$0 = $R$0($EXPECT($R2, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
1488
1494
  function IdentifierName(state) {
1489
1495
  if (state.verbose)
1490
1496
  console.log("ENTER:", "IdentifierName");
@@ -1504,8 +1510,8 @@ var require_parser = __commonJS({
1504
1510
  return IdentifierReference$0(state);
1505
1511
  }
1506
1512
  }
1507
- var ArrayLiteral$0 = $S($EXPECT($L23, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L24, fail, 'ArrayLiteral "]"'));
1508
- var ArrayLiteral$1 = $S($EXPECT($L23, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L24, fail, 'ArrayLiteral "]"'));
1513
+ var ArrayLiteral$0 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
1514
+ var ArrayLiteral$1 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
1509
1515
  function ArrayLiteral(state) {
1510
1516
  if (state.tokenize) {
1511
1517
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1539,8 +1545,8 @@ var require_parser = __commonJS({
1539
1545
  }
1540
1546
  }
1541
1547
  var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1542
- var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L24, fail, 'ArrayElementDelimiter "]"')));
1543
- var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L24, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1548
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
1549
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1544
1550
  return ",";
1545
1551
  });
1546
1552
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1563,7 +1569,7 @@ var require_parser = __commonJS({
1563
1569
  return ElementList$0(state);
1564
1570
  }
1565
1571
  }
1566
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L30, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1572
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1567
1573
  function ArrayElementExpression(state) {
1568
1574
  if (state.verbose)
1569
1575
  console.log("ENTER:", "ArrayElementExpression");
@@ -1583,9 +1589,9 @@ var require_parser = __commonJS({
1583
1589
  return Elision$0(state);
1584
1590
  }
1585
1591
  }
1586
- var ObjectLiteral$0 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L15, fail, 'ObjectLiteral "}"'));
1587
- var ObjectLiteral$1 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L15, fail, 'ObjectLiteral "}"'));
1588
- var ObjectLiteral$2 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), __, $EXPECT($L15, fail, 'ObjectLiteral "}"'));
1592
+ var ObjectLiteral$0 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1593
+ var ObjectLiteral$1 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1594
+ var ObjectLiteral$2 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1589
1595
  var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
1590
1596
  function ObjectLiteral(state) {
1591
1597
  if (state.tokenize) {
@@ -1620,8 +1626,8 @@ var require_parser = __commonJS({
1620
1626
  }
1621
1627
  }
1622
1628
  var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
1623
- var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L15, fail, 'ObjectPropertyDelimiter "}"')));
1624
- var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L15, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1629
+ var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
1630
+ var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1625
1631
  return ",";
1626
1632
  });
1627
1633
  var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1644,9 +1650,9 @@ var require_parser = __commonJS({
1644
1650
  return PropertyDefinitionList$0(state);
1645
1651
  }
1646
1652
  }
1647
- var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L11, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1653
+ var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1648
1654
  var PropertyDefinition$1 = MethodDefinition;
1649
- var PropertyDefinition$2 = $S($EXPECT($L30, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1655
+ var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1650
1656
  var PropertyDefinition$3 = IdentifierReference;
1651
1657
  function PropertyDefinition(state) {
1652
1658
  if (state.tokenize) {
@@ -1658,7 +1664,7 @@ var require_parser = __commonJS({
1658
1664
  var PropertyName$0 = NumericLiteral;
1659
1665
  var PropertyName$1 = StringLiteral;
1660
1666
  var PropertyName$2 = IdentifierName;
1661
- var PropertyName$3 = $S($EXPECT($L23, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L24, fail, 'PropertyName "]"'));
1667
+ var PropertyName$3 = $S($EXPECT($L24, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
1662
1668
  function PropertyName(state) {
1663
1669
  if (state.tokenize) {
1664
1670
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1666,8 +1672,8 @@ var require_parser = __commonJS({
1666
1672
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1667
1673
  }
1668
1674
  }
1669
- var MethodDefinition$0 = $S($EXPECT($L37, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R2, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1670
- var MethodDefinition$1 = $S($EXPECT($L38, fail, 'MethodDefinition "set"'), $N($R$0($EXPECT($R2, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1675
+ var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1676
+ var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1671
1677
  var MethodDefinition$2 = AsyncGeneratorMethod;
1672
1678
  var MethodDefinition$3 = AsyncMethod;
1673
1679
  var MethodDefinition$4 = GeneratorMethod;
@@ -1688,7 +1694,7 @@ var require_parser = __commonJS({
1688
1694
  return ClassElementName$0(state) || ClassElementName$1(state);
1689
1695
  }
1690
1696
  }
1691
- var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
1697
+ var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
1692
1698
  function PrivateIdentifier(state) {
1693
1699
  if (state.verbose)
1694
1700
  console.log("ENTER:", "PrivateIdentifier");
@@ -1698,27 +1704,7 @@ var require_parser = __commonJS({
1698
1704
  return PrivateIdentifier$0(state);
1699
1705
  }
1700
1706
  }
1701
- var GeneratorDeclaration$0 = GeneratorExpression;
1702
- function GeneratorDeclaration(state) {
1703
- if (state.verbose)
1704
- console.log("ENTER:", "GeneratorDeclaration");
1705
- if (state.tokenize) {
1706
- return $TOKEN("GeneratorDeclaration", state, GeneratorDeclaration$0(state));
1707
- } else {
1708
- return GeneratorDeclaration$0(state);
1709
- }
1710
- }
1711
- var GeneratorExpression$0 = $S($EXPECT($L31, fail, 'GeneratorExpression "function"'), __, $EXPECT($L8, fail, 'GeneratorExpression "*"'), $E($S(__, BindingIdentifier)), Parameters, GeneratorBody);
1712
- function GeneratorExpression(state) {
1713
- if (state.verbose)
1714
- console.log("ENTER:", "GeneratorExpression");
1715
- if (state.tokenize) {
1716
- return $TOKEN("GeneratorExpression", state, GeneratorExpression$0(state));
1717
- } else {
1718
- return GeneratorExpression$0(state);
1719
- }
1720
- }
1721
- var GeneratorMethod$0 = $S($EXPECT($L8, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1707
+ var GeneratorMethod$0 = $S($EXPECT($L9, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1722
1708
  function GeneratorMethod(state) {
1723
1709
  if (state.verbose)
1724
1710
  console.log("ENTER:", "GeneratorMethod");
@@ -1738,27 +1724,7 @@ var require_parser = __commonJS({
1738
1724
  return GeneratorBody$0(state);
1739
1725
  }
1740
1726
  }
1741
- var AsyncFunctionDeclaration$0 = AsyncFunctionExpression;
1742
- function AsyncFunctionDeclaration(state) {
1743
- if (state.verbose)
1744
- console.log("ENTER:", "AsyncFunctionDeclaration");
1745
- if (state.tokenize) {
1746
- return $TOKEN("AsyncFunctionDeclaration", state, AsyncFunctionDeclaration$0(state));
1747
- } else {
1748
- return AsyncFunctionDeclaration$0(state);
1749
- }
1750
- }
1751
- var AsyncFunctionExpression$0 = $S($EXPECT($L6, fail, 'AsyncFunctionExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncFunctionExpression "function"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncFunctionBody);
1752
- function AsyncFunctionExpression(state) {
1753
- if (state.verbose)
1754
- console.log("ENTER:", "AsyncFunctionExpression");
1755
- if (state.tokenize) {
1756
- return $TOKEN("AsyncFunctionExpression", state, AsyncFunctionExpression$0(state));
1757
- } else {
1758
- return AsyncFunctionExpression$0(state);
1759
- }
1760
- }
1761
- var AsyncMethod$0 = $S($EXPECT($L6, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
1727
+ var AsyncMethod$0 = $S($EXPECT($L7, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
1762
1728
  function AsyncMethod(state) {
1763
1729
  if (state.verbose)
1764
1730
  console.log("ENTER:", "AsyncMethod");
@@ -1778,27 +1744,7 @@ var require_parser = __commonJS({
1778
1744
  return AsyncFunctionBody$0(state);
1779
1745
  }
1780
1746
  }
1781
- var AsyncGeneratorDeclaration$0 = AsyncGeneratorExpression;
1782
- function AsyncGeneratorDeclaration(state) {
1783
- if (state.verbose)
1784
- console.log("ENTER:", "AsyncGeneratorDeclaration");
1785
- if (state.tokenize) {
1786
- return $TOKEN("AsyncGeneratorDeclaration", state, AsyncGeneratorDeclaration$0(state));
1787
- } else {
1788
- return AsyncGeneratorDeclaration$0(state);
1789
- }
1790
- }
1791
- var AsyncGeneratorExpression$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncGeneratorExpression "function"'), __, $EXPECT($L8, fail, 'AsyncGeneratorExpression "*"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncGeneratorBody);
1792
- function AsyncGeneratorExpression(state) {
1793
- if (state.verbose)
1794
- console.log("ENTER:", "AsyncGeneratorExpression");
1795
- if (state.tokenize) {
1796
- return $TOKEN("AsyncGeneratorExpression", state, AsyncGeneratorExpression$0(state));
1797
- } else {
1798
- return AsyncGeneratorExpression$0(state);
1799
- }
1800
- }
1801
- var AsyncGeneratorMethod$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L8, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1747
+ var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L9, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1802
1748
  function AsyncGeneratorMethod(state) {
1803
1749
  if (state.verbose)
1804
1750
  console.log("ENTER:", "AsyncGeneratorMethod");
@@ -1818,22 +1764,22 @@ var require_parser = __commonJS({
1818
1764
  return AsyncGeneratorBody$0(state);
1819
1765
  }
1820
1766
  }
1821
- var AssignmentOp$0 = $EXPECT($L39, fail, 'AssignmentOp "**="');
1822
- var AssignmentOp$1 = $EXPECT($L40, fail, 'AssignmentOp "*="');
1823
- var AssignmentOp$2 = $EXPECT($L41, fail, 'AssignmentOp "/="');
1824
- var AssignmentOp$3 = $EXPECT($L42, fail, 'AssignmentOp "%="');
1825
- var AssignmentOp$4 = $EXPECT($L43, fail, 'AssignmentOp "+="');
1826
- var AssignmentOp$5 = $EXPECT($L44, fail, 'AssignmentOp "-="');
1827
- var AssignmentOp$6 = $EXPECT($L45, fail, 'AssignmentOp "<<="');
1828
- var AssignmentOp$7 = $EXPECT($L46, fail, 'AssignmentOp ">>>="');
1829
- var AssignmentOp$8 = $EXPECT($L47, fail, 'AssignmentOp ">>="');
1830
- var AssignmentOp$9 = $EXPECT($L48, fail, 'AssignmentOp "&&="');
1831
- var AssignmentOp$10 = $EXPECT($L49, fail, 'AssignmentOp "&="');
1832
- var AssignmentOp$11 = $EXPECT($L50, fail, 'AssignmentOp "^="');
1833
- var AssignmentOp$12 = $EXPECT($L51, fail, 'AssignmentOp "||="');
1834
- var AssignmentOp$13 = $EXPECT($L52, fail, 'AssignmentOp "|="');
1835
- var AssignmentOp$14 = $EXPECT($L53, fail, 'AssignmentOp "??="');
1836
- var AssignmentOp$15 = $EXPECT($L54, fail, 'AssignmentOp "="');
1767
+ var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
1768
+ var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
1769
+ var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
1770
+ var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
1771
+ var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
1772
+ var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
1773
+ var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
1774
+ var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
1775
+ var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
1776
+ var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
1777
+ var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
1778
+ var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
1779
+ var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
1780
+ var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
1781
+ var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
1782
+ var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
1837
1783
  function AssignmentOp(state) {
1838
1784
  if (state.tokenize) {
1839
1785
  return $TOKEN("AssignmentOp", state, AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state));
@@ -1841,48 +1787,48 @@ var require_parser = __commonJS({
1841
1787
  return AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state);
1842
1788
  }
1843
1789
  }
1844
- var BinaryOp$0 = $EXPECT($L55, fail, 'BinaryOp "**"');
1845
- var BinaryOp$1 = $EXPECT($L8, fail, 'BinaryOp "*"');
1846
- var BinaryOp$2 = $EXPECT($L56, fail, 'BinaryOp "/"');
1847
- var BinaryOp$3 = $EXPECT($L57, fail, 'BinaryOp "%"');
1848
- var BinaryOp$4 = $EXPECT($L58, fail, 'BinaryOp "+"');
1849
- var BinaryOp$5 = $EXPECT($L59, fail, 'BinaryOp "-"');
1850
- var BinaryOp$6 = $EXPECT($L60, fail, 'BinaryOp "<="');
1851
- var BinaryOp$7 = $EXPECT($L61, fail, 'BinaryOp ">="');
1852
- var BinaryOp$8 = $EXPECT($L62, fail, 'BinaryOp "<<"');
1853
- var BinaryOp$9 = $EXPECT($L13, fail, 'BinaryOp "<"');
1854
- var BinaryOp$10 = $EXPECT($L63, fail, 'BinaryOp ">>>"');
1855
- var BinaryOp$11 = $EXPECT($L64, fail, 'BinaryOp ">>"');
1856
- var BinaryOp$12 = $EXPECT($L65, fail, 'BinaryOp ">"');
1857
- var BinaryOp$13 = $EXPECT($L66, fail, 'BinaryOp "!=="');
1858
- var BinaryOp$14 = $TV($EXPECT($L67, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1790
+ var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
1791
+ var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
1792
+ var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
1793
+ var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
1794
+ var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
1795
+ var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
1796
+ var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
1797
+ var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
1798
+ var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
1799
+ var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
1800
+ var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
1801
+ var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
1802
+ var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
1803
+ var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
1804
+ var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1859
1805
  if (global.coffeeCompat)
1860
1806
  return "!==";
1861
1807
  return $1;
1862
1808
  });
1863
- var BinaryOp$15 = $T($EXPECT($L68, fail, 'BinaryOp "is"'), function(value) {
1809
+ var BinaryOp$15 = $T($EXPECT($L69, fail, 'BinaryOp "is"'), function(value) {
1864
1810
  return "===";
1865
1811
  });
1866
- var BinaryOp$16 = $EXPECT($L69, fail, 'BinaryOp "==="');
1867
- var BinaryOp$17 = $TV($EXPECT($L70, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1812
+ var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
1813
+ var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1868
1814
  if (global.coffeeCompat)
1869
1815
  return "===";
1870
1816
  return $1;
1871
1817
  });
1872
- var BinaryOp$18 = $T($EXPECT($L71, fail, 'BinaryOp "and"'), function(value) {
1818
+ var BinaryOp$18 = $T($EXPECT($L72, fail, 'BinaryOp "and"'), function(value) {
1873
1819
  return "&&";
1874
1820
  });
1875
- var BinaryOp$19 = $EXPECT($L72, fail, 'BinaryOp "&&"');
1876
- var BinaryOp$20 = $T($EXPECT($L73, fail, 'BinaryOp "or"'), function(value) {
1821
+ var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
1822
+ var BinaryOp$20 = $T($EXPECT($L74, fail, 'BinaryOp "or"'), function(value) {
1877
1823
  return "||";
1878
1824
  });
1879
- var BinaryOp$21 = $EXPECT($L74, fail, 'BinaryOp "||"');
1880
- var BinaryOp$22 = $EXPECT($L75, fail, 'BinaryOp "??"');
1881
- var BinaryOp$23 = $EXPECT($L76, fail, 'BinaryOp "instanceof"');
1882
- var BinaryOp$24 = $EXPECT($L77, fail, 'BinaryOp "in"');
1883
- var BinaryOp$25 = $EXPECT($L78, fail, 'BinaryOp "&"');
1884
- var BinaryOp$26 = $EXPECT($L79, fail, 'BinaryOp "^"');
1885
- var BinaryOp$27 = $EXPECT($L80, fail, 'BinaryOp "|"');
1825
+ var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
1826
+ var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
1827
+ var BinaryOp$23 = $EXPECT($L77, fail, 'BinaryOp "instanceof"');
1828
+ var BinaryOp$24 = $EXPECT($L78, fail, 'BinaryOp "in"');
1829
+ var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
1830
+ var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
1831
+ var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
1886
1832
  function BinaryOp(state) {
1887
1833
  if (state.tokenize) {
1888
1834
  return $TOKEN("BinaryOp", state, BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state));
@@ -1890,8 +1836,8 @@ var require_parser = __commonJS({
1890
1836
  return BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state);
1891
1837
  }
1892
1838
  }
1893
- var UnaryOp$0 = $R$0($EXPECT($R3, fail, "UnaryOp /[!~+-]/"));
1894
- var UnaryOp$1 = $S($C($EXPECT($L81, fail, 'UnaryOp "delete"'), $EXPECT($L82, fail, 'UnaryOp "void"'), $EXPECT($L83, fail, 'UnaryOp "typeof"')), $P(_));
1839
+ var UnaryOp$0 = $R$0($EXPECT($R4, fail, "UnaryOp /[!~+-]/"));
1840
+ var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), $P(_));
1895
1841
  function UnaryOp(state) {
1896
1842
  if (state.tokenize) {
1897
1843
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -1926,7 +1872,7 @@ var require_parser = __commonJS({
1926
1872
  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);
1927
1873
  }
1928
1874
  }
1929
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L84, fail, 'EmptyStatement ";"')));
1875
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"')));
1930
1876
  function EmptyStatement(state) {
1931
1877
  if (state.verbose)
1932
1878
  console.log("ENTER:", "EmptyStatement");
@@ -1936,7 +1882,7 @@ var require_parser = __commonJS({
1936
1882
  return EmptyStatement$0(state);
1937
1883
  }
1938
1884
  }
1939
- var BlockStatement$0 = $S(__, $EXPECT($L10, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'BlockStatement "}"'));
1885
+ var BlockStatement$0 = $S(__, $EXPECT($L11, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BlockStatement "}"'));
1940
1886
  function BlockStatement(state) {
1941
1887
  if (state.verbose)
1942
1888
  console.log("ENTER:", "BlockStatement");
@@ -1946,8 +1892,8 @@ var require_parser = __commonJS({
1946
1892
  return BlockStatement$0(state);
1947
1893
  }
1948
1894
  }
1949
- var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L86, fail, 'IfStatement "else"'), Block)));
1950
- var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1895
+ var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L87, fail, 'IfStatement "else"'), Block)));
1896
+ var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1951
1897
  var condition = $2;
1952
1898
  var block = $3;
1953
1899
  return ["if", condition.map((c) => {
@@ -1977,7 +1923,7 @@ var require_parser = __commonJS({
1977
1923
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
1978
1924
  }
1979
1925
  }
1980
- var LoopStatement$0 = $TS($S($EXPECT($L88, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
1926
+ var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
1981
1927
  var b = $2;
1982
1928
  return ["while(true)", b];
1983
1929
  });
@@ -1990,7 +1936,7 @@ var require_parser = __commonJS({
1990
1936
  return LoopStatement$0(state);
1991
1937
  }
1992
1938
  }
1993
- var DoWhileStatement$0 = $S($EXPECT($L89, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L90, fail, 'DoWhileStatement "while"'), Condition);
1939
+ var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
1994
1940
  function DoWhileStatement(state) {
1995
1941
  if (state.verbose)
1996
1942
  console.log("ENTER:", "DoWhileStatement");
@@ -2000,7 +1946,7 @@ var require_parser = __commonJS({
2000
1946
  return DoWhileStatement$0(state);
2001
1947
  }
2002
1948
  }
2003
- var WhileStatement$0 = $S($EXPECT($L90, fail, 'WhileStatement "while"'), Condition, Block);
1949
+ var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), Condition, Block);
2004
1950
  function WhileStatement(state) {
2005
1951
  if (state.verbose)
2006
1952
  console.log("ENTER:", "WhileStatement");
@@ -2010,7 +1956,7 @@ var require_parser = __commonJS({
2010
1956
  return WhileStatement$0(state);
2011
1957
  }
2012
1958
  }
2013
- var ForStatement$0 = $S($EXPECT($L91, fail, 'ForStatement "for"'), __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L84, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L84, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
1959
+ var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L85, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L85, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2014
1960
  function ForStatement(state) {
2015
1961
  if (state.verbose)
2016
1962
  console.log("ENTER:", "ForStatement");
@@ -2020,10 +1966,10 @@ var require_parser = __commonJS({
2020
1966
  return ForStatement$0(state);
2021
1967
  }
2022
1968
  }
2023
- var ForInOfStatement$0 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L77, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2024
- var ForInOfStatement$1 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), __, InsertOpenParen, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L77, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2025
- var ForInOfStatement$2 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L93, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L94, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2026
- var ForInOfStatement$3 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L93, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L94, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
1969
+ var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
1970
+ var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
1971
+ var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
1972
+ var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2027
1973
  function ForInOfStatement(state) {
2028
1974
  if (state.tokenize) {
2029
1975
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2031,7 +1977,7 @@ var require_parser = __commonJS({
2031
1977
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2032
1978
  }
2033
1979
  }
2034
- var ForDeclaration$0 = $S($C($EXPECT($L95, fail, 'ForDeclaration "let"'), $EXPECT($L96, fail, 'ForDeclaration "const"')), __, ForBinding);
1980
+ var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), __, ForBinding);
2035
1981
  function ForDeclaration(state) {
2036
1982
  if (state.verbose)
2037
1983
  console.log("ENTER:", "ForDeclaration");
@@ -2050,7 +1996,7 @@ var require_parser = __commonJS({
2050
1996
  return ForBinding$0(state) || ForBinding$1(state);
2051
1997
  }
2052
1998
  }
2053
- var SwitchStatement$0 = $S($EXPECT($L97, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
1999
+ var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
2054
2000
  function SwitchStatement(state) {
2055
2001
  if (state.verbose)
2056
2002
  console.log("ENTER:", "SwitchStatement");
@@ -2060,7 +2006,7 @@ var require_parser = __commonJS({
2060
2006
  return SwitchStatement$0(state);
2061
2007
  }
2062
2008
  }
2063
- var CaseBlock$0 = $S(__, $EXPECT($L10, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L15, fail, 'CaseBlock "}"'));
2009
+ var CaseBlock$0 = $S(__, $EXPECT($L11, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L16, fail, 'CaseBlock "}"'));
2064
2010
  var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
2065
2011
  function CaseBlock(state) {
2066
2012
  if (state.tokenize) {
@@ -2094,9 +2040,9 @@ var require_parser = __commonJS({
2094
2040
  return NestedCaseClause$0(state);
2095
2041
  }
2096
2042
  }
2097
- var CaseClause$0 = $S($EXPECT($L98, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2043
+ var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2098
2044
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2099
- var CaseClause$2 = $S($EXPECT($L99, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
2045
+ var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
2100
2046
  function CaseClause(state) {
2101
2047
  if (state.tokenize) {
2102
2048
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2104,7 +2050,7 @@ var require_parser = __commonJS({
2104
2050
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2105
2051
  }
2106
2052
  }
2107
- var When$0 = $T($EXPECT($L100, fail, 'When "when"'), function(value) {
2053
+ var When$0 = $T($EXPECT($L101, fail, 'When "when"'), function(value) {
2108
2054
  return "case";
2109
2055
  });
2110
2056
  function When(state) {
@@ -2116,8 +2062,8 @@ var require_parser = __commonJS({
2116
2062
  return When$0(state);
2117
2063
  }
2118
2064
  }
2119
- var ImpliedColon$0 = $S(__, $EXPECT($L11, fail, 'ImpliedColon ":"'));
2120
- var ImpliedColon$1 = $T($EXPECT($L29, fail, 'ImpliedColon ""'), function(value) {
2065
+ var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2066
+ var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
2121
2067
  return ":";
2122
2068
  });
2123
2069
  function ImpliedColon(state) {
@@ -2127,7 +2073,7 @@ var require_parser = __commonJS({
2127
2073
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2128
2074
  }
2129
2075
  }
2130
- var TryStatement$0 = $TS($S($EXPECT($L101, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2076
+ var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2131
2077
  var c = $3;
2132
2078
  var f = $4;
2133
2079
  if (!c && !f) {
@@ -2144,7 +2090,7 @@ var require_parser = __commonJS({
2144
2090
  return TryStatement$0(state);
2145
2091
  }
2146
2092
  }
2147
- var Catch$0 = $S(__, $EXPECT($L102, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2093
+ var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2148
2094
  function Catch(state) {
2149
2095
  if (state.verbose)
2150
2096
  console.log("ENTER:", "Catch");
@@ -2163,7 +2109,7 @@ var require_parser = __commonJS({
2163
2109
  return CatchBind$0(state) || CatchBind$1(state);
2164
2110
  }
2165
2111
  }
2166
- var Finally$0 = $S(__, $EXPECT($L103, fail, 'Finally "finally"'), BracedBlock);
2112
+ var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
2167
2113
  function Finally(state) {
2168
2114
  if (state.verbose)
2169
2115
  console.log("ENTER:", "Finally");
@@ -2201,12 +2147,12 @@ var require_parser = __commonJS({
2201
2147
  return ExpressionStatement$0(state);
2202
2148
  }
2203
2149
  }
2204
- var KeywordStatement$0 = $EXPECT($L104, fail, 'KeywordStatement "break"');
2205
- var KeywordStatement$1 = $EXPECT($L105, fail, 'KeywordStatement "continue"');
2206
- var KeywordStatement$2 = $EXPECT($L106, fail, 'KeywordStatement "debugger"');
2207
- var KeywordStatement$3 = $S($EXPECT($L107, fail, 'KeywordStatement "return"'), Expression);
2208
- var KeywordStatement$4 = $EXPECT($L107, fail, 'KeywordStatement "return"');
2209
- var KeywordStatement$5 = $S($EXPECT($L108, fail, 'KeywordStatement "throw"'), Expression);
2150
+ var KeywordStatement$0 = $EXPECT($L105, fail, 'KeywordStatement "break"');
2151
+ var KeywordStatement$1 = $EXPECT($L106, fail, 'KeywordStatement "continue"');
2152
+ var KeywordStatement$2 = $EXPECT($L107, fail, 'KeywordStatement "debugger"');
2153
+ var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), Expression);
2154
+ var KeywordStatement$4 = $EXPECT($L108, fail, 'KeywordStatement "return"');
2155
+ var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), Expression);
2210
2156
  function KeywordStatement(state) {
2211
2157
  if (state.tokenize) {
2212
2158
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
@@ -2214,11 +2160,11 @@ var require_parser = __commonJS({
2214
2160
  return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
2215
2161
  }
2216
2162
  }
2217
- var ImportDeclaration$0 = $T($S($EXPECT($L109, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
2163
+ var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
2218
2164
  return { "ts": true, "children": value };
2219
2165
  });
2220
- var ImportDeclaration$1 = $S($EXPECT($L22, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
2221
- var ImportDeclaration$2 = $S($EXPECT($L22, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
2166
+ var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
2167
+ var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
2222
2168
  function ImportDeclaration(state) {
2223
2169
  if (state.tokenize) {
2224
2170
  return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
@@ -2236,7 +2182,7 @@ var require_parser = __commonJS({
2236
2182
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2237
2183
  }
2238
2184
  }
2239
- var NameSpaceImport$0 = $S($EXPECT($L8, fail, 'NameSpaceImport "*"'), __, $EXPECT($L110, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
2185
+ var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
2240
2186
  function NameSpaceImport(state) {
2241
2187
  if (state.verbose)
2242
2188
  console.log("ENTER:", "NameSpaceImport");
@@ -2246,7 +2192,7 @@ var require_parser = __commonJS({
2246
2192
  return NameSpaceImport$0(state);
2247
2193
  }
2248
2194
  }
2249
- var NamedImports$0 = $S($EXPECT($L10, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L15, fail, 'NamedImports "}"'));
2195
+ var NamedImports$0 = $S($EXPECT($L11, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L16, fail, 'NamedImports "}"'));
2250
2196
  function NamedImports(state) {
2251
2197
  if (state.verbose)
2252
2198
  console.log("ENTER:", "NamedImports");
@@ -2266,7 +2212,7 @@ var require_parser = __commonJS({
2266
2212
  return FromClause$0(state);
2267
2213
  }
2268
2214
  }
2269
- var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L110, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
2215
+ var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
2270
2216
  var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
2271
2217
  function ImportSpecifier(state) {
2272
2218
  if (state.tokenize) {
@@ -2304,7 +2250,7 @@ var require_parser = __commonJS({
2304
2250
  return ImportedBinding$0(state);
2305
2251
  }
2306
2252
  }
2307
- var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L99, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2253
+ var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2308
2254
  var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
2309
2255
  var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
2310
2256
  function ExportDeclaration(state) {
@@ -2314,7 +2260,7 @@ var require_parser = __commonJS({
2314
2260
  return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
2315
2261
  }
2316
2262
  }
2317
- var ExportFromClause$0 = $S($EXPECT($L8, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L110, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
2263
+ var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
2318
2264
  var ExportFromClause$1 = NamedExports;
2319
2265
  function ExportFromClause(state) {
2320
2266
  if (state.tokenize) {
@@ -2323,7 +2269,7 @@ var require_parser = __commonJS({
2323
2269
  return ExportFromClause$0(state) || ExportFromClause$1(state);
2324
2270
  }
2325
2271
  }
2326
- var NamedExports$0 = $S($EXPECT($L10, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L15, fail, 'NamedExports "}"'));
2272
+ var NamedExports$0 = $S($EXPECT($L11, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L16, fail, 'NamedExports "}"'));
2327
2273
  function NamedExports(state) {
2328
2274
  if (state.verbose)
2329
2275
  console.log("ENTER:", "NamedExports");
@@ -2333,7 +2279,7 @@ var require_parser = __commonJS({
2333
2279
  return NamedExports$0(state);
2334
2280
  }
2335
2281
  }
2336
- var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L110, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
2282
+ var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L4, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
2337
2283
  function ExportSpecifier(state) {
2338
2284
  if (state.verbose)
2339
2285
  console.log("ENTER:", "ExportSpecifier");
@@ -2354,18 +2300,17 @@ var require_parser = __commonJS({
2354
2300
  return Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state);
2355
2301
  }
2356
2302
  }
2357
- var HoistableDeclaration$0 = AsyncGeneratorDeclaration;
2358
- var HoistableDeclaration$1 = AsyncFunctionDeclaration;
2359
- var HoistableDeclaration$2 = GeneratorDeclaration;
2360
- var HoistableDeclaration$3 = FunctionDeclaration;
2303
+ var HoistableDeclaration$0 = FunctionDeclaration;
2361
2304
  function HoistableDeclaration(state) {
2305
+ if (state.verbose)
2306
+ console.log("ENTER:", "HoistableDeclaration");
2362
2307
  if (state.tokenize) {
2363
- return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state) || HoistableDeclaration$1(state) || HoistableDeclaration$2(state) || HoistableDeclaration$3(state));
2308
+ return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state));
2364
2309
  } else {
2365
- return HoistableDeclaration$0(state) || HoistableDeclaration$1(state) || HoistableDeclaration$2(state) || HoistableDeclaration$3(state);
2310
+ return HoistableDeclaration$0(state);
2366
2311
  }
2367
2312
  }
2368
- var LexicalDeclaration$0 = $S($C($EXPECT($L95, fail, 'LexicalDeclaration "let"'), $EXPECT($L96, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2313
+ var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2369
2314
  var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
2370
2315
  var bind = value[0];
2371
2316
  var suffix = value[1];
@@ -2389,7 +2334,7 @@ var require_parser = __commonJS({
2389
2334
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2390
2335
  }
2391
2336
  }
2392
- var Initializer$0 = $S(__, $EXPECT($L54, fail, 'Initializer "="'), AssignmentExpression);
2337
+ var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2393
2338
  function Initializer(state) {
2394
2339
  if (state.verbose)
2395
2340
  console.log("ENTER:", "Initializer");
@@ -2399,7 +2344,7 @@ var require_parser = __commonJS({
2399
2344
  return Initializer$0(state);
2400
2345
  }
2401
2346
  }
2402
- var VariableStatement$0 = $S($EXPECT($L92, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2347
+ var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2403
2348
  function VariableStatement(state) {
2404
2349
  if (state.verbose)
2405
2350
  console.log("ENTER:", "VariableStatement");
@@ -2440,7 +2385,7 @@ var require_parser = __commonJS({
2440
2385
  return NumericLiteral$0(state) || NumericLiteral$1(state) || NumericLiteral$2(state) || NumericLiteral$3(state) || NumericLiteral$4(state);
2441
2386
  }
2442
2387
  }
2443
- var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R4, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
2388
+ var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
2444
2389
  function DecimalBigIntegerLiteral(state) {
2445
2390
  if (state.verbose)
2446
2391
  console.log("ENTER:", "DecimalBigIntegerLiteral");
@@ -2450,7 +2395,7 @@ var require_parser = __commonJS({
2450
2395
  return DecimalBigIntegerLiteral$0(state);
2451
2396
  }
2452
2397
  }
2453
- var DecimalLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
2398
+ var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
2454
2399
  function DecimalLiteral(state) {
2455
2400
  if (state.verbose)
2456
2401
  console.log("ENTER:", "DecimalLiteral");
@@ -2460,7 +2405,7 @@ var require_parser = __commonJS({
2460
2405
  return DecimalLiteral$0(state);
2461
2406
  }
2462
2407
  }
2463
- var BinaryIntegerLiteral$0 = $R$0($EXPECT($R6, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
2408
+ var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
2464
2409
  function BinaryIntegerLiteral(state) {
2465
2410
  if (state.verbose)
2466
2411
  console.log("ENTER:", "BinaryIntegerLiteral");
@@ -2470,7 +2415,7 @@ var require_parser = __commonJS({
2470
2415
  return BinaryIntegerLiteral$0(state);
2471
2416
  }
2472
2417
  }
2473
- var OctalIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
2418
+ var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
2474
2419
  function OctalIntegerLiteral(state) {
2475
2420
  if (state.verbose)
2476
2421
  console.log("ENTER:", "OctalIntegerLiteral");
@@ -2480,7 +2425,7 @@ var require_parser = __commonJS({
2480
2425
  return OctalIntegerLiteral$0(state);
2481
2426
  }
2482
2427
  }
2483
- var HexLiteral$0 = $R$0($EXPECT($R8, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
2428
+ var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
2484
2429
  function HexLiteral(state) {
2485
2430
  if (state.verbose)
2486
2431
  console.log("ENTER:", "HexLiteral");
@@ -2502,7 +2447,7 @@ var require_parser = __commonJS({
2502
2447
  return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
2503
2448
  }
2504
2449
  }
2505
- var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
2450
+ var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
2506
2451
  var DoubleStringCharacter$1 = EscapeSequence;
2507
2452
  function DoubleStringCharacter(state) {
2508
2453
  if (state.tokenize) {
@@ -2511,7 +2456,7 @@ var require_parser = __commonJS({
2511
2456
  return DoubleStringCharacter$0(state) || DoubleStringCharacter$1(state);
2512
2457
  }
2513
2458
  }
2514
- var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /[^'\\\\]+/"));
2459
+ var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /[^'\\\\]+/"));
2515
2460
  var SingleStringCharacter$1 = EscapeSequence;
2516
2461
  function SingleStringCharacter(state) {
2517
2462
  if (state.tokenize) {
@@ -2520,7 +2465,7 @@ var require_parser = __commonJS({
2520
2465
  return SingleStringCharacter$0(state) || SingleStringCharacter$1(state);
2521
2466
  }
2522
2467
  }
2523
- var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R11, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
2468
+ var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
2524
2469
  function TripleDoubleStringCharacter(state) {
2525
2470
  if (state.verbose)
2526
2471
  console.log("ENTER:", "TripleDoubleStringCharacter");
@@ -2530,7 +2475,7 @@ var require_parser = __commonJS({
2530
2475
  return TripleDoubleStringCharacter$0(state);
2531
2476
  }
2532
2477
  }
2533
- var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R12, fail, "EscapeSequence /./")));
2478
+ var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R13, fail, "EscapeSequence /./")));
2534
2479
  function EscapeSequence(state) {
2535
2480
  if (state.verbose)
2536
2481
  console.log("ENTER:", "EscapeSequence");
@@ -2540,7 +2485,7 @@ var require_parser = __commonJS({
2540
2485
  return EscapeSequence$0(state);
2541
2486
  }
2542
2487
  }
2543
- var RegularExpressionLiteral$0 = $S($EXPECT($L56, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L56, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2488
+ var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2544
2489
  function RegularExpressionLiteral(state) {
2545
2490
  if (state.verbose)
2546
2491
  console.log("ENTER:", "RegularExpressionLiteral");
@@ -2550,7 +2495,7 @@ var require_parser = __commonJS({
2550
2495
  return RegularExpressionLiteral$0(state);
2551
2496
  }
2552
2497
  }
2553
- var RegularExpressionBody$0 = $S($R$0($EXPECT($R13, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
2498
+ var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
2554
2499
  function RegularExpressionBody(state) {
2555
2500
  if (state.verbose)
2556
2501
  console.log("ENTER:", "RegularExpressionBody");
@@ -2560,7 +2505,7 @@ var require_parser = __commonJS({
2560
2505
  return RegularExpressionBody$0(state);
2561
2506
  }
2562
2507
  }
2563
- var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
2508
+ var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
2564
2509
  var RegExpCharacter$1 = EscapeSequence;
2565
2510
  function RegExpCharacter(state) {
2566
2511
  if (state.tokenize) {
@@ -2569,7 +2514,7 @@ var require_parser = __commonJS({
2569
2514
  return RegExpCharacter$0(state) || RegExpCharacter$1(state);
2570
2515
  }
2571
2516
  }
2572
- var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
2517
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
2573
2518
  function RegularExpressionFlags(state) {
2574
2519
  if (state.verbose)
2575
2520
  console.log("ENTER:", "RegularExpressionFlags");
@@ -2589,7 +2534,7 @@ var require_parser = __commonJS({
2589
2534
  return TemplateLiteral$0(state);
2590
2535
  }
2591
2536
  }
2592
- var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L15, fail, 'TemplateSubstitution "}"'));
2537
+ var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2593
2538
  function TemplateSubstitution(state) {
2594
2539
  if (state.verbose)
2595
2540
  console.log("ENTER:", "TemplateSubstitution");
@@ -2599,7 +2544,7 @@ var require_parser = __commonJS({
2599
2544
  return TemplateSubstitution$0(state);
2600
2545
  }
2601
2546
  }
2602
- var TemplateCharacters$0 = $R$0($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
2547
+ var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
2603
2548
  function TemplateCharacters(state) {
2604
2549
  if (state.verbose)
2605
2550
  console.log("ENTER:", "TemplateCharacters");
@@ -2609,7 +2554,7 @@ var require_parser = __commonJS({
2609
2554
  return TemplateCharacters$0(state);
2610
2555
  }
2611
2556
  }
2612
- var ReservedWord$0 = $R$0($EXPECT($R17, fail, "ReservedWord /(?:and|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|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
2557
+ 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|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
2613
2558
  function ReservedWord(state) {
2614
2559
  if (state.verbose)
2615
2560
  console.log("ENTER:", "ReservedWord");
@@ -2628,7 +2573,7 @@ var require_parser = __commonJS({
2628
2573
  return Comment$0(state) || Comment$1(state);
2629
2574
  }
2630
2575
  }
2631
- var SingleLineComment$0 = $R$0($EXPECT($R18, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
2576
+ var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
2632
2577
  var SingleLineComment$1 = CoffeeSingleLineComment;
2633
2578
  function SingleLineComment(state) {
2634
2579
  if (state.tokenize) {
@@ -2646,7 +2591,7 @@ var require_parser = __commonJS({
2646
2591
  return MultiLineComment$0(state) || MultiLineComment$1(state);
2647
2592
  }
2648
2593
  }
2649
- var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R12, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
2594
+ var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R13, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
2650
2595
  function JSMultiLineComment(state) {
2651
2596
  if (state.verbose)
2652
2597
  console.log("ENTER:", "JSMultiLineComment");
@@ -2656,7 +2601,7 @@ var require_parser = __commonJS({
2656
2601
  return JSMultiLineComment$0(state);
2657
2602
  }
2658
2603
  }
2659
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R19, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2604
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2660
2605
  if (!global.coffeeCompat)
2661
2606
  return $skip;
2662
2607
  return ["//", $1];
@@ -2670,7 +2615,7 @@ var require_parser = __commonJS({
2670
2615
  return CoffeeSingleLineComment$0(state);
2671
2616
  }
2672
2617
  }
2673
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R12, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2618
+ var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R13, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2674
2619
  return ["/*", value[1], "*/"];
2675
2620
  });
2676
2621
  function CoffeeMultiLineComment(state) {
@@ -2682,7 +2627,7 @@ var require_parser = __commonJS({
2682
2627
  return CoffeeMultiLineComment$0(state);
2683
2628
  }
2684
2629
  }
2685
- var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($R20, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L121, fail, 'InlineComment "*/"'));
2630
+ var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($R21, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L121, fail, 'InlineComment "*/"'));
2686
2631
  function InlineComment(state) {
2687
2632
  if (state.verbose)
2688
2633
  console.log("ENTER:", "InlineComment");
@@ -2702,7 +2647,7 @@ var require_parser = __commonJS({
2702
2647
  return RestOfLine$0(state);
2703
2648
  }
2704
2649
  }
2705
- var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
2650
+ var TrailingComment$0 = $R$0($EXPECT($R22, fail, "TrailingComment /[\\t ]+/"));
2706
2651
  var TrailingComment$1 = InlineComment;
2707
2652
  var TrailingComment$2 = SingleLineComment;
2708
2653
  function TrailingComment(state) {
@@ -2712,7 +2657,7 @@ var require_parser = __commonJS({
2712
2657
  return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
2713
2658
  }
2714
2659
  }
2715
- var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
2660
+ var _$0 = $P($C($R$0($EXPECT($R22, fail, "_ /[\\t ]+/")), Comment));
2716
2661
  function _(state) {
2717
2662
  if (state.verbose)
2718
2663
  console.log("ENTER:", "_");
@@ -2722,7 +2667,7 @@ var require_parser = __commonJS({
2722
2667
  return _$0(state);
2723
2668
  }
2724
2669
  }
2725
- var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
2670
+ var __$0 = $Q($C($R$0($EXPECT($R23, fail, "__ /[\\s]+/")), Comment));
2726
2671
  function __(state) {
2727
2672
  if (state.verbose)
2728
2673
  console.log("ENTER:", "__");
@@ -2732,7 +2677,7 @@ var require_parser = __commonJS({
2732
2677
  return __$0(state);
2733
2678
  }
2734
2679
  }
2735
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L84, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2680
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L85, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2736
2681
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
2737
2682
  return [";", value];
2738
2683
  });
@@ -2746,7 +2691,6 @@ var require_parser = __commonJS({
2746
2691
  var JSXElement$0 = JSXSelfClosingElement;
2747
2692
  var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
2748
2693
  if ($1[1] !== $4[2]) {
2749
- console.log($1, $4, $loc);
2750
2694
  throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
2751
2695
  }
2752
2696
  return $0;
@@ -2758,7 +2702,7 @@ var require_parser = __commonJS({
2758
2702
  return JSXElement$0(state) || JSXElement$1(state);
2759
2703
  }
2760
2704
  }
2761
- var JSXSelfClosingElement$0 = $S($EXPECT($L13, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
2705
+ var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
2762
2706
  function JSXSelfClosingElement(state) {
2763
2707
  if (state.verbose)
2764
2708
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -2768,7 +2712,7 @@ var require_parser = __commonJS({
2768
2712
  return JSXSelfClosingElement$0(state);
2769
2713
  }
2770
2714
  }
2771
- var JSXOpeningElement$0 = $S($EXPECT($L13, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L65, fail, 'JSXOpeningElement ">"'));
2715
+ var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
2772
2716
  function JSXOpeningElement(state) {
2773
2717
  if (state.verbose)
2774
2718
  console.log("ENTER:", "JSXOpeningElement");
@@ -2778,7 +2722,7 @@ var require_parser = __commonJS({
2778
2722
  return JSXOpeningElement$0(state);
2779
2723
  }
2780
2724
  }
2781
- var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L65, fail, 'JSXClosingElement ">"'));
2725
+ var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
2782
2726
  function JSXClosingElement(state) {
2783
2727
  if (state.verbose)
2784
2728
  console.log("ENTER:", "JSXClosingElement");
@@ -2798,7 +2742,7 @@ var require_parser = __commonJS({
2798
2742
  return JSXFragment$0(state);
2799
2743
  }
2800
2744
  }
2801
- var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L11, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
2745
+ var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L26, fail, 'JSXElementName "."'), JSXIdentifierName))));
2802
2746
  function JSXElementName(state) {
2803
2747
  if (state.verbose)
2804
2748
  console.log("ENTER:", "JSXElementName");
@@ -2808,7 +2752,7 @@ var require_parser = __commonJS({
2808
2752
  return JSXElementName$0(state);
2809
2753
  }
2810
2754
  }
2811
- var JSXIdentifierName$0 = $R$0($EXPECT($R23, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
2755
+ var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
2812
2756
  function JSXIdentifierName(state) {
2813
2757
  if (state.verbose)
2814
2758
  console.log("ENTER:", "JSXIdentifierName");
@@ -2828,7 +2772,7 @@ var require_parser = __commonJS({
2828
2772
  return JSXAttributes$0(state);
2829
2773
  }
2830
2774
  }
2831
- var JSXAttribute$0 = $S($EXPECT($L10, fail, 'JSXAttribute "{"'), __, $EXPECT($L30, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L15, fail, 'JSXAttribute "}"'));
2775
+ var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2832
2776
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
2833
2777
  function JSXAttribute(state) {
2834
2778
  if (state.tokenize) {
@@ -2837,7 +2781,7 @@ var require_parser = __commonJS({
2837
2781
  return JSXAttribute$0(state) || JSXAttribute$1(state);
2838
2782
  }
2839
2783
  }
2840
- var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L11, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
2784
+ var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L12, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
2841
2785
  function JSXAttributeName(state) {
2842
2786
  if (state.verbose)
2843
2787
  console.log("ENTER:", "JSXAttributeName");
@@ -2847,7 +2791,7 @@ var require_parser = __commonJS({
2847
2791
  return JSXAttributeName$0(state);
2848
2792
  }
2849
2793
  }
2850
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L54, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2794
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2851
2795
  function JSXAttributeInitializer(state) {
2852
2796
  if (state.verbose)
2853
2797
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -2857,9 +2801,9 @@ var require_parser = __commonJS({
2857
2801
  return JSXAttributeInitializer$0(state);
2858
2802
  }
2859
2803
  }
2860
- var JSXAttributeValue$0 = $R$0($EXPECT($R24, fail, 'JSXAttributeValue /"[^"]*"/'));
2861
- var JSXAttributeValue$1 = $R$0($EXPECT($R25, fail, "JSXAttributeValue /'[^']*'/"));
2862
- var JSXAttributeValue$2 = $S($EXPECT($L10, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L15, fail, 'JSXAttributeValue "}"'));
2804
+ var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
2805
+ var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
2806
+ var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
2863
2807
  var JSXAttributeValue$3 = JSXElement;
2864
2808
  var JSXAttributeValue$4 = JSXFragment;
2865
2809
  function JSXAttributeValue(state) {
@@ -2882,7 +2826,7 @@ var require_parser = __commonJS({
2882
2826
  var JSXChild$0 = JSXText;
2883
2827
  var JSXChild$1 = JSXElement;
2884
2828
  var JSXChild$2 = JSXFragment;
2885
- var JSXChild$3 = $S($EXPECT($L10, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L15, fail, 'JSXChild "}"'));
2829
+ var JSXChild$3 = $S($EXPECT($L11, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L16, fail, 'JSXChild "}"'));
2886
2830
  function JSXChild(state) {
2887
2831
  if (state.tokenize) {
2888
2832
  return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
@@ -2890,7 +2834,7 @@ var require_parser = __commonJS({
2890
2834
  return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
2891
2835
  }
2892
2836
  }
2893
- var JSXText$0 = $R$0($EXPECT($R26, fail, "JSXText /[^{}<>]+/"));
2837
+ var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
2894
2838
  function JSXText(state) {
2895
2839
  if (state.verbose)
2896
2840
  console.log("ENTER:", "JSXText");
@@ -2900,7 +2844,7 @@ var require_parser = __commonJS({
2900
2844
  return JSXText$0(state);
2901
2845
  }
2902
2846
  }
2903
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L30, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2847
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2904
2848
  function JSXChildExpression(state) {
2905
2849
  if (state.verbose)
2906
2850
  console.log("ENTER:", "JSXChildExpression");
@@ -2910,10 +2854,10 @@ var require_parser = __commonJS({
2910
2854
  return JSXChildExpression$0(state);
2911
2855
  }
2912
2856
  }
2913
- var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L54, fail, 'TypeDeclaration "="'), __, Type), function(value) {
2857
+ var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
2914
2858
  return { "ts": true, "children": value };
2915
2859
  });
2916
- var TypeDeclaration$1 = $T($S($EXPECT($R28, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
2860
+ var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
2917
2861
  return { "ts": true, "children": value };
2918
2862
  });
2919
2863
  function TypeDeclaration(state) {
@@ -2923,13 +2867,14 @@ var require_parser = __commonJS({
2923
2867
  return TypeDeclaration$0(state) || TypeDeclaration$1(state);
2924
2868
  }
2925
2869
  }
2926
- var InterfaceBlock$0 = $S(__, $EXPECT($L10, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L15, fail, 'InterfaceBlock "}"'));
2927
- var InterfaceBlock$1 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
2870
+ var InterfaceBlock$0 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
2871
+ var InterfaceBlock$1 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
2872
+ var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
2928
2873
  function InterfaceBlock(state) {
2929
2874
  if (state.tokenize) {
2930
- return $TOKEN("InterfaceBlock", state, InterfaceBlock$0(state) || InterfaceBlock$1(state));
2875
+ return $TOKEN("InterfaceBlock", state, InterfaceBlock$0(state) || InterfaceBlock$1(state) || InterfaceBlock$2(state));
2931
2876
  } else {
2932
- return InterfaceBlock$0(state) || InterfaceBlock$1(state);
2877
+ return InterfaceBlock$0(state) || InterfaceBlock$1(state) || InterfaceBlock$2(state);
2933
2878
  }
2934
2879
  }
2935
2880
  var NestedInterfaceProperties$0 = $TS($S(PushIndent, $Q(NestedInterfaceProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
@@ -2947,7 +2892,7 @@ var require_parser = __commonJS({
2947
2892
  return NestedInterfaceProperties$0(state);
2948
2893
  }
2949
2894
  }
2950
- var NestedInterfaceProperty$0 = $S(Nested, PropertyName, TypeSuffix, StatementDelimiter);
2895
+ var NestedInterfaceProperty$0 = $S(Nested, InterfaceProperty);
2951
2896
  function NestedInterfaceProperty(state) {
2952
2897
  if (state.verbose)
2953
2898
  console.log("ENTER:", "NestedInterfaceProperty");
@@ -2957,7 +2902,51 @@ var require_parser = __commonJS({
2957
2902
  return NestedInterfaceProperty$0(state);
2958
2903
  }
2959
2904
  }
2960
- var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L11, fail, 'TypeSuffix ":"'), Type), function(value) {
2905
+ var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
2906
+ function InterfaceProperty(state) {
2907
+ if (state.verbose)
2908
+ console.log("ENTER:", "InterfaceProperty");
2909
+ if (state.tokenize) {
2910
+ return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state));
2911
+ } else {
2912
+ return InterfaceProperty$0(state);
2913
+ }
2914
+ }
2915
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L85, fail, 'InterfacePropertyDelimiter ";"'));
2916
+ var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
2917
+ var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
2918
+ return ";";
2919
+ });
2920
+ var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
2921
+ return ";";
2922
+ });
2923
+ function InterfacePropertyDelimiter(state) {
2924
+ if (state.tokenize) {
2925
+ return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state));
2926
+ } else {
2927
+ return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
2928
+ }
2929
+ }
2930
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L127, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
2931
+ function TypeIndexSignature(state) {
2932
+ if (state.verbose)
2933
+ console.log("ENTER:", "TypeIndexSignature");
2934
+ if (state.tokenize) {
2935
+ return $TOKEN("TypeIndexSignature", state, TypeIndexSignature$0(state));
2936
+ } else {
2937
+ return TypeIndexSignature$0(state);
2938
+ }
2939
+ }
2940
+ var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
2941
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
2942
+ function TypeIndex(state) {
2943
+ if (state.tokenize) {
2944
+ return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
2945
+ } else {
2946
+ return TypeIndex$0(state) || TypeIndex$1(state);
2947
+ }
2948
+ }
2949
+ var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L12, fail, 'TypeSuffix ":"'), Type), function(value) {
2961
2950
  return { "ts": true, "children": value };
2962
2951
  });
2963
2952
  function TypeSuffix(state) {
@@ -2969,6 +2958,28 @@ var require_parser = __commonJS({
2969
2958
  return TypeSuffix$0(state);
2970
2959
  }
2971
2960
  }
2961
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L128, fail, 'ReturnTypeSuffix "asserts"'), $EXPECT($R0, fail, "ReturnTypeSuffix /(?!\\p{ID_Continue})/"))), TypePredicate), function(value) {
2962
+ return { "ts": true, "children": value };
2963
+ });
2964
+ function ReturnTypeSuffix(state) {
2965
+ if (state.verbose)
2966
+ console.log("ENTER:", "ReturnTypeSuffix");
2967
+ if (state.tokenize) {
2968
+ return $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
2969
+ } else {
2970
+ return ReturnTypeSuffix$0(state);
2971
+ }
2972
+ }
2973
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), $R$0($EXPECT($R0, fail, "TypePredicate /(?!\\p{ID_Continue})/")), Type)));
2974
+ function TypePredicate(state) {
2975
+ if (state.verbose)
2976
+ console.log("ENTER:", "TypePredicate");
2977
+ if (state.tokenize) {
2978
+ return $TOKEN("TypePredicate", state, TypePredicate$0(state));
2979
+ } else {
2980
+ return TypePredicate$0(state);
2981
+ }
2982
+ }
2972
2983
  var Type$0 = TypeConditional;
2973
2984
  function Type(state) {
2974
2985
  if (state.verbose)
@@ -2989,7 +3000,7 @@ var require_parser = __commonJS({
2989
3000
  return TypeBinary$0(state);
2990
3001
  }
2991
3002
  }
2992
- var TypeUnary$0 = $S($Q(TypeUnaryOp), TypePrimary);
3003
+ var TypeUnary$0 = $S($Q($S(__, TypeUnaryOp, $R$0($EXPECT($R0, fail, "TypeUnary /(?!\\p{ID_Continue})/")))), TypePrimary, $Q(TypeUnarySuffix));
2993
3004
  function TypeUnary(state) {
2994
3005
  if (state.verbose)
2995
3006
  console.log("ENTER:", "TypeUnary");
@@ -2999,19 +3010,40 @@ var require_parser = __commonJS({
2999
3010
  return TypeUnary$0(state);
3000
3011
  }
3001
3012
  }
3002
- var TypeUnaryOp$0 = $S(__, $EXPECT($L83, fail, 'TypeUnaryOp "typeof"'), $R$0($EXPECT($R29, fail, "TypeUnaryOp /(?!\\p{ID_Continue})/")));
3003
- var TypeUnaryOp$1 = $S(__, $EXPECT($L127, fail, 'TypeUnaryOp "infer"'), $R$0($EXPECT($R29, fail, "TypeUnaryOp /(?!\\p{ID_Continue})/")));
3013
+ var TypeUnarySuffix$0 = TypeIndexedAccess;
3014
+ function TypeUnarySuffix(state) {
3015
+ if (state.verbose)
3016
+ console.log("ENTER:", "TypeUnarySuffix");
3017
+ if (state.tokenize) {
3018
+ return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
3019
+ } else {
3020
+ return TypeUnarySuffix$0(state);
3021
+ }
3022
+ }
3023
+ var TypeUnaryOp$0 = $EXPECT($L129, fail, 'TypeUnaryOp "keyof"');
3024
+ var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
3025
+ var TypeUnaryOp$2 = $EXPECT($L130, fail, 'TypeUnaryOp "infer"');
3004
3026
  function TypeUnaryOp(state) {
3005
3027
  if (state.tokenize) {
3006
- return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state));
3028
+ return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
3029
+ } else {
3030
+ return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3031
+ }
3032
+ }
3033
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L24, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L25, fail, 'TypeIndexedAccess "]"'));
3034
+ function TypeIndexedAccess(state) {
3035
+ if (state.verbose)
3036
+ console.log("ENTER:", "TypeIndexedAccess");
3037
+ if (state.tokenize) {
3038
+ return $TOKEN("TypeIndexedAccess", state, TypeIndexedAccess$0(state));
3007
3039
  } else {
3008
- return TypeUnaryOp$0(state) || TypeUnaryOp$1(state);
3040
+ return TypeIndexedAccess$0(state);
3009
3041
  }
3010
3042
  }
3011
3043
  var TypePrimary$0 = InterfaceBlock;
3012
3044
  var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
3013
3045
  var TypePrimary$2 = $S($Q(_), FunctionType);
3014
- var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments), $Q($EXPECT($L128, fail, 'TypePrimary "[]"')));
3046
+ var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L26, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
3015
3047
  var TypePrimary$4 = $S($Q(_), TypeLiteral);
3016
3048
  function TypePrimary(state) {
3017
3049
  if (state.tokenize) {
@@ -3020,7 +3052,7 @@ var require_parser = __commonJS({
3020
3052
  return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
3021
3053
  }
3022
3054
  }
3023
- var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L14, fail, 'TypeConditional "extends"'), Type, __, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L11, fail, 'TypeConditional ":"'), Type)));
3055
+ var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L15, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L12, fail, 'TypeConditional ":"'), Type)))));
3024
3056
  function TypeConditional(state) {
3025
3057
  if (state.verbose)
3026
3058
  console.log("ENTER:", "TypeConditional");
@@ -3031,8 +3063,8 @@ var require_parser = __commonJS({
3031
3063
  }
3032
3064
  }
3033
3065
  var TypeLiteral$0 = Literal;
3034
- var TypeLiteral$1 = $EXPECT($L82, fail, 'TypeLiteral "void"');
3035
- var TypeLiteral$2 = $EXPECT($L128, fail, 'TypeLiteral "[]"');
3066
+ var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3067
+ var TypeLiteral$2 = $EXPECT($L131, fail, 'TypeLiteral "[]"');
3036
3068
  function TypeLiteral(state) {
3037
3069
  if (state.tokenize) {
3038
3070
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3040,8 +3072,8 @@ var require_parser = __commonJS({
3040
3072
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3041
3073
  }
3042
3074
  }
3043
- var TypeBinaryOp$0 = $EXPECT($L80, fail, 'TypeBinaryOp "|"');
3044
- var TypeBinaryOp$1 = $EXPECT($L78, fail, 'TypeBinaryOp "&"');
3075
+ var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3076
+ var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3045
3077
  function TypeBinaryOp(state) {
3046
3078
  if (state.tokenize) {
3047
3079
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3049,7 +3081,7 @@ var require_parser = __commonJS({
3049
3081
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
3050
3082
  }
3051
3083
  }
3052
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L9, fail, 'FunctionType "=>"'), Type);
3084
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L10, fail, 'FunctionType "=>"'), Type);
3053
3085
  function FunctionType(state) {
3054
3086
  if (state.verbose)
3055
3087
  console.log("ENTER:", "FunctionType");
@@ -3059,7 +3091,7 @@ var require_parser = __commonJS({
3059
3091
  return FunctionType$0(state);
3060
3092
  }
3061
3093
  }
3062
- var TypeArguments$0 = $S(__, $EXPECT($L13, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L65, fail, 'TypeArguments ">"'));
3094
+ var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L66, fail, 'TypeArguments ">"'));
3063
3095
  function TypeArguments(state) {
3064
3096
  if (state.verbose)
3065
3097
  console.log("ENTER:", "TypeArguments");
@@ -3069,7 +3101,7 @@ var require_parser = __commonJS({
3069
3101
  return TypeArguments$0(state);
3070
3102
  }
3071
3103
  }
3072
- var TypeParameters$0 = $S(__, $EXPECT($L13, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L65, fail, 'TypeParameters ">"'));
3104
+ var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L66, fail, 'TypeParameters ">"'));
3073
3105
  function TypeParameters(state) {
3074
3106
  if (state.verbose)
3075
3107
  console.log("ENTER:", "TypeParameters");
@@ -3089,7 +3121,7 @@ var require_parser = __commonJS({
3089
3121
  return TypeParameter$0(state);
3090
3122
  }
3091
3123
  }
3092
- var TypeConstraint$0 = $S(__, $EXPECT($L14, fail, 'TypeConstraint "extends"'), Type);
3124
+ var TypeConstraint$0 = $S(__, $EXPECT($L15, fail, 'TypeConstraint "extends"'), Type);
3093
3125
  function TypeConstraint(state) {
3094
3126
  if (state.verbose)
3095
3127
  console.log("ENTER:", "TypeConstraint");
@@ -3100,8 +3132,8 @@ var require_parser = __commonJS({
3100
3132
  }
3101
3133
  }
3102
3134
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3103
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L65, fail, 'TypeParameterDelimiter ">"')));
3104
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L65, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3135
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
3136
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3105
3137
  return ",";
3106
3138
  });
3107
3139
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3114,7 +3146,7 @@ var require_parser = __commonJS({
3114
3146
  return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
3115
3147
  }
3116
3148
  }
3117
- var Shebang$0 = $R$0($EXPECT($R30, fail, "Shebang /#![^\\r\\n]*/"));
3149
+ var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
3118
3150
  function Shebang(state) {
3119
3151
  if (state.verbose)
3120
3152
  console.log("ENTER:", "Shebang");
@@ -3124,7 +3156,7 @@ var require_parser = __commonJS({
3124
3156
  return Shebang$0(state);
3125
3157
  }
3126
3158
  }
3127
- var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R31, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
3159
+ var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
3128
3160
  return $0.map((p) => p.join(""));
3129
3161
  });
3130
3162
  function DirectivePrologue(state) {
@@ -3146,7 +3178,7 @@ var require_parser = __commonJS({
3146
3178
  return EOS$0(state);
3147
3179
  }
3148
3180
  }
3149
- var EOL$0 = $R$0($EXPECT($R32, fail, "EOL /\\r\\n|\\n|\\r|$/"));
3181
+ var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
3150
3182
  function EOL(state) {
3151
3183
  if (state.verbose)
3152
3184
  console.log("ENTER:", "EOL");
@@ -3156,7 +3188,7 @@ var require_parser = __commonJS({
3156
3188
  return EOL$0(state);
3157
3189
  }
3158
3190
  }
3159
- var EOF$0 = $R$0($EXPECT($R33, fail, "EOF /$/"));
3191
+ var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
3160
3192
  function EOF(state) {
3161
3193
  if (state.verbose)
3162
3194
  console.log("ENTER:", "EOF");
@@ -3166,7 +3198,7 @@ var require_parser = __commonJS({
3166
3198
  return EOF$0(state);
3167
3199
  }
3168
3200
  }
3169
- var InsertOpenParen$0 = $T($EXPECT($L29, fail, 'InsertOpenParen ""'), function(value) {
3201
+ var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
3170
3202
  return "(";
3171
3203
  });
3172
3204
  function InsertOpenParen(state) {
@@ -3178,7 +3210,7 @@ var require_parser = __commonJS({
3178
3210
  return InsertOpenParen$0(state);
3179
3211
  }
3180
3212
  }
3181
- var InsertCloseParen$0 = $T($EXPECT($L29, fail, 'InsertCloseParen ""'), function(value) {
3213
+ var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
3182
3214
  return ")";
3183
3215
  });
3184
3216
  function InsertCloseParen(state) {
@@ -3190,7 +3222,7 @@ var require_parser = __commonJS({
3190
3222
  return InsertCloseParen$0(state);
3191
3223
  }
3192
3224
  }
3193
- var InsertOpenBrace$0 = $T($EXPECT($L29, fail, 'InsertOpenBrace ""'), function(value) {
3225
+ var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
3194
3226
  return " {";
3195
3227
  });
3196
3228
  function InsertOpenBrace(state) {
@@ -3202,7 +3234,7 @@ var require_parser = __commonJS({
3202
3234
  return InsertOpenBrace$0(state);
3203
3235
  }
3204
3236
  }
3205
- var InsertCloseBrace$0 = $T($EXPECT($L29, fail, 'InsertCloseBrace ""'), function(value) {
3237
+ var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
3206
3238
  return "}";
3207
3239
  });
3208
3240
  function InsertCloseBrace(state) {
@@ -3214,7 +3246,7 @@ var require_parser = __commonJS({
3214
3246
  return InsertCloseBrace$0(state);
3215
3247
  }
3216
3248
  }
3217
- var InsertNewline$0 = $TV($EXPECT($L29, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3249
+ var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3218
3250
  return "\n";
3219
3251
  });
3220
3252
  function InsertNewline(state) {
@@ -3226,7 +3258,7 @@ var require_parser = __commonJS({
3226
3258
  return InsertNewline$0(state);
3227
3259
  }
3228
3260
  }
3229
- var InsertIndent$0 = $TV($EXPECT($L29, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3261
+ var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3230
3262
  return "".padStart(global.currentIndent * 2);
3231
3263
  });
3232
3264
  function InsertIndent(state) {
@@ -3238,7 +3270,7 @@ var require_parser = __commonJS({
3238
3270
  return InsertIndent$0(state);
3239
3271
  }
3240
3272
  }
3241
- var InsertSpace$0 = $T($EXPECT($L29, fail, 'InsertSpace ""'), function(value) {
3273
+ var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
3242
3274
  return " ";
3243
3275
  });
3244
3276
  function InsertSpace(state) {
@@ -3250,7 +3282,7 @@ var require_parser = __commonJS({
3250
3282
  return InsertSpace$0(state);
3251
3283
  }
3252
3284
  }
3253
- var InsertDot$0 = $T($EXPECT($L29, fail, 'InsertDot ""'), function(value) {
3285
+ var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
3254
3286
  return ".";
3255
3287
  });
3256
3288
  function InsertDot(state) {
@@ -3262,7 +3294,7 @@ var require_parser = __commonJS({
3262
3294
  return InsertDot$0(state);
3263
3295
  }
3264
3296
  }
3265
- var InsertBreak$0 = $T($EXPECT($L29, fail, 'InsertBreak ""'), function(value) {
3297
+ var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
3266
3298
  return "break;";
3267
3299
  });
3268
3300
  function InsertBreak(state) {
@@ -3274,7 +3306,7 @@ var require_parser = __commonJS({
3274
3306
  return InsertBreak$0(state);
3275
3307
  }
3276
3308
  }
3277
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L29, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3309
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3278
3310
  var directives = $2;
3279
3311
  global.currentIndent = 0;
3280
3312
  global.indentLevels = [0];
@@ -3294,7 +3326,7 @@ var require_parser = __commonJS({
3294
3326
  return Init$0(state);
3295
3327
  }
3296
3328
  }
3297
- var Indent$0 = $TV($Q($C($EXPECT($L129, fail, 'Indent " "'), $EXPECT($L130, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3329
+ var Indent$0 = $TV($Q($C($EXPECT($L132, fail, 'Indent " "'), $EXPECT($L133, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3298
3330
  return $1.length;
3299
3331
  });
3300
3332
  function Indent(state) {
@@ -3306,7 +3338,7 @@ var require_parser = __commonJS({
3306
3338
  return Indent$0(state);
3307
3339
  }
3308
3340
  }
3309
- var PushIndent$0 = $TV($EXPECT($L29, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3341
+ var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3310
3342
  global.currentIndent++;
3311
3343
  if (global.verbose) {
3312
3344
  console.log("pushing indent", global.currentIndent);
@@ -3323,7 +3355,7 @@ var require_parser = __commonJS({
3323
3355
  return PushIndent$0(state);
3324
3356
  }
3325
3357
  }
3326
- var PopIndent$0 = $TV($EXPECT($L29, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3358
+ var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3327
3359
  if (global.verbose) {
3328
3360
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3329
3361
  }