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