@danielx/civet 0.1.1 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/README.md +9 -2
  2. package/dist/browser.js +725 -425
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +11 -11
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +725 -425
  7. package/package.json +4 -2
  8. package/register.js +12 -0
  9. package/register.mjs +40 -0
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,
@@ -581,14 +575,45 @@ var require_parser = __commonJS({
581
575
  _,
582
576
  __,
583
577
  StatementDelimiter,
578
+ JSXElement,
579
+ JSXSelfClosingElement,
580
+ JSXOpeningElement,
581
+ JSXClosingElement,
582
+ JSXFragment,
583
+ JSXElementName,
584
+ JSXIdentifierName,
585
+ JSXAttributes,
586
+ JSXAttribute,
587
+ JSXAttributeName,
588
+ JSXAttributeInitializer,
589
+ JSXAttributeValue,
590
+ JSXChildren,
591
+ JSXChild,
592
+ JSXText,
593
+ JSXChildExpression,
584
594
  TypeDeclaration,
585
595
  InterfaceBlock,
586
596
  NestedInterfaceProperties,
587
597
  NestedInterfaceProperty,
588
598
  TypeSuffix,
599
+ ReturnTypeSuffix,
600
+ TypePredicate,
589
601
  Type,
602
+ TypeBinary,
603
+ TypeUnary,
604
+ TypeUnarySuffix,
605
+ TypeUnaryOp,
606
+ TypeIndexedAccess,
607
+ TypePrimary,
608
+ TypeConditional,
609
+ TypeLiteral,
610
+ TypeBinaryOp,
590
611
  FunctionType,
591
612
  TypeArguments,
613
+ TypeParameters,
614
+ TypeParameter,
615
+ TypeConstraint,
616
+ TypeParameterDelimiter,
592
617
  Shebang,
593
618
  DirectivePrologue,
594
619
  EOS,
@@ -613,113 +638,113 @@ var require_parser = __commonJS({
613
638
  var $L1 = $L("(");
614
639
  var $L2 = $L(")");
615
640
  var $L3 = $L("?");
616
- var $L4 = $L("++");
617
- var $L5 = $L("--");
618
- var $L6 = $L("async");
619
- var $L7 = $L("yield");
620
- var $L8 = $L("*");
621
- var $L9 = $L("=>");
622
- var $L10 = $L("{");
623
- var $L11 = $L(":");
624
- var $L12 = $L("class");
625
- var $L13 = $L("<");
626
- var $L14 = $L("extends");
627
- var $L15 = $L("}");
628
- var $L16 = $L("static");
629
- var $L17 = $L("this");
630
- var $L18 = $L("@");
631
- var $L19 = $L("#");
632
- var $L20 = $L("new");
633
- var $L21 = $L("super");
634
- var $L22 = $L("import");
635
- var $L23 = $L("[");
636
- var $L24 = $L("]");
637
- var $L25 = $L(".");
638
- var $L26 = $L("super[");
639
- var $L27 = $L("new.target");
640
- var $L28 = $L("import.meta");
641
- var $L29 = $L("");
642
- var $L30 = $L("...");
643
- var $L31 = $L("function");
644
- var $L32 = $L("->");
645
- var $L33 = $L("true");
646
- var $L34 = $L("false");
647
- var $L35 = $L("null");
648
- var $L36 = $L("undefined");
649
- var $L37 = $L("get");
650
- var $L38 = $L("set");
651
- var $L39 = $L("**=");
652
- var $L40 = $L("*=");
653
- var $L41 = $L("/=");
654
- var $L42 = $L("%=");
655
- var $L43 = $L("+=");
656
- var $L44 = $L("-=");
657
- var $L45 = $L("<<=");
658
- var $L46 = $L(">>>=");
659
- var $L47 = $L(">>=");
660
- var $L48 = $L("&&=");
661
- var $L49 = $L("&=");
662
- var $L50 = $L("^=");
663
- var $L51 = $L("||=");
664
- var $L52 = $L("|=");
665
- var $L53 = $L("??=");
666
- var $L54 = $L("=");
667
- var $L55 = $L("**");
668
- var $L56 = $L("/");
669
- var $L57 = $L("%");
670
- var $L58 = $L("+");
671
- var $L59 = $L("-");
672
- var $L60 = $L("<=");
673
- var $L61 = $L(">=");
674
- var $L62 = $L("<<");
675
- var $L63 = $L(">>>");
676
- var $L64 = $L(">>");
677
- var $L65 = $L(">");
678
- var $L66 = $L("!==");
679
- var $L67 = $L("!=");
680
- var $L68 = $L("is");
681
- var $L69 = $L("===");
682
- var $L70 = $L("==");
683
- var $L71 = $L("and");
684
- var $L72 = $L("&&");
685
- var $L73 = $L("or");
686
- var $L74 = $L("||");
687
- var $L75 = $L("??");
688
- var $L76 = $L("instanceof");
689
- var $L77 = $L("in");
690
- var $L78 = $L("&");
691
- var $L79 = $L("^");
692
- var $L80 = $L("|");
693
- var $L81 = $L("delete");
694
- var $L82 = $L("void");
695
- var $L83 = $L("typeof");
696
- var $L84 = $L(";");
697
- var $L85 = $L("if");
698
- var $L86 = $L("else");
699
- var $L87 = $L("unless");
700
- var $L88 = $L("loop");
701
- var $L89 = $L("do");
702
- var $L90 = $L("while");
703
- var $L91 = $L("for");
704
- var $L92 = $L("var");
705
- var $L93 = $L("await");
706
- var $L94 = $L("of");
707
- var $L95 = $L("let");
708
- var $L96 = $L("const");
709
- var $L97 = $L("switch");
710
- var $L98 = $L("case");
711
- var $L99 = $L("default");
712
- var $L100 = $L("when");
713
- var $L101 = $L("try");
714
- var $L102 = $L("catch");
715
- var $L103 = $L("finally");
716
- var $L104 = $L("break");
717
- var $L105 = $L("continue");
718
- var $L106 = $L("debugger");
719
- var $L107 = $L("return");
720
- var $L108 = $L("throw");
721
- var $L109 = $L("import type");
722
- var $L110 = $L("as");
641
+ var $L4 = $L("as");
642
+ var $L5 = $L("++");
643
+ var $L6 = $L("--");
644
+ var $L7 = $L("async");
645
+ var $L8 = $L("yield");
646
+ var $L9 = $L("*");
647
+ var $L10 = $L("=>");
648
+ var $L11 = $L("{");
649
+ var $L12 = $L(":");
650
+ var $L13 = $L("class");
651
+ var $L14 = $L("<");
652
+ var $L15 = $L("extends");
653
+ var $L16 = $L("}");
654
+ var $L17 = $L("static");
655
+ var $L18 = $L("this");
656
+ var $L19 = $L("@");
657
+ var $L20 = $L("#");
658
+ var $L21 = $L("new");
659
+ var $L22 = $L("super");
660
+ var $L23 = $L("import");
661
+ var $L24 = $L("[");
662
+ var $L25 = $L("]");
663
+ var $L26 = $L(".");
664
+ var $L27 = $L("super[");
665
+ var $L28 = $L("new.target");
666
+ var $L29 = $L("import.meta");
667
+ var $L30 = $L("");
668
+ var $L31 = $L("...");
669
+ var $L32 = $L("function");
670
+ var $L33 = $L("->");
671
+ var $L34 = $L("true");
672
+ var $L35 = $L("false");
673
+ var $L36 = $L("null");
674
+ var $L37 = $L("undefined");
675
+ var $L38 = $L("get");
676
+ var $L39 = $L("set");
677
+ var $L40 = $L("**=");
678
+ var $L41 = $L("*=");
679
+ var $L42 = $L("/=");
680
+ var $L43 = $L("%=");
681
+ var $L44 = $L("+=");
682
+ var $L45 = $L("-=");
683
+ var $L46 = $L("<<=");
684
+ var $L47 = $L(">>>=");
685
+ var $L48 = $L(">>=");
686
+ var $L49 = $L("&&=");
687
+ var $L50 = $L("&=");
688
+ var $L51 = $L("^=");
689
+ var $L52 = $L("||=");
690
+ var $L53 = $L("|=");
691
+ var $L54 = $L("??=");
692
+ var $L55 = $L("=");
693
+ var $L56 = $L("**");
694
+ var $L57 = $L("/");
695
+ var $L58 = $L("%");
696
+ var $L59 = $L("+");
697
+ var $L60 = $L("-");
698
+ var $L61 = $L("<=");
699
+ var $L62 = $L(">=");
700
+ var $L63 = $L("<<");
701
+ var $L64 = $L(">>>");
702
+ var $L65 = $L(">>");
703
+ var $L66 = $L(">");
704
+ var $L67 = $L("!==");
705
+ var $L68 = $L("!=");
706
+ var $L69 = $L("is");
707
+ var $L70 = $L("===");
708
+ var $L71 = $L("==");
709
+ var $L72 = $L("and");
710
+ var $L73 = $L("&&");
711
+ var $L74 = $L("or");
712
+ var $L75 = $L("||");
713
+ var $L76 = $L("??");
714
+ var $L77 = $L("instanceof");
715
+ var $L78 = $L("in");
716
+ var $L79 = $L("&");
717
+ var $L80 = $L("^");
718
+ var $L81 = $L("|");
719
+ var $L82 = $L("delete");
720
+ var $L83 = $L("void");
721
+ var $L84 = $L("typeof");
722
+ var $L85 = $L(";");
723
+ var $L86 = $L("if");
724
+ var $L87 = $L("else");
725
+ var $L88 = $L("unless");
726
+ var $L89 = $L("loop");
727
+ var $L90 = $L("do");
728
+ var $L91 = $L("while");
729
+ var $L92 = $L("for");
730
+ var $L93 = $L("var");
731
+ var $L94 = $L("await");
732
+ var $L95 = $L("of");
733
+ var $L96 = $L("let");
734
+ var $L97 = $L("const");
735
+ var $L98 = $L("switch");
736
+ var $L99 = $L("case");
737
+ var $L100 = $L("default");
738
+ var $L101 = $L("when");
739
+ var $L102 = $L("try");
740
+ var $L103 = $L("catch");
741
+ var $L104 = $L("finally");
742
+ var $L105 = $L("break");
743
+ var $L106 = $L("continue");
744
+ var $L107 = $L("debugger");
745
+ var $L108 = $L("return");
746
+ var $L109 = $L("throw");
747
+ var $L110 = $L("import type");
723
748
  var $L111 = $L("from");
724
749
  var $L112 = $L("export");
725
750
  var $L113 = $L(":=");
@@ -732,37 +757,50 @@ var require_parser = __commonJS({
732
757
  var $L120 = $L("/*");
733
758
  var $L121 = $L("*/");
734
759
  var $L122 = $L("###");
735
- var $L123 = $L("interface");
736
- var $L124 = $L("[]");
737
- var $L125 = $L(" ");
738
- var $L126 = $L(" ");
739
- var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
740
- var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
741
- var $R2 = $R(new RegExp("\\p{ID_Continue}", "suy"));
742
- var $R3 = $R(new RegExp("[!~+-]", "suy"));
743
- var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
744
- var $R5 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
745
- var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
746
- var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
747
- var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
748
- var $R9 = $R(new RegExp('[^"\\\\]+', "suy"));
749
- var $R10 = $R(new RegExp("[^'\\\\]+", "suy"));
750
- var $R11 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
751
- var $R12 = $R(new RegExp(".", "suy"));
752
- var $R13 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
753
- var $R14 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
754
- var $R15 = $R(new RegExp("(:?\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
755
- var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
756
- 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"));
757
- var $R18 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
758
- var $R19 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
759
- var $R20 = $R(new RegExp("[^\\r\\n]", "suy"));
760
- var $R21 = $R(new RegExp("[\\t ]+", "suy"));
761
- var $R22 = $R(new RegExp("[\\s]+", "suy"));
762
- var $R23 = $R(new RegExp("#![^\\r\\n]*", "suy"));
763
- var $R24 = $R(new RegExp("[\\t ]*", "suy"));
764
- var $R25 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
765
- var $R26 = $R(new RegExp("$", "suy"));
760
+ var $L123 = $L("/>");
761
+ var $L124 = $L("</");
762
+ var $L125 = $L("<>");
763
+ var $L126 = $L("</>");
764
+ var $L127 = $L("asserts");
765
+ var $L128 = $L("keyof");
766
+ var $L129 = $L("infer");
767
+ var $L130 = $L("[]");
768
+ var $L131 = $L(" ");
769
+ var $L132 = $L(" ");
770
+ var $R0 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
771
+ var $R1 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
772
+ var $R2 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
773
+ var $R3 = $R(new RegExp("\\p{ID_Continue}", "suy"));
774
+ var $R4 = $R(new RegExp("[!~+-]", "suy"));
775
+ var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
776
+ var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
777
+ var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
778
+ var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
779
+ var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "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(".", "suy"));
784
+ var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
785
+ var $R15 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
786
+ var $R16 = $R(new RegExp("(:?\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
787
+ var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
788
+ 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"));
789
+ var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
790
+ var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
791
+ var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
792
+ var $R22 = $R(new RegExp("[\\t ]+", "suy"));
793
+ var $R23 = $R(new RegExp("[\\s]+", "suy"));
794
+ var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
795
+ var $R25 = $R(new RegExp('"[^"]*"', "suy"));
796
+ var $R26 = $R(new RegExp("'[^']*'", "suy"));
797
+ var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
798
+ var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
799
+ var $R29 = $R(new RegExp("interface(?!\\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"));
766
804
  var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
767
805
  function Program(state) {
768
806
  if (state.verbose)
@@ -861,10 +899,10 @@ var require_parser = __commonJS({
861
899
  var pre = $1;
862
900
  var exp = $2;
863
901
  var post = $3;
864
- if (post) {
902
+ if (post === "?") {
865
903
  return ["(", pre, , "(", exp, ") != null)"];
866
904
  }
867
- return [pre, exp];
905
+ return [pre, exp, post];
868
906
  });
869
907
  function UnaryExpression(state) {
870
908
  if (state.verbose)
@@ -876,17 +914,16 @@ var require_parser = __commonJS({
876
914
  }
877
915
  }
878
916
  var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
917
+ var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), $R$0($EXPECT($R0, fail, "UnaryPostfix /(?!\\p{ID_Continue})/")), Type);
879
918
  function UnaryPostfix(state) {
880
- if (state.verbose)
881
- console.log("ENTER:", "UnaryPostfix");
882
919
  if (state.tokenize) {
883
- return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state));
920
+ return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
884
921
  } else {
885
- return UnaryPostfix$0(state);
922
+ return UnaryPostfix$0(state) || UnaryPostfix$1(state);
886
923
  }
887
924
  }
888
- var UpdateExpression$0 = $S($C($EXPECT($L4, fail, 'UpdateExpression "++"'), $EXPECT($L5, fail, 'UpdateExpression "--"')), UnaryExpression);
889
- var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L4, fail, 'UpdateExpression "++"'), $EXPECT($L5, fail, 'UpdateExpression "--"'))));
925
+ var UpdateExpression$0 = $S($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"')), UnaryExpression);
926
+ var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"'))));
890
927
  function UpdateExpression(state) {
891
928
  if (state.tokenize) {
892
929
  return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
@@ -904,7 +941,7 @@ var require_parser = __commonJS({
904
941
  }
905
942
  }
906
943
  var AssignmentExpressionRest$0 = YieldExpression;
907
- var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L6, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
944
+ var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
908
945
  var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), $C($S($Q(_), Expression), $S(__, Expression)));
909
946
  var AssignmentExpressionRest$3 = ConditionalExpression;
910
947
  function AssignmentExpressionRest(state) {
@@ -914,7 +951,7 @@ var require_parser = __commonJS({
914
951
  return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
915
952
  }
916
953
  }
917
- var YieldExpression$0 = $S($EXPECT($L7, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L8, fail, 'YieldExpression "*"'))), AssignmentExpression);
954
+ var YieldExpression$0 = $S($EXPECT($L8, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L9, fail, 'YieldExpression "*"'))), AssignmentExpression);
918
955
  function YieldExpression(state) {
919
956
  if (state.verbose)
920
957
  console.log("ENTER:", "YieldExpression");
@@ -925,7 +962,7 @@ var require_parser = __commonJS({
925
962
  }
926
963
  }
927
964
  var ArrowFunction$0 = ThinArrowFunction;
928
- var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L9, fail, 'ArrowFunction "=>"'), ConciseBody);
965
+ var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L10, fail, 'ArrowFunction "=>"'), ConciseBody);
929
966
  function ArrowFunction(state) {
930
967
  if (state.tokenize) {
931
968
  return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
@@ -933,7 +970,7 @@ var require_parser = __commonJS({
933
970
  return ArrowFunction$0(state) || ArrowFunction$1(state);
934
971
  }
935
972
  }
936
- var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L10, fail, 'ConciseBody "{"'))), AssignmentExpression);
973
+ var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
937
974
  var ConciseBody$1 = $S(EOS, SingleNestedBlockExpression);
