@danielx/civet 0.4.11 → 0.4.13

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 (5) hide show
  1. package/README.md +2 -0
  2. package/dist/browser.js +482 -439
  3. package/dist/esm.mjs +1 -1
  4. package/dist/main.js +482 -439
  5. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -530,7 +530,8 @@ var require_parser = __commonJS({
530
530
  WhileStatement,
531
531
  WhileClause,
532
532
  ForStatement,
533
- ForInOfStatement,
533
+ ForStatementControl,
534
+ ForInOfDeclaration,
534
535
  ForDeclaration,
535
536
  ForBinding,
536
537
  SwitchStatement,
@@ -622,6 +623,7 @@ var require_parser = __commonJS({
622
623
  As,
623
624
  Async,
624
625
  Await,
626
+ Backtick,
625
627
  Case,
626
628
  Catch,
627
629
  Class,
@@ -632,6 +634,7 @@ var require_parser = __commonJS({
632
634
  Colon,
633
635
  ConstructorShorthand,
634
636
  Default,
637
+ Delete,
635
638
  Dot,
636
639
  DotDotDot,
637
640
  DoubleQuote,
@@ -666,8 +669,10 @@ var require_parser = __commonJS({
666
669
  TripleSingleQuote,
667
670
  TripleTick,
668
671
  Try,
672
+ Typeof,
669
673
  Unless,
670
674
  Var,
675
+ Void,
671
676
  When,
672
677
  Yield,
673
678
  JSXElement,
@@ -733,7 +738,6 @@ var require_parser = __commonJS({
733
738
  DirectivePrologue,
734
739
  EOS,
735
740
  EOL,
736
- EOF,
737
741
  Debugger,
738
742
  InsertOpenParen,
739
743
  InsertCloseParen,
@@ -759,136 +763,136 @@ var require_parser = __commonJS({
759
763
  PopIndent,
760
764
  Nested
761
765
  });
762
- var $L0 = $L("`");
763
- var $L1 = $L("");
764
- var $L2 = $L("++");
765
- var $L3 = $L("--");
766
- var $L4 = $L("=>");
767
- var $L5 = $L("<");
768
- var $L6 = $L("extends");
769
- var $L7 = $L("this");
770
- var $L8 = $L("#");
771
- var $L9 = $L("@");
772
- var $L10 = $L("super");
773
- var $L11 = $L("import");
774
- var $L12 = $L("!");
775
- var $L13 = $L("::");
776
- var $L14 = $L("super[");
777
- var $L15 = $L("import.meta");
778
- var $L16 = $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");
766
+ var $L0 = $L("");
767
+ var $L1 = $L("++");
768
+ var $L2 = $L("--");
769
+ var $L3 = $L("=>");
770
+ var $L4 = $L("<");
771
+ var $L5 = $L("extends");
772
+ var $L6 = $L("this");
773
+ var $L7 = $L("#");
774
+ var $L8 = $L("@");
775
+ var $L9 = $L("super");
776
+ var $L10 = $L("import");
777
+ var $L11 = $L("!");
778
+ var $L12 = $L("::");
779
+ var $L13 = $L("super[");
780
+ var $L14 = $L("import.meta");
781
+ var $L15 = $L(")");
782
+ var $L16 = $L("->");
783
+ var $L17 = $L("null");
784
+ var $L18 = $L("true");
785
+ var $L19 = $L("false");
786
+ var $L20 = $L("yes");
787
+ var $L21 = $L("on");
788
+ var $L22 = $L("no");
789
+ var $L23 = $L("off");
790
+ var $L24 = $L(",");
791
+ var $L25 = $L("]");
792
+ var $L26 = $L("}");
793
+ var $L27 = $L("**=");
794
+ var $L28 = $L("*=");
795
+ var $L29 = $L("/=");
796
+ var $L30 = $L("%=");
797
+ var $L31 = $L("+=");
798
+ var $L32 = $L("-=");
799
+ var $L33 = $L("<<=");
800
+ var $L34 = $L(">>>=");
801
+ var $L35 = $L(">>=");
802
+ var $L36 = $L("&&=");
803
+ var $L37 = $L("&=");
804
+ var $L38 = $L("^=");
805
+ var $L39 = $L("||=");
806
+ var $L40 = $L("|=");
807
+ var $L41 = $L("??=");
808
+ var $L42 = $L("?=");
809
+ var $L43 = $L("=");
810
+ var $L44 = $L("**");
811
+ var $L45 = $L("*");
812
+ var $L46 = $L("/");
813
+ var $L47 = $L("%");
814
+ var $L48 = $L("+");
815
+ var $L49 = $L("-");
816
+ var $L50 = $L("<=");
817
+ var $L51 = $L(">=");
818
+ var $L52 = $L("<<");
819
+ var $L53 = $L(">>>");
820
+ var $L54 = $L(">>");
821
+ var $L55 = $L(">");
822
+ var $L56 = $L("!==");
823
+ var $L57 = $L("!=");
824
+ var $L58 = $L("is");
825
+ var $L59 = $L("===");
826
+ var $L60 = $L("==");
827
+ var $L61 = $L("and");
828
+ var $L62 = $L("&&");
829
+ var $L63 = $L("or");
830
+ var $L64 = $L("||");
831
+ var $L65 = $L("??");
832
+ var $L66 = $L("instanceof");
833
+ var $L67 = $L("in");
834
+ var $L68 = $L("&");
835
+ var $L69 = $L("^");
836
+ var $L70 = $L("|");
837
+ var $L71 = $L(";");
838
+ var $L72 = $L("do");
839
+ var $L73 = $L("while");
840
+ var $L74 = $L("until");
841
+ var $L75 = $L("finally");
842
+ var $L76 = $L("break");
843
+ var $L77 = $L("continue");
844
+ var $L78 = $L("debugger");
845
+ var $L79 = $L("import type");
846
+ var $L80 = $L("default");
847
+ var $L81 = $L(":=");
848
+ var $L82 = $L("/*");
849
+ var $L83 = $L("*/");
850
+ var $L84 = $L("###");
851
+ var $L85 = $L("as");
852
+ var $L86 = $L("async");
853
+ var $L87 = $L("await");
854
+ var $L88 = $L("`");
855
+ var $L89 = $L("case");
856
+ var $L90 = $L("catch");
857
+ var $L91 = $L("class");
858
+ var $L92 = $L("#{");
859
+ var $L93 = $L(":");
860
+ var $L94 = $L("delete");
861
+ var $L95 = $L(".");
862
+ var $L96 = $L("...");
863
+ var $L97 = $L('"');
864
+ var $L98 = $L("else");
865
+ var $L99 = $L("export");
866
+ var $L100 = $L("for");
867
+ var $L101 = $L("from");
868
+ var $L102 = $L("function");
869
+ var $L103 = $L("get");
870
+ var $L104 = $L("set");
871
+ var $L105 = $L("if");
872
+ var $L106 = $L("let");
873
+ var $L107 = $L("const");
874
+ var $L108 = $L("loop");
875
+ var $L109 = $L("new");
876
+ var $L110 = $L("of");
877
+ var $L111 = $L("{");
878
+ var $L112 = $L("[");
879
+ var $L113 = $L("(");
880
+ var $L114 = $L("?");
881
+ var $L115 = $L("return");
882
+ var $L116 = $L("'");
883
+ var $L117 = $L("static");
884
+ var $L118 = $L("${");
885
+ var $L119 = $L("switch");
886
+ var $L120 = $L("target");
887
+ var $L121 = $L("throw");
888
+ var $L122 = $L('"""');
889
+ var $L123 = $L("'''");
890
+ var $L124 = $L("```");
891
+ var $L125 = $L("try");
892
+ var $L126 = $L("typeof");
893
+ var $L127 = $L("unless");
894
+ var $L128 = $L("var");
895
+ var $L129 = $L("void");
892
896
  var $L130 = $L("when");
893
897
  var $L131 = $L("yield");
894
898
  var $L132 = $L("/>");
@@ -907,50 +911,50 @@ var require_parser = __commonJS({
907
911
  var $L145 = $L("civet");
908
912
  var $L146 = $L(" ");
909
913
  var $L147 = $L(" ");
910
- var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
914
+ var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
911
915
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
912
916
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
913
- var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
914
- var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "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"));
917
+ var $R3 = $R(new RegExp("(?=[\\s\\)])", "suy"));
918
+ var $R4 = $R(new RegExp('[^;"\\s]+', "suy"));
919
+ var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
920
+ var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
921
+ var $R7 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?", "suy"));
922
+ var $R8 = $R(new RegExp("(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)", "suy"));
923
+ var $R9 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
924
+ var $R10 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
925
+ var $R11 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
926
+ var $R12 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
927
+ var $R13 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
928
+ var $R14 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
929
+ var $R15 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
930
+ var $R16 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
931
+ var $R17 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
932
+ var $R18 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
933
+ var $R19 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
934
+ var $R20 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
935
+ var $R21 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
936
+ var $R22 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
937
+ var $R23 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
938
+ var $R24 = $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"));
939
+ var $R25 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
940
+ var $R26 = $R(new RegExp(".", "suy"));
941
+ var $R27 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
942
+ var $R28 = $R(new RegExp("[^\\r\\n]", "suy"));
943
+ var $R29 = $R(new RegExp("[ \\t]+", "suy"));
944
+ var $R30 = $R(new RegExp("[\\s]+", "suy"));
945
+ var $R31 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
946
+ var $R32 = $R(new RegExp("\\s", "suy"));
947
+ var $R33 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
948
+ var $R34 = $R(new RegExp('"[^"]*"', "suy"));
949
+ var $R35 = $R(new RegExp("'[^']*'", "suy"));
950
+ var $R36 = $R(new RegExp("[^{}<>]+", "suy"));
951
+ var $R37 = $R(new RegExp("[+-]?", "suy"));
952
+ var $R38 = $R(new RegExp("[+-]", "suy"));
953
+ var $R39 = $R(new RegExp("#![^\\r\\n]*", "suy"));
954
+ var $R40 = $R(new RegExp("[\\t ]*", "suy"));
955
+ var $R41 = $R(new RegExp("[\\s]*", "suy"));
956
+ var $R42 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
957
+ var $R43 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
954
958
  var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
955
959
  function Program(state) {
956
960
  if (state.verbose)
@@ -994,7 +998,7 @@ var require_parser = __commonJS({
994
998
  return Arguments$0(state) || Arguments$1(state);
995
999
  }
996
1000
  }
997
- var ArgumentsWithTrailingCallExpressions$0 = $TS($S(TrackIndent, $C($S(Arguments, $Q($S($Y(EOS), Samedent, $N($EXPECT($L0, fail, 'ArgumentsWithTrailingCallExpressions "`"')), CallExpressionRest)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2) {
1001
+ var ArgumentsWithTrailingCallExpressions$0 = $TS($S(TrackIndent, $C($S(Arguments, $Q($S($Y(EOS), Samedent, $N(Backtick), CallExpressionRest)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2) {
998
1002
  if (!$2)
999
1003
  return $skip;
1000
1004
  return $2;
@@ -1080,7 +1084,7 @@ var require_parser = __commonJS({
1080
1084
  return ApplicationStart$0(state) || ApplicationStart$1(state);
1081
1085
  }
1082
1086
  }
1083
- var IndentedApplicationAllowed$0 = $TV($EXPECT($L1, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
1087
+ var IndentedApplicationAllowed$0 = $TV($EXPECT($L0, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
1084
1088
  if (module2.suppressIndentedApplication)
1085
1089
  return $skip;
1086
1090
  return;
@@ -1158,7 +1162,7 @@ var require_parser = __commonJS({
1158
1162
  return UpdateExpression$0(state) || UpdateExpression$1(state);
1159
1163
  }
1160
1164
  }
1161
- var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L2, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L3, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
1165
+ var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L1, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L2, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
1162
1166
  return { $loc, token: $1 };
1163
1167
  });
1164
1168
  function UpdateExpressionSymbol(state) {
@@ -1238,7 +1242,7 @@ var require_parser = __commonJS({
1238
1242
  return ArrowFunction$0(state) || ArrowFunction$1(state);
1239
1243
  }
1240
1244
  }
1241
- var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1245
+ var FatArrow$0 = $TS($S(__, $EXPECT($L3, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1242
1246
  var ws = $1;
1243
1247
  if (!ws.length)
1244
1248
  return " =>";
@@ -1344,10 +1348,10 @@ var require_parser = __commonJS({
1344
1348
  return ClassHeritage$0(state);
1345
1349
  }
1346
1350
  }
1347
- var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1351
+ var ExtendsToken$0 = $TV($EXPECT($L4, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1348
1352
  return { $loc, token: "extends" };
1349
1353
  });
1350
- var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1354
+ var ExtendsToken$1 = $TV($EXPECT($L5, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1351
1355
  return { $loc, token: $1 };
1352
1356
  });
1353
1357
  function ExtendsToken(state) {
@@ -1417,11 +1421,11 @@ var require_parser = __commonJS({
1417
1421
  return FieldDefinition$0(state) || FieldDefinition$1(state);
1418
1422
  }
1419
1423
  }
1420
- var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1424
+ var This$0 = $TV($EXPECT($L6, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1421
1425
  return { $loc, token: $1 };
1422
1426
  });
1423
- var This$1 = $S(AtAccessor, $S($E($EXPECT($L8, fail, 'This "#"')), IdentifierName));
1424
- var This$2 = $TV($EXPECT($L9, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1427
+ var This$1 = $S(AtAccessor, $S($E($EXPECT($L7, fail, 'This "#"')), IdentifierName));
1428
+ var This$2 = $TV($EXPECT($L8, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1425
1429
  return { $loc, token: "this" };
1426
1430
  });
1427
1431
  function This(state) {
@@ -1431,7 +1435,7 @@ var require_parser = __commonJS({
1431
1435
  return This$0(state) || This$1(state) || This$2(state);
1432
1436
  }
1433
1437
  }
1434
- var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1438
+ var AtAccessor$0 = $TV($EXPECT($L8, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1435
1439
  return { $loc, token: "this." };
1436
1440
  });
1437
1441
  function AtAccessor(state) {
@@ -1462,8 +1466,8 @@ var require_parser = __commonJS({
1462
1466
  return NewExpression$0(state);
1463
1467
  }
1464
1468
  }
1465
- var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1466
- var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1469
+ var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1470
+ var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1467
1471
  var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
1468
1472
  if ($2.length)
1469
1473
  return $0;
@@ -1496,7 +1500,7 @@ var require_parser = __commonJS({
1496
1500
  return OptionalShorthand$0(state);
1497
1501
  }
1498
1502
  }
1499
- var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
1503
+ var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
1500
1504
  return { "ts": true, "children": value };
1501
1505
  });
1502
1506
  function NonNullAssertion(state) {
@@ -1508,7 +1512,7 @@ var require_parser = __commonJS({
1508
1512
  return NonNullAssertion$0(state);
1509
1513
  }
1510
1514
  }
1511
- var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
1515
+ var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
1512
1516
  function AdditionalReservedWords(state) {
1513
1517
  if (state.verbose)
1514
1518
  console.log("ENTER:", "AdditionalReservedWords");
@@ -1534,7 +1538,7 @@ var require_parser = __commonJS({
1534
1538
  }
1535
1539
  var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
1536
1540
  var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
1537
- var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1541
+ var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L12, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1538
1542
  var id = $3;
1539
1543
  if (id)
1540
1544
  return [".prototype.", id];
@@ -1558,7 +1562,7 @@ var require_parser = __commonJS({
1558
1562
  return PropertyAccess$0(state);
1559
1563
  }
1560
1564
  }
1561
- var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1565
+ var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1562
1566
  function SuperProperty(state) {
1563
1567
  if (state.verbose)
1564
1568
  console.log("ENTER:", "SuperProperty");
@@ -1569,7 +1573,7 @@ var require_parser = __commonJS({
1569
1573
  }
1570
1574
  }
1571
1575
  var MetaProperty$0 = $S(New, Dot, Target);
1572
- var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1576
+ var MetaProperty$1 = $TV($EXPECT($L14, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1573
1577
  return { $loc, token: $1 };
1574
1578
  });
1575
1579
  function MetaProperty(state) {
@@ -1580,7 +1584,7 @@ var require_parser = __commonJS({
1580
1584
  }
1581
1585
  }
1582
1586
  var Parameters$0 = NonEmptyParameters;
1583
- var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
1587
+ var Parameters$1 = $TV($EXPECT($L0, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
1584
1588
  return { $loc, token: "()" };
1585
1589
  });
1586
1590
  function Parameters(state) {
@@ -1621,7 +1625,7 @@ var require_parser = __commonJS({
1621
1625
  }
1622
1626
  }
1623
1627
  var ParameterElementDelimiter$0 = $S($Q(_), Comma);
1624
- var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
1628
+ var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
1625
1629
  var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1626
1630
  return { $loc, token: "," };
1627
1631
  });
@@ -1840,7 +1844,7 @@ var require_parser = __commonJS({
1840
1844
  return ThinArrowFunction$0(state);
1841
1845
  }
1842
1846
  }
1843
- var Arrow$0 = $TV($EXPECT($L17, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1847
+ var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1844
1848
  return { $loc, token: $1 };
1845
1849
  });
1846
1850
  function Arrow(state) {
@@ -1964,7 +1968,7 @@ var require_parser = __commonJS({
1964
1968
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1965
1969
  }
1966
1970
  }
1967
- var NullLiteral$0 = $TV($EXPECT($L18, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1971
+ var NullLiteral$0 = $TV($EXPECT($L17, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1968
1972
  return { $loc, token: $1 };
1969
1973
  });
1970
1974
  function NullLiteral(state) {
@@ -1977,7 +1981,7 @@ var require_parser = __commonJS({
1977
1981
  }
1978
1982
  }
1979
1983
  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) {
1984
+ var BooleanLiteral$1 = $TV($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1981
1985
  return { $loc, token: $1 };
1982
1986
  });
1983
1987
  function BooleanLiteral(state) {
@@ -1987,10 +1991,10 @@ var require_parser = __commonJS({
1987
1991
  return BooleanLiteral$0(state) || BooleanLiteral$1(state);
1988
1992
  }
1989
1993
  }
1990
- var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
1994
+ var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
1991
1995
  return { $loc, token: "true" };
1992
1996
  });
1993
- var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
1997
+ var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
1994
1998
  return { $loc, token: "false" };
1995
1999
  });
1996
2000
  function CoffeeScriptBooleanLiteral(state) {
@@ -2000,7 +2004,7 @@ var require_parser = __commonJS({
2000
2004
  return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
2001
2005
  }
2002
2006
  }
2003
- var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
2007
+ var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
2004
2008
  return { $loc, token: $1 };
2005
2009
  });
2006
2010
  function Comma(state) {
@@ -2085,7 +2089,7 @@ var require_parser = __commonJS({
2085
2089
  }
2086
2090
  }
2087
2091
  var ArrayElementDelimiter$0 = $S($Q(_), Comma);
2088
- var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
2092
+ var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
2089
2093
  var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
2090
2094
  return { $loc, token: "," };
2091
2095
  });
@@ -2183,7 +2187,7 @@ var require_parser = __commonJS({
2183
2187
  }
2184
2188
  }
2185
2189
  var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
2186
- var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
2190
+ var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
2187
2191
  var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
2188
2192
  return { $loc, token: "," };
2189
2193
  });
@@ -2218,7 +2222,7 @@ var require_parser = __commonJS({
2218
2222
  var PropertyName$0 = NumericLiteral;
2219
2223
  var PropertyName$1 = StringLiteral;
2220
2224
  var PropertyName$2 = IdentifierName;
2221
- var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
2225
+ var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
2222
2226
  function PropertyName(state) {
2223
2227
  if (state.tokenize) {
2224
2228
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -2293,7 +2297,7 @@ var require_parser = __commonJS({
2293
2297
  return ClassElementName$0(state) || ClassElementName$1(state);
2294
2298
  }
2295
2299
  }
2296
- var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
2300
+ var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L7, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
2297
2301
  return {
2298
2302
  $loc,
2299
2303
  token: $1
@@ -2320,25 +2324,25 @@ var require_parser = __commonJS({
2320
2324
  return AssignmentOp$0(state);
2321
2325
  }
2322
2326
  }
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) {
2327
+ var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
2328
+ var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
2329
+ var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
2330
+ var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
2331
+ var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
2332
+ var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
2333
+ var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
2334
+ var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
2335
+ var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
2336
+ var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
2337
+ var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
2338
+ var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
2339
+ var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
2340
+ var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
2341
+ var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
2342
+ var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
2339
2343
  return "??=";
2340
2344
  });
2341
- var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
2345
+ var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
2342
2346
  function AssignmentOpSymbol(state) {
2343
2347
  if (state.tokenize) {
2344
2348
  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));
@@ -2358,52 +2362,52 @@ var require_parser = __commonJS({
2358
2362
  return BinaryOp$0(state);
2359
2363
  }
2360
2364
  }
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 "<<"');
2370
- var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
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) {
2365
+ var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
2366
+ var BinaryOpSymbol$1 = $EXPECT($L45, fail, 'BinaryOpSymbol "*"');
2367
+ var BinaryOpSymbol$2 = $EXPECT($L46, fail, 'BinaryOpSymbol "/"');
2368
+ var BinaryOpSymbol$3 = $EXPECT($L47, fail, 'BinaryOpSymbol "%"');
2369
+ var BinaryOpSymbol$4 = $EXPECT($L48, fail, 'BinaryOpSymbol "+"');
2370
+ var BinaryOpSymbol$5 = $EXPECT($L49, fail, 'BinaryOpSymbol "-"');
2371
+ var BinaryOpSymbol$6 = $EXPECT($L50, fail, 'BinaryOpSymbol "<="');
2372
+ var BinaryOpSymbol$7 = $EXPECT($L51, fail, 'BinaryOpSymbol ">="');
2373
+ var BinaryOpSymbol$8 = $EXPECT($L52, fail, 'BinaryOpSymbol "<<"');
2374
+ var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
2375
+ var BinaryOpSymbol$10 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>>"');
2376
+ var BinaryOpSymbol$11 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>"');
2377
+ var BinaryOpSymbol$12 = $EXPECT($L55, fail, 'BinaryOpSymbol ">"');
2378
+ var BinaryOpSymbol$13 = $EXPECT($L56, fail, 'BinaryOpSymbol "!=="');
2379
+ var BinaryOpSymbol$14 = $TV($EXPECT($L57, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2376
2380
  if (module2.config.coffeeEq)
2377
2381
  return "!==";
2378
2382
  return $1;
2379
2383
  });
2380
- var BinaryOpSymbol$15 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2384
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L58, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2381
2385
  return "===";
2382
2386
  });
2383
- var BinaryOpSymbol$16 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
2384
- var BinaryOpSymbol$17 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2387
+ var BinaryOpSymbol$16 = $EXPECT($L59, fail, 'BinaryOpSymbol "==="');
2388
+ var BinaryOpSymbol$17 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2385
2389
  if (module2.config.coffeeEq)
2386
2390
  return "===";
2387
2391
  return $1;
2388
2392
  });
2389
- var BinaryOpSymbol$18 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2393
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2390
2394
  return "&&";
2391
2395
  });
2392
- var BinaryOpSymbol$19 = $EXPECT($L63, fail, 'BinaryOpSymbol "&&"');
2393
- var BinaryOpSymbol$20 = $T($S($EXPECT($L64, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2396
+ var BinaryOpSymbol$19 = $EXPECT($L62, fail, 'BinaryOpSymbol "&&"');
2397
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L63, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2394
2398
  return "||";
2395
2399
  });
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) {
2400
+ var BinaryOpSymbol$21 = $EXPECT($L64, fail, 'BinaryOpSymbol "||"');
2401
+ var BinaryOpSymbol$22 = $EXPECT($L65, fail, 'BinaryOpSymbol "??"');
2402
+ var BinaryOpSymbol$23 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2399
2403
  return $1;
2400
2404
  });
2401
- var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2405
+ var BinaryOpSymbol$24 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2402
2406
  return $1;
2403
2407
  });
2404
- var BinaryOpSymbol$25 = $EXPECT($L69, fail, 'BinaryOpSymbol "&"');
2405
- var BinaryOpSymbol$26 = $EXPECT($L70, fail, 'BinaryOpSymbol "^"');
2406
- var BinaryOpSymbol$27 = $EXPECT($L71, fail, 'BinaryOpSymbol "|"');
2408
+ var BinaryOpSymbol$25 = $EXPECT($L68, fail, 'BinaryOpSymbol "&"');
2409
+ var BinaryOpSymbol$26 = $EXPECT($L69, fail, 'BinaryOpSymbol "^"');
2410
+ var BinaryOpSymbol$27 = $EXPECT($L70, fail, 'BinaryOpSymbol "|"');
2407
2411
  function BinaryOpSymbol(state) {
2408
2412
  if (state.tokenize) {
2409
2413
  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));
@@ -2411,8 +2415,10 @@ var require_parser = __commonJS({
2411
2415
  return 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);
2412
2416
  }
2413
2417
  }
2414
- var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2415
- var UnaryOp$1 = $S($C($EXPECT($L72, fail, 'UnaryOp "delete"'), $EXPECT($L73, fail, 'UnaryOp "void"'), $EXPECT($L74, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2418
+ var UnaryOp$0 = $TR($EXPECT($R2, fail, "UnaryOp /[!~+-]/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2419
+ return { $loc, token: $0 };
2420
+ });
2421
+ var UnaryOp$1 = $S($C(Delete, Void, Typeof), __);
2416
2422
  function UnaryOp(state) {
2417
2423
  if (state.tokenize) {
2418
2424
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2491,7 +2497,7 @@ var require_parser = __commonJS({
2491
2497
  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);
2492
2498
  }
2493
2499
  }
2494
- var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
2500
+ var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L71, fail, 'EmptyStatement ";"'))), function(value) {
2495
2501
  return { "type": "EmptyStatement", "children": value[0] };
2496
2502
  });
2497
2503
  function EmptyStatement(state) {
@@ -2550,14 +2556,11 @@ var require_parser = __commonJS({
2550
2556
  var IterationStatement$3 = $T($S(ForStatement), function(value) {
2551
2557
  return { "type": "IterationStatement", "children": value };
2552
2558
  });
2553
- var IterationStatement$4 = $T($S(ForInOfStatement), function(value) {
2554
- return { "type": "IterationStatement", "children": value };
2555
- });
2556
2559
  function IterationStatement(state) {
2557
2560
  if (state.tokenize) {
2558
- return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state));
2561
+ return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state));
2559
2562
  } else {
2560
- return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2563
+ return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state);
2561
2564
  }
2562
2565
  }
2563
2566
  var LoopStatement$0 = $T($S(Loop, Block), function(value) {
@@ -2572,7 +2575,7 @@ var require_parser = __commonJS({
2572
2575
  return LoopStatement$0(state);
2573
2576
  }
2574
2577
  }
2575
- var DoWhileStatement$0 = $T($S($EXPECT($L76, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
2578
+ var DoWhileStatement$0 = $T($S($EXPECT($L72, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
2576
2579
  return { "type": "IterationStatement", "children": value };
2577
2580
  });
2578
2581
  function DoWhileStatement(state) {
@@ -2596,7 +2599,7 @@ var require_parser = __commonJS({
2596
2599
  return WhileStatement$0(state);
2597
2600
  }
2598
2601
  }
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) {
2602
+ var WhileClause$0 = $TS($S($C($EXPECT($L73, fail, 'WhileClause "while"'), $EXPECT($L74, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2600
2603
  var kind = $1;
2601
2604
  var cond = $3;
2602
2605
  if (kind === "until") {
@@ -2615,7 +2618,7 @@ var require_parser = __commonJS({
2615
2618
  return WhileClause$0(state);
2616
2619
  }
2617
2620
  }
2618
- var ForStatement$0 = $S(For, __, OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), CloseParen, Block);
2621
+ var ForStatement$0 = $S(For, __, ForStatementControl, Block);
2619
2622
  function ForStatement(state) {
2620
2623
  if (state.verbose)
2621
2624
  console.log("ENTER:", "ForStatement");
@@ -2625,25 +2628,36 @@ var require_parser = __commonJS({
2625
2628
  return ForStatement$0(state);
2626
2629
  }
2627
2630
  }
2628
- var ForInOfStatement$0 = $S(For, __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, Expression, __, CloseParen, Block);
2629
- var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, Expression, InsertCloseParen, Block);
2630
- var ForInOfStatement$2 = $S(For, $E($S(__, Await)), __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, __, CloseParen, Block);
2631
- var ForInOfStatement$3 = $S(For, $E($S(__, Await)), __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, InsertCloseParen, Block);
2632
- function ForInOfStatement(state) {
2631
+ var ForStatementControl$0 = $S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen);
2632
+ var ForStatementControl$1 = $S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), Expression)), InsertCloseParen);
2633
+ var ForStatementControl$2 = $S(OpenParen, __, ForInOfDeclaration, __, In, Expression, __, CloseParen);
2634
+ var ForStatementControl$3 = $S(InsertOpenParen, ForInOfDeclaration, __, In, Expression, InsertCloseParen);
2635
+ var ForStatementControl$4 = $S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, Of, AssignmentExpression, __, CloseParen);
2636
+ var ForStatementControl$5 = $S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, Of, AssignmentExpression, InsertCloseParen);
2637
+ function ForStatementControl(state) {
2638
+ if (state.tokenize) {
2639
+ return $TOKEN("ForStatementControl", state, ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state) || ForStatementControl$4(state) || ForStatementControl$5(state));
2640
+ } else {
2641
+ return ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state) || ForStatementControl$4(state) || ForStatementControl$5(state);
2642
+ }
2643
+ }
2644
+ var ForInOfDeclaration$0 = $S(Var, ForBinding);
2645
+ var ForInOfDeclaration$1 = ForDeclaration;
2646
+ var ForInOfDeclaration$2 = LeftHandSideExpression;
2647
+ function ForInOfDeclaration(state) {
2633
2648
  if (state.tokenize) {
2634
- return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
2649
+ return $TOKEN("ForInOfDeclaration", state, ForInOfDeclaration$0(state) || ForInOfDeclaration$1(state) || ForInOfDeclaration$2(state));
2635
2650
  } else {
2636
- return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2651
+ return ForInOfDeclaration$0(state) || ForInOfDeclaration$1(state) || ForInOfDeclaration$2(state);
2637
2652
  }
2638
2653
  }
2639
- var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
2654
+ var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, ForBinding);
2655
+ var ForDeclaration$1 = $S(InsertConst, ForBinding, $R$0($EXPECT($R3, fail, "ForDeclaration /(?=[\\s\\)])/")));
2640
2656
  function ForDeclaration(state) {
2641
- if (state.verbose)
2642
- console.log("ENTER:", "ForDeclaration");
2643
2657
  if (state.tokenize) {
2644
- return $TOKEN("ForDeclaration", state, ForDeclaration$0(state));
2658
+ return $TOKEN("ForDeclaration", state, ForDeclaration$0(state) || ForDeclaration$1(state));
2645
2659
  } else {
2646
- return ForDeclaration$0(state);
2660
+ return ForDeclaration$0(state) || ForDeclaration$1(state);
2647
2661
  }
2648
2662
  }
2649
2663
  var ForBinding$0 = BindingIdentifier;
@@ -2767,7 +2781,7 @@ var require_parser = __commonJS({
2767
2781
  return CaseExpressionList$0(state);
2768
2782
  }
2769
2783
  }
2770
- var NoExpressions$0 = $T($EXPECT($L1, fail, 'NoExpressions ""'), function(value) {
2784
+ var NoExpressions$0 = $T($EXPECT($L0, fail, 'NoExpressions ""'), function(value) {
2771
2785
  return [];
2772
2786
  });
2773
2787
  function NoExpressions(state) {
@@ -2780,7 +2794,7 @@ var require_parser = __commonJS({
2780
2794
  }
2781
2795
  }
2782
2796
  var ImpliedColon$0 = $S(__, Colon);
2783
- var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
2797
+ var ImpliedColon$1 = $TV($EXPECT($L0, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
2784
2798
  return { $loc, token: ":" };
2785
2799
  });
2786
2800
  function ImpliedColon(state) {
@@ -2834,7 +2848,7 @@ var require_parser = __commonJS({
2834
2848
  return CatchBind$0(state) || CatchBind$1(state);
2835
2849
  }
2836
2850
  }
2837
- var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
2851
+ var Finally$0 = $S(__, $EXPECT($L75, fail, 'Finally "finally"'), BracedBlock);
2838
2852
  function Finally(state) {
2839
2853
  if (state.verbose)
2840
2854
  console.log("ENTER:", "Finally");
@@ -2878,7 +2892,7 @@ var require_parser = __commonJS({
2878
2892
  return ExpressionWithIndentedApplicationSuppressed$0(state);
2879
2893
  }
2880
2894
  }
2881
- var SuppressIndentedApplication$0 = $TV($EXPECT($L1, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
2895
+ var SuppressIndentedApplication$0 = $TV($EXPECT($L0, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
2882
2896
  module2.suppressIndentedApplication = true;
2883
2897
  });
2884
2898
  function SuppressIndentedApplication(state) {
@@ -2900,13 +2914,13 @@ var require_parser = __commonJS({
2900
2914
  return ExpressionStatement$0(state);
2901
2915
  }
2902
2916
  }
2903
- var KeywordStatement$0 = $T($S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
2917
+ var KeywordStatement$0 = $T($S($EXPECT($L76, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
2904
2918
  return { "type": "BreakStatement", "children": value };
2905
2919
  });
2906
- var KeywordStatement$1 = $T($S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
2920
+ var KeywordStatement$1 = $T($S($EXPECT($L77, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
2907
2921
  return { "type": "ContinueStatement", "children": value };
2908
2922
  });
2909
- var KeywordStatement$2 = $T($S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
2923
+ var KeywordStatement$2 = $T($S($EXPECT($L78, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
2910
2924
  return { "type": "DebuggerStatement", "children": value };
2911
2925
  });
2912
2926
  var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
@@ -2931,7 +2945,7 @@ var require_parser = __commonJS({
2931
2945
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2932
2946
  }
2933
2947
  }
2934
- var ImportDeclaration$0 = $T($S($EXPECT($L83, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2948
+ var ImportDeclaration$0 = $T($S($EXPECT($L79, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2935
2949
  return { "ts": true, "children": value };
2936
2950
  });
2937
2951
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2954,7 +2968,7 @@ var require_parser = __commonJS({
2954
2968
  return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
2955
2969
  }
2956
2970
  }
2957
- var ImpliedImport$0 = $TV($EXPECT($L1, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
2971
+ var ImpliedImport$0 = $TV($EXPECT($L0, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
2958
2972
  return { $loc, token: "import " };
2959
2973
  });
2960
2974
  function ImpliedImport(state) {
@@ -3046,7 +3060,7 @@ var require_parser = __commonJS({
3046
3060
  return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
3047
3061
  }
3048
3062
  }
3049
- var UnquotedSpecifier$0 = $TV($EXPECT($R3, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
3063
+ var UnquotedSpecifier$0 = $TV($EXPECT($R4, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
3050
3064
  var spec = $0;
3051
3065
  return { $loc, token: `"${spec}"` };
3052
3066
  });
@@ -3069,7 +3083,7 @@ var require_parser = __commonJS({
3069
3083
  return ImportedBinding$0(state);
3070
3084
  }
3071
3085
  }
3072
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
3086
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L80, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
3073
3087
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
3074
3088
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
3075
3089
  function ExportDeclaration(state) {
@@ -3151,7 +3165,7 @@ var require_parser = __commonJS({
3151
3165
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
3152
3166
  }
3153
3167
  }
3154
- var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
3168
+ var ConstAssignment$0 = $TV($EXPECT($L81, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
3155
3169
  return { $loc, token: "=" };
3156
3170
  });
3157
3171
  function ConstAssignment(state) {
@@ -3204,8 +3218,8 @@ var require_parser = __commonJS({
3204
3218
  return VariableDeclarationList$0(state);
3205
3219
  }
3206
3220
  }
3207
- var VariableDeclaration$0 = $S(BindingPattern, Initializer);
3208
- var VariableDeclaration$1 = $S(BindingIdentifier, $E(Initializer));
3221
+ var VariableDeclaration$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
3222
+ var VariableDeclaration$1 = $S(BindingIdentifier, $E(TypeSuffix), $E(Initializer));
3209
3223
  function VariableDeclaration(state) {
3210
3224
  if (state.tokenize) {
3211
3225
  return $TOKEN("VariableDeclaration", state, VariableDeclaration$0(state) || VariableDeclaration$1(state));
@@ -3237,7 +3251,7 @@ var require_parser = __commonJS({
3237
3251
  return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
3238
3252
  }
3239
3253
  }
3240
- var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R4, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
3254
+ var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
3241
3255
  function DecimalBigIntegerLiteral(state) {
3242
3256
  if (state.verbose)
3243
3257
  console.log("ENTER:", "DecimalBigIntegerLiteral");
@@ -3247,11 +3261,11 @@ var require_parser = __commonJS({
3247
3261
  return DecimalBigIntegerLiteral$0(state);
3248
3262
  }
3249
3263
  }
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) {
3264
+ var DecimalLiteral$0 = $TV($TEXT($EXPECT($R6, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
3251
3265
  return $1 + ".";
3252
3266
  });
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)));
3267
+ var DecimalLiteral$1 = $TEXT($S($EXPECT($R7, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?/"), $E(ExponentPart)));
3268
+ var DecimalLiteral$2 = $TEXT($S($EXPECT($R8, fail, "DecimalLiteral /(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
3255
3269
  function DecimalLiteral(state) {
3256
3270
  if (state.tokenize) {
3257
3271
  return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
@@ -3259,7 +3273,7 @@ var require_parser = __commonJS({
3259
3273
  return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
3260
3274
  }
3261
3275
  }
3262
- var ExponentPart$0 = $R$0($EXPECT($R8, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
3276
+ var ExponentPart$0 = $R$0($EXPECT($R9, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
3263
3277
  function ExponentPart(state) {
3264
3278
  if (state.verbose)
3265
3279
  console.log("ENTER:", "ExponentPart");
@@ -3269,7 +3283,7 @@ var require_parser = __commonJS({
3269
3283
  return ExponentPart$0(state);
3270
3284
  }
3271
3285
  }
3272
- var BinaryIntegerLiteral$0 = $R$0($EXPECT($R9, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
3286
+ var BinaryIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
3273
3287
  function BinaryIntegerLiteral(state) {
3274
3288
  if (state.verbose)
3275
3289
  console.log("ENTER:", "BinaryIntegerLiteral");
@@ -3279,7 +3293,7 @@ var require_parser = __commonJS({
3279
3293
  return BinaryIntegerLiteral$0(state);
3280
3294
  }
3281
3295
  }
3282
- var OctalIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
3296
+ var OctalIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
3283
3297
  function OctalIntegerLiteral(state) {
3284
3298
  if (state.verbose)
3285
3299
  console.log("ENTER:", "OctalIntegerLiteral");
@@ -3289,7 +3303,7 @@ var require_parser = __commonJS({
3289
3303
  return OctalIntegerLiteral$0(state);
3290
3304
  }
3291
3305
  }
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?/"));
3306
+ var HexLiteral$0 = $R$0($EXPECT($R12, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
3293
3307
  function HexLiteral(state) {
3294
3308
  if (state.verbose)
3295
3309
  console.log("ENTER:", "HexLiteral");
@@ -3338,7 +3352,7 @@ var require_parser = __commonJS({
3338
3352
  return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
3339
3353
  }
3340
3354
  }
3341
- var DoubleStringCharacters$0 = $TR($EXPECT($R12, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3355
+ var DoubleStringCharacters$0 = $TR($EXPECT($R13, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3342
3356
  return { $loc, token: $0 };
3343
3357
  });
3344
3358
  function DoubleStringCharacters(state) {
@@ -3350,7 +3364,7 @@ var require_parser = __commonJS({
3350
3364
  return DoubleStringCharacters$0(state);
3351
3365
  }
3352
3366
  }
3353
- var SingleStringCharacters$0 = $TR($EXPECT($R13, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3367
+ var SingleStringCharacters$0 = $TR($EXPECT($R14, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3354
3368
  return { $loc, token: $0 };
3355
3369
  });
3356
3370
  function SingleStringCharacters(state) {
@@ -3362,7 +3376,7 @@ var require_parser = __commonJS({
3362
3376
  return SingleStringCharacters$0(state);
3363
3377
  }
3364
3378
  }
3365
- var TripleDoubleStringCharacters$0 = $TR($EXPECT($R14, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3379
+ var TripleDoubleStringCharacters$0 = $TR($EXPECT($R15, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3366
3380
  return { $loc, token: $0 };
3367
3381
  });
3368
3382
  function TripleDoubleStringCharacters(state) {
@@ -3374,7 +3388,7 @@ var require_parser = __commonJS({
3374
3388
  return TripleDoubleStringCharacters$0(state);
3375
3389
  }
3376
3390
  }
3377
- var TripleSingleStringCharacters$0 = $TR($EXPECT($R15, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3391
+ var TripleSingleStringCharacters$0 = $TR($EXPECT($R16, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3378
3392
  return { $loc, token: $0 };
3379
3393
  });
3380
3394
  function TripleSingleStringCharacters(state) {
@@ -3425,7 +3439,7 @@ var require_parser = __commonJS({
3425
3439
  return CoffeeInterpolatedDoubleQuotedString$0(state);
3426
3440
  }
3427
3441
  }
3428
- var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R16, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3442
+ var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R17, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3429
3443
  return { $loc, token: $0 };
3430
3444
  });
3431
3445
  function CoffeeDoubleQuotedStringCharacters(state) {
@@ -3437,7 +3451,7 @@ var require_parser = __commonJS({
3437
3451
  return CoffeeDoubleQuotedStringCharacters$0(state);
3438
3452
  }
3439
3453
  }
3440
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3454
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3441
3455
  return { $loc, token: $1 };
3442
3456
  });
3443
3457
  function RegularExpressionLiteral(state) {
@@ -3449,7 +3463,7 @@ var require_parser = __commonJS({
3449
3463
  return RegularExpressionLiteral$0(state);
3450
3464
  }
3451
3465
  }
3452
- var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R17, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3466
+ var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R18, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3453
3467
  function RegularExpressionBody(state) {
3454
3468
  if (state.verbose)
3455
3469
  console.log("ENTER:", "RegularExpressionBody");
@@ -3459,7 +3473,7 @@ var require_parser = __commonJS({
3459
3473
  return RegularExpressionBody$0(state);
3460
3474
  }
3461
3475
  }
3462
- var RegExpCharacter$0 = $R$0($EXPECT($R18, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3476
+ var RegExpCharacter$0 = $R$0($EXPECT($R19, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3463
3477
  function RegExpCharacter(state) {
3464
3478
  if (state.verbose)
3465
3479
  console.log("ENTER:", "RegExpCharacter");
@@ -3469,7 +3483,7 @@ var require_parser = __commonJS({
3469
3483
  return RegExpCharacter$0(state);
3470
3484
  }
3471
3485
  }
3472
- var RegularExpressionFlags$0 = $R$0($EXPECT($R19, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3486
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R20, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3473
3487
  function RegularExpressionFlags(state) {
3474
3488
  if (state.verbose)
3475
3489
  console.log("ENTER:", "RegularExpressionFlags");
@@ -3482,7 +3496,7 @@ var require_parser = __commonJS({
3482
3496
  var TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
3483
3497
  return module2.dedentBlockSubstitutions($0);
3484
3498
  });
3485
- var TemplateLiteral$1 = $S($EXPECT($L0, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L0, fail, 'TemplateLiteral "`"'));
3499
+ var TemplateLiteral$1 = $S(Backtick, $Q($C(TemplateCharacters, TemplateSubstitution)), Backtick);
3486
3500
  function TemplateLiteral(state) {
3487
3501
  if (state.tokenize) {
3488
3502
  return $TOKEN("TemplateLiteral", state, TemplateLiteral$0(state) || TemplateLiteral$1(state));
@@ -3500,7 +3514,7 @@ var require_parser = __commonJS({
3500
3514
  return TemplateSubstitution$0(state);
3501
3515
  }
3502
3516
  }
3503
- var TemplateCharacters$0 = $TR($EXPECT($R20, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3517
+ var TemplateCharacters$0 = $TR($EXPECT($R21, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3504
3518
  return { $loc, token: $0 };
3505
3519
  });
3506
3520
  function TemplateCharacters(state) {
@@ -3512,7 +3526,7 @@ var require_parser = __commonJS({
3512
3526
  return TemplateCharacters$0(state);
3513
3527
  }
3514
3528
  }
3515
- var TemplateBlockCharacters$0 = $TR($EXPECT($R21, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3529
+ var TemplateBlockCharacters$0 = $TR($EXPECT($R22, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3516
3530
  return { $loc, token: $0 };
3517
3531
  });
3518
3532
  function TemplateBlockCharacters(state) {
@@ -3524,8 +3538,8 @@ var require_parser = __commonJS({
3524
3538
  return TemplateBlockCharacters$0(state);
3525
3539
  }
3526
3540
  }
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})/"));
3541
+ var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R23, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
3542
+ var ReservedWord$1 = $R$0($EXPECT($R24, 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})/"));
3529
3543
  function ReservedWord(state) {
3530
3544
  if (state.tokenize) {
3531
3545
  return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
@@ -3542,7 +3556,7 @@ var require_parser = __commonJS({
3542
3556
  return Comment$0(state) || Comment$1(state);
3543
3557
  }
3544
3558
  }
3545
- var SingleLineComment$0 = $TR($EXPECT($R24, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3559
+ var SingleLineComment$0 = $TR($EXPECT($R25, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3546
3560
  return { $loc, token: $0 };
3547
3561
  });
3548
3562
  var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
@@ -3562,7 +3576,7 @@ var require_parser = __commonJS({
3562
3576
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3563
3577
  }
3564
3578
  }
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) {
3579
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L82, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L83, fail, 'JSMultiLineComment "*/"')), $EXPECT($R26, fail, "JSMultiLineComment /./"))), $EXPECT($L83, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3566
3580
  return { $loc, token: $1 };
3567
3581
  });
3568
3582
  function JSMultiLineComment(state) {
@@ -3574,7 +3588,7 @@ var require_parser = __commonJS({
3574
3588
  return JSMultiLineComment$0(state);
3575
3589
  }
3576
3590
  }
3577
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R26, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3591
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R27, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3578
3592
  return { $loc, token: `//${$1}` };
3579
3593
  });
3580
3594
  function CoffeeSingleLineComment(state) {
@@ -3586,7 +3600,7 @@ var require_parser = __commonJS({
3586
3600
  return CoffeeSingleLineComment$0(state);
3587
3601
  }
3588
3602
  }
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) {
3603
+ var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L84, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L84, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L83, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R26, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L84, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3590
3604
  return { $loc, token: `/*${$2}*/` };
3591
3605
  });
3592
3606
  function CoffeeMultiLineComment(state) {
@@ -3598,7 +3612,7 @@ var require_parser = __commonJS({
3598
3612
  return CoffeeMultiLineComment$0(state);
3599
3613
  }
3600
3614
  }
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) {
3615
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L82, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L83, fail, 'InlineComment "*/"')), $EXPECT($R28, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L83, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3602
3616
  return { $loc, token: $1 };
3603
3617
  });
3604
3618
  function InlineComment(state) {
@@ -3640,7 +3654,7 @@ var require_parser = __commonJS({
3640
3654
  return _$0(state);
3641
3655
  }
3642
3656
  }
3643
- var NonNewlineWhitespace$0 = $TR($EXPECT($R28, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3657
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R29, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3644
3658
  return { $loc, token: $0 };
3645
3659
  });
3646
3660
  function NonNewlineWhitespace(state) {
@@ -3662,7 +3676,7 @@ var require_parser = __commonJS({
3662
3676
  return __$0(state);
3663
3677
  }
3664
3678
  }
3665
- var Whitespace$0 = $TR($EXPECT($R29, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3679
+ var Whitespace$0 = $TR($EXPECT($R30, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3666
3680
  return { $loc, token: $0 };
3667
3681
  });
3668
3682
  function Whitespace(state) {
@@ -3683,7 +3697,7 @@ var require_parser = __commonJS({
3683
3697
  return StatementDelimiter$0(state) || StatementDelimiter$1(state);
3684
3698
  }
3685
3699
  }
3686
- var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3700
+ var NonIdContinue$0 = $R$0($EXPECT($R31, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3687
3701
  function NonIdContinue(state) {
3688
3702
  if (state.verbose)
3689
3703
  console.log("ENTER:", "NonIdContinue");
@@ -3693,7 +3707,7 @@ var require_parser = __commonJS({
3693
3707
  return NonIdContinue$0(state);
3694
3708
  }
3695
3709
  }
3696
- var Loc$0 = $TV($EXPECT($L1, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
3710
+ var Loc$0 = $TV($EXPECT($L0, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
3697
3711
  return { $loc, token: "" };
3698
3712
  });
3699
3713
  function Loc(state) {
@@ -3705,7 +3719,7 @@ var require_parser = __commonJS({
3705
3719
  return Loc$0(state);
3706
3720
  }
3707
3721
  }
3708
- var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3722
+ var As$0 = $TS($S($EXPECT($L85, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3709
3723
  return { $loc, token: $1 };
3710
3724
  });
3711
3725
  function As(state) {
@@ -3717,7 +3731,7 @@ var require_parser = __commonJS({
3717
3731
  return As$0(state);
3718
3732
  }
3719
3733
  }
3720
- var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3734
+ var Async$0 = $TV($EXPECT($L86, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3721
3735
  return { $loc, token: $1 };
3722
3736
  });
3723
3737
  function Async(state) {
@@ -3729,7 +3743,7 @@ var require_parser = __commonJS({
3729
3743
  return Async$0(state);
3730
3744
  }
3731
3745
  }
3732
- var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3746
+ var Await$0 = $TS($S($EXPECT($L87, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3733
3747
  return { $loc, token: $1 };
3734
3748
  });
3735
3749
  function Await(state) {
@@ -3741,7 +3755,19 @@ var require_parser = __commonJS({
3741
3755
  return Await$0(state);
3742
3756
  }
3743
3757
  }
3744
- var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3758
+ var Backtick$0 = $TV($EXPECT($L88, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
3759
+ return { $loc, token: $1 };
3760
+ });
3761
+ function Backtick(state) {
3762
+ if (state.verbose)
3763
+ console.log("ENTER:", "Backtick");
3764
+ if (state.tokenize) {
3765
+ return $TOKEN("Backtick", state, Backtick$0(state));
3766
+ } else {
3767
+ return Backtick$0(state);
3768
+ }
3769
+ }
3770
+ var Case$0 = $TS($S($EXPECT($L89, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3745
3771
  return { $loc, token: $1 };
3746
3772
  });
3747
3773
  function Case(state) {
@@ -3753,7 +3779,7 @@ var require_parser = __commonJS({
3753
3779
  return Case$0(state);
3754
3780
  }
3755
3781
  }
3756
- var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3782
+ var Catch$0 = $TV($EXPECT($L90, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3757
3783
  return { $loc, token: $1 };
3758
3784
  });
3759
3785
  function Catch(state) {
@@ -3765,7 +3791,7 @@ var require_parser = __commonJS({
3765
3791
  return Catch$0(state);
3766
3792
  }
3767
3793
  }
3768
- var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3794
+ var Class$0 = $TV($EXPECT($L91, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3769
3795
  return { $loc, token: $1 };
3770
3796
  });
3771
3797
  function Class(state) {
@@ -3777,7 +3803,7 @@ var require_parser = __commonJS({
3777
3803
  return Class$0(state);
3778
3804
  }
3779
3805
  }
3780
- var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3806
+ var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3781
3807
  return { $loc, token: $1 };
3782
3808
  });
3783
3809
  function CloseBrace(state) {
@@ -3789,7 +3815,7 @@ var require_parser = __commonJS({
3789
3815
  return CloseBrace$0(state);
3790
3816
  }
3791
3817
  }
3792
- var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3818
+ var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3793
3819
  return { $loc, token: $1 };
3794
3820
  });
3795
3821
  function CloseBracket(state) {
@@ -3801,7 +3827,7 @@ var require_parser = __commonJS({
3801
3827
  return CloseBracket$0(state);
3802
3828
  }
3803
3829
  }
3804
- var CloseParen$0 = $TV($EXPECT($L16, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3830
+ var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3805
3831
  return { $loc, token: $1 };
3806
3832
  });
3807
3833
  function CloseParen(state) {
@@ -3813,7 +3839,7 @@ var require_parser = __commonJS({
3813
3839
  return CloseParen$0(state);
3814
3840
  }
3815
3841
  }
3816
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3842
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L92, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3817
3843
  return { $loc, token: "${" };
3818
3844
  });
3819
3845
  function CoffeeSubstitutionStart(state) {
@@ -3825,7 +3851,7 @@ var require_parser = __commonJS({
3825
3851
  return CoffeeSubstitutionStart$0(state);
3826
3852
  }
3827
3853
  }
3828
- var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3854
+ var Colon$0 = $TV($EXPECT($L93, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3829
3855
  return { $loc, token: $1 };
3830
3856
  });
3831
3857
  function Colon(state) {
@@ -3837,7 +3863,7 @@ var require_parser = __commonJS({
3837
3863
  return Colon$0(state);
3838
3864
  }
3839
3865
  }
3840
- var ConstructorShorthand$0 = $TV($EXPECT($L9, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
3866
+ var ConstructorShorthand$0 = $TV($EXPECT($L8, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
3841
3867
  return { $loc, token: "constructor" };
3842
3868
  });
3843
3869
  function ConstructorShorthand(state) {
@@ -3849,7 +3875,7 @@ var require_parser = __commonJS({
3849
3875
  return ConstructorShorthand$0(state);
3850
3876
  }
3851
3877
  }
3852
- var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3878
+ var Default$0 = $TS($S($EXPECT($L80, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3853
3879
  return { $loc, token: $1 };
3854
3880
  });
3855
3881
  function Default(state) {
@@ -3861,7 +3887,19 @@ var require_parser = __commonJS({
3861
3887
  return Default$0(state);
3862
3888
  }
3863
3889
  }
3864
- var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3890
+ var Delete$0 = $TS($S($EXPECT($L94, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3891
+ return { $loc, token: $1 };
3892
+ });
3893
+ function Delete(state) {
3894
+ if (state.verbose)
3895
+ console.log("ENTER:", "Delete");
3896
+ if (state.tokenize) {
3897
+ return $TOKEN("Delete", state, Delete$0(state));
3898
+ } else {
3899
+ return Delete$0(state);
3900
+ }
3901
+ }
3902
+ var Dot$0 = $TV($EXPECT($L95, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3865
3903
  return { $loc, token: $1 };
3866
3904
  });
3867
3905
  function Dot(state) {
@@ -3873,7 +3911,7 @@ var require_parser = __commonJS({
3873
3911
  return Dot$0(state);
3874
3912
  }
3875
3913
  }
3876
- var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
3914
+ var DotDotDot$0 = $TV($EXPECT($L96, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
3877
3915
  return { $loc, token: $1 };
3878
3916
  });
3879
3917
  function DotDotDot(state) {
@@ -3885,7 +3923,7 @@ var require_parser = __commonJS({
3885
3923
  return DotDotDot$0(state);
3886
3924
  }
3887
3925
  }
3888
- var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3926
+ var DoubleQuote$0 = $TV($EXPECT($L97, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3889
3927
  return { $loc, token: $1 };
3890
3928
  });
3891
3929
  function DoubleQuote(state) {
@@ -3897,7 +3935,7 @@ var require_parser = __commonJS({
3897
3935
  return DoubleQuote$0(state);
3898
3936
  }
3899
3937
  }
3900
- var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3938
+ var Else$0 = $TV($EXPECT($L98, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3901
3939
  return { $loc, token: $1 };
3902
3940
  });
3903
3941
  function Else(state) {
@@ -3909,7 +3947,7 @@ var require_parser = __commonJS({
3909
3947
  return Else$0(state);
3910
3948
  }
3911
3949
  }
3912
- var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3950
+ var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3913
3951
  return { $loc, token: $1 };
3914
3952
  });
3915
3953
  function Equals(state) {
@@ -3921,7 +3959,7 @@ var require_parser = __commonJS({
3921
3959
  return Equals$0(state);
3922
3960
  }
3923
3961
  }
3924
- var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3962
+ var Export$0 = $TS($S($EXPECT($L99, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3925
3963
  return { $loc, token: $1 };
3926
3964
  });
3927
3965
  function Export(state) {
@@ -3933,7 +3971,7 @@ var require_parser = __commonJS({
3933
3971
  return Export$0(state);
3934
3972
  }
3935
3973
  }
3936
- var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3974
+ var For$0 = $TS($S($EXPECT($L100, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3937
3975
  return { $loc, token: $1 };
3938
3976
  });
3939
3977
  function For(state) {
@@ -3945,7 +3983,7 @@ var require_parser = __commonJS({
3945
3983
  return For$0(state);
3946
3984
  }
3947
3985
  }
3948
- var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3986
+ var From$0 = $TS($S($EXPECT($L101, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3949
3987
  return { $loc, token: $1 };
3950
3988
  });
3951
3989
  function From(state) {
@@ -3957,7 +3995,7 @@ var require_parser = __commonJS({
3957
3995
  return From$0(state);
3958
3996
  }
3959
3997
  }
3960
- var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3998
+ var Function$0 = $TV($EXPECT($L102, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3961
3999
  return { $loc, token: $1 };
3962
4000
  });
3963
4001
  function Function(state) {
@@ -3969,7 +4007,7 @@ var require_parser = __commonJS({
3969
4007
  return Function$0(state);
3970
4008
  }
3971
4009
  }
3972
- var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4010
+ var GetOrSet$0 = $TS($S($C($EXPECT($L103, fail, 'GetOrSet "get"'), $EXPECT($L104, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3973
4011
  return { $loc, token: $1 };
3974
4012
  });
3975
4013
  function GetOrSet(state) {
@@ -3981,7 +4019,7 @@ var require_parser = __commonJS({
3981
4019
  return GetOrSet$0(state);
3982
4020
  }
3983
4021
  }
3984
- var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
4022
+ var If$0 = $TV($EXPECT($L105, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3985
4023
  return { $loc, token: $1 };
3986
4024
  });
3987
4025
  function If(state) {
@@ -3993,7 +4031,7 @@ var require_parser = __commonJS({
3993
4031
  return If$0(state);
3994
4032
  }
3995
4033
  }
3996
- var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
4034
+ var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R32, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3997
4035
  return { $loc, token: $1 };
3998
4036
  });
3999
4037
  function Import(state) {
@@ -4005,7 +4043,7 @@ var require_parser = __commonJS({
4005
4043
  return Import$0(state);
4006
4044
  }
4007
4045
  }
4008
- var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
4046
+ var In$0 = $TV($EXPECT($L67, fail, 'In "in"'), function($skip, $loc, $0, $1) {
4009
4047
  return { $loc, token: $1 };
4010
4048
  });
4011
4049
  function In(state) {
@@ -4017,7 +4055,7 @@ var require_parser = __commonJS({
4017
4055
  return In$0(state);
4018
4056
  }
4019
4057
  }
4020
- var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
4058
+ var LetOrConst$0 = $TV($C($EXPECT($L106, fail, 'LetOrConst "let"'), $EXPECT($L107, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
4021
4059
  return { $loc, token: $1 };
4022
4060
  });
4023
4061
  function LetOrConst(state) {
@@ -4029,7 +4067,7 @@ var require_parser = __commonJS({
4029
4067
  return LetOrConst$0(state);
4030
4068
  }
4031
4069
  }
4032
- var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4070
+ var Loop$0 = $TS($S($EXPECT($L108, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4033
4071
  return { $loc, token: "while(true)" };
4034
4072
  });
4035
4073
  function Loop(state) {
@@ -4041,7 +4079,7 @@ var require_parser = __commonJS({
4041
4079
  return Loop$0(state);
4042
4080
  }
4043
4081
  }
4044
- var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
4082
+ var New$0 = $TV($EXPECT($L109, fail, 'New "new"'), function($skip, $loc, $0, $1) {
4045
4083
  return { $loc, token: $1 };
4046
4084
  });
4047
4085
  function New(state) {
@@ -4053,7 +4091,7 @@ var require_parser = __commonJS({
4053
4091
  return New$0(state);
4054
4092
  }
4055
4093
  }
4056
- var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
4094
+ var Of$0 = $TV($EXPECT($L110, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
4057
4095
  return { $loc, token: $1 };
4058
4096
  });
4059
4097
  function Of(state) {
@@ -4065,7 +4103,7 @@ var require_parser = __commonJS({
4065
4103
  return Of$0(state);
4066
4104
  }
4067
4105
  }
4068
- var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
4106
+ var OpenBrace$0 = $TV($EXPECT($L111, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
4069
4107
  return { $loc, token: $1 };
4070
4108
  });
4071
4109
  function OpenBrace(state) {
@@ -4077,7 +4115,7 @@ var require_parser = __commonJS({
4077
4115
  return OpenBrace$0(state);
4078
4116
  }
4079
4117
  }
4080
- var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
4118
+ var OpenBracket$0 = $TV($EXPECT($L112, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
4081
4119
  return { $loc, token: $1 };
4082
4120
  });
4083
4121
  function OpenBracket(state) {
@@ -4089,7 +4127,7 @@ var require_parser = __commonJS({
4089
4127
  return OpenBracket$0(state);
4090
4128
  }
4091
4129
  }
4092
- var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4130
+ var OpenParen$0 = $TV($EXPECT($L113, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4093
4131
  return { $loc, token: $1 };
4094
4132
  });
4095
4133
  function OpenParen(state) {
@@ -4101,7 +4139,7 @@ var require_parser = __commonJS({
4101
4139
  return OpenParen$0(state);
4102
4140
  }
4103
4141
  }
4104
- var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4142
+ var QuestionMark$0 = $TV($EXPECT($L114, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4105
4143
  return { $loc, token: $1 };
4106
4144
  });
4107
4145
  function QuestionMark(state) {
@@ -4113,7 +4151,7 @@ var require_parser = __commonJS({
4113
4151
  return QuestionMark$0(state);
4114
4152
  }
4115
4153
  }
4116
- var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4154
+ var Return$0 = $TS($S($EXPECT($L115, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4117
4155
  return { $loc, token: $1 };
4118
4156
  });
4119
4157
  function Return(state) {
@@ -4125,7 +4163,7 @@ var require_parser = __commonJS({
4125
4163
  return Return$0(state);
4126
4164
  }
4127
4165
  }
4128
- var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4166
+ var Semicolon$0 = $TV($EXPECT($L71, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4129
4167
  return { $loc, token: $1 };
4130
4168
  });
4131
4169
  function Semicolon(state) {
@@ -4137,7 +4175,7 @@ var require_parser = __commonJS({
4137
4175
  return Semicolon$0(state);
4138
4176
  }
4139
4177
  }
4140
- var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4178
+ var SingleQuote$0 = $TV($EXPECT($L116, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4141
4179
  return { $loc, token: $1 };
4142
4180
  });
4143
4181
  function SingleQuote(state) {
@@ -4149,7 +4187,7 @@ var require_parser = __commonJS({
4149
4187
  return SingleQuote$0(state);
4150
4188
  }
4151
4189
  }
4152
- var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4190
+ var Star$0 = $TV($EXPECT($L45, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4153
4191
  return { $loc, token: $1 };
4154
4192
  });
4155
4193
  function Star(state) {
@@ -4161,10 +4199,10 @@ var require_parser = __commonJS({
4161
4199
  return Star$0(state);
4162
4200
  }
4163
4201
  }
4164
- var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4202
+ var Static$0 = $TV($EXPECT($L117, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4165
4203
  return { $loc, token: $1 };
4166
4204
  });
4167
- var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4205
+ var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($L113, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4168
4206
  return { $loc, token: "static " };
4169
4207
  });
4170
4208
  function Static(state) {
@@ -4174,7 +4212,7 @@ var require_parser = __commonJS({
4174
4212
  return Static$0(state) || Static$1(state);
4175
4213
  }
4176
4214
  }
4177
- var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4215
+ var SubstitutionStart$0 = $TV($EXPECT($L118, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4178
4216
  return { $loc, token: $1 };
4179
4217
  });
4180
4218
  function SubstitutionStart(state) {
@@ -4186,7 +4224,7 @@ var require_parser = __commonJS({
4186
4224
  return SubstitutionStart$0(state);
4187
4225
  }
4188
4226
  }
4189
- var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4227
+ var Switch$0 = $TS($S($EXPECT($L119, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4190
4228
  return { $loc, token: $1 };
4191
4229
  });
4192
4230
  function Switch(state) {
@@ -4198,7 +4236,7 @@ var require_parser = __commonJS({
4198
4236
  return Switch$0(state);
4199
4237
  }
4200
4238
  }
4201
- var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4239
+ var Target$0 = $TV($EXPECT($L120, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4202
4240
  return { $loc, token: $1 };
4203
4241
  });
4204
4242
  function Target(state) {
@@ -4210,7 +4248,7 @@ var require_parser = __commonJS({
4210
4248
  return Target$0(state);
4211
4249
  }
4212
4250
  }
4213
- var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4251
+ var Throw$0 = $TS($S($EXPECT($L121, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4214
4252
  return { $loc, token: $1 };
4215
4253
  });
4216
4254
  function Throw(state) {
@@ -4222,7 +4260,7 @@ var require_parser = __commonJS({
4222
4260
  return Throw$0(state);
4223
4261
  }
4224
4262
  }
4225
- var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4263
+ var TripleDoubleQuote$0 = $TV($EXPECT($L122, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4226
4264
  return { $loc, token: "`" };
4227
4265
  });
4228
4266
  function TripleDoubleQuote(state) {
@@ -4234,7 +4272,7 @@ var require_parser = __commonJS({
4234
4272
  return TripleDoubleQuote$0(state);
4235
4273
  }
4236
4274
  }
4237
- var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4275
+ var TripleSingleQuote$0 = $TV($EXPECT($L123, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4238
4276
  return { $loc, token: "`" };
4239
4277
  });
4240
4278
  function TripleSingleQuote(state) {
@@ -4246,7 +4284,7 @@ var require_parser = __commonJS({
4246
4284
  return TripleSingleQuote$0(state);
4247
4285
  }
4248
4286
  }
4249
- var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4287
+ var TripleTick$0 = $TV($EXPECT($L124, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4250
4288
  return { $loc, token: "`" };
4251
4289
  });
4252
4290
  function TripleTick(state) {
@@ -4258,7 +4296,7 @@ var require_parser = __commonJS({
4258
4296
  return TripleTick$0(state);
4259
4297
  }
4260
4298
  }
4261
- var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4299
+ var Try$0 = $TV($EXPECT($L125, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4262
4300
  return { $loc, token: $1 };
4263
4301
  });
4264
4302
  function Try(state) {
@@ -4270,7 +4308,19 @@ var require_parser = __commonJS({
4270
4308
  return Try$0(state);
4271
4309
  }
4272
4310
  }
4273
- var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4311
+ var Typeof$0 = $TS($S($EXPECT($L126, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4312
+ return { $loc, token: $1 };
4313
+ });
4314
+ function Typeof(state) {
4315
+ if (state.verbose)
4316
+ console.log("ENTER:", "Typeof");
4317
+ if (state.tokenize) {
4318
+ return $TOKEN("Typeof", state, Typeof$0(state));
4319
+ } else {
4320
+ return Typeof$0(state);
4321
+ }
4322
+ }
4323
+ var Unless$0 = $TV($EXPECT($L127, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4274
4324
  return { $loc, token: $1 };
4275
4325
  });
4276
4326
  function Unless(state) {
@@ -4282,7 +4332,7 @@ var require_parser = __commonJS({
4282
4332
  return Unless$0(state);
4283
4333
  }
4284
4334
  }
4285
- var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4335
+ var Var$0 = $TV($EXPECT($L128, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4286
4336
  return { $loc, token: $1 };
4287
4337
  });
4288
4338
  function Var(state) {
@@ -4294,6 +4344,18 @@ var require_parser = __commonJS({
4294
4344
  return Var$0(state);
4295
4345
  }
4296
4346
  }
4347
+ var Void$0 = $TS($S($EXPECT($L129, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4348
+ return { $loc, token: $1 };
4349
+ });
4350
+ function Void(state) {
4351
+ if (state.verbose)
4352
+ console.log("ENTER:", "Void");
4353
+ if (state.tokenize) {
4354
+ return $TOKEN("Void", state, Void$0(state));
4355
+ } else {
4356
+ return Void$0(state);
4357
+ }
4358
+ }
4297
4359
  var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4298
4360
  return { $loc, token: "case" };
4299
4361
  });
@@ -4332,7 +4394,7 @@ var require_parser = __commonJS({
4332
4394
  return JSXElement$0(state) || JSXElement$1(state);
4333
4395
  }
4334
4396
  }
4335
- var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
4397
+ var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
4336
4398
  function JSXSelfClosingElement(state) {
4337
4399
  if (state.verbose)
4338
4400
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -4342,7 +4404,7 @@ var require_parser = __commonJS({
4342
4404
  return JSXSelfClosingElement$0(state);
4343
4405
  }
4344
4406
  }
4345
- var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
4407
+ var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L55, fail, 'JSXOpeningElement ">"'));
4346
4408
  function JSXOpeningElement(state) {
4347
4409
  if (state.verbose)
4348
4410
  console.log("ENTER:", "JSXOpeningElement");
@@ -4352,7 +4414,7 @@ var require_parser = __commonJS({
4352
4414
  return JSXOpeningElement$0(state);
4353
4415
  }
4354
4416
  }
4355
- var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
4417
+ var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L55, fail, 'JSXClosingElement ">"'));
4356
4418
  function JSXClosingElement(state) {
4357
4419
  if (state.verbose)
4358
4420
  console.log("ENTER:", "JSXClosingElement");
@@ -4382,7 +4444,7 @@ var require_parser = __commonJS({
4382
4444
  return JSXElementName$0(state);
4383
4445
  }
4384
4446
  }
4385
- var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4447
+ var JSXIdentifierName$0 = $R$0($EXPECT($R33, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4386
4448
  function JSXIdentifierName(state) {
4387
4449
  if (state.verbose)
4388
4450
  console.log("ENTER:", "JSXIdentifierName");
@@ -4431,8 +4493,8 @@ var require_parser = __commonJS({
4431
4493
  return JSXAttributeInitializer$0(state);
4432
4494
  }
4433
4495
  }
4434
- var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
4435
- var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
4496
+ var JSXAttributeValue$0 = $R$0($EXPECT($R34, fail, 'JSXAttributeValue /"[^"]*"/'));
4497
+ var JSXAttributeValue$1 = $R$0($EXPECT($R35, fail, "JSXAttributeValue /'[^']*'/"));
4436
4498
  var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
4437
4499
  var JSXAttributeValue$3 = JSXElement;
4438
4500
  var JSXAttributeValue$4 = JSXFragment;
@@ -4464,7 +4526,7 @@ var require_parser = __commonJS({
4464
4526
  return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
4465
4527
  }
4466
4528
  }
4467
- var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
4529
+ var JSXText$0 = $R$0($EXPECT($R36, fail, "JSXText /[^{}<>]+/"));
4468
4530
  function JSXText(state) {
4469
4531
  if (state.verbose)
4470
4532
  console.log("ENTER:", "JSXText");
@@ -4636,7 +4698,7 @@ var require_parser = __commonJS({
4636
4698
  return NestedTypeDeclaration$0(state);
4637
4699
  }
4638
4700
  }
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)));
4701
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R37, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L140, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R38, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
4640
4702
  function TypeIndexSignature(state) {
4641
4703
  if (state.verbose)
4642
4704
  console.log("ENTER:", "TypeIndexSignature");
@@ -4687,7 +4749,7 @@ var require_parser = __commonJS({
4687
4749
  return ReturnTypeSuffix$0(state);
4688
4750
  }
4689
4751
  }
4690
- var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4752
+ var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L58, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4691
4753
  if (!$2)
4692
4754
  return $1;
4693
4755
  return $0;
@@ -4751,7 +4813,7 @@ var require_parser = __commonJS({
4751
4813
  }
4752
4814
  }
4753
4815
  var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
4754
- var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
4816
+ var TypeUnaryOp$1 = $EXPECT($L126, fail, 'TypeUnaryOp "typeof"');
4755
4817
  var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
4756
4818
  function TypeUnaryOp(state) {
4757
4819
  if (state.tokenize) {
@@ -4827,7 +4889,7 @@ var require_parser = __commonJS({
4827
4889
  return NestedType$0(state);
4828
4890
  }
4829
4891
  }
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) {
4892
+ var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L5, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
4831
4893
  if ($2)
4832
4894
  return $0;
4833
4895
  return $1;
@@ -4842,7 +4904,7 @@ var require_parser = __commonJS({
4842
4904
  }
4843
4905
  }
4844
4906
  var TypeLiteral$0 = Literal;
4845
- var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
4907
+ var TypeLiteral$1 = $TV($EXPECT($L129, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
4846
4908
  return { $loc, token: "void" };
4847
4909
  });
4848
4910
  var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
@@ -4855,10 +4917,10 @@ var require_parser = __commonJS({
4855
4917
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
4856
4918
  }
4857
4919
  }
4858
- var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
4920
+ var TypeBinaryOp$0 = $TV($EXPECT($L70, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
4859
4921
  return { $loc, token: "|" };
4860
4922
  });
4861
- var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
4923
+ var TypeBinaryOp$1 = $TV($EXPECT($L68, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
4862
4924
  return { $loc, token: "&" };
4863
4925
  });
4864
4926
  function TypeBinaryOp(state) {
@@ -4868,7 +4930,7 @@ var require_parser = __commonJS({
4868
4930
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
4869
4931
  }
4870
4932
  }
4871
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
4933
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L3, fail, 'FunctionType "=>"'), Type);
4872
4934
  function FunctionType(state) {
4873
4935
  if (state.verbose)
4874
4936
  console.log("ENTER:", "FunctionType");
@@ -4878,7 +4940,7 @@ var require_parser = __commonJS({
4878
4940
  return FunctionType$0(state);
4879
4941
  }
4880
4942
  }
4881
- var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
4943
+ var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeArguments ">"'));
4882
4944
  function TypeArguments(state) {
4883
4945
  if (state.verbose)
4884
4946
  console.log("ENTER:", "TypeArguments");
@@ -4888,7 +4950,7 @@ var require_parser = __commonJS({
4888
4950
  return TypeArguments$0(state);
4889
4951
  }
4890
4952
  }
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) {
4953
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
4892
4954
  return { ts: true, children: $0 };
4893
4955
  });
4894
4956
  function TypeParameters(state) {
@@ -4910,7 +4972,7 @@ var require_parser = __commonJS({
4910
4972
  return TypeParameter$0(state);
4911
4973
  }
4912
4974
  }
4913
- var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
4975
+ var TypeConstraint$0 = $S(__, $EXPECT($L5, fail, 'TypeConstraint "extends"'), Type);
4914
4976
  function TypeConstraint(state) {
4915
4977
  if (state.verbose)
4916
4978
  console.log("ENTER:", "TypeConstraint");
@@ -4921,8 +4983,8 @@ var require_parser = __commonJS({
4921
4983
  }
4922
4984
  }
4923
4985
  var TypeParameterDelimiter$0 = $S($Q(_), Comma);
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) {
4986
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L55, fail, 'TypeParameterDelimiter ">"')));
4987
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L55, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4926
4988
  return { $loc, token: "," };
4927
4989
  });
4928
4990
  var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -4935,7 +4997,7 @@ var require_parser = __commonJS({
4935
4997
  return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
4936
4998
  }
4937
4999
  }
4938
- var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
5000
+ var Shebang$0 = $S($R$0($EXPECT($R39, fail, "Shebang /#![^\\r\\n]*/")), EOL);
4939
5001
  function Shebang(state) {
4940
5002
  if (state.verbose)
4941
5003
  console.log("ENTER:", "Shebang");
@@ -4945,11 +5007,11 @@ var require_parser = __commonJS({
4945
5007
  return Shebang$0(state);
4946
5008
  }
4947
5009
  }
4948
- var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
5010
+ var CivetPrologue$0 = $T($S($EXPECT($R40, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4949
5011
  var content = value[2];
4950
5012
  return content;
4951
5013
  });
4952
- var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
5014
+ var CivetPrologue$1 = $T($S($EXPECT($R40, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4953
5015
  var content = value[2];
4954
5016
  return content;
4955
5017
  });
@@ -4960,7 +5022,7 @@ var require_parser = __commonJS({
4960
5022
  return CivetPrologue$0(state) || CivetPrologue$1(state);
4961
5023
  }
4962
5024
  }
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) {
5025
+ var CivetPrologueContent$0 = $TS($S($EXPECT($L145, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R41, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
4964
5026
  var options = $2;
4965
5027
  return {
4966
5028
  type: "CivetPrologue",
@@ -4977,7 +5039,7 @@ var require_parser = __commonJS({
4977
5039
  return CivetPrologueContent$0(state);
4978
5040
  }
4979
5041
  }
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) {
5042
+ var CivetOption$0 = $TR($EXPECT($R42, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4981
5043
  const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
4982
5044
  if (l)
4983
5045
  return l.toUpperCase();
@@ -4995,7 +5057,7 @@ var require_parser = __commonJS({
4995
5057
  return CivetOption$0(state);
4996
5058
  }
4997
5059
  }
4998
- var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
5060
+ var UnknownPrologue$0 = $S($R$0($EXPECT($R40, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
4999
5061
  function UnknownPrologue(state) {
5000
5062
  if (state.verbose)
5001
5063
  console.log("ENTER:", "UnknownPrologue");
@@ -5024,7 +5086,9 @@ var require_parser = __commonJS({
5024
5086
  return EOS$0(state);
5025
5087
  }
5026
5088
  }
5027
- var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
5089
+ var EOL$0 = $TR($EXPECT($R43, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
5090
+ return { $loc, token: $0 };
5091
+ });
5028
5092
  function EOL(state) {
5029
5093
  if (state.verbose)
5030
5094
  console.log("ENTER:", "EOL");
@@ -5034,17 +5098,7 @@ var require_parser = __commonJS({
5034
5098
  return EOL$0(state);
5035
5099
  }
5036
5100
  }
5037
- var EOF$0 = $R$0($EXPECT($R43, fail, "EOF /$/"));
5038
- function EOF(state) {
5039
- if (state.verbose)
5040
- console.log("ENTER:", "EOF");
5041
- if (state.tokenize) {
5042
- return $TOKEN("EOF", state, EOF$0(state));
5043
- } else {
5044
- return EOF$0(state);
5045
- }
5046
- }
5047
- var Debugger$0 = $TV($EXPECT($L1, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
5101
+ var Debugger$0 = $TV($EXPECT($L0, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
5048
5102
  debugger;
5049
5103
  });
5050
5104
  function Debugger(state) {
@@ -5056,7 +5110,7 @@ var require_parser = __commonJS({
5056
5110
  return Debugger$0(state);
5057
5111
  }
5058
5112
  }
5059
- var InsertOpenParen$0 = $TV($EXPECT($L1, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
5113
+ var InsertOpenParen$0 = $TV($EXPECT($L0, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
5060
5114
  return { $loc, token: "(" };
5061
5115
  });
5062
5116
  function InsertOpenParen(state) {
@@ -5068,7 +5122,7 @@ var require_parser = __commonJS({
5068
5122
  return InsertOpenParen$0(state);
5069
5123
  }
5070
5124
  }
5071
- var InsertCloseParen$0 = $TV($EXPECT($L1, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
5125
+ var InsertCloseParen$0 = $TV($EXPECT($L0, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
5072
5126
  return { $loc, token: ")" };
5073
5127
  });
5074
5128
  function InsertCloseParen(state) {
@@ -5080,7 +5134,7 @@ var require_parser = __commonJS({
5080
5134
  return InsertCloseParen$0(state);
5081
5135
  }
5082
5136
  }
5083
- var InsertOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
5137
+ var InsertOpenBrace$0 = $TV($EXPECT($L0, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
5084
5138
  return [{ $loc, token: " " }, { $loc, token: "{" }];
5085
5139
  });
5086
5140
  function InsertOpenBrace(state) {
@@ -5092,7 +5146,7 @@ var require_parser = __commonJS({
5092
5146
  return InsertOpenBrace$0(state);
5093
5147
  }
5094
5148
  }
5095
- var InsertCloseBrace$0 = $TV($EXPECT($L1, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
5149
+ var InsertCloseBrace$0 = $TV($EXPECT($L0, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
5096
5150
  return { $loc, token: "}" };
5097
5151
  });
5098
5152
  function InsertCloseBrace(state) {
@@ -5104,7 +5158,7 @@ var require_parser = __commonJS({
5104
5158
  return InsertCloseBrace$0(state);
5105
5159
  }
5106
5160
  }
5107
- var InsertConst$0 = $TV($EXPECT($L1, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
5161
+ var InsertConst$0 = $TV($EXPECT($L0, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
5108
5162
  return { $loc, token: "const " };
5109
5163
  });
5110
5164
  function InsertConst(state) {
@@ -5116,7 +5170,7 @@ var require_parser = __commonJS({
5116
5170
  return InsertConst$0(state);
5117
5171
  }
5118
5172
  }
5119
- var InsertReadonly$0 = $TV($EXPECT($L1, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
5173
+ var InsertReadonly$0 = $TV($EXPECT($L0, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
5120
5174
  return { ts: true, children: [{ $loc, token: "readonly " }] };
5121
5175
  });
5122
5176
  function InsertReadonly(state) {
@@ -5128,7 +5182,7 @@ var require_parser = __commonJS({
5128
5182
  return InsertReadonly$0(state);
5129
5183
  }
5130
5184
  }
5131
- var InsertNewline$0 = $TV($EXPECT($L1, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
5185
+ var InsertNewline$0 = $TV($EXPECT($L0, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
5132
5186
  return "\n";
5133
5187
  });
5134
5188
  function InsertNewline(state) {
@@ -5140,7 +5194,7 @@ var require_parser = __commonJS({
5140
5194
  return InsertNewline$0(state);
5141
5195
  }
5142
5196
  }
5143
- var InsertIndent$0 = $TV($EXPECT($L1, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
5197
+ var InsertIndent$0 = $TV($EXPECT($L0, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
5144
5198
  return "".padStart(module2.currentIndent * 2);
5145
5199
  });
5146
5200
  function InsertIndent(state) {
@@ -5152,7 +5206,7 @@ var require_parser = __commonJS({
5152
5206
  return InsertIndent$0(state);
5153
5207
  }
5154
5208
  }
5155
- var InsertSpace$0 = $TV($EXPECT($L1, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
5209
+ var InsertSpace$0 = $TV($EXPECT($L0, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
5156
5210
  return { $loc, token: " " };
5157
5211
  });
5158
5212
  function InsertSpace(state) {
@@ -5164,7 +5218,7 @@ var require_parser = __commonJS({
5164
5218
  return InsertSpace$0(state);
5165
5219
  }
5166
5220
  }
5167
- var InsertDot$0 = $TV($EXPECT($L1, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
5221
+ var InsertDot$0 = $TV($EXPECT($L0, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
5168
5222
  return { $loc, token: "." };
5169
5223
  });
5170
5224
  function InsertDot(state) {
@@ -5176,7 +5230,7 @@ var require_parser = __commonJS({
5176
5230
  return InsertDot$0(state);
5177
5231
  }
5178
5232
  }
5179
- var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
5233
+ var InsertBreak$0 = $TV($EXPECT($L0, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
5180
5234
  return { $loc, token: ";break;" };
5181
5235
  });
5182
5236
  function InsertBreak(state) {
@@ -5188,7 +5242,7 @@ var require_parser = __commonJS({
5188
5242
  return InsertBreak$0(state);
5189
5243
  }
5190
5244
  }
5191
- var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
5245
+ var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
5192
5246
  if (module2.config.coffeeComment)
5193
5247
  return;
5194
5248
  return $skip;
@@ -5202,7 +5256,7 @@ var require_parser = __commonJS({
5202
5256
  return CoffeeCommentEnabled$0(state);
5203
5257
  }
5204
5258
  }
5205
- var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
5259
+ var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
5206
5260
  if (module2.config.coffeeBooleans)
5207
5261
  return;
5208
5262
  return $skip;
@@ -5216,7 +5270,7 @@ var require_parser = __commonJS({
5216
5270
  return CoffeeBooleansEnabled$0(state);
5217
5271
  }
5218
5272
  }
5219
- var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
5273
+ var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
5220
5274
  if (module2.config.coffeeInterpolation)
5221
5275
  return;
5222
5276
  return $skip;
@@ -5230,7 +5284,7 @@ var require_parser = __commonJS({
5230
5284
  return CoffeeInterpolationEnabled$0(state);
5231
5285
  }
5232
5286
  }
5233
- var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
5287
+ var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
5234
5288
  module2.currentIndent = 0;
5235
5289
  module2.indentLevels = [0];
5236
5290
  module2.verbose = false;
@@ -5274,26 +5328,13 @@ var require_parser = __commonJS({
5274
5328
  return Reset$0(state);
5275
5329
  }
5276
5330
  }
5277
- var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
5331
+ var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L0, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
5278
5332
  var directives = $2;
5279
5333
  directives.forEach((directive) => {
5280
5334
  if (directive.type === "CivetPrologue") {
5281
5335
  Object.assign(module2.config, directive.config);
5282
5336
  }
5283
5337
  });
5284
- function hasReturnStatement(node) {
5285
- if (!node)
5286
- return false;
5287
- if (Array.isArray(node))
5288
- return node.some(hasReturnStatement);
5289
- if (node.type === "ReturnStatement")
5290
- return true;
5291
- if (node.type === "FunctionExpression")
5292
- return false;
5293
- if (node.children)
5294
- return hasReturnStatement(node.children);
5295
- return false;
5296
- }
5297
5338
  function insertReturn(node) {
5298
5339
  if (!node)
5299
5340
  return;
@@ -5324,7 +5365,10 @@ var require_parser = __commonJS({
5324
5365
  }
5325
5366
  if (!Array.isArray(node))
5326
5367
  return;
5327
- const [indent, exp] = node;
5368
+ const [, exp] = node;
5369
+ let indent = node[0];
5370
+ if (Array.isArray(indent))
5371
+ indent = indent[indent.length - 1];
5328
5372
  if (!exp)
5329
5373
  return;
5330
5374
  switch (exp.type) {
@@ -5333,6 +5377,7 @@ var require_parser = __commonJS({
5333
5377
  case "DebuggerStatement":
5334
5378
  case "EmptyStatement":
5335
5379
  case "IterationStatement":
5380
+ case "ReturnStatement":
5336
5381
  case "ThrowStatement":
5337
5382
  case "VariableDeclaration":
5338
5383
  return;
@@ -5357,8 +5402,6 @@ var require_parser = __commonJS({
5357
5402
  node.splice(1, 0, "return ");
5358
5403
  }
5359
5404
  module2.addImplicitReturns = function(block) {
5360
- if (hasReturnStatement(block))
5361
- return block;
5362
5405
  insertReturn(block);
5363
5406
  return block;
5364
5407
  };
@@ -5519,7 +5562,7 @@ var require_parser = __commonJS({
5519
5562
  return Indent$0(state);
5520
5563
  }
5521
5564
  }
5522
- var TrackIndent$0 = $TV($EXPECT($L1, fail, 'TrackIndent ""'), function($skip, $loc, $0, $1) {
5565
+ var TrackIndent$0 = $TV($EXPECT($L0, fail, 'TrackIndent ""'), function($skip, $loc, $0, $1) {
5523
5566
  module2.indentLevels.push(module2.currentIndent);
5524
5567
  });
5525
5568
  function TrackIndent(state) {
@@ -5567,7 +5610,7 @@ var require_parser = __commonJS({
5567
5610
  return IndentedFurther$0(state);
5568
5611
  }
5569
5612
  }
5570
- var PushIndent$0 = $TV($EXPECT($L1, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
5613
+ var PushIndent$0 = $TV($EXPECT($L0, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
5571
5614
  module2.currentIndent++;
5572
5615
  if (module2.verbose) {
5573
5616
  console.log("pushing indent", module2.currentIndent);
@@ -5583,7 +5626,7 @@ var require_parser = __commonJS({
5583
5626
  return PushIndent$0(state);
5584
5627
  }
5585
5628
  }
5586
- var PopIndent$0 = $TV($EXPECT($L1, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
5629
+ var PopIndent$0 = $TV($EXPECT($L0, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
5587
5630
  if (module2.verbose) {
5588
5631
  console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
5589
5632
  }