@danielx/civet 0.4.9 → 0.4.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/README.md +26 -6
  2. package/dist/browser.js +605 -407
  3. package/dist/main.js +605 -407
  4. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -412,10 +412,10 @@ var require_parser = __commonJS({
412
412
  ArgumentList,
413
413
  NestedArgumentList,
414
414
  NestedArgument,
415
+ InlineArgumentExpressions,
415
416
  ImplicitApplication,
416
417
  ApplicationStart,
417
418
  IndentedApplicationAllowed,
418
- CommaExpression,
419
419
  BinaryOpExpression,
420
420
  UnaryExpression,
421
421
  UnaryPostfix,
@@ -456,6 +456,7 @@ var require_parser = __commonJS({
456
456
  MetaProperty,
457
457
  Parameters,
458
458
  NonEmptyParameters,
459
+ FunctionRestParameter,
459
460
  ParameterElement,
460
461
  ParameterElementDelimiter,
461
462
  BindingIdentifier,
@@ -471,6 +472,7 @@ var require_parser = __commonJS({
471
472
  BindingElement,
472
473
  BindingRestElement,
473
474
  FunctionDeclaration,
475
+ FunctionSignature,
474
476
  FunctionExpression,
475
477
  ThinArrowFunction,
476
478
  Arrow,
@@ -484,6 +486,7 @@ var require_parser = __commonJS({
484
486
  Literal,
485
487
  NullLiteral,
486
488
  BooleanLiteral,
489
+ CoffeeScriptBooleanLiteral,
487
490
  Comma,
488
491
  Identifier,
489
492
  IdentifierName,
@@ -578,6 +581,7 @@ var require_parser = __commonJS({
578
581
  NumericLiteralKind,
579
582
  DecimalBigIntegerLiteral,
580
583
  DecimalLiteral,
584
+ ExponentPart,
581
585
  BinaryIntegerLiteral,
582
586
  OctalIntegerLiteral,
583
587
  HexLiteral,
@@ -629,6 +633,7 @@ var require_parser = __commonJS({
629
633
  ConstructorShorthand,
630
634
  Default,
631
635
  Dot,
636
+ DotDotDot,
632
637
  DoubleQuote,
633
638
  Else,
634
639
  Equals,
@@ -707,6 +712,10 @@ var require_parser = __commonJS({
707
712
  TypeUnaryOp,
708
713
  TypeIndexedAccess,
709
714
  TypePrimary,
715
+ TypeTuple,
716
+ TypeList,
717
+ NestedTypeList,
718
+ NestedType,
710
719
  TypeConditional,
711
720
  TypeLiteral,
712
721
  TypeBinaryOp,
@@ -738,6 +747,7 @@ var require_parser = __commonJS({
738
747
  InsertDot,
739
748
  InsertBreak,
740
749
  CoffeeCommentEnabled,
750
+ CoffeeBooleansEnabled,
741
751
  CoffeeInterpolationEnabled,
742
752
  Reset,
743
753
  Init,
@@ -766,173 +776,181 @@ var require_parser = __commonJS({
766
776
  var $L14 = $L("super[");
767
777
  var $L15 = $L("import.meta");
768
778
  var $L16 = $L(")");
769
- var $L17 = $L("...");
770
- var $L18 = $L("->");
771
- var $L19 = $L("null");
772
- var $L20 = $L("true");
773
- var $L21 = $L("false");
774
- var $L22 = $L(",");
775
- var $L23 = $L("]");
776
- var $L24 = $L("}");
777
- var $L25 = $L("**=");
778
- var $L26 = $L("*=");
779
- var $L27 = $L("/=");
780
- var $L28 = $L("%=");
781
- var $L29 = $L("+=");
782
- var $L30 = $L("-=");
783
- var $L31 = $L("<<=");
784
- var $L32 = $L(">>>=");
785
- var $L33 = $L(">>=");
786
- var $L34 = $L("&&=");
787
- var $L35 = $L("&=");
788
- var $L36 = $L("^=");
789
- var $L37 = $L("||=");
790
- var $L38 = $L("|=");
791
- var $L39 = $L("??=");
792
- var $L40 = $L("?=");
793
- var $L41 = $L("=");
794
- var $L42 = $L("**");
795
- var $L43 = $L("*");
796
- var $L44 = $L("/");
797
- var $L45 = $L("%");
798
- var $L46 = $L("+");
799
- var $L47 = $L("-");
800
- var $L48 = $L("<=");
801
- var $L49 = $L(">=");
802
- var $L50 = $L("<<");
803
- var $L51 = $L(">>>");
804
- var $L52 = $L(">>");
805
- var $L53 = $L(">");
806
- var $L54 = $L("!==");
807
- var $L55 = $L("!=");
808
- var $L56 = $L("is");
809
- var $L57 = $L("===");
810
- var $L58 = $L("==");
811
- var $L59 = $L("and");
812
- var $L60 = $L("&&");
813
- var $L61 = $L("or");
814
- var $L62 = $L("||");
815
- var $L63 = $L("??");
816
- var $L64 = $L("instanceof");
817
- var $L65 = $L("in");
818
- var $L66 = $L("&");
819
- var $L67 = $L("^");
820
- var $L68 = $L("|");
821
- var $L69 = $L("delete");
822
- var $L70 = $L("void");
823
- var $L71 = $L("typeof");
824
- var $L72 = $L(";");
825
- var $L73 = $L("do");
826
- var $L74 = $L("while");
827
- var $L75 = $L("until");
828
- var $L76 = $L("finally");
829
- var $L77 = $L("break");
830
- var $L78 = $L("continue");
831
- var $L79 = $L("debugger");
832
- var $L80 = $L("import type");
833
- var $L81 = $L("default");
834
- var $L82 = $L(":=");
835
- var $L83 = $L("/*");
836
- var $L84 = $L("*/");
837
- var $L85 = $L("###");
838
- var $L86 = $L("as");
839
- var $L87 = $L("async");
840
- var $L88 = $L("await");
841
- var $L89 = $L("case");
842
- var $L90 = $L("catch");
843
- var $L91 = $L("class");
844
- var $L92 = $L("#{");
845
- var $L93 = $L(":");
846
- var $L94 = $L(".");
847
- var $L95 = $L('"');
848
- var $L96 = $L("else");
849
- var $L97 = $L("export");
850
- var $L98 = $L("for");
851
- var $L99 = $L("from");
852
- var $L100 = $L("function");
853
- var $L101 = $L("get");
854
- var $L102 = $L("set");
855
- var $L103 = $L("if");
856
- var $L104 = $L("let");
857
- var $L105 = $L("const");
858
- var $L106 = $L("loop");
859
- var $L107 = $L("new");
860
- var $L108 = $L("of");
861
- var $L109 = $L("{");
862
- var $L110 = $L("[");
863
- var $L111 = $L("(");
864
- var $L112 = $L("?");
865
- var $L113 = $L("return");
866
- var $L114 = $L("'");
867
- var $L115 = $L("static");
868
- var $L116 = $L("${");
869
- var $L117 = $L("switch");
870
- var $L118 = $L("target");
871
- var $L119 = $L("throw");
872
- var $L120 = $L('"""');
873
- var $L121 = $L("'''");
874
- var $L122 = $L("```");
875
- var $L123 = $L("try");
876
- var $L124 = $L("unless");
877
- var $L125 = $L("var");
878
- var $L126 = $L("when");
879
- var $L127 = $L("yield");
880
- var $L128 = $L("/>");
881
- var $L129 = $L("</");
882
- var $L130 = $L("<>");
883
- var $L131 = $L("</>");
884
- var $L132 = $L("declare");
885
- var $L133 = $L("type");
886
- var $L134 = $L("interface");
887
- var $L135 = $L("namespace");
888
- var $L136 = $L("readonly");
889
- var $L137 = $L("asserts");
890
- var $L138 = $L("keyof");
891
- var $L139 = $L("infer");
892
- var $L140 = $L("[]");
893
- var $L141 = $L("civet");
894
- var $L142 = $L(" ");
895
- var $L143 = $L(" ");
779
+ var $L17 = $L("->");
780
+ var $L18 = $L("null");
781
+ var $L19 = $L("true");
782
+ var $L20 = $L("false");
783
+ var $L21 = $L("yes");
784
+ var $L22 = $L("on");
785
+ var $L23 = $L("no");
786
+ var $L24 = $L("off");
787
+ var $L25 = $L(",");
788
+ var $L26 = $L("]");
789
+ var $L27 = $L("}");
790
+ var $L28 = $L("**=");
791
+ var $L29 = $L("*=");
792
+ var $L30 = $L("/=");
793
+ var $L31 = $L("%=");
794
+ var $L32 = $L("+=");
795
+ var $L33 = $L("-=");
796
+ var $L34 = $L("<<=");
797
+ var $L35 = $L(">>>=");
798
+ var $L36 = $L(">>=");
799
+ var $L37 = $L("&&=");
800
+ var $L38 = $L("&=");
801
+ var $L39 = $L("^=");
802
+ var $L40 = $L("||=");
803
+ var $L41 = $L("|=");
804
+ var $L42 = $L("??=");
805
+ var $L43 = $L("?=");
806
+ var $L44 = $L("=");
807
+ var $L45 = $L("**");
808
+ var $L46 = $L("*");
809
+ var $L47 = $L("/");
810
+ var $L48 = $L("%");
811
+ var $L49 = $L("+");
812
+ var $L50 = $L("-");
813
+ var $L51 = $L("<=");
814
+ var $L52 = $L(">=");
815
+ var $L53 = $L("<<");
816
+ var $L54 = $L(">>>");
817
+ var $L55 = $L(">>");
818
+ var $L56 = $L(">");
819
+ var $L57 = $L("!==");
820
+ var $L58 = $L("!=");
821
+ var $L59 = $L("is");
822
+ var $L60 = $L("===");
823
+ var $L61 = $L("==");
824
+ var $L62 = $L("and");
825
+ var $L63 = $L("&&");
826
+ var $L64 = $L("or");
827
+ var $L65 = $L("||");
828
+ var $L66 = $L("??");
829
+ var $L67 = $L("instanceof");
830
+ var $L68 = $L("in");
831
+ var $L69 = $L("&");
832
+ var $L70 = $L("^");
833
+ var $L71 = $L("|");
834
+ var $L72 = $L("delete");
835
+ var $L73 = $L("void");
836
+ var $L74 = $L("typeof");
837
+ var $L75 = $L(";");
838
+ var $L76 = $L("do");
839
+ var $L77 = $L("while");
840
+ var $L78 = $L("until");
841
+ var $L79 = $L("finally");
842
+ var $L80 = $L("break");
843
+ var $L81 = $L("continue");
844
+ var $L82 = $L("debugger");
845
+ var $L83 = $L("import type");
846
+ var $L84 = $L("default");
847
+ var $L85 = $L(":=");
848
+ var $L86 = $L("/*");
849
+ var $L87 = $L("*/");
850
+ var $L88 = $L("###");
851
+ var $L89 = $L("as");
852
+ var $L90 = $L("async");
853
+ var $L91 = $L("await");
854
+ var $L92 = $L("case");
855
+ var $L93 = $L("catch");
856
+ var $L94 = $L("class");
857
+ var $L95 = $L("#{");
858
+ var $L96 = $L(":");
859
+ var $L97 = $L(".");
860
+ var $L98 = $L("...");
861
+ var $L99 = $L('"');
862
+ var $L100 = $L("else");
863
+ var $L101 = $L("export");
864
+ var $L102 = $L("for");
865
+ var $L103 = $L("from");
866
+ var $L104 = $L("function");
867
+ var $L105 = $L("get");
868
+ var $L106 = $L("set");
869
+ var $L107 = $L("if");
870
+ var $L108 = $L("let");
871
+ var $L109 = $L("const");
872
+ var $L110 = $L("loop");
873
+ var $L111 = $L("new");
874
+ var $L112 = $L("of");
875
+ var $L113 = $L("{");
876
+ var $L114 = $L("[");
877
+ var $L115 = $L("(");
878
+ var $L116 = $L("?");
879
+ var $L117 = $L("return");
880
+ var $L118 = $L("'");
881
+ var $L119 = $L("static");
882
+ var $L120 = $L("${");
883
+ var $L121 = $L("switch");
884
+ var $L122 = $L("target");
885
+ var $L123 = $L("throw");
886
+ var $L124 = $L('"""');
887
+ var $L125 = $L("'''");
888
+ var $L126 = $L("```");
889
+ var $L127 = $L("try");
890
+ var $L128 = $L("unless");
891
+ var $L129 = $L("var");
892
+ var $L130 = $L("when");
893
+ var $L131 = $L("yield");
894
+ var $L132 = $L("/>");
895
+ var $L133 = $L("</");
896
+ var $L134 = $L("<>");
897
+ var $L135 = $L("</>");
898
+ var $L136 = $L("declare");
899
+ var $L137 = $L("type");
900
+ var $L138 = $L("interface");
901
+ var $L139 = $L("namespace");
902
+ var $L140 = $L("readonly");
903
+ var $L141 = $L("asserts");
904
+ var $L142 = $L("keyof");
905
+ var $L143 = $L("infer");
906
+ var $L144 = $L("[]");
907
+ var $L145 = $L("civet");
908
+ var $L146 = $L(" ");
909
+ var $L147 = $L(" ");
896
910
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
897
911
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
898
912
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
899
913
  var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
900
914
  var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
901
- var $R5 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
902
- var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
903
- var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
904
- var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
905
- var $R9 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
906
- var $R10 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
907
- var $R11 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
908
- var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
909
- var $R13 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
910
- var $R14 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
911
- var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
912
- var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
913
- var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
914
- var $R18 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
915
- var $R19 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
916
- var $R20 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
917
- var $R21 = $R(new RegExp(".", "suy"));
918
- var $R22 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
919
- var $R23 = $R(new RegExp("[^\\r\\n]", "suy"));
920
- var $R24 = $R(new RegExp("[ \\t]+", "suy"));
921
- var $R25 = $R(new RegExp("[\\s]+", "suy"));
922
- var $R26 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
923
- var $R27 = $R(new RegExp("\\s", "suy"));
924
- var $R28 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
925
- var $R29 = $R(new RegExp('"[^"]*"', "suy"));
926
- var $R30 = $R(new RegExp("'[^']*'", "suy"));
927
- var $R31 = $R(new RegExp("[^{}<>]+", "suy"));
928
- var $R32 = $R(new RegExp("[+-]?", "suy"));
929
- var $R33 = $R(new RegExp("[+-]", "suy"));
930
- var $R34 = $R(new RegExp("#![^\\r\\n]*", "suy"));
931
- var $R35 = $R(new RegExp("[\\t ]*", "suy"));
932
- var $R36 = $R(new RegExp("[\\s]*", "suy"));
933
- var $R37 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
934
- var $R38 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
935
- var $R39 = $R(new RegExp("$", "suy"));
915
+ var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
916
+ var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?", "suy"));
917
+ var $R7 = $R(new RegExp("(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)", "suy"));
918
+ var $R8 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
919
+ var $R9 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
920
+ var $R10 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
921
+ var $R11 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
922
+ var $R12 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
923
+ var $R13 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
924
+ var $R14 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
925
+ var $R15 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
926
+ var $R16 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
927
+ var $R17 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
928
+ var $R18 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
929
+ var $R19 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
930
+ var $R20 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
931
+ var $R21 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
932
+ var $R22 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
933
+ var $R23 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
934
+ var $R24 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
935
+ var $R25 = $R(new RegExp(".", "suy"));
936
+ var $R26 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
937
+ var $R27 = $R(new RegExp("[^\\r\\n]", "suy"));
938
+ var $R28 = $R(new RegExp("[ \\t]+", "suy"));
939
+ var $R29 = $R(new RegExp("[\\s]+", "suy"));
940
+ var $R30 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
941
+ var $R31 = $R(new RegExp("\\s", "suy"));
942
+ var $R32 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
943
+ var $R33 = $R(new RegExp('"[^"]*"', "suy"));
944
+ var $R34 = $R(new RegExp("'[^']*'", "suy"));
945
+ var $R35 = $R(new RegExp("[^{}<>]+", "suy"));
946
+ var $R36 = $R(new RegExp("[+-]?", "suy"));
947
+ var $R37 = $R(new RegExp("[+-]", "suy"));
948
+ var $R38 = $R(new RegExp("#![^\\r\\n]*", "suy"));
949
+ var $R39 = $R(new RegExp("[\\t ]*", "suy"));
950
+ var $R40 = $R(new RegExp("[\\s]*", "suy"));
951
+ var $R41 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
952
+ var $R42 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
953
+ var $R43 = $R(new RegExp("$", "suy"));
936
954
  var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
937
955
  function Program(state) {
938
956
  if (state.verbose)
@@ -991,7 +1009,7 @@ var require_parser = __commonJS({
991
1009
  }
992
1010
  }
993
1011
  var ArgumentList$0 = $S($Y(EOS), NestedArgumentList);
994
- var ArgumentList$1 = $S(Expression, $Q(CommaExpression));
1012
+ var ArgumentList$1 = InlineArgumentExpressions;
995
1013
  function ArgumentList(state) {
996
1014
  if (state.tokenize) {
997
1015
  return $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
@@ -1014,7 +1032,7 @@ var require_parser = __commonJS({
1014
1032
  return NestedArgumentList$0(state);
1015
1033
  }
1016
1034
  }
1017
- var NestedArgument$0 = $S(Nested, Expression, ParameterElementDelimiter);
1035
+ var NestedArgument$0 = $S(Nested, InlineArgumentExpressions, ParameterElementDelimiter);
1018
1036
  function NestedArgument(state) {
1019
1037
  if (state.verbose)
1020
1038
  console.log("ENTER:", "NestedArgument");
@@ -1024,6 +1042,20 @@ var require_parser = __commonJS({
1024
1042
  return NestedArgument$0(state);
1025
1043
  }
1026
1044
  }
1045
+ var InlineArgumentExpressions$0 = $TS($S($S($E(DotDotDot), AssignmentExpressionRest), $Q($S(__, Comma, $Q(TrailingComment), $E(DotDotDot), AssignmentExpressionRest))), function($skip, $loc, $0, $1, $2) {
1046
+ if ($2.length == 0)
1047
+ return $1;
1048
+ return $0;
1049
+ });
1050
+ function InlineArgumentExpressions(state) {
1051
+ if (state.verbose)
1052
+ console.log("ENTER:", "InlineArgumentExpressions");
1053
+ if (state.tokenize) {
1054
+ return $TOKEN("InlineArgumentExpressions", state, InlineArgumentExpressions$0(state));
1055
+ } else {
1056
+ return InlineArgumentExpressions$0(state);
1057
+ }
1058
+ }
1027
1059
  var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
1028
1060
  function ImplicitApplication(state) {
1029
1061
  if (state.verbose)
@@ -1062,19 +1094,10 @@ var require_parser = __commonJS({
1062
1094
  return IndentedApplicationAllowed$0(state);
1063
1095
  }
1064
1096
  }
1065
- var CommaExpression$0 = $S(__, Comma, Expression);
1066
- function CommaExpression(state) {
1067
- if (state.verbose)
1068
- console.log("ENTER:", "CommaExpression");
1069
- if (state.tokenize) {
1070
- return $TOKEN("CommaExpression", state, CommaExpression$0(state));
1071
- } else {
1072
- return CommaExpression$0(state);
1073
- }
1074
- }
1075
1097
  var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2) {
1076
- if ($2.length)
1077
- return $0;
1098
+ if ($2.length) {
1099
+ return module2.expandChainedComparisons($0);
1100
+ }
1078
1101
  return $1;
1079
1102
  });
1080
1103
  function BinaryOpExpression(state) {
@@ -1091,9 +1114,16 @@ var require_parser = __commonJS({
1091
1114
  var exp = $2;
1092
1115
  var post = $3;
1093
1116
  if (post?.token === "?") {
1094
- return ["(", pre, , "(", exp, ") != null)"];
1095
- }
1096
- return [pre, exp, post];
1117
+ return ["(", pre, "(", exp, ") != null)"];
1118
+ }
1119
+ const result = [pre, exp, post];
1120
+ if (!post)
1121
+ result.pop();
1122
+ if (!pre.length)
1123
+ result.shift();
1124
+ if (result.length === 1)
1125
+ return result[0];
1126
+ return result;
1097
1127
  });
1098
1128
  function UnaryExpression(state) {
1099
1129
  if (state.verbose)
@@ -1105,7 +1135,7 @@ var require_parser = __commonJS({
1105
1135
  }
1106
1136
  }
1107
1137
  var UnaryPostfix$0 = QuestionMark;
1108
- var UnaryPostfix$1 = $T($S(__, As, NonIdContinue, Type), function(value) {
1138
+ var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
1109
1139
  return { "ts": true, "children": value };
1110
1140
  });
1111
1141
  function UnaryPostfix(state) {
@@ -1560,7 +1590,7 @@ var require_parser = __commonJS({
1560
1590
  return Parameters$0(state) || Parameters$1(state);
1561
1591
  }
1562
1592
  }
1563
- var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
1593
+ var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), $E(FunctionRestParameter), __, CloseParen);
1564
1594
  function NonEmptyParameters(state) {
1565
1595
  if (state.verbose)
1566
1596
  console.log("ENTER:", "NonEmptyParameters");
@@ -1570,6 +1600,16 @@ var require_parser = __commonJS({
1570
1600
  return NonEmptyParameters$0(state);
1571
1601
  }
1572
1602
  }
1603
+ var FunctionRestParameter$0 = $S(__, BindingRestElement, $E(TypeSuffix));
1604
+ function FunctionRestParameter(state) {
1605
+ if (state.verbose)
1606
+ console.log("ENTER:", "FunctionRestParameter");
1607
+ if (state.tokenize) {
1608
+ return $TOKEN("FunctionRestParameter", state, FunctionRestParameter$0(state));
1609
+ } else {
1610
+ return FunctionRestParameter$0(state);
1611
+ }
1612
+ }
1573
1613
  var ParameterElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter);
1574
1614
  function ParameterElement(state) {
1575
1615
  if (state.verbose)
@@ -1581,18 +1621,15 @@ var require_parser = __commonJS({
1581
1621
  }
1582
1622
  }
1583
1623
  var ParameterElementDelimiter$0 = $S($Q(_), Comma);
1584
- var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
1585
- var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
1586
- return { $loc, token: "," };
1587
- });
1588
- var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1624
+ var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
1625
+ var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1589
1626
  return { $loc, token: "," };
1590
1627
  });
1591
1628
  function ParameterElementDelimiter(state) {
1592
1629
  if (state.tokenize) {
1593
- return $TOKEN("ParameterElementDelimiter", state, ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state) || ParameterElementDelimiter$3(state));
1630
+ return $TOKEN("ParameterElementDelimiter", state, ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state));
1594
1631
  } else {
1595
- return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state) || ParameterElementDelimiter$3(state);
1632
+ return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state);
1596
1633
  }
1597
1634
  }
1598
1635
  var BindingIdentifier$0 = $S(__, Identifier);
@@ -1669,7 +1706,7 @@ var require_parser = __commonJS({
1669
1706
  return BindingProperty$0(state) || BindingProperty$1(state);
1670
1707
  }
1671
1708
  }
1672
- var BindingRestProperty$0 = $S($EXPECT($L17, fail, 'BindingRestProperty "..."'), BindingIdentifier);
1709
+ var BindingRestProperty$0 = $S(DotDotDot, BindingIdentifier);
1673
1710
  function BindingRestProperty(state) {
1674
1711
  if (state.verbose)
1675
1712
  console.log("ENTER:", "BindingRestProperty");
@@ -1717,7 +1754,7 @@ var require_parser = __commonJS({
1717
1754
  return BindingElement$0(state);
1718
1755
  }
1719
1756
  }
1720
- var BindingRestElement$0 = $S($EXPECT($L17, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1757
+ var BindingRestElement$0 = $S(DotDotDot, __, $C(BindingIdentifier, BindingPattern));
1721
1758
  function BindingRestElement(state) {
1722
1759
  if (state.verbose)
1723
1760
  console.log("ENTER:", "BindingRestElement");
@@ -1737,17 +1774,35 @@ var require_parser = __commonJS({
1737
1774
  return FunctionDeclaration$0(state);
1738
1775
  }
1739
1776
  }
1777
+ var FunctionSignature$0 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix));
1778
+ function FunctionSignature(state) {
1779
+ if (state.verbose)
1780
+ console.log("ENTER:", "FunctionSignature");
1781
+ if (state.tokenize) {
1782
+ return $TOKEN("FunctionSignature", state, FunctionSignature$0(state));
1783
+ } else {
1784
+ return FunctionSignature$0(state);
1785
+ }
1786
+ }
1740
1787
  var FunctionExpression$0 = ThinArrowFunction;
1741
- var FunctionExpression$1 = $TS($S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
1742
- var suffix = $7;
1743
- var block = $8;
1788
+ var FunctionExpression$1 = $TS($S(FunctionSignature, $E(BracedBlock)), function($skip, $loc, $0, $1, $2) {
1789
+ var block = $2;
1790
+ if (!block) {
1791
+ return {
1792
+ type: "FunctionDeclaration",
1793
+ ts: true,
1794
+ children: $1
1795
+ };
1796
+ }
1797
+ const suffix = $1[$1.length - 1];
1744
1798
  const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
1745
1799
  if (module2.config.implicitReturns && !isVoid) {
1746
1800
  module2.addImplicitReturns(block);
1747
1801
  }
1802
+ $1.push(block);
1748
1803
  return {
1749
1804
  type: "FunctionExpression",
1750
- children: $0
1805
+ children: $1
1751
1806
  };
1752
1807
  });
1753
1808
  function FunctionExpression(state) {
@@ -1785,7 +1840,7 @@ var require_parser = __commonJS({
1785
1840
  return ThinArrowFunction$0(state);
1786
1841
  }
1787
1842
  }
1788
- var Arrow$0 = $TV($EXPECT($L18, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1843
+ var Arrow$0 = $TV($EXPECT($L17, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1789
1844
  return { $loc, token: $1 };
1790
1845
  });
1791
1846
  function Arrow(state) {
@@ -1909,7 +1964,7 @@ var require_parser = __commonJS({
1909
1964
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1910
1965
  }
1911
1966
  }
1912
- var NullLiteral$0 = $TV($EXPECT($L19, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1967
+ var NullLiteral$0 = $TV($EXPECT($L18, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1913
1968
  return { $loc, token: $1 };
1914
1969
  });
1915
1970
  function NullLiteral(state) {
@@ -1921,19 +1976,31 @@ var require_parser = __commonJS({
1921
1976
  return NullLiteral$0(state);
1922
1977
  }
1923
1978
  }
1924
- var BooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'BooleanLiteral "true"'), $EXPECT($L21, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1979
+ var BooleanLiteral$0 = CoffeeScriptBooleanLiteral;
1980
+ var BooleanLiteral$1 = $TV($C($EXPECT($L19, fail, 'BooleanLiteral "true"'), $EXPECT($L20, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1925
1981
  return { $loc, token: $1 };
1926
1982
  });
1927
1983
  function BooleanLiteral(state) {
1928
- if (state.verbose)
1929
- console.log("ENTER:", "BooleanLiteral");
1930
1984
  if (state.tokenize) {
1931
- return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
1985
+ return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state) || BooleanLiteral$1(state));
1986
+ } else {
1987
+ return BooleanLiteral$0(state) || BooleanLiteral$1(state);
1988
+ }
1989
+ }
1990
+ var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
1991
+ return { $loc, token: "true" };
1992
+ });
1993
+ var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
1994
+ return { $loc, token: "false" };
1995
+ });
1996
+ function CoffeeScriptBooleanLiteral(state) {
1997
+ if (state.tokenize) {
1998
+ return $TOKEN("CoffeeScriptBooleanLiteral", state, CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state));
1932
1999
  } else {
1933
- return BooleanLiteral$0(state);
2000
+ return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
1934
2001
  }
1935
2002
  }
1936
- var Comma$0 = $TV($EXPECT($L22, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
2003
+ var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
1937
2004
  return { $loc, token: $1 };
1938
2005
  });
1939
2006
  function Comma(state) {
@@ -1959,6 +2026,7 @@ var require_parser = __commonJS({
1959
2026
  }
1960
2027
  var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
1961
2028
  return {
2029
+ type: "Identifier",
1962
2030
  $loc,
1963
2031
  token: $0
1964
2032
  };
@@ -2017,7 +2085,7 @@ var require_parser = __commonJS({
2017
2085
  }
2018
2086
  }
2019
2087
  var ArrayElementDelimiter$0 = $S($Q(_), Comma);
2020
- var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L23, fail, 'ArrayElementDelimiter "]"')));
2088
+ var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
2021
2089
  var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
2022
2090
  return { $loc, token: "," };
2023
2091
  });
@@ -2048,7 +2116,7 @@ var require_parser = __commonJS({
2048
2116
  return InlineElementList$0(state);
2049
2117
  }
2050
2118
  }
2051
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L17, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
2119
+ var ArrayElementExpression$0 = $E($S($E($S(DotDotDot, __)), AssignmentExpression));
2052
2120
  function ArrayElementExpression(state) {
2053
2121
  if (state.verbose)
2054
2122
  console.log("ENTER:", "ArrayElementExpression");
@@ -2115,7 +2183,7 @@ var require_parser = __commonJS({
2115
2183
  }
2116
2184
  }
2117
2185
  var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
2118
- var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ObjectPropertyDelimiter "}"')));
2186
+ var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
2119
2187
  var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
2120
2188
  return { $loc, token: "," };
2121
2189
  });
@@ -2138,7 +2206,7 @@ var require_parser = __commonJS({
2138
2206
  }
2139
2207
  var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
2140
2208
  var PropertyDefinition$1 = MethodDefinition;
2141
- var PropertyDefinition$2 = $S($EXPECT($L17, fail, 'PropertyDefinition "..."'), AssignmentExpression);
2209
+ var PropertyDefinition$2 = $S(DotDotDot, AssignmentExpression);
2142
2210
  var PropertyDefinition$3 = IdentifierReference;
2143
2211
  function PropertyDefinition(state) {
2144
2212
  if (state.tokenize) {
@@ -2150,7 +2218,7 @@ var require_parser = __commonJS({
2150
2218
  var PropertyName$0 = NumericLiteral;
2151
2219
  var PropertyName$1 = StringLiteral;
2152
2220
  var PropertyName$2 = IdentifierName;
2153
- var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L23, fail, 'PropertyName "]"'));
2221
+ var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
2154
2222
  function PropertyName(state) {
2155
2223
  if (state.tokenize) {
2156
2224
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -2252,25 +2320,25 @@ var require_parser = __commonJS({
2252
2320
  return AssignmentOp$0(state);
2253
2321
  }
2254
2322
  }
2255
- var AssignmentOpSymbol$0 = $EXPECT($L25, fail, 'AssignmentOpSymbol "**="');
2256
- var AssignmentOpSymbol$1 = $EXPECT($L26, fail, 'AssignmentOpSymbol "*="');
2257
- var AssignmentOpSymbol$2 = $EXPECT($L27, fail, 'AssignmentOpSymbol "/="');
2258
- var AssignmentOpSymbol$3 = $EXPECT($L28, fail, 'AssignmentOpSymbol "%="');
2259
- var AssignmentOpSymbol$4 = $EXPECT($L29, fail, 'AssignmentOpSymbol "+="');
2260
- var AssignmentOpSymbol$5 = $EXPECT($L30, fail, 'AssignmentOpSymbol "-="');
2261
- var AssignmentOpSymbol$6 = $EXPECT($L31, fail, 'AssignmentOpSymbol "<<="');
2262
- var AssignmentOpSymbol$7 = $EXPECT($L32, fail, 'AssignmentOpSymbol ">>>="');
2263
- var AssignmentOpSymbol$8 = $EXPECT($L33, fail, 'AssignmentOpSymbol ">>="');
2264
- var AssignmentOpSymbol$9 = $EXPECT($L34, fail, 'AssignmentOpSymbol "&&="');
2265
- var AssignmentOpSymbol$10 = $EXPECT($L35, fail, 'AssignmentOpSymbol "&="');
2266
- var AssignmentOpSymbol$11 = $EXPECT($L36, fail, 'AssignmentOpSymbol "^="');
2267
- var AssignmentOpSymbol$12 = $EXPECT($L37, fail, 'AssignmentOpSymbol "||="');
2268
- var AssignmentOpSymbol$13 = $EXPECT($L38, fail, 'AssignmentOpSymbol "|="');
2269
- var AssignmentOpSymbol$14 = $EXPECT($L39, fail, 'AssignmentOpSymbol "??="');
2270
- var AssignmentOpSymbol$15 = $T($EXPECT($L40, fail, 'AssignmentOpSymbol "?="'), function(value) {
2323
+ var AssignmentOpSymbol$0 = $EXPECT($L28, fail, 'AssignmentOpSymbol "**="');
2324
+ var AssignmentOpSymbol$1 = $EXPECT($L29, fail, 'AssignmentOpSymbol "*="');
2325
+ var AssignmentOpSymbol$2 = $EXPECT($L30, fail, 'AssignmentOpSymbol "/="');
2326
+ var AssignmentOpSymbol$3 = $EXPECT($L31, fail, 'AssignmentOpSymbol "%="');
2327
+ var AssignmentOpSymbol$4 = $EXPECT($L32, fail, 'AssignmentOpSymbol "+="');
2328
+ var AssignmentOpSymbol$5 = $EXPECT($L33, fail, 'AssignmentOpSymbol "-="');
2329
+ var AssignmentOpSymbol$6 = $EXPECT($L34, fail, 'AssignmentOpSymbol "<<="');
2330
+ var AssignmentOpSymbol$7 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>>="');
2331
+ var AssignmentOpSymbol$8 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>="');
2332
+ var AssignmentOpSymbol$9 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&&="');
2333
+ var AssignmentOpSymbol$10 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&="');
2334
+ var AssignmentOpSymbol$11 = $EXPECT($L39, fail, 'AssignmentOpSymbol "^="');
2335
+ var AssignmentOpSymbol$12 = $EXPECT($L40, fail, 'AssignmentOpSymbol "||="');
2336
+ var AssignmentOpSymbol$13 = $EXPECT($L41, fail, 'AssignmentOpSymbol "|="');
2337
+ var AssignmentOpSymbol$14 = $EXPECT($L42, fail, 'AssignmentOpSymbol "??="');
2338
+ var AssignmentOpSymbol$15 = $T($EXPECT($L43, fail, 'AssignmentOpSymbol "?="'), function(value) {
2271
2339
  return "??=";
2272
2340
  });
2273
- var AssignmentOpSymbol$16 = $EXPECT($L41, fail, 'AssignmentOpSymbol "="');
2341
+ var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
2274
2342
  function AssignmentOpSymbol(state) {
2275
2343
  if (state.tokenize) {
2276
2344
  return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state));
@@ -2290,52 +2358,52 @@ var require_parser = __commonJS({
2290
2358
  return BinaryOp$0(state);
2291
2359
  }
2292
2360
  }
2293
- var BinaryOpSymbol$0 = $EXPECT($L42, fail, 'BinaryOpSymbol "**"');
2294
- var BinaryOpSymbol$1 = $EXPECT($L43, fail, 'BinaryOpSymbol "*"');
2295
- var BinaryOpSymbol$2 = $EXPECT($L44, fail, 'BinaryOpSymbol "/"');
2296
- var BinaryOpSymbol$3 = $EXPECT($L45, fail, 'BinaryOpSymbol "%"');
2297
- var BinaryOpSymbol$4 = $EXPECT($L46, fail, 'BinaryOpSymbol "+"');
2298
- var BinaryOpSymbol$5 = $EXPECT($L47, fail, 'BinaryOpSymbol "-"');
2299
- var BinaryOpSymbol$6 = $EXPECT($L48, fail, 'BinaryOpSymbol "<="');
2300
- var BinaryOpSymbol$7 = $EXPECT($L49, fail, 'BinaryOpSymbol ">="');
2301
- var BinaryOpSymbol$8 = $EXPECT($L50, fail, 'BinaryOpSymbol "<<"');
2361
+ var BinaryOpSymbol$0 = $EXPECT($L45, fail, 'BinaryOpSymbol "**"');
2362
+ var BinaryOpSymbol$1 = $EXPECT($L46, fail, 'BinaryOpSymbol "*"');
2363
+ var BinaryOpSymbol$2 = $EXPECT($L47, fail, 'BinaryOpSymbol "/"');
2364
+ var BinaryOpSymbol$3 = $EXPECT($L48, fail, 'BinaryOpSymbol "%"');
2365
+ var BinaryOpSymbol$4 = $EXPECT($L49, fail, 'BinaryOpSymbol "+"');
2366
+ var BinaryOpSymbol$5 = $EXPECT($L50, fail, 'BinaryOpSymbol "-"');
2367
+ var BinaryOpSymbol$6 = $EXPECT($L51, fail, 'BinaryOpSymbol "<="');
2368
+ var BinaryOpSymbol$7 = $EXPECT($L52, fail, 'BinaryOpSymbol ">="');
2369
+ var BinaryOpSymbol$8 = $EXPECT($L53, fail, 'BinaryOpSymbol "<<"');
2302
2370
  var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
2303
- var BinaryOpSymbol$10 = $EXPECT($L51, fail, 'BinaryOpSymbol ">>>"');
2304
- var BinaryOpSymbol$11 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>"');
2305
- var BinaryOpSymbol$12 = $EXPECT($L53, fail, 'BinaryOpSymbol ">"');
2306
- var BinaryOpSymbol$13 = $EXPECT($L54, fail, 'BinaryOpSymbol "!=="');
2307
- var BinaryOpSymbol$14 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2371
+ var BinaryOpSymbol$10 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>>"');
2372
+ var BinaryOpSymbol$11 = $EXPECT($L55, fail, 'BinaryOpSymbol ">>"');
2373
+ var BinaryOpSymbol$12 = $EXPECT($L56, fail, 'BinaryOpSymbol ">"');
2374
+ var BinaryOpSymbol$13 = $EXPECT($L57, fail, 'BinaryOpSymbol "!=="');
2375
+ var BinaryOpSymbol$14 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2308
2376
  if (module2.config.coffeeEq)
2309
2377
  return "!==";
2310
2378
  return $1;
2311
2379
  });
2312
- var BinaryOpSymbol$15 = $T($S($EXPECT($L56, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2380
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2313
2381
  return "===";
2314
2382
  });
2315
- var BinaryOpSymbol$16 = $EXPECT($L57, fail, 'BinaryOpSymbol "==="');
2316
- var BinaryOpSymbol$17 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2383
+ var BinaryOpSymbol$16 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
2384
+ var BinaryOpSymbol$17 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2317
2385
  if (module2.config.coffeeEq)
2318
2386
  return "===";
2319
2387
  return $1;
2320
2388
  });
2321
- var BinaryOpSymbol$18 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2389
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2322
2390
  return "&&";
2323
2391
  });
2324
- var BinaryOpSymbol$19 = $EXPECT($L60, fail, 'BinaryOpSymbol "&&"');
2325
- var BinaryOpSymbol$20 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2392
+ var BinaryOpSymbol$19 = $EXPECT($L63, fail, 'BinaryOpSymbol "&&"');
2393
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L64, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2326
2394
  return "||";
2327
2395
  });
2328
- var BinaryOpSymbol$21 = $EXPECT($L62, fail, 'BinaryOpSymbol "||"');
2329
- var BinaryOpSymbol$22 = $EXPECT($L63, fail, 'BinaryOpSymbol "??"');
2330
- var BinaryOpSymbol$23 = $TS($S($EXPECT($L64, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2396
+ var BinaryOpSymbol$21 = $EXPECT($L65, fail, 'BinaryOpSymbol "||"');
2397
+ var BinaryOpSymbol$22 = $EXPECT($L66, fail, 'BinaryOpSymbol "??"');
2398
+ var BinaryOpSymbol$23 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2331
2399
  return $1;
2332
2400
  });
2333
- var BinaryOpSymbol$24 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2401
+ var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2334
2402
  return $1;
2335
2403
  });
2336
- var BinaryOpSymbol$25 = $EXPECT($L66, fail, 'BinaryOpSymbol "&"');
2337
- var BinaryOpSymbol$26 = $EXPECT($L67, fail, 'BinaryOpSymbol "^"');
2338
- var BinaryOpSymbol$27 = $EXPECT($L68, fail, 'BinaryOpSymbol "|"');
2404
+ var BinaryOpSymbol$25 = $EXPECT($L69, fail, 'BinaryOpSymbol "&"');
2405
+ var BinaryOpSymbol$26 = $EXPECT($L70, fail, 'BinaryOpSymbol "^"');
2406
+ var BinaryOpSymbol$27 = $EXPECT($L71, fail, 'BinaryOpSymbol "|"');
2339
2407
  function BinaryOpSymbol(state) {
2340
2408
  if (state.tokenize) {
2341
2409
  return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
@@ -2344,7 +2412,7 @@ var require_parser = __commonJS({
2344
2412
  }
2345
2413
  }
2346
2414
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2347
- var UnaryOp$1 = $S($C($EXPECT($L69, fail, 'UnaryOp "delete"'), $EXPECT($L70, fail, 'UnaryOp "void"'), $EXPECT($L71, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2415
+ var UnaryOp$1 = $S($C($EXPECT($L72, fail, 'UnaryOp "delete"'), $EXPECT($L73, fail, 'UnaryOp "void"'), $EXPECT($L74, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2348
2416
  function UnaryOp(state) {
2349
2417
  if (state.tokenize) {
2350
2418
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2423,7 +2491,7 @@ var require_parser = __commonJS({
2423
2491
  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);
2424
2492
  }
2425
2493
  }
2426
- var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L72, fail, 'EmptyStatement ";"'))), function(value) {
2494
+ var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
2427
2495
  return { "type": "EmptyStatement", "children": value[0] };
2428
2496
  });
2429
2497
  function EmptyStatement(state) {
@@ -2504,7 +2572,7 @@ var require_parser = __commonJS({
2504
2572
  return LoopStatement$0(state);
2505
2573
  }
2506
2574
  }
2507
- var DoWhileStatement$0 = $T($S($EXPECT($L73, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
2575
+ var DoWhileStatement$0 = $T($S($EXPECT($L76, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
2508
2576
  return { "type": "IterationStatement", "children": value };
2509
2577
  });
2510
2578
  function DoWhileStatement(state) {
@@ -2528,7 +2596,7 @@ var require_parser = __commonJS({
2528
2596
  return WhileStatement$0(state);
2529
2597
  }
2530
2598
  }
2531
- var WhileClause$0 = $TS($S($C($EXPECT($L74, fail, 'WhileClause "while"'), $EXPECT($L75, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2599
+ var WhileClause$0 = $TS($S($C($EXPECT($L77, fail, 'WhileClause "while"'), $EXPECT($L78, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2532
2600
  var kind = $1;
2533
2601
  var cond = $3;
2534
2602
  if (kind === "until") {
@@ -2766,7 +2834,7 @@ var require_parser = __commonJS({
2766
2834
  return CatchBind$0(state) || CatchBind$1(state);
2767
2835
  }
2768
2836
  }
2769
- var Finally$0 = $S(__, $EXPECT($L76, fail, 'Finally "finally"'), BracedBlock);
2837
+ var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
2770
2838
  function Finally(state) {
2771
2839
  if (state.verbose)
2772
2840
  console.log("ENTER:", "Finally");
@@ -2832,13 +2900,13 @@ var require_parser = __commonJS({
2832
2900
  return ExpressionStatement$0(state);
2833
2901
  }
2834
2902
  }
2835
- var KeywordStatement$0 = $T($S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
2903
+ var KeywordStatement$0 = $T($S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
2836
2904
  return { "type": "BreakStatement", "children": value };
2837
2905
  });
2838
- var KeywordStatement$1 = $T($S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
2906
+ var KeywordStatement$1 = $T($S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
2839
2907
  return { "type": "ContinueStatement", "children": value };
2840
2908
  });
2841
- var KeywordStatement$2 = $T($S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
2909
+ var KeywordStatement$2 = $T($S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
2842
2910
  return { "type": "DebuggerStatement", "children": value };
2843
2911
  });
2844
2912
  var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
@@ -2863,7 +2931,7 @@ var require_parser = __commonJS({
2863
2931
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2864
2932
  }
2865
2933
  }
2866
- var ImportDeclaration$0 = $T($S($EXPECT($L80, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2934
+ var ImportDeclaration$0 = $T($S($EXPECT($L83, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2867
2935
  return { "ts": true, "children": value };
2868
2936
  });
2869
2937
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -3001,7 +3069,7 @@ var require_parser = __commonJS({
3001
3069
  return ImportedBinding$0(state);
3002
3070
  }
3003
3071
  }
3004
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L81, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
3072
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
3005
3073
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
3006
3074
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
3007
3075
  function ExportDeclaration(state) {
@@ -3083,7 +3151,7 @@ var require_parser = __commonJS({
3083
3151
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
3084
3152
  }
3085
3153
  }
3086
- var ConstAssignment$0 = $TV($EXPECT($L82, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
3154
+ var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
3087
3155
  return { $loc, token: "=" };
3088
3156
  });
3089
3157
  function ConstAssignment(state) {
@@ -3179,17 +3247,29 @@ var require_parser = __commonJS({
3179
3247
  return DecimalBigIntegerLiteral$0(state);
3180
3248
  }
3181
3249
  }
3182
- var DecimalLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
3250
+ var DecimalLiteral$0 = $TV($TEXT($EXPECT($R5, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
3251
+ return $1 + ".";
3252
+ });
3253
+ var DecimalLiteral$1 = $TEXT($S($EXPECT($R6, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?/"), $E(ExponentPart)));
3254
+ var DecimalLiteral$2 = $TEXT($S($EXPECT($R7, fail, "DecimalLiteral /(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
3183
3255
  function DecimalLiteral(state) {
3256
+ if (state.tokenize) {
3257
+ return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
3258
+ } else {
3259
+ return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
3260
+ }
3261
+ }
3262
+ var ExponentPart$0 = $R$0($EXPECT($R8, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
3263
+ function ExponentPart(state) {
3184
3264
  if (state.verbose)
3185
- console.log("ENTER:", "DecimalLiteral");
3265
+ console.log("ENTER:", "ExponentPart");
3186
3266
  if (state.tokenize) {
3187
- return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state));
3267
+ return $TOKEN("ExponentPart", state, ExponentPart$0(state));
3188
3268
  } else {
3189
- return DecimalLiteral$0(state);
3269
+ return ExponentPart$0(state);
3190
3270
  }
3191
3271
  }
3192
- var BinaryIntegerLiteral$0 = $R$0($EXPECT($R6, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
3272
+ var BinaryIntegerLiteral$0 = $R$0($EXPECT($R9, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
3193
3273
  function BinaryIntegerLiteral(state) {
3194
3274
  if (state.verbose)
3195
3275
  console.log("ENTER:", "BinaryIntegerLiteral");
@@ -3199,7 +3279,7 @@ var require_parser = __commonJS({
3199
3279
  return BinaryIntegerLiteral$0(state);
3200
3280
  }
3201
3281
  }
3202
- var OctalIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
3282
+ var OctalIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
3203
3283
  function OctalIntegerLiteral(state) {
3204
3284
  if (state.verbose)
3205
3285
  console.log("ENTER:", "OctalIntegerLiteral");
@@ -3209,7 +3289,7 @@ var require_parser = __commonJS({
3209
3289
  return OctalIntegerLiteral$0(state);
3210
3290
  }
3211
3291
  }
3212
- var HexLiteral$0 = $R$0($EXPECT($R8, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
3292
+ var HexLiteral$0 = $R$0($EXPECT($R11, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
3213
3293
  function HexLiteral(state) {
3214
3294
  if (state.verbose)
3215
3295
  console.log("ENTER:", "HexLiteral");
@@ -3258,7 +3338,7 @@ var require_parser = __commonJS({
3258
3338
  return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
3259
3339
  }
3260
3340
  }
3261
- var DoubleStringCharacters$0 = $TR($EXPECT($R9, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3341
+ var DoubleStringCharacters$0 = $TR($EXPECT($R12, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3262
3342
  return { $loc, token: $0 };
3263
3343
  });
3264
3344
  function DoubleStringCharacters(state) {
@@ -3270,7 +3350,7 @@ var require_parser = __commonJS({
3270
3350
  return DoubleStringCharacters$0(state);
3271
3351
  }
3272
3352
  }
3273
- var SingleStringCharacters$0 = $TR($EXPECT($R10, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3353
+ var SingleStringCharacters$0 = $TR($EXPECT($R13, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3274
3354
  return { $loc, token: $0 };
3275
3355
  });
3276
3356
  function SingleStringCharacters(state) {
@@ -3282,7 +3362,7 @@ var require_parser = __commonJS({
3282
3362
  return SingleStringCharacters$0(state);
3283
3363
  }
3284
3364
  }
3285
- var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3365
+ var TripleDoubleStringCharacters$0 = $TR($EXPECT($R14, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3286
3366
  return { $loc, token: $0 };
3287
3367
  });
3288
3368
  function TripleDoubleStringCharacters(state) {
@@ -3294,7 +3374,7 @@ var require_parser = __commonJS({
3294
3374
  return TripleDoubleStringCharacters$0(state);
3295
3375
  }
3296
3376
  }
3297
- var TripleSingleStringCharacters$0 = $TR($EXPECT($R12, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3377
+ var TripleSingleStringCharacters$0 = $TR($EXPECT($R15, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3298
3378
  return { $loc, token: $0 };
3299
3379
  });
3300
3380
  function TripleSingleStringCharacters(state) {
@@ -3345,7 +3425,7 @@ var require_parser = __commonJS({
3345
3425
  return CoffeeInterpolatedDoubleQuotedString$0(state);
3346
3426
  }
3347
3427
  }
3348
- var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R13, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3428
+ var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R16, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3349
3429
  return { $loc, token: $0 };
3350
3430
  });
3351
3431
  function CoffeeDoubleQuotedStringCharacters(state) {
@@ -3357,7 +3437,7 @@ var require_parser = __commonJS({
3357
3437
  return CoffeeDoubleQuotedStringCharacters$0(state);
3358
3438
  }
3359
3439
  }
3360
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3440
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3361
3441
  return { $loc, token: $1 };
3362
3442
  });
3363
3443
  function RegularExpressionLiteral(state) {
@@ -3369,7 +3449,7 @@ var require_parser = __commonJS({
3369
3449
  return RegularExpressionLiteral$0(state);
3370
3450
  }
3371
3451
  }
3372
- var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R14, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3452
+ var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R17, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3373
3453
  function RegularExpressionBody(state) {
3374
3454
  if (state.verbose)
3375
3455
  console.log("ENTER:", "RegularExpressionBody");
@@ -3379,7 +3459,7 @@ var require_parser = __commonJS({
3379
3459
  return RegularExpressionBody$0(state);
3380
3460
  }
3381
3461
  }
3382
- var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3462
+ var RegExpCharacter$0 = $R$0($EXPECT($R18, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3383
3463
  function RegExpCharacter(state) {
3384
3464
  if (state.verbose)
3385
3465
  console.log("ENTER:", "RegExpCharacter");
@@ -3389,7 +3469,7 @@ var require_parser = __commonJS({
3389
3469
  return RegExpCharacter$0(state);
3390
3470
  }
3391
3471
  }
3392
- var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3472
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R19, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3393
3473
  function RegularExpressionFlags(state) {
3394
3474
  if (state.verbose)
3395
3475
  console.log("ENTER:", "RegularExpressionFlags");
@@ -3420,7 +3500,7 @@ var require_parser = __commonJS({
3420
3500
  return TemplateSubstitution$0(state);
3421
3501
  }
3422
3502
  }
3423
- var TemplateCharacters$0 = $TR($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3503
+ var TemplateCharacters$0 = $TR($EXPECT($R20, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3424
3504
  return { $loc, token: $0 };
3425
3505
  });
3426
3506
  function TemplateCharacters(state) {
@@ -3432,7 +3512,7 @@ var require_parser = __commonJS({
3432
3512
  return TemplateCharacters$0(state);
3433
3513
  }
3434
3514
  }
3435
- var TemplateBlockCharacters$0 = $TR($EXPECT($R18, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3515
+ var TemplateBlockCharacters$0 = $TR($EXPECT($R21, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3436
3516
  return { $loc, token: $0 };
3437
3517
  });
3438
3518
  function TemplateBlockCharacters(state) {
@@ -3444,14 +3524,13 @@ var require_parser = __commonJS({
3444
3524
  return TemplateBlockCharacters$0(state);
3445
3525
  }
3446
3526
  }
3447
- var ReservedWord$0 = $R$0($EXPECT($R19, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3527
+ var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R22, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
3528
+ var ReservedWord$1 = $R$0($EXPECT($R23, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3448
3529
  function ReservedWord(state) {
3449
- if (state.verbose)
3450
- console.log("ENTER:", "ReservedWord");
3451
3530
  if (state.tokenize) {
3452
- return $TOKEN("ReservedWord", state, ReservedWord$0(state));
3531
+ return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
3453
3532
  } else {
3454
- return ReservedWord$0(state);
3533
+ return ReservedWord$0(state) || ReservedWord$1(state);
3455
3534
  }
3456
3535
  }
3457
3536
  var Comment$0 = MultiLineComment;
@@ -3463,7 +3542,7 @@ var require_parser = __commonJS({
3463
3542
  return Comment$0(state) || Comment$1(state);
3464
3543
  }
3465
3544
  }
3466
- var SingleLineComment$0 = $TR($EXPECT($R20, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3545
+ var SingleLineComment$0 = $TR($EXPECT($R24, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3467
3546
  return { $loc, token: $0 };
3468
3547
  });
3469
3548
  var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
@@ -3483,7 +3562,7 @@ var require_parser = __commonJS({
3483
3562
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3484
3563
  }
3485
3564
  }
3486
- var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L84, fail, 'JSMultiLineComment "*/"')), $EXPECT($R21, fail, "JSMultiLineComment /./"))), $EXPECT($L84, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3565
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L87, fail, 'JSMultiLineComment "*/"')), $EXPECT($R25, fail, "JSMultiLineComment /./"))), $EXPECT($L87, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3487
3566
  return { $loc, token: $1 };
3488
3567
  });
3489
3568
  function JSMultiLineComment(state) {
@@ -3495,7 +3574,7 @@ var require_parser = __commonJS({
3495
3574
  return JSMultiLineComment$0(state);
3496
3575
  }
3497
3576
  }
3498
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R22, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3577
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R26, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3499
3578
  return { $loc, token: `//${$1}` };
3500
3579
  });
3501
3580
  function CoffeeSingleLineComment(state) {
@@ -3507,7 +3586,7 @@ var require_parser = __commonJS({
3507
3586
  return CoffeeSingleLineComment$0(state);
3508
3587
  }
3509
3588
  }
3510
- var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L84, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R21, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L85, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3589
+ var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L88, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L88, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L87, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R25, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L88, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3511
3590
  return { $loc, token: `/*${$2}*/` };
3512
3591
  });
3513
3592
  function CoffeeMultiLineComment(state) {
@@ -3519,7 +3598,7 @@ var require_parser = __commonJS({
3519
3598
  return CoffeeMultiLineComment$0(state);
3520
3599
  }
3521
3600
  }
3522
- var InlineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L84, fail, 'InlineComment "*/"')), $EXPECT($R23, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L84, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3601
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L87, fail, 'InlineComment "*/"')), $EXPECT($R27, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L87, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3523
3602
  return { $loc, token: $1 };
3524
3603
  });
3525
3604
  function InlineComment(state) {
@@ -3561,7 +3640,7 @@ var require_parser = __commonJS({
3561
3640
  return _$0(state);
3562
3641
  }
3563
3642
  }
3564
- var NonNewlineWhitespace$0 = $TR($EXPECT($R24, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3643
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R28, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3565
3644
  return { $loc, token: $0 };
3566
3645
  });
3567
3646
  function NonNewlineWhitespace(state) {
@@ -3583,7 +3662,7 @@ var require_parser = __commonJS({
3583
3662
  return __$0(state);
3584
3663
  }
3585
3664
  }
3586
- var Whitespace$0 = $TR($EXPECT($R25, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3665
+ var Whitespace$0 = $TR($EXPECT($R29, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3587
3666
  return { $loc, token: $0 };
3588
3667
  });
3589
3668
  function Whitespace(state) {
@@ -3606,7 +3685,7 @@ var require_parser = __commonJS({
3606
3685
  return StatementDelimiter$0(state) || StatementDelimiter$1(state);
3607
3686
  }
3608
3687
  }
3609
- var NonIdContinue$0 = $R$0($EXPECT($R26, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3688
+ var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3610
3689
  function NonIdContinue(state) {
3611
3690
  if (state.verbose)
3612
3691
  console.log("ENTER:", "NonIdContinue");
@@ -3628,7 +3707,7 @@ var require_parser = __commonJS({
3628
3707
  return Loc$0(state);
3629
3708
  }
3630
3709
  }
3631
- var As$0 = $TS($S($EXPECT($L86, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3710
+ var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3632
3711
  return { $loc, token: $1 };
3633
3712
  });
3634
3713
  function As(state) {
@@ -3640,7 +3719,7 @@ var require_parser = __commonJS({
3640
3719
  return As$0(state);
3641
3720
  }
3642
3721
  }
3643
- var Async$0 = $TV($EXPECT($L87, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3722
+ var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3644
3723
  return { $loc, token: $1 };
3645
3724
  });
3646
3725
  function Async(state) {
@@ -3652,7 +3731,7 @@ var require_parser = __commonJS({
3652
3731
  return Async$0(state);
3653
3732
  }
3654
3733
  }
3655
- var Await$0 = $TS($S($EXPECT($L88, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3734
+ var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3656
3735
  return { $loc, token: $1 };
3657
3736
  });
3658
3737
  function Await(state) {
@@ -3664,7 +3743,7 @@ var require_parser = __commonJS({
3664
3743
  return Await$0(state);
3665
3744
  }
3666
3745
  }
3667
- var Case$0 = $TS($S($EXPECT($L89, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3746
+ var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3668
3747
  return { $loc, token: $1 };
3669
3748
  });
3670
3749
  function Case(state) {
@@ -3676,7 +3755,7 @@ var require_parser = __commonJS({
3676
3755
  return Case$0(state);
3677
3756
  }
3678
3757
  }
3679
- var Catch$0 = $TV($EXPECT($L90, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3758
+ var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3680
3759
  return { $loc, token: $1 };
3681
3760
  });
3682
3761
  function Catch(state) {
@@ -3688,7 +3767,7 @@ var require_parser = __commonJS({
3688
3767
  return Catch$0(state);
3689
3768
  }
3690
3769
  }
3691
- var Class$0 = $TV($EXPECT($L91, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3770
+ var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3692
3771
  return { $loc, token: $1 };
3693
3772
  });
3694
3773
  function Class(state) {
@@ -3700,7 +3779,7 @@ var require_parser = __commonJS({
3700
3779
  return Class$0(state);
3701
3780
  }
3702
3781
  }
3703
- var CloseBrace$0 = $TV($EXPECT($L24, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3782
+ var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3704
3783
  return { $loc, token: $1 };
3705
3784
  });
3706
3785
  function CloseBrace(state) {
@@ -3712,7 +3791,7 @@ var require_parser = __commonJS({
3712
3791
  return CloseBrace$0(state);
3713
3792
  }
3714
3793
  }
3715
- var CloseBracket$0 = $TV($EXPECT($L23, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3794
+ var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3716
3795
  return { $loc, token: $1 };
3717
3796
  });
3718
3797
  function CloseBracket(state) {
@@ -3736,7 +3815,7 @@ var require_parser = __commonJS({
3736
3815
  return CloseParen$0(state);
3737
3816
  }
3738
3817
  }
3739
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L92, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3818
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3740
3819
  return { $loc, token: "${" };
3741
3820
  });
3742
3821
  function CoffeeSubstitutionStart(state) {
@@ -3748,7 +3827,7 @@ var require_parser = __commonJS({
3748
3827
  return CoffeeSubstitutionStart$0(state);
3749
3828
  }
3750
3829
  }
3751
- var Colon$0 = $TV($EXPECT($L93, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3830
+ var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3752
3831
  return { $loc, token: $1 };
3753
3832
  });
3754
3833
  function Colon(state) {
@@ -3772,7 +3851,7 @@ var require_parser = __commonJS({
3772
3851
  return ConstructorShorthand$0(state);
3773
3852
  }
3774
3853
  }
3775
- var Default$0 = $TS($S($EXPECT($L81, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3854
+ var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3776
3855
  return { $loc, token: $1 };
3777
3856
  });
3778
3857
  function Default(state) {
@@ -3784,7 +3863,7 @@ var require_parser = __commonJS({
3784
3863
  return Default$0(state);
3785
3864
  }
3786
3865
  }
3787
- var Dot$0 = $TV($EXPECT($L94, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3866
+ var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3788
3867
  return { $loc, token: $1 };
3789
3868
  });
3790
3869
  function Dot(state) {
@@ -3796,7 +3875,19 @@ var require_parser = __commonJS({
3796
3875
  return Dot$0(state);
3797
3876
  }
3798
3877
  }
3799
- var DoubleQuote$0 = $TV($EXPECT($L95, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3878
+ var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
3879
+ return { $loc, token: $1 };
3880
+ });
3881
+ function DotDotDot(state) {
3882
+ if (state.verbose)
3883
+ console.log("ENTER:", "DotDotDot");
3884
+ if (state.tokenize) {
3885
+ return $TOKEN("DotDotDot", state, DotDotDot$0(state));
3886
+ } else {
3887
+ return DotDotDot$0(state);
3888
+ }
3889
+ }
3890
+ var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3800
3891
  return { $loc, token: $1 };
3801
3892
  });
3802
3893
  function DoubleQuote(state) {
@@ -3808,7 +3899,7 @@ var require_parser = __commonJS({
3808
3899
  return DoubleQuote$0(state);
3809
3900
  }
3810
3901
  }
3811
- var Else$0 = $TV($EXPECT($L96, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3902
+ var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3812
3903
  return { $loc, token: $1 };
3813
3904
  });
3814
3905
  function Else(state) {
@@ -3820,7 +3911,7 @@ var require_parser = __commonJS({
3820
3911
  return Else$0(state);
3821
3912
  }
3822
3913
  }
3823
- var Equals$0 = $TV($EXPECT($L41, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3914
+ var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3824
3915
  return { $loc, token: $1 };
3825
3916
  });
3826
3917
  function Equals(state) {
@@ -3832,7 +3923,7 @@ var require_parser = __commonJS({
3832
3923
  return Equals$0(state);
3833
3924
  }
3834
3925
  }
3835
- var Export$0 = $TS($S($EXPECT($L97, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3926
+ var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3836
3927
  return { $loc, token: $1 };
3837
3928
  });
3838
3929
  function Export(state) {
@@ -3844,7 +3935,7 @@ var require_parser = __commonJS({
3844
3935
  return Export$0(state);
3845
3936
  }
3846
3937
  }
3847
- var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3938
+ var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3848
3939
  return { $loc, token: $1 };
3849
3940
  });
3850
3941
  function For(state) {
@@ -3856,7 +3947,7 @@ var require_parser = __commonJS({
3856
3947
  return For$0(state);
3857
3948
  }
3858
3949
  }
3859
- var From$0 = $TS($S($EXPECT($L99, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3950
+ var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3860
3951
  return { $loc, token: $1 };
3861
3952
  });
3862
3953
  function From(state) {
@@ -3868,7 +3959,7 @@ var require_parser = __commonJS({
3868
3959
  return From$0(state);
3869
3960
  }
3870
3961
  }
3871
- var Function$0 = $TV($EXPECT($L100, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3962
+ var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3872
3963
  return { $loc, token: $1 };
3873
3964
  });
3874
3965
  function Function(state) {
@@ -3880,7 +3971,7 @@ var require_parser = __commonJS({
3880
3971
  return Function$0(state);
3881
3972
  }
3882
3973
  }
3883
- var GetOrSet$0 = $TS($S($C($EXPECT($L101, fail, 'GetOrSet "get"'), $EXPECT($L102, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3974
+ var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3884
3975
  return { $loc, token: $1 };
3885
3976
  });
3886
3977
  function GetOrSet(state) {
@@ -3892,7 +3983,7 @@ var require_parser = __commonJS({
3892
3983
  return GetOrSet$0(state);
3893
3984
  }
3894
3985
  }
3895
- var If$0 = $TV($EXPECT($L103, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3986
+ var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3896
3987
  return { $loc, token: $1 };
3897
3988
  });
3898
3989
  function If(state) {
@@ -3904,7 +3995,7 @@ var require_parser = __commonJS({
3904
3995
  return If$0(state);
3905
3996
  }
3906
3997
  }
3907
- var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R27, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3998
+ var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3908
3999
  return { $loc, token: $1 };
3909
4000
  });
3910
4001
  function Import(state) {
@@ -3916,7 +4007,7 @@ var require_parser = __commonJS({
3916
4007
  return Import$0(state);
3917
4008
  }
3918
4009
  }
3919
- var In$0 = $TV($EXPECT($L65, fail, 'In "in"'), function($skip, $loc, $0, $1) {
4010
+ var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
3920
4011
  return { $loc, token: $1 };
3921
4012
  });
3922
4013
  function In(state) {
@@ -3928,7 +4019,7 @@ var require_parser = __commonJS({
3928
4019
  return In$0(state);
3929
4020
  }
3930
4021
  }
3931
- var LetOrConst$0 = $TV($C($EXPECT($L104, fail, 'LetOrConst "let"'), $EXPECT($L105, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
4022
+ var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
3932
4023
  return { $loc, token: $1 };
3933
4024
  });
3934
4025
  function LetOrConst(state) {
@@ -3940,7 +4031,7 @@ var require_parser = __commonJS({
3940
4031
  return LetOrConst$0(state);
3941
4032
  }
3942
4033
  }
3943
- var Loop$0 = $TS($S($EXPECT($L106, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4034
+ var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3944
4035
  return { $loc, token: "while(true)" };
3945
4036
  });
3946
4037
  function Loop(state) {
@@ -3952,7 +4043,7 @@ var require_parser = __commonJS({
3952
4043
  return Loop$0(state);
3953
4044
  }
3954
4045
  }
3955
- var New$0 = $TV($EXPECT($L107, fail, 'New "new"'), function($skip, $loc, $0, $1) {
4046
+ var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
3956
4047
  return { $loc, token: $1 };
3957
4048
  });
3958
4049
  function New(state) {
@@ -3964,7 +4055,7 @@ var require_parser = __commonJS({
3964
4055
  return New$0(state);
3965
4056
  }
3966
4057
  }
3967
- var Of$0 = $TV($EXPECT($L108, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
4058
+ var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
3968
4059
  return { $loc, token: $1 };
3969
4060
  });
3970
4061
  function Of(state) {
@@ -3976,7 +4067,7 @@ var require_parser = __commonJS({
3976
4067
  return Of$0(state);
3977
4068
  }
3978
4069
  }
3979
- var OpenBrace$0 = $TV($EXPECT($L109, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
4070
+ var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
3980
4071
  return { $loc, token: $1 };
3981
4072
  });
3982
4073
  function OpenBrace(state) {
@@ -3988,7 +4079,7 @@ var require_parser = __commonJS({
3988
4079
  return OpenBrace$0(state);
3989
4080
  }
3990
4081
  }
3991
- var OpenBracket$0 = $TV($EXPECT($L110, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
4082
+ var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
3992
4083
  return { $loc, token: $1 };
3993
4084
  });
3994
4085
  function OpenBracket(state) {
@@ -4000,7 +4091,7 @@ var require_parser = __commonJS({
4000
4091
  return OpenBracket$0(state);
4001
4092
  }
4002
4093
  }
4003
- var OpenParen$0 = $TV($EXPECT($L111, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4094
+ var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4004
4095
  return { $loc, token: $1 };
4005
4096
  });
4006
4097
  function OpenParen(state) {
@@ -4012,7 +4103,7 @@ var require_parser = __commonJS({
4012
4103
  return OpenParen$0(state);
4013
4104
  }
4014
4105
  }
4015
- var QuestionMark$0 = $TV($EXPECT($L112, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4106
+ var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4016
4107
  return { $loc, token: $1 };
4017
4108
  });
4018
4109
  function QuestionMark(state) {
@@ -4024,7 +4115,7 @@ var require_parser = __commonJS({
4024
4115
  return QuestionMark$0(state);
4025
4116
  }
4026
4117
  }
4027
- var Return$0 = $TS($S($EXPECT($L113, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4118
+ var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4028
4119
  return { $loc, token: $1 };
4029
4120
  });
4030
4121
  function Return(state) {
@@ -4036,7 +4127,7 @@ var require_parser = __commonJS({
4036
4127
  return Return$0(state);
4037
4128
  }
4038
4129
  }
4039
- var Semicolon$0 = $TV($EXPECT($L72, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4130
+ var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4040
4131
  return { $loc, token: $1 };
4041
4132
  });
4042
4133
  function Semicolon(state) {
@@ -4048,7 +4139,7 @@ var require_parser = __commonJS({
4048
4139
  return Semicolon$0(state);
4049
4140
  }
4050
4141
  }
4051
- var SingleQuote$0 = $TV($EXPECT($L114, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4142
+ var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4052
4143
  return { $loc, token: $1 };
4053
4144
  });
4054
4145
  function SingleQuote(state) {
@@ -4060,7 +4151,7 @@ var require_parser = __commonJS({
4060
4151
  return SingleQuote$0(state);
4061
4152
  }
4062
4153
  }
4063
- var Star$0 = $TV($EXPECT($L43, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4154
+ var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4064
4155
  return { $loc, token: $1 };
4065
4156
  });
4066
4157
  function Star(state) {
@@ -4072,10 +4163,10 @@ var require_parser = __commonJS({
4072
4163
  return Star$0(state);
4073
4164
  }
4074
4165
  }
4075
- var Static$0 = $TV($EXPECT($L115, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4166
+ var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4076
4167
  return { $loc, token: $1 };
4077
4168
  });
4078
- var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L111, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4169
+ var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4079
4170
  return { $loc, token: "static " };
4080
4171
  });
4081
4172
  function Static(state) {
@@ -4085,7 +4176,7 @@ var require_parser = __commonJS({
4085
4176
  return Static$0(state) || Static$1(state);
4086
4177
  }
4087
4178
  }
4088
- var SubstitutionStart$0 = $TV($EXPECT($L116, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4179
+ var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4089
4180
  return { $loc, token: $1 };
4090
4181
  });
4091
4182
  function SubstitutionStart(state) {
@@ -4097,7 +4188,7 @@ var require_parser = __commonJS({
4097
4188
  return SubstitutionStart$0(state);
4098
4189
  }
4099
4190
  }
4100
- var Switch$0 = $TS($S($EXPECT($L117, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4191
+ var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4101
4192
  return { $loc, token: $1 };
4102
4193
  });
4103
4194
  function Switch(state) {
@@ -4109,7 +4200,7 @@ var require_parser = __commonJS({
4109
4200
  return Switch$0(state);
4110
4201
  }
4111
4202
  }
4112
- var Target$0 = $TV($EXPECT($L118, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4203
+ var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4113
4204
  return { $loc, token: $1 };
4114
4205
  });
4115
4206
  function Target(state) {
@@ -4121,7 +4212,7 @@ var require_parser = __commonJS({
4121
4212
  return Target$0(state);
4122
4213
  }
4123
4214
  }
4124
- var Throw$0 = $TS($S($EXPECT($L119, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4215
+ var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4125
4216
  return { $loc, token: $1 };
4126
4217
  });
4127
4218
  function Throw(state) {
@@ -4133,7 +4224,7 @@ var require_parser = __commonJS({
4133
4224
  return Throw$0(state);
4134
4225
  }
4135
4226
  }
4136
- var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4227
+ var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4137
4228
  return { $loc, token: "`" };
4138
4229
  });
4139
4230
  function TripleDoubleQuote(state) {
@@ -4145,7 +4236,7 @@ var require_parser = __commonJS({
4145
4236
  return TripleDoubleQuote$0(state);
4146
4237
  }
4147
4238
  }
4148
- var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4239
+ var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4149
4240
  return { $loc, token: "`" };
4150
4241
  });
4151
4242
  function TripleSingleQuote(state) {
@@ -4157,7 +4248,7 @@ var require_parser = __commonJS({
4157
4248
  return TripleSingleQuote$0(state);
4158
4249
  }
4159
4250
  }
4160
- var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4251
+ var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4161
4252
  return { $loc, token: "`" };
4162
4253
  });
4163
4254
  function TripleTick(state) {
@@ -4169,7 +4260,7 @@ var require_parser = __commonJS({
4169
4260
  return TripleTick$0(state);
4170
4261
  }
4171
4262
  }
4172
- var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4263
+ var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4173
4264
  return { $loc, token: $1 };
4174
4265
  });
4175
4266
  function Try(state) {
@@ -4181,7 +4272,7 @@ var require_parser = __commonJS({
4181
4272
  return Try$0(state);
4182
4273
  }
4183
4274
  }
4184
- var Unless$0 = $TV($EXPECT($L124, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4275
+ var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4185
4276
  return { $loc, token: $1 };
4186
4277
  });
4187
4278
  function Unless(state) {
@@ -4193,7 +4284,7 @@ var require_parser = __commonJS({
4193
4284
  return Unless$0(state);
4194
4285
  }
4195
4286
  }
4196
- var Var$0 = $TV($EXPECT($L125, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4287
+ var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4197
4288
  return { $loc, token: $1 };
4198
4289
  });
4199
4290
  function Var(state) {
@@ -4205,7 +4296,7 @@ var require_parser = __commonJS({
4205
4296
  return Var$0(state);
4206
4297
  }
4207
4298
  }
4208
- var When$0 = $TS($S($EXPECT($L126, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4299
+ var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4209
4300
  return { $loc, token: "case" };
4210
4301
  });
4211
4302
  function When(state) {
@@ -4217,7 +4308,7 @@ var require_parser = __commonJS({
4217
4308
  return When$0(state);
4218
4309
  }
4219
4310
  }
4220
- var Yield$0 = $TS($S($EXPECT($L127, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4311
+ var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4221
4312
  return { $loc, token: $1 };
4222
4313
  });
4223
4314
  function Yield(state) {
@@ -4243,7 +4334,7 @@ var require_parser = __commonJS({
4243
4334
  return JSXElement$0(state) || JSXElement$1(state);
4244
4335
  }
4245
4336
  }
4246
- var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
4337
+ var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
4247
4338
  function JSXSelfClosingElement(state) {
4248
4339
  if (state.verbose)
4249
4340
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -4253,7 +4344,7 @@ var require_parser = __commonJS({
4253
4344
  return JSXSelfClosingElement$0(state);
4254
4345
  }
4255
4346
  }
4256
- var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L53, fail, 'JSXOpeningElement ">"'));
4347
+ var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
4257
4348
  function JSXOpeningElement(state) {
4258
4349
  if (state.verbose)
4259
4350
  console.log("ENTER:", "JSXOpeningElement");
@@ -4263,7 +4354,7 @@ var require_parser = __commonJS({
4263
4354
  return JSXOpeningElement$0(state);
4264
4355
  }
4265
4356
  }
4266
- var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L53, fail, 'JSXClosingElement ">"'));
4357
+ var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
4267
4358
  function JSXClosingElement(state) {
4268
4359
  if (state.verbose)
4269
4360
  console.log("ENTER:", "JSXClosingElement");
@@ -4273,7 +4364,7 @@ var require_parser = __commonJS({
4273
4364
  return JSXClosingElement$0(state);
4274
4365
  }
4275
4366
  }
4276
- var JSXFragment$0 = $S($EXPECT($L130, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L131, fail, 'JSXFragment "</>"'));
4367
+ var JSXFragment$0 = $S($EXPECT($L134, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L135, fail, 'JSXFragment "</>"'));
4277
4368
  function JSXFragment(state) {
4278
4369
  if (state.verbose)
4279
4370
  console.log("ENTER:", "JSXFragment");
@@ -4293,7 +4384,7 @@ var require_parser = __commonJS({
4293
4384
  return JSXElementName$0(state);
4294
4385
  }
4295
4386
  }
4296
- var JSXIdentifierName$0 = $R$0($EXPECT($R28, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4387
+ var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4297
4388
  function JSXIdentifierName(state) {
4298
4389
  if (state.verbose)
4299
4390
  console.log("ENTER:", "JSXIdentifierName");
@@ -4313,7 +4404,7 @@ var require_parser = __commonJS({
4313
4404
  return JSXAttributes$0(state);
4314
4405
  }
4315
4406
  }
4316
- var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L17, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
4407
+ var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot, __, AssignmentExpression, __, CloseBrace);
4317
4408
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
4318
4409
  function JSXAttribute(state) {
4319
4410
  if (state.tokenize) {
@@ -4342,8 +4433,8 @@ var require_parser = __commonJS({
4342
4433
  return JSXAttributeInitializer$0(state);
4343
4434
  }
4344
4435
  }
4345
- var JSXAttributeValue$0 = $R$0($EXPECT($R29, fail, 'JSXAttributeValue /"[^"]*"/'));
4346
- var JSXAttributeValue$1 = $R$0($EXPECT($R30, fail, "JSXAttributeValue /'[^']*'/"));
4436
+ var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
4437
+ var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
4347
4438
  var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
4348
4439
  var JSXAttributeValue$3 = JSXElement;
4349
4440
  var JSXAttributeValue$4 = JSXFragment;
@@ -4375,7 +4466,7 @@ var require_parser = __commonJS({
4375
4466
  return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
4376
4467
  }
4377
4468
  }
4378
- var JSXText$0 = $R$0($EXPECT($R31, fail, "JSXText /[^{}<>]+/"));
4469
+ var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
4379
4470
  function JSXText(state) {
4380
4471
  if (state.verbose)
4381
4472
  console.log("ENTER:", "JSXText");
@@ -4385,7 +4476,7 @@ var require_parser = __commonJS({
4385
4476
  return JSXText$0(state);
4386
4477
  }
4387
4478
  }
4388
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L17, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
4479
+ var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)), AssignmentExpression);
4389
4480
  function JSXChildExpression(state) {
4390
4481
  if (state.verbose)
4391
4482
  console.log("ENTER:", "JSXChildExpression");
@@ -4407,7 +4498,7 @@ var require_parser = __commonJS({
4407
4498
  return TypeDeclaration$0(state);
4408
4499
  }
4409
4500
  }
4410
- var TypeDeclarationModifier$0 = $S($EXPECT($L132, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
4501
+ var TypeDeclarationModifier$0 = $S($EXPECT($L136, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
4411
4502
  var TypeDeclarationModifier$1 = Export;
4412
4503
  function TypeDeclarationModifier(state) {
4413
4504
  if (state.tokenize) {
@@ -4417,16 +4508,17 @@ var require_parser = __commonJS({
4417
4508
  }
4418
4509
  }
4419
4510
  var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
4420
- var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
4511
+ var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
4421
4512
  var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
4513
+ var TypeDeclarationRest$3 = FunctionSignature;
4422
4514
  function TypeDeclarationRest(state) {
4423
4515
  if (state.tokenize) {
4424
- return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state));
4516
+ return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state));
4425
4517
  } else {
4426
- return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
4518
+ return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
4427
4519
  }
4428
4520
  }
4429
- var TypeKeyword$0 = $S($EXPECT($L133, fail, 'TypeKeyword "type"'), NonIdContinue);
4521
+ var TypeKeyword$0 = $S($EXPECT($L137, fail, 'TypeKeyword "type"'), NonIdContinue);
4430
4522
  function TypeKeyword(state) {
4431
4523
  if (state.verbose)
4432
4524
  console.log("ENTER:", "TypeKeyword");
@@ -4436,7 +4528,7 @@ var require_parser = __commonJS({
4436
4528
  return TypeKeyword$0(state);
4437
4529
  }
4438
4530
  }
4439
- var Interface$0 = $S($EXPECT($L134, fail, 'Interface "interface"'), NonIdContinue);
4531
+ var Interface$0 = $S($EXPECT($L138, fail, 'Interface "interface"'), NonIdContinue);
4440
4532
  function Interface(state) {
4441
4533
  if (state.verbose)
4442
4534
  console.log("ENTER:", "Interface");
@@ -4446,7 +4538,7 @@ var require_parser = __commonJS({
4446
4538
  return Interface$0(state);
4447
4539
  }
4448
4540
  }
4449
- var Namespace$0 = $S($EXPECT($L135, fail, 'Namespace "namespace"'), NonIdContinue);
4541
+ var Namespace$0 = $S($EXPECT($L139, fail, 'Namespace "namespace"'), NonIdContinue);
4450
4542
  function Namespace(state) {
4451
4543
  if (state.verbose)
4452
4544
  console.log("ENTER:", "Namespace");
@@ -4492,27 +4584,23 @@ var require_parser = __commonJS({
4492
4584
  }
4493
4585
  }
4494
4586
  var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
4495
- var InterfaceProperty$1 = MethodSignature;
4587
+ var InterfaceProperty$1 = $S(NonEmptyParameters, TypeSuffix, InterfacePropertyDelimiter);
4588
+ var InterfaceProperty$2 = $S(MethodSignature, InterfacePropertyDelimiter);
4496
4589
  function InterfaceProperty(state) {
4497
4590
  if (state.tokenize) {
4498
- return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
4591
+ return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state));
4499
4592
  } else {
4500
- return InterfaceProperty$0(state) || InterfaceProperty$1(state);
4593
+ return InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state);
4501
4594
  }
4502
4595
  }
4503
- var InterfacePropertyDelimiter$0 = $S($Q(_), Semicolon);
4504
- var InterfacePropertyDelimiter$1 = $Y($S($Q(_), CloseBrace));
4505
- var InterfacePropertyDelimiter$2 = $TV($Y($S(__, CloseBrace)), function($skip, $loc, $0, $1) {
4506
- return { $loc, token: ";" };
4507
- });
4508
- var InterfacePropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
4509
- return { $loc, token: ";" };
4510
- });
4596
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $C(Semicolon, Comma));
4597
+ var InterfacePropertyDelimiter$1 = $Y($S(__, CloseBrace));
4598
+ var InterfacePropertyDelimiter$2 = $Y(EOS);
4511
4599
  function InterfacePropertyDelimiter(state) {
4512
4600
  if (state.tokenize) {
4513
- return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state));
4601
+ return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state));
4514
4602
  } else {
4515
- return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
4603
+ return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state);
4516
4604
  }
4517
4605
  }
4518
4606
  var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
@@ -4550,7 +4638,7 @@ var require_parser = __commonJS({
4550
4638
  return NestedTypeDeclaration$0(state);
4551
4639
  }
4552
4640
  }
4553
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L136, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R33, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
4641
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R36, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L140, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R37, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
4554
4642
  function TypeIndexSignature(state) {
4555
4643
  if (state.verbose)
4556
4644
  console.log("ENTER:", "TypeIndexSignature");
@@ -4581,7 +4669,7 @@ var require_parser = __commonJS({
4581
4669
  return TypeSuffix$0(state);
4582
4670
  }
4583
4671
  }
4584
- var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L137, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
4672
+ var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L141, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
4585
4673
  if (!$3)
4586
4674
  $0.splice(2, 1);
4587
4675
  if ($1.length === 0)
@@ -4601,7 +4689,7 @@ var require_parser = __commonJS({
4601
4689
  return ReturnTypeSuffix$0(state);
4602
4690
  }
4603
4691
  }
4604
- var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4692
+ var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4605
4693
  if (!$2)
4606
4694
  return $1;
4607
4695
  return $0;
@@ -4656,18 +4744,17 @@ var require_parser = __commonJS({
4656
4744
  }
4657
4745
  }
4658
4746
  var TypeUnarySuffix$0 = TypeIndexedAccess;
4747
+ var TypeUnarySuffix$1 = QuestionMark;
4659
4748
  function TypeUnarySuffix(state) {
4660
- if (state.verbose)
4661
- console.log("ENTER:", "TypeUnarySuffix");
4662
4749
  if (state.tokenize) {
4663
- return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
4750
+ return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state));
4664
4751
  } else {
4665
- return TypeUnarySuffix$0(state);
4752
+ return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
4666
4753
  }
4667
4754
  }
4668
- var TypeUnaryOp$0 = $EXPECT($L138, fail, 'TypeUnaryOp "keyof"');
4669
- var TypeUnaryOp$1 = $EXPECT($L71, fail, 'TypeUnaryOp "typeof"');
4670
- var TypeUnaryOp$2 = $EXPECT($L139, fail, 'TypeUnaryOp "infer"');
4755
+ var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
4756
+ var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
4757
+ var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
4671
4758
  function TypeUnaryOp(state) {
4672
4759
  if (state.tokenize) {
4673
4760
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -4687,14 +4774,59 @@ var require_parser = __commonJS({
4687
4774
  }
4688
4775
  var TypePrimary$0 = InterfaceBlock;
4689
4776
  var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
4690
- var TypePrimary$2 = $S($Q(_), FunctionType);
4691
- var TypePrimary$3 = $S($Q(_), TypeLiteral);
4692
- var TypePrimary$4 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
4777
+ var TypePrimary$2 = $S(__, TypeTuple);
4778
+ var TypePrimary$3 = $S($Q(_), FunctionType);
4779
+ var TypePrimary$4 = $S($Q(_), TypeLiteral);
4780
+ var TypePrimary$5 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
4693
4781
  function TypePrimary(state) {
4694
4782
  if (state.tokenize) {
4695
- return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
4783
+ return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
4784
+ } else {
4785
+ return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
4786
+ }
4787
+ }
4788
+ var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
4789
+ var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
4790
+ function TypeTuple(state) {
4791
+ if (state.tokenize) {
4792
+ return $TOKEN("TypeTuple", state, TypeTuple$0(state) || TypeTuple$1(state));
4793
+ } else {
4794
+ return TypeTuple$0(state) || TypeTuple$1(state);
4795
+ }
4796
+ }
4797
+ var TypeList$0 = $S(Type, $Q($S(__, Comma, Type)));
4798
+ function TypeList(state) {
4799
+ if (state.verbose)
4800
+ console.log("ENTER:", "TypeList");
4801
+ if (state.tokenize) {
4802
+ return $TOKEN("TypeList", state, TypeList$0(state));
4803
+ } else {
4804
+ return TypeList$0(state);
4805
+ }
4806
+ }
4807
+ var NestedTypeList$0 = $TS($S(PushIndent, $Q(NestedType), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
4808
+ var types = $2;
4809
+ if (types.length)
4810
+ return types;
4811
+ return $skip;
4812
+ });
4813
+ function NestedTypeList(state) {
4814
+ if (state.verbose)
4815
+ console.log("ENTER:", "NestedTypeList");
4816
+ if (state.tokenize) {
4817
+ return $TOKEN("NestedTypeList", state, NestedTypeList$0(state));
4818
+ } else {
4819
+ return NestedTypeList$0(state);
4820
+ }
4821
+ }
4822
+ var NestedType$0 = $S(Nested, Type, ArrayElementDelimiter);
4823
+ function NestedType(state) {
4824
+ if (state.verbose)
4825
+ console.log("ENTER:", "NestedType");
4826
+ if (state.tokenize) {
4827
+ return $TOKEN("NestedType", state, NestedType$0(state));
4696
4828
  } else {
4697
- return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
4829
+ return NestedType$0(state);
4698
4830
  }
4699
4831
  }
4700
4832
  var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
@@ -4712,10 +4844,10 @@ var require_parser = __commonJS({
4712
4844
  }
4713
4845
  }
4714
4846
  var TypeLiteral$0 = Literal;
4715
- var TypeLiteral$1 = $TV($EXPECT($L70, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
4847
+ var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
4716
4848
  return { $loc, token: "void" };
4717
4849
  });
4718
- var TypeLiteral$2 = $TV($EXPECT($L140, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
4850
+ var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
4719
4851
  return { $loc, token: "[]" };
4720
4852
  });
4721
4853
  function TypeLiteral(state) {
@@ -4725,10 +4857,10 @@ var require_parser = __commonJS({
4725
4857
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
4726
4858
  }
4727
4859
  }
4728
- var TypeBinaryOp$0 = $TV($EXPECT($L68, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
4860
+ var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
4729
4861
  return { $loc, token: "|" };
4730
4862
  });
4731
- var TypeBinaryOp$1 = $TV($EXPECT($L66, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
4863
+ var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
4732
4864
  return { $loc, token: "&" };
4733
4865
  });
4734
4866
  function TypeBinaryOp(state) {
@@ -4748,7 +4880,7 @@ var require_parser = __commonJS({
4748
4880
  return FunctionType$0(state);
4749
4881
  }
4750
4882
  }
4751
- var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeArguments ">"'));
4883
+ var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
4752
4884
  function TypeArguments(state) {
4753
4885
  if (state.verbose)
4754
4886
  console.log("ENTER:", "TypeArguments");
@@ -4758,7 +4890,7 @@ var require_parser = __commonJS({
4758
4890
  return TypeArguments$0(state);
4759
4891
  }
4760
4892
  }
4761
- var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
4893
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
4762
4894
  return { ts: true, children: $0 };
4763
4895
  });
4764
4896
  function TypeParameters(state) {
@@ -4791,8 +4923,8 @@ var require_parser = __commonJS({
4791
4923
  }
4792
4924
  }
4793
4925
  var TypeParameterDelimiter$0 = $S($Q(_), Comma);
4794
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L53, fail, 'TypeParameterDelimiter ">"')));
4795
- var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L53, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4926
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L56, fail, 'TypeParameterDelimiter ">"')));
4927
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L56, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4796
4928
  return { $loc, token: "," };
4797
4929
  });
4798
4930
  var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -4805,7 +4937,7 @@ var require_parser = __commonJS({
4805
4937
  return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
4806
4938
  }
4807
4939
  }
4808
- var Shebang$0 = $S($R$0($EXPECT($R34, fail, "Shebang /#![^\\r\\n]*/")), EOL);
4940
+ var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
4809
4941
  function Shebang(state) {
4810
4942
  if (state.verbose)
4811
4943
  console.log("ENTER:", "Shebang");
@@ -4815,11 +4947,11 @@ var require_parser = __commonJS({
4815
4947
  return Shebang$0(state);
4816
4948
  }
4817
4949
  }
4818
- var CivetPrologue$0 = $T($S($EXPECT($R35, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4950
+ var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4819
4951
  var content = value[2];
4820
4952
  return content;
4821
4953
  });
4822
- var CivetPrologue$1 = $T($S($EXPECT($R35, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4954
+ var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4823
4955
  var content = value[2];
4824
4956
  return content;
4825
4957
  });
@@ -4830,7 +4962,7 @@ var require_parser = __commonJS({
4830
4962
  return CivetPrologue$0(state) || CivetPrologue$1(state);
4831
4963
  }
4832
4964
  }
4833
- var CivetPrologueContent$0 = $TS($S($EXPECT($L141, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R36, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
4965
+ var CivetPrologueContent$0 = $TS($S($EXPECT($L145, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R40, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
4834
4966
  var options = $2;
4835
4967
  return {
4836
4968
  type: "CivetPrologue",
@@ -4847,8 +4979,8 @@ var require_parser = __commonJS({
4847
4979
  return CivetPrologueContent$0(state);
4848
4980
  }
4849
4981
  }
4850
- var CivetOption$0 = $TR($EXPECT($R37, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4851
- const optionName = $2.toLowerCase().replace(/-+([a-z]?)/g, (_2, l) => {
4982
+ var CivetOption$0 = $TR($EXPECT($R41, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4983
+ const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
4852
4984
  if (l)
4853
4985
  return l.toUpperCase();
4854
4986
  return "";
@@ -4865,7 +4997,7 @@ var require_parser = __commonJS({
4865
4997
  return CivetOption$0(state);
4866
4998
  }
4867
4999
  }
4868
- var UnknownPrologue$0 = $S($R$0($EXPECT($R35, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
5000
+ var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
4869
5001
  function UnknownPrologue(state) {
4870
5002
  if (state.verbose)
4871
5003
  console.log("ENTER:", "UnknownPrologue");
@@ -4894,7 +5026,7 @@ var require_parser = __commonJS({
4894
5026
  return EOS$0(state);
4895
5027
  }
4896
5028
  }
4897
- var EOL$0 = $R$0($EXPECT($R38, fail, "EOL /\\r\\n|\\n|\\r|$/"));
5029
+ var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
4898
5030
  function EOL(state) {
4899
5031
  if (state.verbose)
4900
5032
  console.log("ENTER:", "EOL");
@@ -4904,7 +5036,7 @@ var require_parser = __commonJS({
4904
5036
  return EOL$0(state);
4905
5037
  }
4906
5038
  }
4907
- var EOF$0 = $R$0($EXPECT($R39, fail, "EOF /$/"));
5039
+ var EOF$0 = $R$0($EXPECT($R43, fail, "EOF /$/"));
4908
5040
  function EOF(state) {
4909
5041
  if (state.verbose)
4910
5042
  console.log("ENTER:", "EOF");
@@ -5072,6 +5204,20 @@ var require_parser = __commonJS({
5072
5204
  return CoffeeCommentEnabled$0(state);
5073
5205
  }
5074
5206
  }
5207
+ var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
5208
+ if (module2.config.coffeeBooleans)
5209
+ return;
5210
+ return $skip;
5211
+ });
5212
+ function CoffeeBooleansEnabled(state) {
5213
+ if (state.verbose)
5214
+ console.log("ENTER:", "CoffeeBooleansEnabled");
5215
+ if (state.tokenize) {
5216
+ return $TOKEN("CoffeeBooleansEnabled", state, CoffeeBooleansEnabled$0(state));
5217
+ } else {
5218
+ return CoffeeBooleansEnabled$0(state);
5219
+ }
5220
+ }
5075
5221
  var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
5076
5222
  if (module2.config.coffeeInterpolation)
5077
5223
  return;
@@ -5092,6 +5238,7 @@ var require_parser = __commonJS({
5092
5238
  module2.verbose = false;
5093
5239
  module2.config = {
5094
5240
  autoVar: false,
5241
+ coffeeBooleans: false,
5095
5242
  coffeeComment: false,
5096
5243
  coffeeEq: false,
5097
5244
  coffeeInterpolation: false,
@@ -5101,12 +5248,14 @@ var require_parser = __commonJS({
5101
5248
  set(b) {
5102
5249
  if (b) {
5103
5250
  this.autoVar = true;
5251
+ this.coffeeBooleans = true;
5104
5252
  this.coffeeComment = true;
5105
5253
  this.coffeeEq = true;
5106
5254
  this.coffeeInterpolation = true;
5107
5255
  this.implicitReturns = true;
5108
5256
  } else {
5109
5257
  this.autoVar = false;
5258
+ this.coffeeBooleans = false;
5110
5259
  this.coffeeComment = false;
5111
5260
  this.coffeeEq = false;
5112
5261
  this.coffeeInterpolation = false;
@@ -5154,6 +5303,9 @@ var require_parser = __commonJS({
5154
5303
  case "AssignmentExpression":
5155
5304
  node.children.unshift("return ");
5156
5305
  return;
5306
+ case "Identifier":
5307
+ node.token = "return " + node.token;
5308
+ return;
5157
5309
  case "BlockStatement":
5158
5310
  insertReturn(node.expressions[node.expressions.length - 1]);
5159
5311
  return;
@@ -5174,7 +5326,7 @@ var require_parser = __commonJS({
5174
5326
  }
5175
5327
  if (!Array.isArray(node))
5176
5328
  return;
5177
- const [, exp] = node;
5329
+ const [indent, exp] = node;
5178
5330
  if (!exp)
5179
5331
  return;
5180
5332
  switch (exp.type) {
@@ -5193,6 +5345,8 @@ var require_parser = __commonJS({
5193
5345
  insertReturn(exp.children[2]);
5194
5346
  if (exp.children[3])
5195
5347
  insertReturn(exp.children[3][2]);
5348
+ else
5349
+ exp.children.push(["\n", indent, "return"]);
5196
5350
  return;
5197
5351
  case "SwitchStatement":
5198
5352
  insertReturn(exp.children[2]);
@@ -5210,6 +5364,50 @@ var require_parser = __commonJS({
5210
5364
  insertReturn(block);
5211
5365
  return block;
5212
5366
  };
5367
+ module2.expandChainedComparisons = function([first, binops]) {
5368
+ const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
5369
+ const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
5370
+ let results = [];
5371
+ let i = 0;
5372
+ let l = binops.length;
5373
+ let start = 0;
5374
+ let chains = [];
5375
+ while (i < l) {
5376
+ const [, op] = binops[i];
5377
+ if (relationalOps.includes(op.token)) {
5378
+ chains.push(i);
5379
+ } else if (lowerPrecedenceOps.includes(op.token)) {
5380
+ processChains();
5381
+ first = [];
5382
+ }
5383
+ i++;
5384
+ }
5385
+ processChains();
5386
+ return results;
5387
+ function processChains() {
5388
+ if (chains.length > 1) {
5389
+ chains.forEach((index, k) => {
5390
+ if (k > 0) {
5391
+ results.push(" && ");
5392
+ }
5393
+ const [pre, op, post, exp] = binops[index];
5394
+ let endIndex;
5395
+ if (k < chains.length - 1) {
5396
+ endIndex = chains[k + 1];
5397
+ } else {
5398
+ endIndex = i + 1;
5399
+ }
5400
+ results = results.concat(first, ...binops.slice(start, endIndex));
5401
+ first = [exp].concat(binops.slice(index + 1, endIndex));
5402
+ start = endIndex;
5403
+ });
5404
+ } else {
5405
+ results = results.concat(first, ...binops.slice(start, i + 1));
5406
+ start = i + 1;
5407
+ }
5408
+ chains.length = 0;
5409
+ }
5410
+ };
5213
5411
  module2.parsePosition = function() {
5214
5412
  let s = Error().stack.split(/\n at /);
5215
5413
  s.shift();
@@ -5306,7 +5504,7 @@ var require_parser = __commonJS({
5306
5504
  return Init$0(state);
5307
5505
  }
5308
5506
  }
5309
- var Indent$0 = $TV($Q($C($EXPECT($L142, fail, 'Indent " "'), $EXPECT($L143, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
5507
+ var Indent$0 = $TV($Q($C($EXPECT($L146, fail, 'Indent " "'), $EXPECT($L147, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
5310
5508
  const level = $1.length;
5311
5509
  return {
5312
5510
  $loc,