@danielx/civet 0.4.9 → 0.4.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/README.md +26 -6
  2. package/dist/browser.js +607 -411
  3. package/dist/esbuild-plugin.js +10 -10
  4. package/dist/esm.mjs +47 -47
  5. package/dist/main.js +607 -411
  6. 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) {
@@ -3596,9 +3675,7 @@ var require_parser = __commonJS({
3596
3675
  }
3597
3676
  }
3598
3677
  var StatementDelimiter$0 = $S($Q(TrailingComment), Semicolon, $Q(TrailingComment));
3599
- var StatementDelimiter$1 = $TS($S($EXPECT($L1, fail, 'StatementDelimiter ""'), $Y(EOS)), function($skip, $loc, $0, $1, $2) {
3600
- return { $loc, token: ";" };
3601
- });
3678
+ var StatementDelimiter$1 = $Y(EOS);
3602
3679
  function StatementDelimiter(state) {
3603
3680
  if (state.tokenize) {
3604
3681
  return $TOKEN("StatementDelimiter", state, StatementDelimiter$0(state) || StatementDelimiter$1(state));
@@ -3606,7 +3683,7 @@ var require_parser = __commonJS({
3606
3683
  return StatementDelimiter$0(state) || StatementDelimiter$1(state);
3607
3684
  }
3608
3685
  }
3609
- var NonIdContinue$0 = $R$0($EXPECT($R26, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3686
+ var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3610
3687
  function NonIdContinue(state) {
3611
3688
  if (state.verbose)
3612
3689
  console.log("ENTER:", "NonIdContinue");
@@ -3628,7 +3705,7 @@ var require_parser = __commonJS({
3628
3705
  return Loc$0(state);
3629
3706
  }
3630
3707
  }
3631
- var As$0 = $TS($S($EXPECT($L86, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3708
+ var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3632
3709
  return { $loc, token: $1 };
3633
3710
  });
3634
3711
  function As(state) {
@@ -3640,7 +3717,7 @@ var require_parser = __commonJS({
3640
3717
  return As$0(state);
3641
3718
  }
3642
3719
  }
3643
- var Async$0 = $TV($EXPECT($L87, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3720
+ var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3644
3721
  return { $loc, token: $1 };
3645
3722
  });
3646
3723
  function Async(state) {
@@ -3652,7 +3729,7 @@ var require_parser = __commonJS({
3652
3729
  return Async$0(state);
3653
3730
  }
3654
3731
  }
3655
- var Await$0 = $TS($S($EXPECT($L88, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3732
+ var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3656
3733
  return { $loc, token: $1 };
3657
3734
  });
3658
3735
  function Await(state) {
@@ -3664,7 +3741,7 @@ var require_parser = __commonJS({
3664
3741
  return Await$0(state);
3665
3742
  }
3666
3743
  }
3667
- var Case$0 = $TS($S($EXPECT($L89, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3744
+ var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3668
3745
  return { $loc, token: $1 };
3669
3746
  });
3670
3747
  function Case(state) {
@@ -3676,7 +3753,7 @@ var require_parser = __commonJS({
3676
3753
  return Case$0(state);
3677
3754
  }
3678
3755
  }
3679
- var Catch$0 = $TV($EXPECT($L90, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3756
+ var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3680
3757
  return { $loc, token: $1 };
3681
3758
  });
3682
3759
  function Catch(state) {
@@ -3688,7 +3765,7 @@ var require_parser = __commonJS({
3688
3765
  return Catch$0(state);
3689
3766
  }
3690
3767
  }
3691
- var Class$0 = $TV($EXPECT($L91, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3768
+ var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3692
3769
  return { $loc, token: $1 };
3693
3770
  });
3694
3771
  function Class(state) {
@@ -3700,7 +3777,7 @@ var require_parser = __commonJS({
3700
3777
  return Class$0(state);
3701
3778
  }
3702
3779
  }
3703
- var CloseBrace$0 = $TV($EXPECT($L24, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3780
+ var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3704
3781
  return { $loc, token: $1 };
3705
3782
  });
3706
3783
  function CloseBrace(state) {
@@ -3712,7 +3789,7 @@ var require_parser = __commonJS({
3712
3789
  return CloseBrace$0(state);
3713
3790
  }
3714
3791
  }
3715
- var CloseBracket$0 = $TV($EXPECT($L23, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3792
+ var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3716
3793
  return { $loc, token: $1 };
3717
3794
  });
3718
3795
  function CloseBracket(state) {
@@ -3736,7 +3813,7 @@ var require_parser = __commonJS({
3736
3813
  return CloseParen$0(state);
3737
3814
  }
3738
3815
  }
3739
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L92, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3816
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3740
3817
  return { $loc, token: "${" };
3741
3818
  });
3742
3819
  function CoffeeSubstitutionStart(state) {
@@ -3748,7 +3825,7 @@ var require_parser = __commonJS({
3748
3825
  return CoffeeSubstitutionStart$0(state);
3749
3826
  }
3750
3827
  }
3751
- var Colon$0 = $TV($EXPECT($L93, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3828
+ var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3752
3829
  return { $loc, token: $1 };
3753
3830
  });
3754
3831
  function Colon(state) {
@@ -3772,7 +3849,7 @@ var require_parser = __commonJS({
3772
3849
  return ConstructorShorthand$0(state);
3773
3850
  }
3774
3851
  }
3775
- var Default$0 = $TS($S($EXPECT($L81, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3852
+ var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3776
3853
  return { $loc, token: $1 };
3777
3854
  });
3778
3855
  function Default(state) {
@@ -3784,7 +3861,7 @@ var require_parser = __commonJS({
3784
3861
  return Default$0(state);
3785
3862
  }
3786
3863
  }
3787
- var Dot$0 = $TV($EXPECT($L94, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3864
+ var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3788
3865
  return { $loc, token: $1 };
3789
3866
  });
3790
3867
  function Dot(state) {
@@ -3796,7 +3873,19 @@ var require_parser = __commonJS({
3796
3873
  return Dot$0(state);
3797
3874
  }
3798
3875
  }
3799
- var DoubleQuote$0 = $TV($EXPECT($L95, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3876
+ var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
3877
+ return { $loc, token: $1 };
3878
+ });
3879
+ function DotDotDot(state) {
3880
+ if (state.verbose)
3881
+ console.log("ENTER:", "DotDotDot");
3882
+ if (state.tokenize) {
3883
+ return $TOKEN("DotDotDot", state, DotDotDot$0(state));
3884
+ } else {
3885
+ return DotDotDot$0(state);
3886
+ }
3887
+ }
3888
+ var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3800
3889
  return { $loc, token: $1 };
3801
3890
  });
3802
3891
  function DoubleQuote(state) {
@@ -3808,7 +3897,7 @@ var require_parser = __commonJS({
3808
3897
  return DoubleQuote$0(state);
3809
3898
  }
3810
3899
  }
3811
- var Else$0 = $TV($EXPECT($L96, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3900
+ var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3812
3901
  return { $loc, token: $1 };
3813
3902
  });
3814
3903
  function Else(state) {
@@ -3820,7 +3909,7 @@ var require_parser = __commonJS({
3820
3909
  return Else$0(state);
3821
3910
  }
3822
3911
  }
3823
- var Equals$0 = $TV($EXPECT($L41, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3912
+ var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3824
3913
  return { $loc, token: $1 };
3825
3914
  });
3826
3915
  function Equals(state) {
@@ -3832,7 +3921,7 @@ var require_parser = __commonJS({
3832
3921
  return Equals$0(state);
3833
3922
  }
3834
3923
  }
3835
- var Export$0 = $TS($S($EXPECT($L97, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3924
+ var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3836
3925
  return { $loc, token: $1 };
3837
3926
  });
3838
3927
  function Export(state) {
@@ -3844,7 +3933,7 @@ var require_parser = __commonJS({
3844
3933
  return Export$0(state);
3845
3934
  }
3846
3935
  }
3847
- var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3936
+ var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3848
3937
  return { $loc, token: $1 };
3849
3938
  });
3850
3939
  function For(state) {
@@ -3856,7 +3945,7 @@ var require_parser = __commonJS({
3856
3945
  return For$0(state);
3857
3946
  }
3858
3947
  }
3859
- var From$0 = $TS($S($EXPECT($L99, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3948
+ var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3860
3949
  return { $loc, token: $1 };
3861
3950
  });
3862
3951
  function From(state) {
@@ -3868,7 +3957,7 @@ var require_parser = __commonJS({
3868
3957
  return From$0(state);
3869
3958
  }
3870
3959
  }
3871
- var Function$0 = $TV($EXPECT($L100, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3960
+ var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3872
3961
  return { $loc, token: $1 };
3873
3962
  });
3874
3963
  function Function(state) {
@@ -3880,7 +3969,7 @@ var require_parser = __commonJS({
3880
3969
  return Function$0(state);
3881
3970
  }
3882
3971
  }
3883
- var GetOrSet$0 = $TS($S($C($EXPECT($L101, fail, 'GetOrSet "get"'), $EXPECT($L102, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3972
+ var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3884
3973
  return { $loc, token: $1 };
3885
3974
  });
3886
3975
  function GetOrSet(state) {
@@ -3892,7 +3981,7 @@ var require_parser = __commonJS({
3892
3981
  return GetOrSet$0(state);
3893
3982
  }
3894
3983
  }
3895
- var If$0 = $TV($EXPECT($L103, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3984
+ var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3896
3985
  return { $loc, token: $1 };
3897
3986
  });
3898
3987
  function If(state) {
@@ -3904,7 +3993,7 @@ var require_parser = __commonJS({
3904
3993
  return If$0(state);
3905
3994
  }
3906
3995
  }
3907
- var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R27, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3996
+ var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3908
3997
  return { $loc, token: $1 };
3909
3998
  });
3910
3999
  function Import(state) {
@@ -3916,7 +4005,7 @@ var require_parser = __commonJS({
3916
4005
  return Import$0(state);
3917
4006
  }
3918
4007
  }
3919
- var In$0 = $TV($EXPECT($L65, fail, 'In "in"'), function($skip, $loc, $0, $1) {
4008
+ var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
3920
4009
  return { $loc, token: $1 };
3921
4010
  });
3922
4011
  function In(state) {
@@ -3928,7 +4017,7 @@ var require_parser = __commonJS({
3928
4017
  return In$0(state);
3929
4018
  }
3930
4019
  }
3931
- var LetOrConst$0 = $TV($C($EXPECT($L104, fail, 'LetOrConst "let"'), $EXPECT($L105, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
4020
+ var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
3932
4021
  return { $loc, token: $1 };
3933
4022
  });
3934
4023
  function LetOrConst(state) {
@@ -3940,7 +4029,7 @@ var require_parser = __commonJS({
3940
4029
  return LetOrConst$0(state);
3941
4030
  }
3942
4031
  }
3943
- var Loop$0 = $TS($S($EXPECT($L106, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4032
+ var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3944
4033
  return { $loc, token: "while(true)" };
3945
4034
  });
3946
4035
  function Loop(state) {
@@ -3952,7 +4041,7 @@ var require_parser = __commonJS({
3952
4041
  return Loop$0(state);
3953
4042
  }
3954
4043
  }
3955
- var New$0 = $TV($EXPECT($L107, fail, 'New "new"'), function($skip, $loc, $0, $1) {
4044
+ var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
3956
4045
  return { $loc, token: $1 };
3957
4046
  });
3958
4047
  function New(state) {
@@ -3964,7 +4053,7 @@ var require_parser = __commonJS({
3964
4053
  return New$0(state);
3965
4054
  }
3966
4055
  }
3967
- var Of$0 = $TV($EXPECT($L108, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
4056
+ var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
3968
4057
  return { $loc, token: $1 };
3969
4058
  });
3970
4059
  function Of(state) {
@@ -3976,7 +4065,7 @@ var require_parser = __commonJS({
3976
4065
  return Of$0(state);
3977
4066
  }
3978
4067
  }
3979
- var OpenBrace$0 = $TV($EXPECT($L109, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
4068
+ var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
3980
4069
  return { $loc, token: $1 };
3981
4070
  });
3982
4071
  function OpenBrace(state) {
@@ -3988,7 +4077,7 @@ var require_parser = __commonJS({
3988
4077
  return OpenBrace$0(state);
3989
4078
  }
3990
4079
  }
3991
- var OpenBracket$0 = $TV($EXPECT($L110, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
4080
+ var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
3992
4081
  return { $loc, token: $1 };
3993
4082
  });
3994
4083
  function OpenBracket(state) {
@@ -4000,7 +4089,7 @@ var require_parser = __commonJS({
4000
4089
  return OpenBracket$0(state);
4001
4090
  }
4002
4091
  }
4003
- var OpenParen$0 = $TV($EXPECT($L111, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4092
+ var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4004
4093
  return { $loc, token: $1 };
4005
4094
  });
4006
4095
  function OpenParen(state) {
@@ -4012,7 +4101,7 @@ var require_parser = __commonJS({
4012
4101
  return OpenParen$0(state);
4013
4102
  }
4014
4103
  }
4015
- var QuestionMark$0 = $TV($EXPECT($L112, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4104
+ var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4016
4105
  return { $loc, token: $1 };
4017
4106
  });
4018
4107
  function QuestionMark(state) {
@@ -4024,7 +4113,7 @@ var require_parser = __commonJS({
4024
4113
  return QuestionMark$0(state);
4025
4114
  }
4026
4115
  }
4027
- var Return$0 = $TS($S($EXPECT($L113, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4116
+ var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4028
4117
  return { $loc, token: $1 };
4029
4118
  });
4030
4119
  function Return(state) {
@@ -4036,7 +4125,7 @@ var require_parser = __commonJS({
4036
4125
  return Return$0(state);
4037
4126
  }
4038
4127
  }
4039
- var Semicolon$0 = $TV($EXPECT($L72, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4128
+ var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4040
4129
  return { $loc, token: $1 };
4041
4130
  });
4042
4131
  function Semicolon(state) {
@@ -4048,7 +4137,7 @@ var require_parser = __commonJS({
4048
4137
  return Semicolon$0(state);
4049
4138
  }
4050
4139
  }
4051
- var SingleQuote$0 = $TV($EXPECT($L114, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4140
+ var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4052
4141
  return { $loc, token: $1 };
4053
4142
  });
4054
4143
  function SingleQuote(state) {
@@ -4060,7 +4149,7 @@ var require_parser = __commonJS({
4060
4149
  return SingleQuote$0(state);
4061
4150
  }
4062
4151
  }
4063
- var Star$0 = $TV($EXPECT($L43, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4152
+ var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4064
4153
  return { $loc, token: $1 };
4065
4154
  });
4066
4155
  function Star(state) {
@@ -4072,10 +4161,10 @@ var require_parser = __commonJS({
4072
4161
  return Star$0(state);
4073
4162
  }
4074
4163
  }
4075
- var Static$0 = $TV($EXPECT($L115, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4164
+ var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4076
4165
  return { $loc, token: $1 };
4077
4166
  });
4078
- var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L111, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4167
+ var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4079
4168
  return { $loc, token: "static " };
4080
4169
  });
4081
4170
  function Static(state) {
@@ -4085,7 +4174,7 @@ var require_parser = __commonJS({
4085
4174
  return Static$0(state) || Static$1(state);
4086
4175
  }
4087
4176
  }
4088
- var SubstitutionStart$0 = $TV($EXPECT($L116, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4177
+ var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4089
4178
  return { $loc, token: $1 };
4090
4179
  });
4091
4180
  function SubstitutionStart(state) {
@@ -4097,7 +4186,7 @@ var require_parser = __commonJS({
4097
4186
  return SubstitutionStart$0(state);
4098
4187
  }
4099
4188
  }
4100
- var Switch$0 = $TS($S($EXPECT($L117, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4189
+ var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4101
4190
  return { $loc, token: $1 };
4102
4191
  });
4103
4192
  function Switch(state) {
@@ -4109,7 +4198,7 @@ var require_parser = __commonJS({
4109
4198
  return Switch$0(state);
4110
4199
  }
4111
4200
  }
4112
- var Target$0 = $TV($EXPECT($L118, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4201
+ var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4113
4202
  return { $loc, token: $1 };
4114
4203
  });
4115
4204
  function Target(state) {
@@ -4121,7 +4210,7 @@ var require_parser = __commonJS({
4121
4210
  return Target$0(state);
4122
4211
  }
4123
4212
  }
4124
- var Throw$0 = $TS($S($EXPECT($L119, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4213
+ var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4125
4214
  return { $loc, token: $1 };
4126
4215
  });
4127
4216
  function Throw(state) {
@@ -4133,7 +4222,7 @@ var require_parser = __commonJS({
4133
4222
  return Throw$0(state);
4134
4223
  }
4135
4224
  }
4136
- var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4225
+ var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4137
4226
  return { $loc, token: "`" };
4138
4227
  });
4139
4228
  function TripleDoubleQuote(state) {
@@ -4145,7 +4234,7 @@ var require_parser = __commonJS({
4145
4234
  return TripleDoubleQuote$0(state);
4146
4235
  }
4147
4236
  }
4148
- var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4237
+ var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4149
4238
  return { $loc, token: "`" };
4150
4239
  });
4151
4240
  function TripleSingleQuote(state) {
@@ -4157,7 +4246,7 @@ var require_parser = __commonJS({
4157
4246
  return TripleSingleQuote$0(state);
4158
4247
  }
4159
4248
  }
4160
- var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4249
+ var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4161
4250
  return { $loc, token: "`" };
4162
4251
  });
4163
4252
  function TripleTick(state) {
@@ -4169,7 +4258,7 @@ var require_parser = __commonJS({
4169
4258
  return TripleTick$0(state);
4170
4259
  }
4171
4260
  }
4172
- var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4261
+ var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4173
4262
  return { $loc, token: $1 };
4174
4263
  });
4175
4264
  function Try(state) {
@@ -4181,7 +4270,7 @@ var require_parser = __commonJS({
4181
4270
  return Try$0(state);
4182
4271
  }
4183
4272
  }
4184
- var Unless$0 = $TV($EXPECT($L124, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4273
+ var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4185
4274
  return { $loc, token: $1 };
4186
4275
  });
4187
4276
  function Unless(state) {
@@ -4193,7 +4282,7 @@ var require_parser = __commonJS({
4193
4282
  return Unless$0(state);
4194
4283
  }
4195
4284
  }
4196
- var Var$0 = $TV($EXPECT($L125, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4285
+ var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4197
4286
  return { $loc, token: $1 };
4198
4287
  });
4199
4288
  function Var(state) {
@@ -4205,7 +4294,7 @@ var require_parser = __commonJS({
4205
4294
  return Var$0(state);
4206
4295
  }
4207
4296
  }
4208
- var When$0 = $TS($S($EXPECT($L126, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4297
+ var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4209
4298
  return { $loc, token: "case" };
4210
4299
  });
4211
4300
  function When(state) {
@@ -4217,7 +4306,7 @@ var require_parser = __commonJS({
4217
4306
  return When$0(state);
4218
4307
  }
4219
4308
  }
4220
- var Yield$0 = $TS($S($EXPECT($L127, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4309
+ var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4221
4310
  return { $loc, token: $1 };
4222
4311
  });
4223
4312
  function Yield(state) {
@@ -4243,7 +4332,7 @@ var require_parser = __commonJS({
4243
4332
  return JSXElement$0(state) || JSXElement$1(state);
4244
4333
  }
4245
4334
  }
4246
- var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
4335
+ var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
4247
4336
  function JSXSelfClosingElement(state) {
4248
4337
  if (state.verbose)
4249
4338
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -4253,7 +4342,7 @@ var require_parser = __commonJS({
4253
4342
  return JSXSelfClosingElement$0(state);
4254
4343
  }
4255
4344
  }
4256
- var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L53, fail, 'JSXOpeningElement ">"'));
4345
+ var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
4257
4346
  function JSXOpeningElement(state) {
4258
4347
  if (state.verbose)
4259
4348
  console.log("ENTER:", "JSXOpeningElement");
@@ -4263,7 +4352,7 @@ var require_parser = __commonJS({
4263
4352
  return JSXOpeningElement$0(state);
4264
4353
  }
4265
4354
  }
4266
- var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L53, fail, 'JSXClosingElement ">"'));
4355
+ var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
4267
4356
  function JSXClosingElement(state) {
4268
4357
  if (state.verbose)
4269
4358
  console.log("ENTER:", "JSXClosingElement");
@@ -4273,7 +4362,7 @@ var require_parser = __commonJS({
4273
4362
  return JSXClosingElement$0(state);
4274
4363
  }
4275
4364
  }
4276
- var JSXFragment$0 = $S($EXPECT($L130, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L131, fail, 'JSXFragment "</>"'));
4365
+ var JSXFragment$0 = $S($EXPECT($L134, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L135, fail, 'JSXFragment "</>"'));
4277
4366
  function JSXFragment(state) {
4278
4367
  if (state.verbose)
4279
4368
  console.log("ENTER:", "JSXFragment");
@@ -4293,7 +4382,7 @@ var require_parser = __commonJS({
4293
4382
  return JSXElementName$0(state);
4294
4383
  }
4295
4384
  }
4296
- var JSXIdentifierName$0 = $R$0($EXPECT($R28, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4385
+ var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4297
4386
  function JSXIdentifierName(state) {
4298
4387
  if (state.verbose)
4299
4388
  console.log("ENTER:", "JSXIdentifierName");
@@ -4313,7 +4402,7 @@ var require_parser = __commonJS({
4313
4402
  return JSXAttributes$0(state);
4314
4403
  }
4315
4404
  }
4316
- var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L17, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
4405
+ var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot, __, AssignmentExpression, __, CloseBrace);
4317
4406
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
4318
4407
  function JSXAttribute(state) {
4319
4408
  if (state.tokenize) {
@@ -4342,8 +4431,8 @@ var require_parser = __commonJS({
4342
4431
  return JSXAttributeInitializer$0(state);
4343
4432
  }
4344
4433
  }
4345
- var JSXAttributeValue$0 = $R$0($EXPECT($R29, fail, 'JSXAttributeValue /"[^"]*"/'));
4346
- var JSXAttributeValue$1 = $R$0($EXPECT($R30, fail, "JSXAttributeValue /'[^']*'/"));
4434
+ var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
4435
+ var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
4347
4436
  var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
4348
4437
  var JSXAttributeValue$3 = JSXElement;
4349
4438
  var JSXAttributeValue$4 = JSXFragment;
@@ -4375,7 +4464,7 @@ var require_parser = __commonJS({
4375
4464
  return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
4376
4465
  }
4377
4466
  }
4378
- var JSXText$0 = $R$0($EXPECT($R31, fail, "JSXText /[^{}<>]+/"));
4467
+ var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
4379
4468
  function JSXText(state) {
4380
4469
  if (state.verbose)
4381
4470
  console.log("ENTER:", "JSXText");
@@ -4385,7 +4474,7 @@ var require_parser = __commonJS({
4385
4474
  return JSXText$0(state);
4386
4475
  }
4387
4476
  }
4388
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L17, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
4477
+ var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)), AssignmentExpression);
4389
4478
  function JSXChildExpression(state) {
4390
4479
  if (state.verbose)
4391
4480
  console.log("ENTER:", "JSXChildExpression");
@@ -4407,7 +4496,7 @@ var require_parser = __commonJS({
4407
4496
  return TypeDeclaration$0(state);
4408
4497
  }
4409
4498
  }
4410
- var TypeDeclarationModifier$0 = $S($EXPECT($L132, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
4499
+ var TypeDeclarationModifier$0 = $S($EXPECT($L136, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
4411
4500
  var TypeDeclarationModifier$1 = Export;
4412
4501
  function TypeDeclarationModifier(state) {
4413
4502
  if (state.tokenize) {
@@ -4417,16 +4506,17 @@ var require_parser = __commonJS({
4417
4506
  }
4418
4507
  }
4419
4508
  var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
4420
- var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
4509
+ var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
4421
4510
  var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
4511
+ var TypeDeclarationRest$3 = FunctionSignature;
4422
4512
  function TypeDeclarationRest(state) {
4423
4513
  if (state.tokenize) {
4424
- return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state));
4514
+ return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state));
4425
4515
  } else {
4426
- return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
4516
+ return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
4427
4517
  }
4428
4518
  }
4429
- var TypeKeyword$0 = $S($EXPECT($L133, fail, 'TypeKeyword "type"'), NonIdContinue);
4519
+ var TypeKeyword$0 = $S($EXPECT($L137, fail, 'TypeKeyword "type"'), NonIdContinue);
4430
4520
  function TypeKeyword(state) {
4431
4521
  if (state.verbose)
4432
4522
  console.log("ENTER:", "TypeKeyword");
@@ -4436,7 +4526,7 @@ var require_parser = __commonJS({
4436
4526
  return TypeKeyword$0(state);
4437
4527
  }
4438
4528
  }
4439
- var Interface$0 = $S($EXPECT($L134, fail, 'Interface "interface"'), NonIdContinue);
4529
+ var Interface$0 = $S($EXPECT($L138, fail, 'Interface "interface"'), NonIdContinue);
4440
4530
  function Interface(state) {
4441
4531
  if (state.verbose)
4442
4532
  console.log("ENTER:", "Interface");
@@ -4446,7 +4536,7 @@ var require_parser = __commonJS({
4446
4536
  return Interface$0(state);
4447
4537
  }
4448
4538
  }
4449
- var Namespace$0 = $S($EXPECT($L135, fail, 'Namespace "namespace"'), NonIdContinue);
4539
+ var Namespace$0 = $S($EXPECT($L139, fail, 'Namespace "namespace"'), NonIdContinue);
4450
4540
  function Namespace(state) {
4451
4541
  if (state.verbose)
4452
4542
  console.log("ENTER:", "Namespace");
@@ -4492,27 +4582,23 @@ var require_parser = __commonJS({
4492
4582
  }
4493
4583
  }
4494
4584
  var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
4495
- var InterfaceProperty$1 = MethodSignature;
4585
+ var InterfaceProperty$1 = $S(NonEmptyParameters, TypeSuffix, InterfacePropertyDelimiter);
4586
+ var InterfaceProperty$2 = $S(MethodSignature, InterfacePropertyDelimiter);
4496
4587
  function InterfaceProperty(state) {
4497
4588
  if (state.tokenize) {
4498
- return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
4589
+ return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state));
4499
4590
  } else {
4500
- return InterfaceProperty$0(state) || InterfaceProperty$1(state);
4591
+ return InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state);
4501
4592
  }
4502
4593
  }
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
- });
4594
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $C(Semicolon, Comma));
4595
+ var InterfacePropertyDelimiter$1 = $Y($S(__, CloseBrace));
4596
+ var InterfacePropertyDelimiter$2 = $Y(EOS);
4511
4597
  function InterfacePropertyDelimiter(state) {
4512
4598
  if (state.tokenize) {
4513
- return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state));
4599
+ return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state));
4514
4600
  } else {
4515
- return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
4601
+ return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state);
4516
4602
  }
4517
4603
  }
4518
4604
  var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
@@ -4550,7 +4636,7 @@ var require_parser = __commonJS({
4550
4636
  return NestedTypeDeclaration$0(state);
4551
4637
  }
4552
4638
  }
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)));
4639
+ 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
4640
  function TypeIndexSignature(state) {
4555
4641
  if (state.verbose)
4556
4642
  console.log("ENTER:", "TypeIndexSignature");
@@ -4581,7 +4667,7 @@ var require_parser = __commonJS({
4581
4667
  return TypeSuffix$0(state);
4582
4668
  }
4583
4669
  }
4584
- var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L137, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
4670
+ var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L141, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
4585
4671
  if (!$3)
4586
4672
  $0.splice(2, 1);
4587
4673
  if ($1.length === 0)
@@ -4601,7 +4687,7 @@ var require_parser = __commonJS({
4601
4687
  return ReturnTypeSuffix$0(state);
4602
4688
  }
4603
4689
  }
4604
- var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4690
+ var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4605
4691
  if (!$2)
4606
4692
  return $1;
4607
4693
  return $0;
@@ -4656,18 +4742,17 @@ var require_parser = __commonJS({
4656
4742
  }
4657
4743
  }
4658
4744
  var TypeUnarySuffix$0 = TypeIndexedAccess;
4745
+ var TypeUnarySuffix$1 = QuestionMark;
4659
4746
  function TypeUnarySuffix(state) {
4660
- if (state.verbose)
4661
- console.log("ENTER:", "TypeUnarySuffix");
4662
4747
  if (state.tokenize) {
4663
- return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
4748
+ return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state));
4664
4749
  } else {
4665
- return TypeUnarySuffix$0(state);
4750
+ return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
4666
4751
  }
4667
4752
  }
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"');
4753
+ var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
4754
+ var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
4755
+ var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
4671
4756
  function TypeUnaryOp(state) {
4672
4757
  if (state.tokenize) {
4673
4758
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -4687,14 +4772,59 @@ var require_parser = __commonJS({
4687
4772
  }
4688
4773
  var TypePrimary$0 = InterfaceBlock;
4689
4774
  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));
4775
+ var TypePrimary$2 = $S(__, TypeTuple);
4776
+ var TypePrimary$3 = $S($Q(_), FunctionType);
4777
+ var TypePrimary$4 = $S($Q(_), TypeLiteral);
4778
+ var TypePrimary$5 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
4693
4779
  function TypePrimary(state) {
4694
4780
  if (state.tokenize) {
4695
- return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
4781
+ return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
4782
+ } else {
4783
+ return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
4784
+ }
4785
+ }
4786
+ var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
4787
+ var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
4788
+ function TypeTuple(state) {
4789
+ if (state.tokenize) {
4790
+ return $TOKEN("TypeTuple", state, TypeTuple$0(state) || TypeTuple$1(state));
4791
+ } else {
4792
+ return TypeTuple$0(state) || TypeTuple$1(state);
4793
+ }
4794
+ }
4795
+ var TypeList$0 = $S(Type, $Q($S(__, Comma, Type)));
4796
+ function TypeList(state) {
4797
+ if (state.verbose)
4798
+ console.log("ENTER:", "TypeList");
4799
+ if (state.tokenize) {
4800
+ return $TOKEN("TypeList", state, TypeList$0(state));
4696
4801
  } else {
4697
- return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
4802
+ return TypeList$0(state);
4803
+ }
4804
+ }
4805
+ var NestedTypeList$0 = $TS($S(PushIndent, $Q(NestedType), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
4806
+ var types = $2;
4807
+ if (types.length)
4808
+ return types;
4809
+ return $skip;
4810
+ });
4811
+ function NestedTypeList(state) {
4812
+ if (state.verbose)
4813
+ console.log("ENTER:", "NestedTypeList");
4814
+ if (state.tokenize) {
4815
+ return $TOKEN("NestedTypeList", state, NestedTypeList$0(state));
4816
+ } else {
4817
+ return NestedTypeList$0(state);
4818
+ }
4819
+ }
4820
+ var NestedType$0 = $S(Nested, Type, ArrayElementDelimiter);
4821
+ function NestedType(state) {
4822
+ if (state.verbose)
4823
+ console.log("ENTER:", "NestedType");
4824
+ if (state.tokenize) {
4825
+ return $TOKEN("NestedType", state, NestedType$0(state));
4826
+ } else {
4827
+ return NestedType$0(state);
4698
4828
  }
4699
4829
  }
4700
4830
  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 +4842,10 @@ var require_parser = __commonJS({
4712
4842
  }
4713
4843
  }
4714
4844
  var TypeLiteral$0 = Literal;
4715
- var TypeLiteral$1 = $TV($EXPECT($L70, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
4845
+ var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
4716
4846
  return { $loc, token: "void" };
4717
4847
  });
4718
- var TypeLiteral$2 = $TV($EXPECT($L140, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
4848
+ var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
4719
4849
  return { $loc, token: "[]" };
4720
4850
  });
4721
4851
  function TypeLiteral(state) {
@@ -4725,10 +4855,10 @@ var require_parser = __commonJS({
4725
4855
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
4726
4856
  }
4727
4857
  }
4728
- var TypeBinaryOp$0 = $TV($EXPECT($L68, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
4858
+ var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
4729
4859
  return { $loc, token: "|" };
4730
4860
  });
4731
- var TypeBinaryOp$1 = $TV($EXPECT($L66, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
4861
+ var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
4732
4862
  return { $loc, token: "&" };
4733
4863
  });
4734
4864
  function TypeBinaryOp(state) {
@@ -4748,7 +4878,7 @@ var require_parser = __commonJS({
4748
4878
  return FunctionType$0(state);
4749
4879
  }
4750
4880
  }
4751
- var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeArguments ">"'));
4881
+ var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
4752
4882
  function TypeArguments(state) {
4753
4883
  if (state.verbose)
4754
4884
  console.log("ENTER:", "TypeArguments");
@@ -4758,7 +4888,7 @@ var require_parser = __commonJS({
4758
4888
  return TypeArguments$0(state);
4759
4889
  }
4760
4890
  }
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) {
4891
+ 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
4892
  return { ts: true, children: $0 };
4763
4893
  });
4764
4894
  function TypeParameters(state) {
@@ -4791,8 +4921,8 @@ var require_parser = __commonJS({
4791
4921
  }
4792
4922
  }
4793
4923
  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) {
4924
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L56, fail, 'TypeParameterDelimiter ">"')));
4925
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L56, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4796
4926
  return { $loc, token: "," };
4797
4927
  });
4798
4928
  var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -4805,7 +4935,7 @@ var require_parser = __commonJS({
4805
4935
  return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
4806
4936
  }
4807
4937
  }
4808
- var Shebang$0 = $S($R$0($EXPECT($R34, fail, "Shebang /#![^\\r\\n]*/")), EOL);
4938
+ var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
4809
4939
  function Shebang(state) {
4810
4940
  if (state.verbose)
4811
4941
  console.log("ENTER:", "Shebang");
@@ -4815,11 +4945,11 @@ var require_parser = __commonJS({
4815
4945
  return Shebang$0(state);
4816
4946
  }
4817
4947
  }
4818
- var CivetPrologue$0 = $T($S($EXPECT($R35, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4948
+ var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4819
4949
  var content = value[2];
4820
4950
  return content;
4821
4951
  });
4822
- var CivetPrologue$1 = $T($S($EXPECT($R35, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4952
+ var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4823
4953
  var content = value[2];
4824
4954
  return content;
4825
4955
  });
@@ -4830,7 +4960,7 @@ var require_parser = __commonJS({
4830
4960
  return CivetPrologue$0(state) || CivetPrologue$1(state);
4831
4961
  }
4832
4962
  }
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) {
4963
+ 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
4964
  var options = $2;
4835
4965
  return {
4836
4966
  type: "CivetPrologue",
@@ -4847,8 +4977,8 @@ var require_parser = __commonJS({
4847
4977
  return CivetPrologueContent$0(state);
4848
4978
  }
4849
4979
  }
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) => {
4980
+ 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) {
4981
+ const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
4852
4982
  if (l)
4853
4983
  return l.toUpperCase();
4854
4984
  return "";
@@ -4865,7 +4995,7 @@ var require_parser = __commonJS({
4865
4995
  return CivetOption$0(state);
4866
4996
  }
4867
4997
  }
4868
- var UnknownPrologue$0 = $S($R$0($EXPECT($R35, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
4998
+ var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
4869
4999
  function UnknownPrologue(state) {
4870
5000
  if (state.verbose)
4871
5001
  console.log("ENTER:", "UnknownPrologue");
@@ -4894,7 +5024,7 @@ var require_parser = __commonJS({
4894
5024
  return EOS$0(state);
4895
5025
  }
4896
5026
  }
4897
- var EOL$0 = $R$0($EXPECT($R38, fail, "EOL /\\r\\n|\\n|\\r|$/"));
5027
+ var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
4898
5028
  function EOL(state) {
4899
5029
  if (state.verbose)
4900
5030
  console.log("ENTER:", "EOL");
@@ -4904,7 +5034,7 @@ var require_parser = __commonJS({
4904
5034
  return EOL$0(state);
4905
5035
  }
4906
5036
  }
4907
- var EOF$0 = $R$0($EXPECT($R39, fail, "EOF /$/"));
5037
+ var EOF$0 = $R$0($EXPECT($R43, fail, "EOF /$/"));
4908
5038
  function EOF(state) {
4909
5039
  if (state.verbose)
4910
5040
  console.log("ENTER:", "EOF");
@@ -5047,7 +5177,7 @@ var require_parser = __commonJS({
5047
5177
  }
5048
5178
  }
5049
5179
  var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
5050
- return { $loc, token: "break;" };
5180
+ return { $loc, token: ";break;" };
5051
5181
  });
5052
5182
  function InsertBreak(state) {
5053
5183
  if (state.verbose)
@@ -5072,6 +5202,20 @@ var require_parser = __commonJS({
5072
5202
  return CoffeeCommentEnabled$0(state);
5073
5203
  }
5074
5204
  }
5205
+ var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
5206
+ if (module2.config.coffeeBooleans)
5207
+ return;
5208
+ return $skip;
5209
+ });
5210
+ function CoffeeBooleansEnabled(state) {
5211
+ if (state.verbose)
5212
+ console.log("ENTER:", "CoffeeBooleansEnabled");
5213
+ if (state.tokenize) {
5214
+ return $TOKEN("CoffeeBooleansEnabled", state, CoffeeBooleansEnabled$0(state));
5215
+ } else {
5216
+ return CoffeeBooleansEnabled$0(state);
5217
+ }
5218
+ }
5075
5219
  var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
5076
5220
  if (module2.config.coffeeInterpolation)
5077
5221
  return;
@@ -5092,6 +5236,7 @@ var require_parser = __commonJS({
5092
5236
  module2.verbose = false;
5093
5237
  module2.config = {
5094
5238
  autoVar: false,
5239
+ coffeeBooleans: false,
5095
5240
  coffeeComment: false,
5096
5241
  coffeeEq: false,
5097
5242
  coffeeInterpolation: false,
@@ -5101,12 +5246,14 @@ var require_parser = __commonJS({
5101
5246
  set(b) {
5102
5247
  if (b) {
5103
5248
  this.autoVar = true;
5249
+ this.coffeeBooleans = true;
5104
5250
  this.coffeeComment = true;
5105
5251
  this.coffeeEq = true;
5106
5252
  this.coffeeInterpolation = true;
5107
5253
  this.implicitReturns = true;
5108
5254
  } else {
5109
5255
  this.autoVar = false;
5256
+ this.coffeeBooleans = false;
5110
5257
  this.coffeeComment = false;
5111
5258
  this.coffeeEq = false;
5112
5259
  this.coffeeInterpolation = false;
@@ -5154,6 +5301,9 @@ var require_parser = __commonJS({
5154
5301
  case "AssignmentExpression":
5155
5302
  node.children.unshift("return ");
5156
5303
  return;
5304
+ case "Identifier":
5305
+ node.token = "return " + node.token;
5306
+ return;
5157
5307
  case "BlockStatement":
5158
5308
  insertReturn(node.expressions[node.expressions.length - 1]);
5159
5309
  return;
@@ -5174,7 +5324,7 @@ var require_parser = __commonJS({
5174
5324
  }
5175
5325
  if (!Array.isArray(node))
5176
5326
  return;
5177
- const [, exp] = node;
5327
+ const [indent, exp] = node;
5178
5328
  if (!exp)
5179
5329
  return;
5180
5330
  switch (exp.type) {
@@ -5193,6 +5343,8 @@ var require_parser = __commonJS({
5193
5343
  insertReturn(exp.children[2]);
5194
5344
  if (exp.children[3])
5195
5345
  insertReturn(exp.children[3][2]);
5346
+ else
5347
+ exp.children.push(["\n", indent, "return"]);
5196
5348
  return;
5197
5349
  case "SwitchStatement":
5198
5350
  insertReturn(exp.children[2]);
@@ -5210,6 +5362,50 @@ var require_parser = __commonJS({
5210
5362
  insertReturn(block);
5211
5363
  return block;
5212
5364
  };
5365
+ module2.expandChainedComparisons = function([first, binops]) {
5366
+ const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
5367
+ const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
5368
+ let results = [];
5369
+ let i = 0;
5370
+ let l = binops.length;
5371
+ let start = 0;
5372
+ let chains = [];
5373
+ while (i < l) {
5374
+ const [, op] = binops[i];
5375
+ if (relationalOps.includes(op.token)) {
5376
+ chains.push(i);
5377
+ } else if (lowerPrecedenceOps.includes(op.token)) {
5378
+ processChains();
5379
+ first = [];
5380
+ }
5381
+ i++;
5382
+ }
5383
+ processChains();
5384
+ return results;
5385
+ function processChains() {
5386
+ if (chains.length > 1) {
5387
+ chains.forEach((index, k) => {
5388
+ if (k > 0) {
5389
+ results.push(" && ");
5390
+ }
5391
+ const [pre, op, post, exp] = binops[index];
5392
+ let endIndex;
5393
+ if (k < chains.length - 1) {
5394
+ endIndex = chains[k + 1];
5395
+ } else {
5396
+ endIndex = i + 1;
5397
+ }
5398
+ results = results.concat(first, ...binops.slice(start, endIndex));
5399
+ first = [exp].concat(binops.slice(index + 1, endIndex));
5400
+ start = endIndex;
5401
+ });
5402
+ } else {
5403
+ results = results.concat(first, ...binops.slice(start, i + 1));
5404
+ start = i + 1;
5405
+ }
5406
+ chains.length = 0;
5407
+ }
5408
+ };
5213
5409
  module2.parsePosition = function() {
5214
5410
  let s = Error().stack.split(/\n at /);
5215
5411
  s.shift();
@@ -5306,7 +5502,7 @@ var require_parser = __commonJS({
5306
5502
  return Init$0(state);
5307
5503
  }
5308
5504
  }
5309
- var Indent$0 = $TV($Q($C($EXPECT($L142, fail, 'Indent " "'), $EXPECT($L143, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
5505
+ var Indent$0 = $TV($Q($C($EXPECT($L146, fail, 'Indent " "'), $EXPECT($L147, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
5310
5506
  const level = $1.length;
5311
5507
  return {
5312
5508
  $loc,