938
975
  var ConciseBody$2 = BracedBlock;
939
976
  function ConciseBody(state) {
@@ -943,7 +980,7 @@ var require_parser = __commonJS({
943
980
  return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
944
981
  }
945
982
  }
946
- var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L11, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
983
+ var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L12, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
947
984
  function ConditionalExpression(state) {
948
985
  if (state.verbose)
949
986
  console.log("ENTER:", "ConditionalExpression");
@@ -973,11 +1010,13 @@ var require_parser = __commonJS({
973
1010
  var PrimaryExpression$7 = RegularExpressionLiteral;
974
1011
  var PrimaryExpression$8 = TemplateLiteral;
975
1012
  var PrimaryExpression$9 = $S($EXPECT($L1, fail, 'PrimaryExpression "("'), __, Expression, __, $EXPECT($L2, fail, 'PrimaryExpression ")"'));
1013
+ var PrimaryExpression$10 = JSXElement;
1014
+ var PrimaryExpression$11 = JSXFragment;
976
1015
  function PrimaryExpression(state) {
977
1016
  if (state.tokenize) {
978
- return $TOKEN("PrimaryExpression", state, PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state));
1017
+ return $TOKEN("PrimaryExpression", state, PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state) || PrimaryExpression$10(state) || PrimaryExpression$11(state));
979
1018
  } else {
980
- return PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state);
1019
+ return PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state) || PrimaryExpression$10(state) || PrimaryExpression$11(state);
981
1020
  }
982
1021
  }
983
1022
  var ClassDeclaration$0 = ClassExpression;
@@ -990,7 +1029,7 @@ var require_parser = __commonJS({
990
1029
  return ClassDeclaration$0(state);
991
1030
  }
992
1031
  }
993
- var ClassExpression$0 = $S($EXPECT($L12, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
1032
+ var ClassExpression$0 = $S($EXPECT($L13, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
994
1033
  function ClassExpression(state) {
995
1034
  if (state.verbose)
996
1035
  console.log("ENTER:", "ClassExpression");
@@ -1010,10 +1049,10 @@ var require_parser = __commonJS({
1010
1049
  return ClassHeritage$0(state);
1011
1050
  }
1012
1051
  }
1013
- var ExtendsToken$0 = $T($EXPECT($L13, fail, 'ExtendsToken "<"'), function(value) {
1052
+ var ExtendsToken$0 = $T($EXPECT($L14, fail, 'ExtendsToken "<"'), function(value) {
1014
1053
  return "extends";
1015
1054
  });
1016
- var ExtendsToken$1 = $EXPECT($L14, fail, 'ExtendsToken "extends"');
1055
+ var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
1017
1056
  function ExtendsToken(state) {
1018
1057
  if (state.tokenize) {
1019
1058
  return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
@@ -1021,7 +1060,7 @@ var require_parser = __commonJS({
1021
1060
  return ExtendsToken$0(state) || ExtendsToken$1(state);
1022
1061
  }
1023
1062
  }
1024
- var ClassBody$0 = $S(__, $EXPECT($L10, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L15, fail, 'ClassBody "}"'));
1063
+ var ClassBody$0 = $S(__, $EXPECT($L11, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L16, fail, 'ClassBody "}"'));
1025
1064
  var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
1026
1065
  function ClassBody(state) {
1027
1066
  if (state.tokenize) {
@@ -1055,8 +1094,8 @@ var require_parser = __commonJS({
1055
1094
  return NestedClassElement$0(state);
1056
1095
  }
1057
1096
  }
1058
- var ClassElement$0 = $S($EXPECT($L16, fail, 'ClassElement "static"'), BracedBlock);
1059
- var ClassElement$1 = $S($E($S($EXPECT($L16, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
1097
+ var ClassElement$0 = $S($EXPECT($L17, fail, 'ClassElement "static"'), BracedBlock);
1098
+ var ClassElement$1 = $S($E($S($EXPECT($L17, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
1060
1099
  function ClassElement(state) {
1061
1100
  if (state.tokenize) {
1062
1101
  return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
@@ -1074,12 +1113,12 @@ var require_parser = __commonJS({
1074
1113
  return FieldDefinition$0(state);
1075
1114
  }
1076
1115
  }
1077
- var This$0 = $EXPECT($L17, fail, 'This "this"');
1078
- var This$1 = $T($S($EXPECT($L18, fail, 'This "@"'), $S($E($EXPECT($L19, fail, 'This "#"')), IdentifierName)), function(value) {
1116
+ var This$0 = $EXPECT($L18, fail, 'This "this"');
1117
+ var This$1 = $T($S($EXPECT($L19, fail, 'This "@"'), $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName)), function(value) {
1079
1118
  var ref = value[1];
1080
1119
  return ["this.", ref];
1081
1120
  });
1082
- var This$2 = $T($EXPECT($L18, fail, 'This "@"'), function(value) {
1121
+ var This$2 = $T($EXPECT($L19, fail, 'This "@"'), function(value) {
1083
1122
  return "this";
1084
1123
  });
1085
1124
  function This(state) {
@@ -1098,7 +1137,7 @@ var require_parser = __commonJS({
1098
1137
  return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
1099
1138
  }
1100
1139
  }
1101
- var NewExpression$0 = $S($P($S($EXPECT($L20, fail, 'NewExpression "new"'), __)), MemberExpression);
1140
+ var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), MemberExpression);
1102
1141
  function NewExpression(state) {
1103
1142
  if (state.verbose)
1104
1143
  console.log("ENTER:", "NewExpression");
@@ -1108,8 +1147,8 @@ var require_parser = __commonJS({
1108
1147
  return NewExpression$0(state);
1109
1148
  }
1110
1149
  }
1111
- var CallExpression$0 = $S($EXPECT($L21, fail, 'CallExpression "super"'), __, Arguments);
1112
- var CallExpression$1 = $S($EXPECT($L22, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1150
+ var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
1151
+ var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1113
1152
  var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
1114
1153
  function CallExpression(state) {
1115
1154
  if (state.tokenize) {
@@ -1119,8 +1158,8 @@ var require_parser = __commonJS({
1119
1158
  }
1120
1159
  }
1121
1160
  var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1122
- var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L23, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L24, fail, 'CallExpressionRest "]"'));
1123
- var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L25, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1161
+ var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
1162
+ var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1124
1163
  var CallExpressionRest$3 = TemplateLiteral;
1125
1164
  function CallExpressionRest(state) {
1126
1165
  if (state.tokenize) {
@@ -1129,7 +1168,7 @@ var require_parser = __commonJS({
1129
1168
  return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1130
1169
  }
1131
1170
  }
1132
- var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
1171
+ var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
1133
1172
  function OptionalShorthand(state) {
1134
1173
  if (state.verbose)
1135
1174
  console.log("ENTER:", "OptionalShorthand");
@@ -1163,7 +1202,7 @@ var require_parser = __commonJS({
1163
1202
  return ApplicationStart$0(state);
1164
1203
  }
1165
1204
  }
1166
- var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
1205
+ var AdditionalReservedWords$0 = $R$0($EXPECT($R1, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
1167
1206
  function AdditionalReservedWords(state) {
1168
1207
  if (state.verbose)
1169
1208
  console.log("ENTER:", "AdditionalReservedWords");
@@ -1183,7 +1222,7 @@ var require_parser = __commonJS({
1183
1222
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1184
1223
  }
1185
1224
  }
1186
- var SuperProperty$0 = $S($EXPECT($L26, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L24, fail, 'SuperProperty "]"'));
1225
+ var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
1187
1226
  function SuperProperty(state) {
1188
1227
  if (state.verbose)
1189
1228
  console.log("ENTER:", "SuperProperty");
@@ -1193,8 +1232,8 @@ var require_parser = __commonJS({
1193
1232
  return SuperProperty$0(state);
1194
1233
  }
1195
1234
  }
1196
- var MetaProperty$0 = $EXPECT($L27, fail, 'MetaProperty "new.target"');
1197
- var MetaProperty$1 = $EXPECT($L28, fail, 'MetaProperty "import.meta"');
1235
+ var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
1236
+ var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
1198
1237
  function MetaProperty(state) {
1199
1238
  if (state.tokenize) {
1200
1239
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1203,7 +1242,7 @@ var require_parser = __commonJS({
1203
1242
  }
1204
1243
  }
1205
1244
  var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1206
- var Parameters$1 = $T($EXPECT($L29, fail, 'Parameters ""'), function(value) {
1245
+ var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
1207
1246
  return "()";
1208
1247
  });
1209
1248
  function Parameters(state) {
@@ -1257,7 +1296,7 @@ var require_parser = __commonJS({
1257
1296
  return BindingPattern$0(state) || BindingPattern$1(state);
1258
1297
  }
1259
1298
  }
1260
- var ObjectBindingPattern$0 = $S($EXPECT($L10, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L15, fail, 'ObjectBindingPattern "}"'));
1299
+ var ObjectBindingPattern$0 = $S($EXPECT($L11, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L16, fail, 'ObjectBindingPattern "}"'));
1261
1300
  function ObjectBindingPattern(state) {
1262
1301
  if (state.verbose)
1263
1302
  console.log("ENTER:", "ObjectBindingPattern");
@@ -1267,7 +1306,7 @@ var require_parser = __commonJS({
1267
1306
  return ObjectBindingPattern$0(state);
1268
1307
  }
1269
1308
  }
1270
- var ArrayBindingPattern$0 = $S($EXPECT($L23, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L24, fail, 'ArrayBindingPattern "]"'));
1309
+ var ArrayBindingPattern$0 = $S($EXPECT($L24, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L25, fail, 'ArrayBindingPattern "]"'));
1271
1310
  function ArrayBindingPattern(state) {
1272
1311
  if (state.verbose)
1273
1312
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1277,7 +1316,7 @@ var require_parser = __commonJS({
1277
1316
  return ArrayBindingPattern$0(state);
1278
1317
  }
1279
1318
  }
1280
- var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L11, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1319
+ var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L12, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1281
1320
  var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
1282
1321
  function BindingProperty(state) {
1283
1322
  if (state.tokenize) {
@@ -1286,7 +1325,7 @@ var require_parser = __commonJS({
1286
1325
  return BindingProperty$0(state) || BindingProperty$1(state);
1287
1326
  }
1288
1327
  }
1289
- var BindingRestProperty$0 = $S($EXPECT($L30, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1328
+ var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1290
1329
  function BindingRestProperty(state) {
1291
1330
  if (state.verbose)
1292
1331
  console.log("ENTER:", "BindingRestProperty");
@@ -1306,7 +1345,7 @@ var require_parser = __commonJS({
1306
1345
  return BindingElement$0(state);
1307
1346
  }
1308
1347
  }
1309
- var BindingRestElement$0 = $S($EXPECT($L30, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1348
+ var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1310
1349
  function BindingRestElement(state) {
1311
1350
  if (state.verbose)
1312
1351
  console.log("ENTER:", "BindingRestElement");
@@ -1327,7 +1366,7 @@ var require_parser = __commonJS({
1327
1366
  }
1328
1367
  }
1329
1368
  var FunctionExpression$0 = ThinArrowFunction;
1330
- var FunctionExpression$1 = $S($EXPECT($L31, fail, 'FunctionExpression "function"'), __, Parameters, BracedBlock);
1369
+ 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);
1331
1370
  function FunctionExpression(state) {
1332
1371
  if (state.tokenize) {
1333
1372
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1335,7 +1374,7 @@ var require_parser = __commonJS({
1335
1374
  return FunctionExpression$0(state) || FunctionExpression$1(state);
1336
1375
  }
1337
1376
  }
1338
- var ThinArrowFunction$0 = $T($S(Parameters, $E(TypeSuffix), __, $EXPECT($L32, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1377
+ var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1339
1378
  var params = value[0];
1340
1379
  var suffix = value[1];
1341
1380
  var block = value[4];
@@ -1350,7 +1389,7 @@ var require_parser = __commonJS({
1350
1389
  return ThinArrowFunction$0(state);
1351
1390
  }
1352
1391
  }
1353
- var Block$0 = $S(__, $EXPECT($L10, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'Block "}"'));
1392
+ var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
1354
1393
  var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1355
1394
  var Block$2 = Statement;
1356
1395
  var Block$3 = $S(__, Statement);
@@ -1361,7 +1400,7 @@ var require_parser = __commonJS({
1361
1400
  return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
1362
1401
  }
1363
1402
  }
1364
- var BracedBlock$0 = $S(__, $EXPECT($L10, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'BracedBlock "}"'));
1403
+ var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
1365
1404
  var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1366
1405
  var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
1367
1406
  function BracedBlock(state) {
@@ -1413,10 +1452,10 @@ var require_parser = __commonJS({
1413
1452
  }
1414
1453
  var Literal$0 = StringLiteral;
1415
1454
  var Literal$1 = NumericLiteral;
1416
- var Literal$2 = $EXPECT($L33, fail, 'Literal "true"');
1417
- var Literal$3 = $EXPECT($L34, fail, 'Literal "false"');
1418
- var Literal$4 = $EXPECT($L35, fail, 'Literal "null"');
1419
- var Literal$5 = $EXPECT($L36, fail, 'Literal "undefined"');
1455
+ var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
1456
+ var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
1457
+ var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
1458
+ var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
1420
1459
  function Literal(state) {
1421
1460
  if (state.tokenize) {
1422
1461
  return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
@@ -1444,7 +1483,7 @@ var require_parser = __commonJS({
1444
1483
  return Identifier$0(state);
1445
1484
  }
1446
1485
  }
1447
- var IdentifierName$0 = $R$0($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
1486
+ var IdentifierName$0 = $R$0($EXPECT($R2, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
1448
1487
  function IdentifierName(state) {
1449
1488
  if (state.verbose)
1450
1489
  console.log("ENTER:", "IdentifierName");
@@ -1464,8 +1503,8 @@ var require_parser = __commonJS({
1464
1503
  return IdentifierReference$0(state);
1465
1504
  }
1466
1505
  }
1467
- var ArrayLiteral$0 = $S($EXPECT($L23, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L24, fail, 'ArrayLiteral "]"'));
1468
- var ArrayLiteral$1 = $S($EXPECT($L23, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L24, fail, 'ArrayLiteral "]"'));
1506
+ var ArrayLiteral$0 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
1507
+ var ArrayLiteral$1 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
1469
1508
  function ArrayLiteral(state) {
1470
1509
  if (state.tokenize) {
1471
1510
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1499,8 +1538,8 @@ var require_parser = __commonJS({
1499
1538
  }
1500
1539
  }
1501
1540
  var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1502
- var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L24, fail, 'ArrayElementDelimiter "]"')));
1503
- var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L24, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1541
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
1542
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1504
1543
  return ",";
1505
1544
  });
1506
1545
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1523,7 +1562,7 @@ var require_parser = __commonJS({
1523
1562
  return ElementList$0(state);
1524
1563
  }
1525
1564
  }
1526
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L30, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1565
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1527
1566
  function ArrayElementExpression(state) {
1528
1567
  if (state.verbose)
1529
1568
  console.log("ENTER:", "ArrayElementExpression");
@@ -1543,9 +1582,9 @@ var require_parser = __commonJS({
1543
1582
  return Elision$0(state);
1544
1583
  }
1545
1584
  }
1546
- var ObjectLiteral$0 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L15, fail, 'ObjectLiteral "}"'));
1547
- var ObjectLiteral$1 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L15, fail, 'ObjectLiteral "}"'));
1548
- var ObjectLiteral$2 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), __, $EXPECT($L15, fail, 'ObjectLiteral "}"'));
1585
+ var ObjectLiteral$0 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1586
+ var ObjectLiteral$1 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1587
+ var ObjectLiteral$2 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
1549
1588
  var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
1550
1589
  function ObjectLiteral(state) {
1551
1590
  if (state.tokenize) {
@@ -1580,8 +1619,8 @@ var require_parser = __commonJS({
1580
1619
  }
1581
1620
  }
1582
1621
  var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
1583
- var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L15, fail, 'ObjectPropertyDelimiter "}"')));
1584
- var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L15, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1622
+ var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
1623
+ var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1585
1624
  return ",";
1586
1625
  });
1587
1626
  var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1604,9 +1643,9 @@ var require_parser = __commonJS({
1604
1643
  return PropertyDefinitionList$0(state);
1605
1644
  }
1606
1645
  }
1607
- var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L11, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1646
+ var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1608
1647
  var PropertyDefinition$1 = MethodDefinition;
1609
- var PropertyDefinition$2 = $S($EXPECT($L30, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1648
+ var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1610
1649
  var PropertyDefinition$3 = IdentifierReference;
1611
1650
  function PropertyDefinition(state) {
1612
1651
  if (state.tokenize) {
@@ -1618,7 +1657,7 @@ var require_parser = __commonJS({
1618
1657
  var PropertyName$0 = NumericLiteral;
1619
1658
  var PropertyName$1 = StringLiteral;
1620
1659
  var PropertyName$2 = IdentifierName;
1621
- var PropertyName$3 = $S($EXPECT($L23, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L24, fail, 'PropertyName "]"'));
1660
+ var PropertyName$3 = $S($EXPECT($L24, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
1622
1661
  function PropertyName(state) {
1623
1662
  if (state.tokenize) {
1624
1663
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1626,8 +1665,8 @@ var require_parser = __commonJS({
1626
1665
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1627
1666
  }
1628
1667
  }
1629
- var MethodDefinition$0 = $S($EXPECT($L37, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R2, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1630
- var MethodDefinition$1 = $S($EXPECT($L38, fail, 'MethodDefinition "set"'), $N($R$0($EXPECT($R2, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1668
+ var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1669
+ var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1631
1670
  var MethodDefinition$2 = AsyncGeneratorMethod;
1632
1671
  var MethodDefinition$3 = AsyncMethod;
1633
1672
  var MethodDefinition$4 = GeneratorMethod;
@@ -1648,7 +1687,7 @@ var require_parser = __commonJS({
1648
1687
  return ClassElementName$0(state) || ClassElementName$1(state);
1649
1688
  }
1650
1689
  }
1651
- var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
1690
+ var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
1652
1691
  function PrivateIdentifier(state) {
1653
1692
  if (state.verbose)
1654
1693
  console.log("ENTER:", "PrivateIdentifier");
@@ -1658,27 +1697,7 @@ var require_parser = __commonJS({
1658
1697
  return PrivateIdentifier$0(state);
1659
1698
  }
1660
1699
  }
1661
- var GeneratorDeclaration$0 = GeneratorExpression;
1662
- function GeneratorDeclaration(state) {
1663
- if (state.verbose)
1664
- console.log("ENTER:", "GeneratorDeclaration");
1665
- if (state.tokenize) {
1666
- return $TOKEN("GeneratorDeclaration", state, GeneratorDeclaration$0(state));
1667
- } else {
1668
- return GeneratorDeclaration$0(state);
1669
- }
1670
- }
1671
- var GeneratorExpression$0 = $S($EXPECT($L31, fail, 'GeneratorExpression "function"'), __, $EXPECT($L8, fail, 'GeneratorExpression "*"'), $E($S(__, BindingIdentifier)), Parameters, GeneratorBody);
1672
- function GeneratorExpression(state) {
1673
- if (state.verbose)
1674
- console.log("ENTER:", "GeneratorExpression");
1675
- if (state.tokenize) {
1676
- return $TOKEN("GeneratorExpression", state, GeneratorExpression$0(state));
1677
- } else {
1678
- return GeneratorExpression$0(state);
1679
- }
1680
- }
1681
- var GeneratorMethod$0 = $S($EXPECT($L8, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1700
+ var GeneratorMethod$0 = $S($EXPECT($L9, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1682
1701
  function GeneratorMethod(state) {
1683
1702
  if (state.verbose)
1684
1703
  console.log("ENTER:", "GeneratorMethod");
@@ -1698,27 +1717,7 @@ var require_parser = __commonJS({
1698
1717
  return GeneratorBody$0(state);
1699
1718
  }
1700
1719
  }
1701
- var AsyncFunctionDeclaration$0 = AsyncFunctionExpression;
1702
- function AsyncFunctionDeclaration(state) {
1703
- if (state.verbose)
1704
- console.log("ENTER:", "AsyncFunctionDeclaration");
1705
- if (state.tokenize) {
1706
- return $TOKEN("AsyncFunctionDeclaration", state, AsyncFunctionDeclaration$0(state));
1707
- } else {
1708
- return AsyncFunctionDeclaration$0(state);
1709
- }
1710
- }
1711
- var AsyncFunctionExpression$0 = $S($EXPECT($L6, fail, 'AsyncFunctionExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncFunctionExpression "function"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncFunctionBody);
1712
- function AsyncFunctionExpression(state) {
1713
- if (state.verbose)
1714
- console.log("ENTER:", "AsyncFunctionExpression");
1715
- if (state.tokenize) {
1716
- return $TOKEN("AsyncFunctionExpression", state, AsyncFunctionExpression$0(state));
1717
- } else {
1718
- return AsyncFunctionExpression$0(state);
1719
- }
1720
- }
1721
- var AsyncMethod$0 = $S($EXPECT($L6, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
1720
+ var AsyncMethod$0 = $S($EXPECT($L7, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
1722
1721
  function AsyncMethod(state) {
1723
1722
  if (state.verbose)
1724
1723
  console.log("ENTER:", "AsyncMethod");
@@ -1738,27 +1737,7 @@ var require_parser = __commonJS({
1738
1737
  return AsyncFunctionBody$0(state);
1739
1738
  }
1740
1739
  }
1741
- var AsyncGeneratorDeclaration$0 = AsyncGeneratorExpression;
1742
- function AsyncGeneratorDeclaration(state) {
1743
- if (state.verbose)
1744
- console.log("ENTER:", "AsyncGeneratorDeclaration");
1745
- if (state.tokenize) {
1746
- return $TOKEN("AsyncGeneratorDeclaration", state, AsyncGeneratorDeclaration$0(state));
1747
- } else {
1748
- return AsyncGeneratorDeclaration$0(state);
1749
- }
1750
- }
1751
- 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);
1752
- function AsyncGeneratorExpression(state) {
1753
- if (state.verbose)
1754
- console.log("ENTER:", "AsyncGeneratorExpression");
1755
- if (state.tokenize) {
1756
- return $TOKEN("AsyncGeneratorExpression", state, AsyncGeneratorExpression$0(state));
1757
- } else {
1758
- return AsyncGeneratorExpression$0(state);
1759
- }
1760
- }
1761
- var AsyncGeneratorMethod$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L8, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1740
+ var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L9, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
1762
1741
  function AsyncGeneratorMethod(state) {
1763
1742
  if (state.verbose)
1764
1743
  console.log("ENTER:", "AsyncGeneratorMethod");
@@ -1778,22 +1757,22 @@ var require_parser = __commonJS({
1778
1757
  return AsyncGeneratorBody$0(state);
1779
1758
  }
1780
1759
  }
1781
- var AssignmentOp$0 = $EXPECT($L39, fail, 'AssignmentOp "**="');
1782
- var AssignmentOp$1 = $EXPECT($L40, fail, 'AssignmentOp "*="');
1783
- var AssignmentOp$2 = $EXPECT($L41, fail, 'AssignmentOp "/="');
1784
- var AssignmentOp$3 = $EXPECT($L42, fail, 'AssignmentOp "%="');
1785
- var AssignmentOp$4 = $EXPECT($L43, fail, 'AssignmentOp "+="');
1786
- var AssignmentOp$5 = $EXPECT($L44, fail, 'AssignmentOp "-="');
1787
- var AssignmentOp$6 = $EXPECT($L45, fail, 'AssignmentOp "<<="');
1788
- var AssignmentOp$7 = $EXPECT($L46, fail, 'AssignmentOp ">>>="');
1789
- var AssignmentOp$8 = $EXPECT($L47, fail, 'AssignmentOp ">>="');
1790
- var AssignmentOp$9 = $EXPECT($L48, fail, 'AssignmentOp "&&="');
1791
- var AssignmentOp$10 = $EXPECT($L49, fail, 'AssignmentOp "&="');
1792
- var AssignmentOp$11 = $EXPECT($L50, fail, 'AssignmentOp "^="');
1793
- var AssignmentOp$12 = $EXPECT($L51, fail, 'AssignmentOp "||="');
1794
- var AssignmentOp$13 = $EXPECT($L52, fail, 'AssignmentOp "|="');
1795
- var AssignmentOp$14 = $EXPECT($L53, fail, 'AssignmentOp "??="');
1796
- var AssignmentOp$15 = $EXPECT($L54, fail, 'AssignmentOp "="');
1760
+ var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
1761
+ var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
1762
+ var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
1763
+ var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
1764
+ var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
1765
+ var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
1766
+ var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
1767
+ var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
1768
+ var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
1769
+ var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
1770
+ var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
1771
+ var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
1772
+ var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
1773
+ var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
1774
+ var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
1775
+ var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
1797
1776
  function AssignmentOp(state) {
1798
1777
  if (state.tokenize) {
1799
1778
  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));
@@ -1801,48 +1780,48 @@ var require_parser = __commonJS({
1801
1780
  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);
1802
1781
  }
1803
1782
  }
1804
- var BinaryOp$0 = $EXPECT($L55, fail, 'BinaryOp "**"');
1805
- var BinaryOp$1 = $EXPECT($L8, fail, 'BinaryOp "*"');
1806
- var BinaryOp$2 = $EXPECT($L56, fail, 'BinaryOp "/"');
1807
- var BinaryOp$3 = $EXPECT($L57, fail, 'BinaryOp "%"');
1808
- var BinaryOp$4 = $EXPECT($L58, fail, 'BinaryOp "+"');
1809
- var BinaryOp$5 = $EXPECT($L59, fail, 'BinaryOp "-"');
1810
- var BinaryOp$6 = $EXPECT($L60, fail, 'BinaryOp "<="');
1811
- var BinaryOp$7 = $EXPECT($L61, fail, 'BinaryOp ">="');
1812
- var BinaryOp$8 = $EXPECT($L62, fail, 'BinaryOp "<<"');
1813
- var BinaryOp$9 = $EXPECT($L13, fail, 'BinaryOp "<"');
1814
- var BinaryOp$10 = $EXPECT($L63, fail, 'BinaryOp ">>>"');
1815
- var BinaryOp$11 = $EXPECT($L64, fail, 'BinaryOp ">>"');
1816
- var BinaryOp$12 = $EXPECT($L65, fail, 'BinaryOp ">"');
1817
- var BinaryOp$13 = $EXPECT($L66, fail, 'BinaryOp "!=="');
1818
- var BinaryOp$14 = $TV($EXPECT($L67, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1783
+ var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
1784
+ var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
1785
+ var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
1786
+ var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
1787
+ var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
1788
+ var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
1789
+ var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
1790
+ var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
1791
+ var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
1792
+ var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
1793
+ var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
1794
+ var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
1795
+ var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
1796
+ var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
1797
+ var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1819
1798
  if (global.coffeeCompat)
1820
1799
  return "!==";
1821
1800
  return $1;
1822
1801
  });
1823
- var BinaryOp$15 = $T($EXPECT($L68, fail, 'BinaryOp "is"'), function(value) {
1802
+ var BinaryOp$15 = $T($EXPECT($L69, fail, 'BinaryOp "is"'), function(value) {
1824
1803
  return "===";
1825
1804
  });
1826
- var BinaryOp$16 = $EXPECT($L69, fail, 'BinaryOp "==="');
1827
- var BinaryOp$17 = $TV($EXPECT($L70, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1805
+ var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
1806
+ var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1828
1807
  if (global.coffeeCompat)
1829
1808
  return "===";
1830
1809
  return $1;
1831
1810
  });
1832
- var BinaryOp$18 = $T($EXPECT($L71, fail, 'BinaryOp "and"'), function(value) {
1811
+ var BinaryOp$18 = $T($EXPECT($L72, fail, 'BinaryOp "and"'), function(value) {
1833
1812
  return "&&";
1834
1813
  });
1835
- var BinaryOp$19 = $EXPECT($L72, fail, 'BinaryOp "&&"');
1836
- var BinaryOp$20 = $T($EXPECT($L73, fail, 'BinaryOp "or"'), function(value) {
1814
+ var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
1815
+ var BinaryOp$20 = $T($EXPECT($L74, fail, 'BinaryOp "or"'), function(value) {
1837
1816
  return "||";
1838
1817
  });
1839
- var BinaryOp$21 = $EXPECT($L74, fail, 'BinaryOp "||"');
1840
- var BinaryOp$22 = $EXPECT($L75, fail, 'BinaryOp "??"');
1841
- var BinaryOp$23 = $EXPECT($L76, fail, 'BinaryOp "instanceof"');
1842
- var BinaryOp$24 = $EXPECT($L77, fail, 'BinaryOp "in"');
1843
- var BinaryOp$25 = $EXPECT($L78, fail, 'BinaryOp "&"');
1844
- var BinaryOp$26 = $EXPECT($L79, fail, 'BinaryOp "^"');
1845
- var BinaryOp$27 = $EXPECT($L80, fail, 'BinaryOp "|"');
1818
+ var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
1819
+ var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
1820
+ var BinaryOp$23 = $EXPECT($L77, fail, 'BinaryOp "instanceof"');
1821
+ var BinaryOp$24 = $EXPECT($L78, fail, 'BinaryOp "in"');
1822
+ var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
1823
+ var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
1824
+ var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
1846
1825
  function BinaryOp(state) {
1847
1826
  if (state.tokenize) {
1848
1827
  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));
@@ -1850,8 +1829,8 @@ var require_parser = __commonJS({
1850
1829
  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);
1851
1830
  }
1852
1831
  }
1853
- var UnaryOp$0 = $R$0($EXPECT($R3, fail, "UnaryOp /[!~+-]/"));
1854
- var UnaryOp$1 = $S($C($EXPECT($L81, fail, 'UnaryOp "delete"'), $EXPECT($L82, fail, 'UnaryOp "void"'), $EXPECT($L83, fail, 'UnaryOp "typeof"')), $P(_));
1832
+ var UnaryOp$0 = $R$0($EXPECT($R4, fail, "UnaryOp /[!~+-]/"));
1833
+ var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), $P(_));
1855
1834
  function UnaryOp(state) {
1856
1835
  if (state.tokenize) {
1857
1836
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -1886,7 +1865,7 @@ var require_parser = __commonJS({
1886
1865
  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);
1887
1866
  }
1888
1867
  }
1889
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L84, fail, 'EmptyStatement ";"')));
1868
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"')));
1890
1869
  function EmptyStatement(state) {
1891
1870
  if (state.verbose)
1892
1871
  console.log("ENTER:", "EmptyStatement");
@@ -1896,7 +1875,7 @@ var require_parser = __commonJS({
1896
1875
  return EmptyStatement$0(state);
1897
1876
  }
1898
1877
  }
1899
- var BlockStatement$0 = $S(__, $EXPECT($L10, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'BlockStatement "}"'));
1878
+ var BlockStatement$0 = $S(__, $EXPECT($L11, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BlockStatement "}"'));
1900
1879
  function BlockStatement(state) {
1901
1880
  if (state.verbose)
1902
1881
  console.log("ENTER:", "BlockStatement");
@@ -1906,8 +1885,8 @@ var require_parser = __commonJS({
1906
1885
  return BlockStatement$0(state);
1907
1886
  }
1908
1887
  }
1909
- var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L86, fail, 'IfStatement "else"'), Block)));
1910
- var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1888
+ var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L87, fail, 'IfStatement "else"'), Block)));
1889
+ var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1911
1890
  var condition = $2;
1912
1891
  var block = $3;
1913
1892
  return ["if", condition.map((c) => {
@@ -1937,7 +1916,7 @@ var require_parser = __commonJS({
1937
1916
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
1938
1917
  }
1939
1918
  }
1940
- var LoopStatement$0 = $TS($S($EXPECT($L88, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
1919
+ var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
1941
1920
  var b = $2;
1942
1921
  return ["while(true)", b];
1943
1922
  });
@@ -1950,7 +1929,7 @@ var require_parser = __commonJS({
1950
1929
  return LoopStatement$0(state);
1951
1930
  }
1952
1931
  }
1953
- var DoWhileStatement$0 = $S($EXPECT($L89, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L90, fail, 'DoWhileStatement "while"'), Condition);
1932
+ var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
1954
1933
  function DoWhileStatement(state) {
1955
1934
  if (state.verbose)
1956
1935
  console.log("ENTER:", "DoWhileStatement");
@@ -1960,7 +1939,7 @@ var require_parser = __commonJS({
1960
1939
  return DoWhileStatement$0(state);
1961
1940
  }
1962
1941
  }
1963
- var WhileStatement$0 = $S($EXPECT($L90, fail, 'WhileStatement "while"'), Condition, Block);
1942
+ var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), Condition, Block);
1964
1943
  function WhileStatement(state) {
1965
1944
  if (state.verbose)
1966
1945
  console.log("ENTER:", "WhileStatement");
@@ -1970,7 +1949,7 @@ var require_parser = __commonJS({
1970
1949
  return WhileStatement$0(state);
1971
1950
  }
1972
1951
  }
1973
- 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);
1952
+ 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);
1974
1953
  function ForStatement(state) {
1975
1954
  if (state.verbose)
1976
1955
  console.log("ENTER:", "ForStatement");
@@ -1980,10 +1959,10 @@ var require_parser = __commonJS({
1980
1959
  return ForStatement$0(state);
1981
1960
  }
1982
1961
  }
1983
- 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);
1984
- 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);
1985
- 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);
1986
- 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);
1962
+ 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);
1963
+ 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);
1964
+ 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);
1965
+ 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);
1987
1966
  function ForInOfStatement(state) {
1988
1967
  if (state.tokenize) {
1989
1968
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -1991,7 +1970,7 @@ var require_parser = __commonJS({
1991
1970
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
1992
1971
  }
1993
1972
  }
1994
- var ForDeclaration$0 = $S($C($EXPECT($L95, fail, 'ForDeclaration "let"'), $EXPECT($L96, fail, 'ForDeclaration "const"')), __, ForBinding);
1973
+ var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), __, ForBinding);
1995
1974
  function ForDeclaration(state) {
1996
1975
  if (state.verbose)
1997
1976
  console.log("ENTER:", "ForDeclaration");
@@ -2010,7 +1989,7 @@ var require_parser = __commonJS({
2010
1989
  return ForBinding$0(state) || ForBinding$1(state);
2011
1990
  }
2012
1991
  }
2013
- var SwitchStatement$0 = $S($EXPECT($L97, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
1992
+ var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
2014
1993
  function SwitchStatement(state) {
2015
1994
  if (state.verbose)
2016
1995
  console.log("ENTER:", "SwitchStatement");
@@ -2020,7 +1999,7 @@ var require_parser = __commonJS({
2020
1999
  return SwitchStatement$0(state);
2021
2000
  }
2022
2001
  }
2023
- var CaseBlock$0 = $S(__, $EXPECT($L10, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L15, fail, 'CaseBlock "}"'));
2002
+ var CaseBlock$0 = $S(__, $EXPECT($L11, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L16, fail, 'CaseBlock "}"'));
2024
2003
  var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
2025
2004
  function CaseBlock(state) {
2026
2005
  if (state.tokenize) {
@@ -2054,9 +2033,9 @@ var require_parser = __commonJS({
2054
2033
  return NestedCaseClause$0(state);
2055
2034
  }
2056
2035
  }
2057
- var CaseClause$0 = $S($EXPECT($L98, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2036
+ var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2058
2037
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2059
- var CaseClause$2 = $S($EXPECT($L99, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
2038
+ var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
2060
2039
  function CaseClause(state) {
2061
2040
  if (state.tokenize) {
2062
2041
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2064,7 +2043,7 @@ var require_parser = __commonJS({
2064
2043
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2065
2044
  }
2066
2045
  }
2067
- var When$0 = $T($EXPECT($L100, fail, 'When "when"'), function(value) {
2046
+ var When$0 = $T($EXPECT($L101, fail, 'When "when"'), function(value) {
2068
2047
  return "case";
2069
2048
  });
2070
2049
  function When(state) {
@@ -2076,8 +2055,8 @@ var require_parser = __commonJS({
2076
2055
  return When$0(state);
2077
2056
  }
2078
2057
  }
2079
- var ImpliedColon$0 = $S(__, $EXPECT($L11, fail, 'ImpliedColon ":"'));
2080
- var ImpliedColon$1 = $T($EXPECT($L29, fail, 'ImpliedColon ""'), function(value) {
2058
+ var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2059
+ var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
2081
2060
  return ":";
2082
2061
  });
2083
2062
  function ImpliedColon(state) {
@@ -2087,7 +2066,7 @@ var require_parser = __commonJS({
2087
2066
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2088
2067
  }
2089
2068
  }
2090
- var TryStatement$0 = $TS($S($EXPECT($L101, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2069
+ var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2091
2070
  var c = $3;
2092
2071
  var f = $4;
2093
2072
  if (!c && !f) {
@@ -2104,7 +2083,7 @@ var require_parser = __commonJS({
2104
2083
  return TryStatement$0(state);
2105
2084
  }
2106
2085
  }
2107
- var Catch$0 = $S(__, $EXPECT($L102, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2086
+ var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2108
2087
  function Catch(state) {
2109
2088
  if (state.verbose)
2110
2089
  console.log("ENTER:", "Catch");
@@ -2123,7 +2102,7 @@ var require_parser = __commonJS({
2123
2102
  return CatchBind$0(state) || CatchBind$1(state);
2124
2103
  }
2125
2104
  }
2126
- var Finally$0 = $S(__, $EXPECT($L103, fail, 'Finally "finally"'), BracedBlock);
2105
+ var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
2127
2106
  function Finally(state) {
2128
2107
  if (state.verbose)
2129
2108
  console.log("ENTER:", "Finally");
@@ -2161,12 +2140,12 @@ var require_parser = __commonJS({
2161
2140
  return ExpressionStatement$0(state);
2162
2141
  }
2163
2142
  }
2164
- var KeywordStatement$0 = $EXPECT($L104, fail, 'KeywordStatement "break"');
2165
- var KeywordStatement$1 = $EXPECT($L105, fail, 'KeywordStatement "continue"');
2166
- var KeywordStatement$2 = $EXPECT($L106, fail, 'KeywordStatement "debugger"');
2167
- var KeywordStatement$3 = $S($EXPECT($L107, fail, 'KeywordStatement "return"'), $P(_), Expression);
2168
- var KeywordStatement$4 = $EXPECT($L107, fail, 'KeywordStatement "return"');
2169
- var KeywordStatement$5 = $S($EXPECT($L108, fail, 'KeywordStatement "throw"'), $P(_), Expression);
2143
+ var KeywordStatement$0 = $EXPECT($L105, fail, 'KeywordStatement "break"');
2144
+ var KeywordStatement$1 = $EXPECT($L106, fail, 'KeywordStatement "continue"');
2145
+ var KeywordStatement$2 = $EXPECT($L107, fail, 'KeywordStatement "debugger"');
2146
+ var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), Expression);
2147
+ var KeywordStatement$4 = $EXPECT($L108, fail, 'KeywordStatement "return"');
2148
+ var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), Expression);
2170
2149
  function KeywordStatement(state) {
2171
2150
  if (state.tokenize) {
2172
2151
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
@@ -2174,11 +2153,11 @@ var require_parser = __commonJS({
2174
2153
  return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
2175
2154
  }
2176
2155
  }
2177
- var ImportDeclaration$0 = $T($S($EXPECT($L109, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
2156
+ var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
2178
2157
  return { "ts": true, "children": value };
2179
2158
  });
2180
- var ImportDeclaration$1 = $S($EXPECT($L22, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
2181
- var ImportDeclaration$2 = $S($EXPECT($L22, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
2159
+ var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
2160
+ var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
2182
2161
  function ImportDeclaration(state) {
2183
2162
  if (state.tokenize) {
2184
2163
  return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
@@ -2196,7 +2175,7 @@ var require_parser = __commonJS({
2196
2175
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2197
2176
  }
2198
2177
  }
2199
- var NameSpaceImport$0 = $S($EXPECT($L8, fail, 'NameSpaceImport "*"'), __, $EXPECT($L110, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
2178
+ var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
2200
2179
  function NameSpaceImport(state) {
2201
2180
  if (state.verbose)
2202
2181
  console.log("ENTER:", "NameSpaceImport");
@@ -2206,7 +2185,7 @@ var require_parser = __commonJS({
2206
2185
  return NameSpaceImport$0(state);
2207
2186
  }
2208
2187
  }
2209
- var NamedImports$0 = $S($EXPECT($L10, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L15, fail, 'NamedImports "}"'));
2188
+ var NamedImports$0 = $S($EXPECT($L11, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L16, fail, 'NamedImports "}"'));
2210
2189
  function NamedImports(state) {
2211
2190
  if (state.verbose)
2212
2191
  console.log("ENTER:", "NamedImports");
@@ -2226,7 +2205,7 @@ var require_parser = __commonJS({
2226
2205
  return FromClause$0(state);
2227
2206
  }
2228
2207
  }
2229
- var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L110, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
2208
+ var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
2230
2209
  var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
2231
2210
  function ImportSpecifier(state) {
2232
2211
  if (state.tokenize) {
@@ -2264,7 +2243,7 @@ var require_parser = __commonJS({
2264
2243
  return ImportedBinding$0(state);
2265
2244
  }
2266
2245
  }
2267
- var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L99, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2246
+ var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2268
2247
  var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
2269
2248
  var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
2270
2249
  function ExportDeclaration(state) {
@@ -2274,7 +2253,7 @@ var require_parser = __commonJS({
2274
2253
  return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
2275
2254
  }
2276
2255
  }
2277
- var ExportFromClause$0 = $S($EXPECT($L8, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L110, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
2256
+ var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
2278
2257
  var ExportFromClause$1 = NamedExports;
2279
2258
  function ExportFromClause(state) {
2280
2259
  if (state.tokenize) {
@@ -2283,7 +2262,7 @@ var require_parser = __commonJS({
2283
2262
  return ExportFromClause$0(state) || ExportFromClause$1(state);
2284
2263
  }
2285
2264
  }
2286
- var NamedExports$0 = $S($EXPECT($L10, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L15, fail, 'NamedExports "}"'));
2265
+ var NamedExports$0 = $S($EXPECT($L11, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L16, fail, 'NamedExports "}"'));
2287
2266
  function NamedExports(state) {
2288
2267
  if (state.verbose)
2289
2268
  console.log("ENTER:", "NamedExports");
@@ -2293,7 +2272,7 @@ var require_parser = __commonJS({
2293
2272
  return NamedExports$0(state);
2294
2273
  }
2295
2274
  }
2296
- var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L110, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
2275
+ var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L4, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
2297
2276
  function ExportSpecifier(state) {
2298
2277
  if (state.verbose)
2299
2278
  console.log("ENTER:", "ExportSpecifier");
@@ -2314,18 +2293,17 @@ var require_parser = __commonJS({
2314
2293
  return Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state);
2315
2294
  }
2316
2295
  }
2317
- var HoistableDeclaration$0 = AsyncGeneratorDeclaration;
2318
- var HoistableDeclaration$1 = AsyncFunctionDeclaration;
2319
- var HoistableDeclaration$2 = GeneratorDeclaration;
2320
- var HoistableDeclaration$3 = FunctionDeclaration;
2296
+ var HoistableDeclaration$0 = FunctionDeclaration;
2321
2297
  function HoistableDeclaration(state) {
2298
+ if (state.verbose)
2299
+ console.log("ENTER:", "HoistableDeclaration");
2322
2300
  if (state.tokenize) {
2323
- return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state) || HoistableDeclaration$1(state) || HoistableDeclaration$2(state) || HoistableDeclaration$3(state));
2301
+ return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state));
2324
2302
  } else {
2325
- return HoistableDeclaration$0(state) || HoistableDeclaration$1(state) || HoistableDeclaration$2(state) || HoistableDeclaration$3(state);
2303
+ return HoistableDeclaration$0(state);
2326
2304
  }
2327
2305
  }
2328
- var LexicalDeclaration$0 = $S($C($EXPECT($L95, fail, 'LexicalDeclaration "let"'), $EXPECT($L96, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2306
+ var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2329
2307
  var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
2330
2308
  var bind = value[0];
2331
2309
  var suffix = value[1];
@@ -2349,7 +2327,7 @@ var require_parser = __commonJS({
2349
2327
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2350
2328
  }
2351
2329
  }
2352
- var Initializer$0 = $S(__, $EXPECT($L54, fail, 'Initializer "="'), AssignmentExpression);
2330
+ var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2353
2331
  function Initializer(state) {
2354
2332
  if (state.verbose)
2355
2333
  console.log("ENTER:", "Initializer");
@@ -2359,7 +2337,7 @@ var require_parser = __commonJS({
2359
2337
  return Initializer$0(state);
2360
2338
  }
2361
2339
  }
2362
- var VariableStatement$0 = $S($EXPECT($L92, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2340
+ var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2363
2341
  function VariableStatement(state) {
2364
2342
  if (state.verbose)
2365
2343
  console.log("ENTER:", "VariableStatement");
@@ -2400,7 +2378,7 @@ var require_parser = __commonJS({
2400
2378
  return NumericLiteral$0(state) || NumericLiteral$1(state) || NumericLiteral$2(state) || NumericLiteral$3(state) || NumericLiteral$4(state);
2401
2379
  }
2402
2380
  }
2403
- var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R4, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
2381
+ var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
2404
2382
  function DecimalBigIntegerLiteral(state) {
2405
2383
  if (state.verbose)
2406
2384
  console.log("ENTER:", "DecimalBigIntegerLiteral");
@@ -2410,7 +2388,7 @@ var require_parser = __commonJS({
2410
2388
  return DecimalBigIntegerLiteral$0(state);
2411
2389
  }
2412
2390
  }
2413
- var DecimalLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
2391
+ var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
2414
2392
  function DecimalLiteral(state) {
2415
2393
  if (state.verbose)
2416
2394
  console.log("ENTER:", "DecimalLiteral");
@@ -2420,7 +2398,7 @@ var require_parser = __commonJS({
2420
2398
  return DecimalLiteral$0(state);
2421
2399
  }
2422
2400
  }
2423
- var BinaryIntegerLiteral$0 = $R$0($EXPECT($R6, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
2401
+ var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
2424
2402
  function BinaryIntegerLiteral(state) {
2425
2403
  if (state.verbose)
2426
2404
  console.log("ENTER:", "BinaryIntegerLiteral");
@@ -2430,7 +2408,7 @@ var require_parser = __commonJS({
2430
2408
  return BinaryIntegerLiteral$0(state);
2431
2409
  }
2432
2410
  }
2433
- var OctalIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
2411
+ var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
2434
2412
  function OctalIntegerLiteral(state) {
2435
2413
  if (state.verbose)
2436
2414
  console.log("ENTER:", "OctalIntegerLiteral");
@@ -2440,7 +2418,7 @@ var require_parser = __commonJS({
2440
2418
  return OctalIntegerLiteral$0(state);
2441
2419
  }
2442
2420
  }
2443
- var HexLiteral$0 = $R$0($EXPECT($R8, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
2421
+ var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
2444
2422
  function HexLiteral(state) {
2445
2423
  if (state.verbose)
2446
2424
  console.log("ENTER:", "HexLiteral");
@@ -2462,7 +2440,7 @@ var require_parser = __commonJS({
2462
2440
  return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
2463
2441
  }
2464
2442
  }
2465
- var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
2443
+ var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
2466
2444
  var DoubleStringCharacter$1 = EscapeSequence;
2467
2445
  function DoubleStringCharacter(state) {
2468
2446
  if (state.tokenize) {
@@ -2471,7 +2449,7 @@ var require_parser = __commonJS({
2471
2449
  return DoubleStringCharacter$0(state) || DoubleStringCharacter$1(state);
2472
2450
  }
2473
2451
  }
2474
- var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /[^'\\\\]+/"));
2452
+ var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /[^'\\\\]+/"));
2475
2453
  var SingleStringCharacter$1 = EscapeSequence;
2476
2454
  function SingleStringCharacter(state) {
2477
2455
  if (state.tokenize) {
@@ -2480,7 +2458,7 @@ var require_parser = __commonJS({
2480
2458
  return SingleStringCharacter$0(state) || SingleStringCharacter$1(state);
2481
2459
  }
2482
2460
  }
2483
- var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R11, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
2461
+ var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
2484
2462
  function TripleDoubleStringCharacter(state) {
2485
2463
  if (state.verbose)
2486
2464
  console.log("ENTER:", "TripleDoubleStringCharacter");
@@ -2490,7 +2468,7 @@ var require_parser = __commonJS({
2490
2468
  return TripleDoubleStringCharacter$0(state);
2491
2469
  }
2492
2470
  }
2493
- var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R12, fail, "EscapeSequence /./")));
2471
+ var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R13, fail, "EscapeSequence /./")));
2494
2472
  function EscapeSequence(state) {
2495
2473
  if (state.verbose)
2496
2474
  console.log("ENTER:", "EscapeSequence");
@@ -2500,7 +2478,7 @@ var require_parser = __commonJS({
2500
2478
  return EscapeSequence$0(state);
2501
2479
  }
2502
2480
  }
2503
- var RegularExpressionLiteral$0 = $S($EXPECT($L56, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L56, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2481
+ var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2504
2482
  function RegularExpressionLiteral(state) {
2505
2483
  if (state.verbose)
2506
2484
  console.log("ENTER:", "RegularExpressionLiteral");
@@ -2510,7 +2488,7 @@ var require_parser = __commonJS({
2510
2488
  return RegularExpressionLiteral$0(state);
2511
2489
  }
2512
2490
  }
2513
- var RegularExpressionBody$0 = $S($R$0($EXPECT($R13, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
2491
+ var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
2514
2492
  function RegularExpressionBody(state) {
2515
2493
  if (state.verbose)
2516
2494
  console.log("ENTER:", "RegularExpressionBody");
@@ -2520,7 +2498,7 @@ var require_parser = __commonJS({
2520
2498
  return RegularExpressionBody$0(state);
2521
2499
  }
2522
2500
  }
2523
- var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
2501
+ var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
2524
2502
  var RegExpCharacter$1 = EscapeSequence;
2525
2503
  function RegExpCharacter(state) {
2526
2504
  if (state.tokenize) {
@@ -2529,7 +2507,7 @@ var require_parser = __commonJS({
2529
2507
  return RegExpCharacter$0(state) || RegExpCharacter$1(state);
2530
2508
  }
2531
2509
  }
2532
- var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
2510
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
2533
2511
  function RegularExpressionFlags(state) {
2534
2512
  if (state.verbose)
2535
2513
  console.log("ENTER:", "RegularExpressionFlags");
@@ -2549,7 +2527,7 @@ var require_parser = __commonJS({
2549
2527
  return TemplateLiteral$0(state);
2550
2528
  }
2551
2529
  }
2552
- var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L15, fail, 'TemplateSubstitution "}"'));
2530
+ var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2553
2531
  function TemplateSubstitution(state) {
2554
2532
  if (state.verbose)
2555
2533
  console.log("ENTER:", "TemplateSubstitution");
@@ -2559,7 +2537,7 @@ var require_parser = __commonJS({
2559
2537
  return TemplateSubstitution$0(state);
2560
2538
  }
2561
2539
  }
2562
- var TemplateCharacters$0 = $R$0($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
2540
+ var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
2563
2541
  function TemplateCharacters(state) {
2564
2542
  if (state.verbose)
2565
2543
  console.log("ENTER:", "TemplateCharacters");
@@ -2569,7 +2547,7 @@ var require_parser = __commonJS({
2569
2547
  return TemplateCharacters$0(state);
2570
2548
  }
2571
2549
  }
2572
- 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})/"));
2550
+ 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})/"));
2573
2551
  function ReservedWord(state) {
2574
2552
  if (state.verbose)
2575
2553
  console.log("ENTER:", "ReservedWord");
@@ -2588,7 +2566,7 @@ var require_parser = __commonJS({
2588
2566
  return Comment$0(state) || Comment$1(state);
2589
2567
  }
2590
2568
  }
2591
- var SingleLineComment$0 = $R$0($EXPECT($R18, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
2569
+ var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
2592
2570
  var SingleLineComment$1 = CoffeeSingleLineComment;
2593
2571
  function SingleLineComment(state) {
2594
2572
  if (state.tokenize) {
@@ -2606,7 +2584,7 @@ var require_parser = __commonJS({
2606
2584
  return MultiLineComment$0(state) || MultiLineComment$1(state);
2607
2585
  }
2608
2586
  }
2609
- var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R12, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
2587
+ var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R13, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
2610
2588
  function JSMultiLineComment(state) {
2611
2589
  if (state.verbose)
2612
2590
  console.log("ENTER:", "JSMultiLineComment");
@@ -2616,7 +2594,7 @@ var require_parser = __commonJS({
2616
2594
  return JSMultiLineComment$0(state);
2617
2595
  }
2618
2596
  }
2619
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R19, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2597
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2620
2598
  if (!global.coffeeCompat)
2621
2599
  return $skip;
2622
2600
  return ["//", $1];
@@ -2630,7 +2608,7 @@ var require_parser = __commonJS({
2630
2608
  return CoffeeSingleLineComment$0(state);
2631
2609
  }
2632
2610
  }
2633
- 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) {
2611
+ 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) {
2634
2612
  return ["/*", value[1], "*/"];
2635
2613
  });
2636
2614
  function CoffeeMultiLineComment(state) {
@@ -2642,7 +2620,7 @@ var require_parser = __commonJS({
2642
2620
  return CoffeeMultiLineComment$0(state);
2643
2621
  }
2644
2622
  }
2645
- 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 "*/"'));
2623
+ 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 "*/"'));
2646
2624
  function InlineComment(state) {
2647
2625
  if (state.verbose)
2648
2626
  console.log("ENTER:", "InlineComment");
@@ -2662,7 +2640,7 @@ var require_parser = __commonJS({
2662
2640
  return RestOfLine$0(state);
2663
2641
  }
2664
2642
  }
2665
- var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
2643
+ var TrailingComment$0 = $R$0($EXPECT($R22, fail, "TrailingComment /[\\t ]+/"));
2666
2644
  var TrailingComment$1 = InlineComment;
2667
2645
  var TrailingComment$2 = SingleLineComment;
2668
2646
  function TrailingComment(state) {
@@ -2672,7 +2650,7 @@ var require_parser = __commonJS({
2672
2650
  return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
2673
2651
  }
2674
2652
  }
2675
- var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
2653
+ var _$0 = $P($C($R$0($EXPECT($R22, fail, "_ /[\\t ]+/")), Comment));
2676
2654
  function _(state) {
2677
2655
  if (state.verbose)
2678
2656
  console.log("ENTER:", "_");
@@ -2682,7 +2660,7 @@ var require_parser = __commonJS({
2682
2660
  return _$0(state);
2683
2661
  }
2684
2662
  }
2685
- var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
2663
+ var __$0 = $Q($C($R$0($EXPECT($R23, fail, "__ /[\\s]+/")), Comment));
2686
2664
  function __(state) {
2687
2665
  if (state.verbose)
2688
2666
  console.log("ENTER:", "__");
@@ -2692,7 +2670,7 @@ var require_parser = __commonJS({
2692
2670
  return __$0(state);
2693
2671
  }
2694
2672
  }
2695
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L84, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2673
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L85, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2696
2674
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
2697
2675
  return [";", value];
2698
2676
  });
@@ -2703,19 +2681,186 @@ var require_parser = __commonJS({
2703
2681
  return StatementDelimiter$0(state) || StatementDelimiter$1(state);
2704
2682
  }
2705
2683
  }
2706
- var TypeDeclaration$0 = $T($S($EXPECT($L123, fail, 'TypeDeclaration "interface"'), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
2684
+ var JSXElement$0 = JSXSelfClosingElement;
2685
+ var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
2686
+ if ($1[1] !== $4[2]) {
2687
+ throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
2688
+ }
2689
+ return $0;
2690
+ });
2691
+ function JSXElement(state) {
2692
+ if (state.tokenize) {
2693
+ return $TOKEN("JSXElement", state, JSXElement$0(state) || JSXElement$1(state));
2694
+ } else {
2695
+ return JSXElement$0(state) || JSXElement$1(state);
2696
+ }
2697
+ }
2698
+ var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
2699
+ function JSXSelfClosingElement(state) {
2700
+ if (state.verbose)
2701
+ console.log("ENTER:", "JSXSelfClosingElement");
2702
+ if (state.tokenize) {
2703
+ return $TOKEN("JSXSelfClosingElement", state, JSXSelfClosingElement$0(state));
2704
+ } else {
2705
+ return JSXSelfClosingElement$0(state);
2706
+ }
2707
+ }
2708
+ var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
2709
+ function JSXOpeningElement(state) {
2710
+ if (state.verbose)
2711
+ console.log("ENTER:", "JSXOpeningElement");
2712
+ if (state.tokenize) {
2713
+ return $TOKEN("JSXOpeningElement", state, JSXOpeningElement$0(state));
2714
+ } else {
2715
+ return JSXOpeningElement$0(state);
2716
+ }
2717
+ }
2718
+ var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
2719
+ function JSXClosingElement(state) {
2720
+ if (state.verbose)
2721
+ console.log("ENTER:", "JSXClosingElement");
2722
+ if (state.tokenize) {
2723
+ return $TOKEN("JSXClosingElement", state, JSXClosingElement$0(state));
2724
+ } else {
2725
+ return JSXClosingElement$0(state);
2726
+ }
2727
+ }
2728
+ var JSXFragment$0 = $S($EXPECT($L125, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L126, fail, 'JSXFragment "</>"'));
2729
+ function JSXFragment(state) {
2730
+ if (state.verbose)
2731
+ console.log("ENTER:", "JSXFragment");
2732
+ if (state.tokenize) {
2733
+ return $TOKEN("JSXFragment", state, JSXFragment$0(state));
2734
+ } else {
2735
+ return JSXFragment$0(state);
2736
+ }
2737
+ }
2738
+ var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L26, fail, 'JSXElementName "."'), JSXIdentifierName))));
2739
+ function JSXElementName(state) {
2740
+ if (state.verbose)
2741
+ console.log("ENTER:", "JSXElementName");
2742
+ if (state.tokenize) {
2743
+ return $TOKEN("JSXElementName", state, JSXElementName$0(state));
2744
+ } else {
2745
+ return JSXElementName$0(state);
2746
+ }
2747
+ }
2748
+ var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
2749
+ function JSXIdentifierName(state) {
2750
+ if (state.verbose)
2751
+ console.log("ENTER:", "JSXIdentifierName");
2752
+ if (state.tokenize) {
2753
+ return $TOKEN("JSXIdentifierName", state, JSXIdentifierName$0(state));
2754
+ } else {
2755
+ return JSXIdentifierName$0(state);
2756
+ }
2757
+ }
2758
+ var JSXAttributes$0 = $Q($S(__, JSXAttribute));
2759
+ function JSXAttributes(state) {
2760
+ if (state.verbose)
2761
+ console.log("ENTER:", "JSXAttributes");
2762
+ if (state.tokenize) {
2763
+ return $TOKEN("JSXAttributes", state, JSXAttributes$0(state));
2764
+ } else {
2765
+ return JSXAttributes$0(state);
2766
+ }
2767
+ }
2768
+ var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2769
+ var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
2770
+ function JSXAttribute(state) {
2771
+ if (state.tokenize) {
2772
+ return $TOKEN("JSXAttribute", state, JSXAttribute$0(state) || JSXAttribute$1(state));
2773
+ } else {
2774
+ return JSXAttribute$0(state) || JSXAttribute$1(state);
2775
+ }
2776
+ }
2777
+ var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L12, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
2778
+ function JSXAttributeName(state) {
2779
+ if (state.verbose)
2780
+ console.log("ENTER:", "JSXAttributeName");
2781
+ if (state.tokenize) {
2782
+ return $TOKEN("JSXAttributeName", state, JSXAttributeName$0(state));
2783
+ } else {
2784
+ return JSXAttributeName$0(state);
2785
+ }
2786
+ }
2787
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2788
+ function JSXAttributeInitializer(state) {
2789
+ if (state.verbose)
2790
+ console.log("ENTER:", "JSXAttributeInitializer");
2791
+ if (state.tokenize) {
2792
+ return $TOKEN("JSXAttributeInitializer", state, JSXAttributeInitializer$0(state));
2793
+ } else {
2794
+ return JSXAttributeInitializer$0(state);
2795
+ }
2796
+ }
2797
+ var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
2798
+ var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
2799
+ var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
2800
+ var JSXAttributeValue$3 = JSXElement;
2801
+ var JSXAttributeValue$4 = JSXFragment;
2802
+ function JSXAttributeValue(state) {
2803
+ if (state.tokenize) {
2804
+ return $TOKEN("JSXAttributeValue", state, JSXAttributeValue$0(state) || JSXAttributeValue$1(state) || JSXAttributeValue$2(state) || JSXAttributeValue$3(state) || JSXAttributeValue$4(state));
2805
+ } else {
2806
+ return JSXAttributeValue$0(state) || JSXAttributeValue$1(state) || JSXAttributeValue$2(state) || JSXAttributeValue$3(state) || JSXAttributeValue$4(state);
2807
+ }
2808
+ }
2809
+ var JSXChildren$0 = $Q($S(__, JSXChild));
2810
+ function JSXChildren(state) {
2811
+ if (state.verbose)
2812
+ console.log("ENTER:", "JSXChildren");
2813
+ if (state.tokenize) {
2814
+ return $TOKEN("JSXChildren", state, JSXChildren$0(state));
2815
+ } else {
2816
+ return JSXChildren$0(state);
2817
+ }
2818
+ }
2819
+ var JSXChild$0 = JSXText;
2820
+ var JSXChild$1 = JSXElement;
2821
+ var JSXChild$2 = JSXFragment;
2822
+ var JSXChild$3 = $S($EXPECT($L11, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L16, fail, 'JSXChild "}"'));
2823
+ function JSXChild(state) {
2824
+ if (state.tokenize) {
2825
+ return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
2826
+ } else {
2827
+ return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
2828
+ }
2829
+ }
2830
+ var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
2831
+ function JSXText(state) {
2832
+ if (state.verbose)
2833
+ console.log("ENTER:", "JSXText");
2834
+ if (state.tokenize) {
2835
+ return $TOKEN("JSXText", state, JSXText$0(state));
2836
+ } else {
2837
+ return JSXText$0(state);
2838
+ }
2839
+ }
2840
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2841
+ function JSXChildExpression(state) {
2842
+ if (state.verbose)
2843
+ console.log("ENTER:", "JSXChildExpression");
2844
+ if (state.tokenize) {
2845
+ return $TOKEN("JSXChildExpression", state, JSXChildExpression$0(state));
2846
+ } else {
2847
+ return JSXChildExpression$0(state);
2848
+ }
2849
+ }
2850
+ 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) {
2851
+ return { "ts": true, "children": value };
2852
+ });
2853
+ var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
2707
2854
  return { "ts": true, "children": value };
2708
2855
  });
2709
2856
  function TypeDeclaration(state) {
2710
- if (state.verbose)
2711
- console.log("ENTER:", "TypeDeclaration");
2712
2857
  if (state.tokenize) {
2713
- return $TOKEN("TypeDeclaration", state, TypeDeclaration$0(state));
2858
+ return $TOKEN("TypeDeclaration", state, TypeDeclaration$0(state) || TypeDeclaration$1(state));
2714
2859
  } else {
2715
- return TypeDeclaration$0(state);
2860
+ return TypeDeclaration$0(state) || TypeDeclaration$1(state);
2716
2861
  }
2717
2862
  }
2718
- var InterfaceBlock$0 = $S(__, $EXPECT($L10, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L15, fail, 'InterfaceBlock "}"'));
2863
+ var InterfaceBlock$0 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
2719
2864
  var InterfaceBlock$1 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
2720
2865
  function InterfaceBlock(state) {
2721
2866
  if (state.tokenize) {
@@ -2749,7 +2894,7 @@ var require_parser = __commonJS({
2749
2894
  return NestedInterfaceProperty$0(state);
2750
2895
  }
2751
2896
  }
2752
- var TypeSuffix$0 = $T($S(__, $EXPECT($L11, fail, 'TypeSuffix ":"'), Type), function(value) {
2897
+ var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L12, fail, 'TypeSuffix ":"'), Type), function(value) {
2753
2898
  return { "ts": true, "children": value };
2754
2899
  });
2755
2900
  function TypeSuffix(state) {
@@ -2761,20 +2906,130 @@ var require_parser = __commonJS({
2761
2906
  return TypeSuffix$0(state);
2762
2907
  }
2763
2908
  }
2764
- var Type$0 = InterfaceBlock;
2765
- var Type$1 = $S($Q(_), FunctionType);
2766
- var Type$2 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'Type "."'), IdentifierName)), $E(TypeArguments), $Q($EXPECT($L124, fail, 'Type "[]"')));
2767
- var Type$3 = $S($Q(_), NumericLiteral);
2768
- var Type$4 = $S($Q(_), StringLiteral);
2769
- var Type$5 = $S($Q(_), $EXPECT($L82, fail, 'Type "void"'));
2909
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L127, fail, 'ReturnTypeSuffix "asserts"'), $EXPECT($R0, fail, "ReturnTypeSuffix /(?!\\p{ID_Continue})/"))), TypePredicate), function(value) {
2910
+ return { "ts": true, "children": value };
2911
+ });
2912
+ function ReturnTypeSuffix(state) {
2913
+ if (state.verbose)
2914
+ console.log("ENTER:", "ReturnTypeSuffix");
2915
+ if (state.tokenize) {
2916
+ return $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
2917
+ } else {
2918
+ return ReturnTypeSuffix$0(state);
2919
+ }
2920
+ }
2921
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), $R$0($EXPECT($R0, fail, "TypePredicate /(?!\\p{ID_Continue})/")), Type)));
2922
+ function TypePredicate(state) {
2923
+ if (state.verbose)
2924
+ console.log("ENTER:", "TypePredicate");
2925
+ if (state.tokenize) {
2926
+ return $TOKEN("TypePredicate", state, TypePredicate$0(state));
2927
+ } else {
2928
+ return TypePredicate$0(state);
2929
+ }
2930
+ }
2931
+ var Type$0 = TypeConditional;
2770
2932
  function Type(state) {
2933
+ if (state.verbose)
2934
+ console.log("ENTER:", "Type");
2935
+ if (state.tokenize) {
2936
+ return $TOKEN("Type", state, Type$0(state));
2937
+ } else {
2938
+ return Type$0(state);
2939
+ }
2940
+ }
2941
+ var TypeBinary$0 = $S(TypeUnary, $Q($S(__, TypeBinaryOp, TypeUnary)));
2942
+ function TypeBinary(state) {
2943
+ if (state.verbose)
2944
+ console.log("ENTER:", "TypeBinary");
2771
2945
  if (state.tokenize) {
2772
- return $TOKEN("Type", state, Type$0(state) || Type$1(state) || Type$2(state) || Type$3(state) || Type$4(state) || Type$5(state));
2946
+ return $TOKEN("TypeBinary", state, TypeBinary$0(state));
2773
2947
  } else {
2774
- return Type$0(state) || Type$1(state) || Type$2(state) || Type$3(state) || Type$4(state) || Type$5(state);
2948
+ return TypeBinary$0(state);
2775
2949
  }
2776
2950
  }
2777
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L9, fail, 'FunctionType "=>"'), Type);
2951
+ var TypeUnary$0 = $S($Q($S(__, TypeUnaryOp, $R$0($EXPECT($R0, fail, "TypeUnary /(?!\\p{ID_Continue})/")))), TypePrimary, $Q(TypeUnarySuffix));
2952
+ function TypeUnary(state) {
2953
+ if (state.verbose)
2954
+ console.log("ENTER:", "TypeUnary");
2955
+ if (state.tokenize) {
2956
+ return $TOKEN("TypeUnary", state, TypeUnary$0(state));
2957
+ } else {
2958
+ return TypeUnary$0(state);
2959
+ }
2960
+ }
2961
+ var TypeUnarySuffix$0 = TypeIndexedAccess;
2962
+ function TypeUnarySuffix(state) {
2963
+ if (state.verbose)
2964
+ console.log("ENTER:", "TypeUnarySuffix");
2965
+ if (state.tokenize) {
2966
+ return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
2967
+ } else {
2968
+ return TypeUnarySuffix$0(state);
2969
+ }
2970
+ }
2971
+ var TypeUnaryOp$0 = $EXPECT($L128, fail, 'TypeUnaryOp "keyof"');
2972
+ var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
2973
+ var TypeUnaryOp$2 = $EXPECT($L129, fail, 'TypeUnaryOp "infer"');
2974
+ function TypeUnaryOp(state) {
2975
+ if (state.tokenize) {
2976
+ return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
2977
+ } else {
2978
+ return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
2979
+ }
2980
+ }
2981
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L24, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L25, fail, 'TypeIndexedAccess "]"'));
2982
+ function TypeIndexedAccess(state) {
2983
+ if (state.verbose)
2984
+ console.log("ENTER:", "TypeIndexedAccess");
2985
+ if (state.tokenize) {
2986
+ return $TOKEN("TypeIndexedAccess", state, TypeIndexedAccess$0(state));
2987
+ } else {
2988
+ return TypeIndexedAccess$0(state);
2989
+ }
2990
+ }
2991
+ var TypePrimary$0 = InterfaceBlock;
2992
+ var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
2993
+ var TypePrimary$2 = $S($Q(_), FunctionType);
2994
+ var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L26, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
2995
+ var TypePrimary$4 = $S($Q(_), TypeLiteral);
2996
+ function TypePrimary(state) {
2997
+ if (state.tokenize) {
2998
+ return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
2999
+ } else {
3000
+ return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
3001
+ }
3002
+ }
3003
+ var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L15, fail, 'TypeConditional "extends"'), Type, __, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L12, fail, 'TypeConditional ":"'), Type)));
3004
+ function TypeConditional(state) {
3005
+ if (state.verbose)
3006
+ console.log("ENTER:", "TypeConditional");
3007
+ if (state.tokenize) {
3008
+ return $TOKEN("TypeConditional", state, TypeConditional$0(state));
3009
+ } else {
3010
+ return TypeConditional$0(state);
3011
+ }
3012
+ }
3013
+ var TypeLiteral$0 = Literal;
3014
+ var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3015
+ var TypeLiteral$2 = $EXPECT($L130, fail, 'TypeLiteral "[]"');
3016
+ function TypeLiteral(state) {
3017
+ if (state.tokenize) {
3018
+ return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
3019
+ } else {
3020
+ return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3021
+ }
3022
+ }
3023
+ var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3024
+ var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3025
+ function TypeBinaryOp(state) {
3026
+ if (state.tokenize) {
3027
+ return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
3028
+ } else {
3029
+ return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
3030
+ }
3031
+ }
3032
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L10, fail, 'FunctionType "=>"'), Type);
2778
3033
  function FunctionType(state) {
2779
3034
  if (state.verbose)
2780
3035
  console.log("ENTER:", "FunctionType");
@@ -2784,7 +3039,7 @@ var require_parser = __commonJS({
2784
3039
  return FunctionType$0(state);
2785
3040
  }
2786
3041
  }
2787
- 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 ">"'));
3042
+ 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 ">"'));
2788
3043
  function TypeArguments(state) {
2789
3044
  if (state.verbose)
2790
3045
  console.log("ENTER:", "TypeArguments");
@@ -2794,7 +3049,52 @@ var require_parser = __commonJS({
2794
3049
  return TypeArguments$0(state);
2795
3050
  }
2796
3051
  }
2797
- var Shebang$0 = $R$0($EXPECT($R23, fail, "Shebang /#![^\\r\\n]*/"));
3052
+ 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 ">"'));
3053
+ function TypeParameters(state) {
3054
+ if (state.verbose)
3055
+ console.log("ENTER:", "TypeParameters");
3056
+ if (state.tokenize) {
3057
+ return $TOKEN("TypeParameters", state, TypeParameters$0(state));
3058
+ } else {
3059
+ return TypeParameters$0(state);
3060
+ }
3061
+ }
3062
+ var TypeParameter$0 = $S(__, Identifier, $E(TypeConstraint), TypeParameterDelimiter);
3063
+ function TypeParameter(state) {
3064
+ if (state.verbose)
3065
+ console.log("ENTER:", "TypeParameter");
3066
+ if (state.tokenize) {
3067
+ return $TOKEN("TypeParameter", state, TypeParameter$0(state));
3068
+ } else {
3069
+ return TypeParameter$0(state);
3070
+ }
3071
+ }
3072
+ var TypeConstraint$0 = $S(__, $EXPECT($L15, fail, 'TypeConstraint "extends"'), Type);
3073
+ function TypeConstraint(state) {
3074
+ if (state.verbose)
3075
+ console.log("ENTER:", "TypeConstraint");
3076
+ if (state.tokenize) {
3077
+ return $TOKEN("TypeConstraint", state, TypeConstraint$0(state));
3078
+ } else {
3079
+ return TypeConstraint$0(state);
3080
+ }
3081
+ }
3082
+ var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3083
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
3084
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3085
+ return ",";
3086
+ });
3087
+ var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
3088
+ return ",";
3089
+ });
3090
+ function TypeParameterDelimiter(state) {
3091
+ if (state.tokenize) {
3092
+ return $TOKEN("TypeParameterDelimiter", state, TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state));
3093
+ } else {
3094
+ return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
3095
+ }
3096
+ }
3097
+ var Shebang$0 = $R$0($EXPECT($R30, fail, "Shebang /#![^\\r\\n]*/"));
2798
3098
  function Shebang(state) {
2799
3099
  if (state.verbose)
2800
3100
  console.log("ENTER:", "Shebang");
@@ -2804,7 +3104,7 @@ var require_parser = __commonJS({
2804
3104
  return Shebang$0(state);
2805
3105
  }
2806
3106
  }
2807
- var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R24, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
3107
+ var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R31, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
2808
3108
  return $0.map((p) => p.join(""));
2809
3109
  });
2810
3110
  function DirectivePrologue(state) {
@@ -2826,7 +3126,7 @@ var require_parser = __commonJS({
2826
3126
  return EOS$0(state);
2827
3127
  }
2828
3128
  }
2829
- var EOL$0 = $R$0($EXPECT($R25, fail, "EOL /\\r\\n|\\n|\\r|$/"));
3129
+ var EOL$0 = $R$0($EXPECT($R32, fail, "EOL /\\r\\n|\\n|\\r|$/"));
2830
3130
  function EOL(state) {
2831
3131
  if (state.verbose)
2832
3132
  console.log("ENTER:", "EOL");
@@ -2836,7 +3136,7 @@ var require_parser = __commonJS({
2836
3136
  return EOL$0(state);
2837
3137
  }
2838
3138
  }
2839
- var EOF$0 = $R$0($EXPECT($R26, fail, "EOF /$/"));
3139
+ var EOF$0 = $R$0($EXPECT($R33, fail, "EOF /$/"));
2840
3140
  function EOF(state) {
2841
3141
  if (state.verbose)
2842
3142
  console.log("ENTER:", "EOF");
@@ -2846,7 +3146,7 @@ var require_parser = __commonJS({
2846
3146
  return EOF$0(state);
2847
3147
  }
2848
3148
  }
2849
- var InsertOpenParen$0 = $T($EXPECT($L29, fail, 'InsertOpenParen ""'), function(value) {
3149
+ var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
2850
3150
  return "(";
2851
3151
  });
2852
3152
  function InsertOpenParen(state) {
@@ -2858,7 +3158,7 @@ var require_parser = __commonJS({
2858
3158
  return InsertOpenParen$0(state);
2859
3159
  }
2860
3160
  }
2861
- var InsertCloseParen$0 = $T($EXPECT($L29, fail, 'InsertCloseParen ""'), function(value) {
3161
+ var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
2862
3162
  return ")";
2863
3163
  });
2864
3164
  function InsertCloseParen(state) {
@@ -2870,7 +3170,7 @@ var require_parser = __commonJS({
2870
3170
  return InsertCloseParen$0(state);
2871
3171
  }
2872
3172
  }
2873
- var InsertOpenBrace$0 = $T($EXPECT($L29, fail, 'InsertOpenBrace ""'), function(value) {
3173
+ var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
2874
3174
  return " {";
2875
3175
  });
2876
3176
  function InsertOpenBrace(state) {
@@ -2882,7 +3182,7 @@ var require_parser = __commonJS({
2882
3182
  return InsertOpenBrace$0(state);
2883
3183
  }
2884
3184
  }
2885
- var InsertCloseBrace$0 = $T($EXPECT($L29, fail, 'InsertCloseBrace ""'), function(value) {
3185
+ var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
2886
3186
  return "}";
2887
3187
  });
2888
3188
  function InsertCloseBrace(state) {
@@ -2894,7 +3194,7 @@ var require_parser = __commonJS({
2894
3194
  return InsertCloseBrace$0(state);
2895
3195
  }
2896
3196
  }
2897
- var InsertNewline$0 = $TV($EXPECT($L29, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3197
+ var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
2898
3198
  return "\n";
2899
3199
  });
2900
3200
  function InsertNewline(state) {
@@ -2906,7 +3206,7 @@ var require_parser = __commonJS({
2906
3206
  return InsertNewline$0(state);
2907
3207
  }
2908
3208
  }
2909
- var InsertIndent$0 = $TV($EXPECT($L29, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3209
+ var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
2910
3210
  return "".padStart(global.currentIndent * 2);
2911
3211
  });
2912
3212
  function InsertIndent(state) {
@@ -2918,7 +3218,7 @@ var require_parser = __commonJS({
2918
3218
  return InsertIndent$0(state);
2919
3219
  }
2920
3220
  }
2921
- var InsertSpace$0 = $T($EXPECT($L29, fail, 'InsertSpace ""'), function(value) {
3221
+ var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
2922
3222
  return " ";
2923
3223
  });
2924
3224
  function InsertSpace(state) {
@@ -2930,7 +3230,7 @@ var require_parser = __commonJS({
2930
3230
  return InsertSpace$0(state);
2931
3231
  }
2932
3232
  }
2933
- var InsertDot$0 = $T($EXPECT($L29, fail, 'InsertDot ""'), function(value) {
3233
+ var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
2934
3234
  return ".";
2935
3235
  });
2936
3236
  function InsertDot(state) {
@@ -2942,7 +3242,7 @@ var require_parser = __commonJS({
2942
3242
  return InsertDot$0(state);
2943
3243
  }
2944
3244
  }
2945
- var InsertBreak$0 = $T($EXPECT($L29, fail, 'InsertBreak ""'), function(value) {
3245
+ var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
2946
3246
  return "break;";
2947
3247
  });
2948
3248
  function InsertBreak(state) {
@@ -2954,7 +3254,7 @@ var require_parser = __commonJS({
2954
3254
  return InsertBreak$0(state);
2955
3255
  }
2956
3256
  }
2957
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L29, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3257
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
2958
3258
  var directives = $2;
2959
3259
  global.currentIndent = 0;
2960
3260
  global.indentLevels = [0];
@@ -2974,7 +3274,7 @@ var require_parser = __commonJS({
2974
3274
  return Init$0(state);
2975
3275
  }
2976
3276
  }
2977
- var Indent$0 = $TV($Q($C($EXPECT($L125, fail, 'Indent " "'), $EXPECT($L126, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3277
+ var Indent$0 = $TV($Q($C($EXPECT($L131, fail, 'Indent " "'), $EXPECT($L132, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
2978
3278
  return $1.length;
2979
3279
  });
2980
3280
  function Indent(state) {
@@ -2986,7 +3286,7 @@ var require_parser = __commonJS({
2986
3286
  return Indent$0(state);
2987
3287
  }
2988
3288
  }
2989
- var PushIndent$0 = $TV($EXPECT($L29, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3289
+ var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
2990
3290
  global.currentIndent++;
2991
3291
  if (global.verbose) {
2992
3292
  console.log("pushing indent", global.currentIndent);
@@ -3003,7 +3303,7 @@ var require_parser = __commonJS({
3003
3303
  return PushIndent$0(state);
3004
3304
  }
3005
3305
  }
3006
- var PopIndent$0 = $TV($EXPECT($L29, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3306
+ var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3007
3307
  if (global.verbose) {
3008
3308
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3009
3309
  }