@danielx/civet 0.4.12 → 0.4.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/README.md +18 -10
  2. package/dist/browser.js +648 -493
  3. package/dist/esbuild-plugin.js +7 -1
  4. package/dist/esm.mjs +2 -2
  5. package/dist/main.js +648 -493
  6. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -519,18 +519,23 @@ var require_parser = __commonJS({
519
519
  UnaryOp,
520
520
  ModuleItem,
521
521
  StatementListItem,
522
- PostfixConditional,
522
+ PostfixStatement,
523
523
  Statement,
524
524
  EmptyStatement,
525
525
  BlockStatement,
526
526
  IfStatement,
527
+ IfClause,
528
+ UnlessClause,
527
529
  IterationStatement,
528
530
  LoopStatement,
531
+ LoopClause,
529
532
  DoWhileStatement,
530
533
  WhileStatement,
531
534
  WhileClause,
532
535
  ForStatement,
533
- ForInOfStatement,
536
+ ForClause,
537
+ ForStatementControl,
538
+ ForInOfDeclaration,
534
539
  ForDeclaration,
535
540
  ForBinding,
536
541
  SwitchStatement,
@@ -622,6 +627,7 @@ var require_parser = __commonJS({
622
627
  As,
623
628
  Async,
624
629
  Await,
630
+ Backtick,
625
631
  Case,
626
632
  Catch,
627
633
  Class,
@@ -632,6 +638,8 @@ var require_parser = __commonJS({
632
638
  Colon,
633
639
  ConstructorShorthand,
634
640
  Default,
641
+ Delete,
642
+ Do,
635
643
  Dot,
636
644
  DotDotDot,
637
645
  DoubleQuote,
@@ -666,9 +674,13 @@ var require_parser = __commonJS({
666
674
  TripleSingleQuote,
667
675
  TripleTick,
668
676
  Try,
677
+ Typeof,
669
678
  Unless,
679
+ Until,
670
680
  Var,
681
+ Void,
671
682
  When,
683
+ While,
672
684
  Yield,
673
685
  JSXElement,
674
686
  JSXSelfClosingElement,
@@ -733,7 +745,6 @@ var require_parser = __commonJS({
733
745
  DirectivePrologue,
734
746
  EOS,
735
747
  EOL,
736
- EOF,
737
748
  Debugger,
738
749
  InsertOpenParen,
739
750
  InsertCloseParen,
@@ -759,137 +770,137 @@ var require_parser = __commonJS({
759
770
  PopIndent,
760
771
  Nested
761
772
  });
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");
892
- var $L130 = $L("when");
773
+ var $L0 = $L("");
774
+ var $L1 = $L("++");
775
+ var $L2 = $L("--");
776
+ var $L3 = $L("=>");
777
+ var $L4 = $L("<");
778
+ var $L5 = $L("extends");
779
+ var $L6 = $L("this");
780
+ var $L7 = $L("#");
781
+ var $L8 = $L("@");
782
+ var $L9 = $L("super");
783
+ var $L10 = $L("import");
784
+ var $L11 = $L("!");
785
+ var $L12 = $L("::");
786
+ var $L13 = $L("super[");
787
+ var $L14 = $L("import.meta");
788
+ var $L15 = $L(")");
789
+ var $L16 = $L("->");
790
+ var $L17 = $L("null");
791
+ var $L18 = $L("true");
792
+ var $L19 = $L("false");
793
+ var $L20 = $L("yes");
794
+ var $L21 = $L("on");
795
+ var $L22 = $L("no");
796
+ var $L23 = $L("off");
797
+ var $L24 = $L(",");
798
+ var $L25 = $L("]");
799
+ var $L26 = $L("}");
800
+ var $L27 = $L("**=");
801
+ var $L28 = $L("*=");
802
+ var $L29 = $L("/=");
803
+ var $L30 = $L("%=");
804
+ var $L31 = $L("+=");
805
+ var $L32 = $L("-=");
806
+ var $L33 = $L("<<=");
807
+ var $L34 = $L(">>>=");
808
+ var $L35 = $L(">>=");
809
+ var $L36 = $L("&&=");
810
+ var $L37 = $L("&=");
811
+ var $L38 = $L("^=");
812
+ var $L39 = $L("||=");
813
+ var $L40 = $L("|=");
814
+ var $L41 = $L("??=");
815
+ var $L42 = $L("?=");
816
+ var $L43 = $L("=");
817
+ var $L44 = $L("**");
818
+ var $L45 = $L("*");
819
+ var $L46 = $L("/");
820
+ var $L47 = $L("%");
821
+ var $L48 = $L("+");
822
+ var $L49 = $L("-");
823
+ var $L50 = $L("<=");
824
+ var $L51 = $L(">=");
825
+ var $L52 = $L("<<");
826
+ var $L53 = $L(">>>");
827
+ var $L54 = $L(">>");
828
+ var $L55 = $L(">");
829
+ var $L56 = $L("!==");
830
+ var $L57 = $L("!=");
831
+ var $L58 = $L("is");
832
+ var $L59 = $L("===");
833
+ var $L60 = $L("==");
834
+ var $L61 = $L("and");
835
+ var $L62 = $L("&&");
836
+ var $L63 = $L("or");
837
+ var $L64 = $L("||");
838
+ var $L65 = $L("??");
839
+ var $L66 = $L("instanceof");
840
+ var $L67 = $L("in");
841
+ var $L68 = $L("&");
842
+ var $L69 = $L("^");
843
+ var $L70 = $L("|");
844
+ var $L71 = $L(";");
845
+ var $L72 = $L("finally");
846
+ var $L73 = $L("break");
847
+ var $L74 = $L("continue");
848
+ var $L75 = $L("debugger");
849
+ var $L76 = $L("import type");
850
+ var $L77 = $L("default");
851
+ var $L78 = $L(":=");
852
+ var $L79 = $L("/*");
853
+ var $L80 = $L("*/");
854
+ var $L81 = $L("###");
855
+ var $L82 = $L("as");
856
+ var $L83 = $L("async");
857
+ var $L84 = $L("await");
858
+ var $L85 = $L("`");
859
+ var $L86 = $L("case");
860
+ var $L87 = $L("catch");
861
+ var $L88 = $L("class");
862
+ var $L89 = $L("#{");
863
+ var $L90 = $L(":");
864
+ var $L91 = $L("delete");
865
+ var $L92 = $L("do");
866
+ var $L93 = $L(".");
867
+ var $L94 = $L("...");
868
+ var $L95 = $L('"');
869
+ var $L96 = $L("else");
870
+ var $L97 = $L("export");
871
+ var $L98 = $L("for");
872
+ var $L99 = $L("from");
873
+ var $L100 = $L("function");
874
+ var $L101 = $L("get");
875
+ var $L102 = $L("set");
876
+ var $L103 = $L("if");
877
+ var $L104 = $L("let");
878
+ var $L105 = $L("const");
879
+ var $L106 = $L("loop");
880
+ var $L107 = $L("new");
881
+ var $L108 = $L("of");
882
+ var $L109 = $L("{");
883
+ var $L110 = $L("[");
884
+ var $L111 = $L("(");
885
+ var $L112 = $L("?");
886
+ var $L113 = $L("return");
887
+ var $L114 = $L("'");
888
+ var $L115 = $L("static");
889
+ var $L116 = $L("${");
890
+ var $L117 = $L("switch");
891
+ var $L118 = $L("target");
892
+ var $L119 = $L("throw");
893
+ var $L120 = $L('"""');
894
+ var $L121 = $L("'''");
895
+ var $L122 = $L("```");
896
+ var $L123 = $L("try");
897
+ var $L124 = $L("typeof");
898
+ var $L125 = $L("unless");
899
+ var $L126 = $L("until");
900
+ var $L127 = $L("var");
901
+ var $L128 = $L("void");
902
+ var $L129 = $L("when");
903
+ var $L130 = $L("while");
893
904
  var $L131 = $L("yield");
894
905
  var $L132 = $L("/>");
895
906
  var $L133 = $L("</");
@@ -907,50 +918,50 @@ var require_parser = __commonJS({
907
918
  var $L145 = $L("civet");
908
919
  var $L146 = $L(" ");
909
920
  var $L147 = $L(" ");
910
- var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
921
+ var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
911
922
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
912
923
  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"));
924
+ var $R3 = $R(new RegExp("(?=[\\s\\)])", "suy"));
925
+ var $R4 = $R(new RegExp('[^;"\\s]+', "suy"));
926
+ var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
927
+ var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
928
+ var $R7 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?", "suy"));
929
+ var $R8 = $R(new RegExp("(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)", "suy"));
930
+ var $R9 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
931
+ var $R10 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
932
+ var $R11 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
933
+ var $R12 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
934
+ var $R13 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
935
+ var $R14 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
936
+ var $R15 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
937
+ var $R16 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
938
+ var $R17 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
939
+ var $R18 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
940
+ var $R19 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
941
+ var $R20 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
942
+ var $R21 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
943
+ var $R22 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
944
+ var $R23 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
945
+ 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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
946
+ var $R25 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
947
+ var $R26 = $R(new RegExp(".", "suy"));
948
+ var $R27 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
949
+ var $R28 = $R(new RegExp("[^\\r\\n]", "suy"));
950
+ var $R29 = $R(new RegExp("[ \\t]+", "suy"));
951
+ var $R30 = $R(new RegExp("[\\s]+", "suy"));
952
+ var $R31 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
953
+ var $R32 = $R(new RegExp("\\s", "suy"));
954
+ var $R33 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
955
+ var $R34 = $R(new RegExp('"[^"]*"', "suy"));
956
+ var $R35 = $R(new RegExp("'[^']*'", "suy"));
957
+ var $R36 = $R(new RegExp("[^{}<>]+", "suy"));
958
+ var $R37 = $R(new RegExp("[+-]?", "suy"));
959
+ var $R38 = $R(new RegExp("[+-]", "suy"));
960
+ var $R39 = $R(new RegExp("#![^\\r\\n]*", "suy"));
961
+ var $R40 = $R(new RegExp("[\\t ]*", "suy"));
962
+ var $R41 = $R(new RegExp("[\\s]*", "suy"));
963
+ var $R42 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
964
+ var $R43 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
954
965
  var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
955
966
  function Program(state) {
956
967
  if (state.verbose)
@@ -994,7 +1005,7 @@ var require_parser = __commonJS({
994
1005
  return Arguments$0(state) || Arguments$1(state);
995
1006
  }
996
1007
  }
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) {
1008
+ 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
1009
  if (!$2)
999
1010
  return $skip;
1000
1011
  return $2;
@@ -1080,7 +1091,7 @@ var require_parser = __commonJS({
1080
1091
  return ApplicationStart$0(state) || ApplicationStart$1(state);
1081
1092
  }
1082
1093
  }
1083
- var IndentedApplicationAllowed$0 = $TV($EXPECT($L1, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
1094
+ var IndentedApplicationAllowed$0 = $TV($EXPECT($L0, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
1084
1095
  if (module2.suppressIndentedApplication)
1085
1096
  return $skip;
1086
1097
  return;
@@ -1158,7 +1169,7 @@ var require_parser = __commonJS({
1158
1169
  return UpdateExpression$0(state) || UpdateExpression$1(state);
1159
1170
  }
1160
1171
  }
1161
- var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L2, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L3, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
1172
+ var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L1, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L2, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
1162
1173
  return { $loc, token: $1 };
1163
1174
  });
1164
1175
  function UpdateExpressionSymbol(state) {
@@ -1238,7 +1249,7 @@ var require_parser = __commonJS({
1238
1249
  return ArrowFunction$0(state) || ArrowFunction$1(state);
1239
1250
  }
1240
1251
  }
1241
- var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1252
+ var FatArrow$0 = $TS($S(__, $EXPECT($L3, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1242
1253
  var ws = $1;
1243
1254
  if (!ws.length)
1244
1255
  return " =>";
@@ -1344,10 +1355,10 @@ var require_parser = __commonJS({
1344
1355
  return ClassHeritage$0(state);
1345
1356
  }
1346
1357
  }
1347
- var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1358
+ var ExtendsToken$0 = $TV($EXPECT($L4, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1348
1359
  return { $loc, token: "extends" };
1349
1360
  });
1350
- var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1361
+ var ExtendsToken$1 = $TV($EXPECT($L5, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1351
1362
  return { $loc, token: $1 };
1352
1363
  });
1353
1364
  function ExtendsToken(state) {
@@ -1417,11 +1428,11 @@ var require_parser = __commonJS({
1417
1428
  return FieldDefinition$0(state) || FieldDefinition$1(state);
1418
1429
  }
1419
1430
  }
1420
- var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1431
+ var This$0 = $TV($EXPECT($L6, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1421
1432
  return { $loc, token: $1 };
1422
1433
  });
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) {
1434
+ var This$1 = $S(AtAccessor, $S($E($EXPECT($L7, fail, 'This "#"')), IdentifierName));
1435
+ var This$2 = $TV($EXPECT($L8, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1425
1436
  return { $loc, token: "this" };
1426
1437
  });
1427
1438
  function This(state) {
@@ -1431,7 +1442,7 @@ var require_parser = __commonJS({
1431
1442
  return This$0(state) || This$1(state) || This$2(state);
1432
1443
  }
1433
1444
  }
1434
- var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1445
+ var AtAccessor$0 = $TV($EXPECT($L8, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1435
1446
  return { $loc, token: "this." };
1436
1447
  });
1437
1448
  function AtAccessor(state) {
@@ -1462,8 +1473,8 @@ var require_parser = __commonJS({
1462
1473
  return NewExpression$0(state);
1463
1474
  }
1464
1475
  }
1465
- var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1466
- var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1476
+ var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1477
+ var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1467
1478
  var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
1468
1479
  if ($2.length)
1469
1480
  return $0;
@@ -1496,7 +1507,7 @@ var require_parser = __commonJS({
1496
1507
  return OptionalShorthand$0(state);
1497
1508
  }
1498
1509
  }
1499
- var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
1510
+ var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
1500
1511
  return { "ts": true, "children": value };
1501
1512
  });
1502
1513
  function NonNullAssertion(state) {
@@ -1508,7 +1519,7 @@ var require_parser = __commonJS({
1508
1519
  return NonNullAssertion$0(state);
1509
1520
  }
1510
1521
  }
1511
- var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
1522
+ var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
1512
1523
  function AdditionalReservedWords(state) {
1513
1524
  if (state.verbose)
1514
1525
  console.log("ENTER:", "AdditionalReservedWords");
@@ -1534,7 +1545,7 @@ var require_parser = __commonJS({
1534
1545
  }
1535
1546
  var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
1536
1547
  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) {
1548
+ var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L12, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1538
1549
  var id = $3;
1539
1550
  if (id)
1540
1551
  return [".prototype.", id];
@@ -1558,7 +1569,7 @@ var require_parser = __commonJS({
1558
1569
  return PropertyAccess$0(state);
1559
1570
  }
1560
1571
  }
1561
- var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1572
+ var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1562
1573
  function SuperProperty(state) {
1563
1574
  if (state.verbose)
1564
1575
  console.log("ENTER:", "SuperProperty");
@@ -1569,7 +1580,7 @@ var require_parser = __commonJS({
1569
1580
  }
1570
1581
  }
1571
1582
  var MetaProperty$0 = $S(New, Dot, Target);
1572
- var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1583
+ var MetaProperty$1 = $TV($EXPECT($L14, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1573
1584
  return { $loc, token: $1 };
1574
1585
  });
1575
1586
  function MetaProperty(state) {
@@ -1580,7 +1591,7 @@ var require_parser = __commonJS({
1580
1591
  }
1581
1592
  }
1582
1593
  var Parameters$0 = NonEmptyParameters;
1583
- var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
1594
+ var Parameters$1 = $TV($EXPECT($L0, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
1584
1595
  return { $loc, token: "()" };
1585
1596
  });
1586
1597
  function Parameters(state) {
@@ -1621,7 +1632,7 @@ var require_parser = __commonJS({
1621
1632
  }
1622
1633
  }
1623
1634
  var ParameterElementDelimiter$0 = $S($Q(_), Comma);
1624
- var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
1635
+ var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
1625
1636
  var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1626
1637
  return { $loc, token: "," };
1627
1638
  });
@@ -1840,7 +1851,7 @@ var require_parser = __commonJS({
1840
1851
  return ThinArrowFunction$0(state);
1841
1852
  }
1842
1853
  }
1843
- var Arrow$0 = $TV($EXPECT($L17, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1854
+ var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1844
1855
  return { $loc, token: $1 };
1845
1856
  });
1846
1857
  function Arrow(state) {
@@ -1964,7 +1975,7 @@ var require_parser = __commonJS({
1964
1975
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1965
1976
  }
1966
1977
  }
1967
- var NullLiteral$0 = $TV($EXPECT($L18, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1978
+ var NullLiteral$0 = $TV($EXPECT($L17, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1968
1979
  return { $loc, token: $1 };
1969
1980
  });
1970
1981
  function NullLiteral(state) {
@@ -1977,7 +1988,7 @@ var require_parser = __commonJS({
1977
1988
  }
1978
1989
  }
1979
1990
  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) {
1991
+ var BooleanLiteral$1 = $TV($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1981
1992
  return { $loc, token: $1 };
1982
1993
  });
1983
1994
  function BooleanLiteral(state) {
@@ -1987,10 +1998,10 @@ var require_parser = __commonJS({
1987
1998
  return BooleanLiteral$0(state) || BooleanLiteral$1(state);
1988
1999
  }
1989
2000
  }
1990
- var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
2001
+ var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
1991
2002
  return { $loc, token: "true" };
1992
2003
  });
1993
- var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
2004
+ var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
1994
2005
  return { $loc, token: "false" };
1995
2006
  });
1996
2007
  function CoffeeScriptBooleanLiteral(state) {
@@ -2000,7 +2011,7 @@ var require_parser = __commonJS({
2000
2011
  return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
2001
2012
  }
2002
2013
  }
2003
- var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
2014
+ var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
2004
2015
  return { $loc, token: $1 };
2005
2016
  });
2006
2017
  function Comma(state) {
@@ -2085,7 +2096,7 @@ var require_parser = __commonJS({
2085
2096
  }
2086
2097
  }
2087
2098
  var ArrayElementDelimiter$0 = $S($Q(_), Comma);
2088
- var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
2099
+ var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
2089
2100
  var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
2090
2101
  return { $loc, token: "," };
2091
2102
  });
@@ -2183,7 +2194,7 @@ var require_parser = __commonJS({
2183
2194
  }
2184
2195
  }
2185
2196
  var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
2186
- var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
2197
+ var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
2187
2198
  var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
2188
2199
  return { $loc, token: "," };
2189
2200
  });
@@ -2218,7 +2229,7 @@ var require_parser = __commonJS({
2218
2229
  var PropertyName$0 = NumericLiteral;
2219
2230
  var PropertyName$1 = StringLiteral;
2220
2231
  var PropertyName$2 = IdentifierName;
2221
- var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
2232
+ var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
2222
2233
  function PropertyName(state) {
2223
2234
  if (state.tokenize) {
2224
2235
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -2293,7 +2304,7 @@ var require_parser = __commonJS({
2293
2304
  return ClassElementName$0(state) || ClassElementName$1(state);
2294
2305
  }
2295
2306
  }
2296
- var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
2307
+ var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L7, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
2297
2308
  return {
2298
2309
  $loc,
2299
2310
  token: $1
@@ -2320,25 +2331,25 @@ var require_parser = __commonJS({
2320
2331
  return AssignmentOp$0(state);
2321
2332
  }
2322
2333
  }
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) {
2334
+ var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
2335
+ var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
2336
+ var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
2337
+ var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
2338
+ var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
2339
+ var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
2340
+ var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
2341
+ var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
2342
+ var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
2343
+ var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
2344
+ var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
2345
+ var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
2346
+ var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
2347
+ var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
2348
+ var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
2349
+ var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
2339
2350
  return "??=";
2340
2351
  });
2341
- var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
2352
+ var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
2342
2353
  function AssignmentOpSymbol(state) {
2343
2354
  if (state.tokenize) {
2344
2355
  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 +2369,52 @@ var require_parser = __commonJS({
2358
2369
  return BinaryOp$0(state);
2359
2370
  }
2360
2371
  }
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) {
2372
+ var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
2373
+ var BinaryOpSymbol$1 = $EXPECT($L45, fail, 'BinaryOpSymbol "*"');
2374
+ var BinaryOpSymbol$2 = $EXPECT($L46, fail, 'BinaryOpSymbol "/"');
2375
+ var BinaryOpSymbol$3 = $EXPECT($L47, fail, 'BinaryOpSymbol "%"');
2376
+ var BinaryOpSymbol$4 = $EXPECT($L48, fail, 'BinaryOpSymbol "+"');
2377
+ var BinaryOpSymbol$5 = $EXPECT($L49, fail, 'BinaryOpSymbol "-"');
2378
+ var BinaryOpSymbol$6 = $EXPECT($L50, fail, 'BinaryOpSymbol "<="');
2379
+ var BinaryOpSymbol$7 = $EXPECT($L51, fail, 'BinaryOpSymbol ">="');
2380
+ var BinaryOpSymbol$8 = $EXPECT($L52, fail, 'BinaryOpSymbol "<<"');
2381
+ var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
2382
+ var BinaryOpSymbol$10 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>>"');
2383
+ var BinaryOpSymbol$11 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>"');
2384
+ var BinaryOpSymbol$12 = $EXPECT($L55, fail, 'BinaryOpSymbol ">"');
2385
+ var BinaryOpSymbol$13 = $EXPECT($L56, fail, 'BinaryOpSymbol "!=="');
2386
+ var BinaryOpSymbol$14 = $TV($EXPECT($L57, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2376
2387
  if (module2.config.coffeeEq)
2377
2388
  return "!==";
2378
2389
  return $1;
2379
2390
  });
2380
- var BinaryOpSymbol$15 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2391
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L58, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2381
2392
  return "===";
2382
2393
  });
2383
- var BinaryOpSymbol$16 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
2384
- var BinaryOpSymbol$17 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2394
+ var BinaryOpSymbol$16 = $EXPECT($L59, fail, 'BinaryOpSymbol "==="');
2395
+ var BinaryOpSymbol$17 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2385
2396
  if (module2.config.coffeeEq)
2386
2397
  return "===";
2387
2398
  return $1;
2388
2399
  });
2389
- var BinaryOpSymbol$18 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2400
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2390
2401
  return "&&";
2391
2402
  });
2392
- var BinaryOpSymbol$19 = $EXPECT($L63, fail, 'BinaryOpSymbol "&&"');
2393
- var BinaryOpSymbol$20 = $T($S($EXPECT($L64, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2403
+ var BinaryOpSymbol$19 = $EXPECT($L62, fail, 'BinaryOpSymbol "&&"');
2404
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L63, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2394
2405
  return "||";
2395
2406
  });
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) {
2407
+ var BinaryOpSymbol$21 = $EXPECT($L64, fail, 'BinaryOpSymbol "||"');
2408
+ var BinaryOpSymbol$22 = $EXPECT($L65, fail, 'BinaryOpSymbol "??"');
2409
+ var BinaryOpSymbol$23 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2399
2410
  return $1;
2400
2411
  });
2401
- var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2412
+ var BinaryOpSymbol$24 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2402
2413
  return $1;
2403
2414
  });
2404
- var BinaryOpSymbol$25 = $EXPECT($L69, fail, 'BinaryOpSymbol "&"');
2405
- var BinaryOpSymbol$26 = $EXPECT($L70, fail, 'BinaryOpSymbol "^"');
2406
- var BinaryOpSymbol$27 = $EXPECT($L71, fail, 'BinaryOpSymbol "|"');
2415
+ var BinaryOpSymbol$25 = $EXPECT($L68, fail, 'BinaryOpSymbol "&"');
2416
+ var BinaryOpSymbol$26 = $EXPECT($L69, fail, 'BinaryOpSymbol "^"');
2417
+ var BinaryOpSymbol$27 = $EXPECT($L70, fail, 'BinaryOpSymbol "|"');
2407
2418
  function BinaryOpSymbol(state) {
2408
2419
  if (state.tokenize) {
2409
2420
  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 +2422,10 @@ var require_parser = __commonJS({
2411
2422
  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
2423
  }
2413
2424
  }
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, __);
2425
+ var UnaryOp$0 = $TR($EXPECT($R2, fail, "UnaryOp /[!~+-]/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2426
+ return { $loc, token: $0 };
2427
+ });
2428
+ var UnaryOp$1 = $S($C(Delete, Void, Typeof), __);
2416
2429
  function UnaryOp(state) {
2417
2430
  if (state.tokenize) {
2418
2431
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2430,49 +2443,36 @@ var require_parser = __commonJS({
2430
2443
  return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state);
2431
2444
  }
2432
2445
  }
2433
- var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional), Loc), function($skip, $loc, $0, $1, $2, $3) {
2446
+ var StatementListItem$0 = Declaration;
2447
+ var StatementListItem$1 = $TS($S(Statement, $Q(TrailingComment), $E(PostfixStatement)), function($skip, $loc, $0, $1, $2, $3) {
2434
2448
  var statement = $1;
2435
- var cond = $2;
2436
- var l = $3;
2437
- if (cond)
2438
- return [cond, statement, { $loc: l.$loc, token: "}" }];
2449
+ var ws = $2;
2450
+ var post = $3;
2451
+ if (post) {
2452
+ post.children.push(statement);
2453
+ if (!module2.isWhitespaceOrEmpty(ws))
2454
+ post.children.push(ws);
2455
+ return post;
2456
+ }
2439
2457
  return statement;
2440
2458
  });
2441
2459
  function StatementListItem(state) {
2442
- if (state.verbose)
2443
- console.log("ENTER:", "StatementListItem");
2444
2460
  if (state.tokenize) {
2445
- return $TOKEN("StatementListItem", state, StatementListItem$0(state));
2461
+ return $TOKEN("StatementListItem", state, StatementListItem$0(state) || StatementListItem$1(state));
2446
2462
  } else {
2447
- return StatementListItem$0(state);
2463
+ return StatementListItem$0(state) || StatementListItem$1(state);
2448
2464
  }
2449
2465
  }
2450
- var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C(If, Unless), NonIdContinue, Loc, ExpressionWithIndentedApplicationSuppressed, Loc), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
2451
- var ws = $1;
2452
- var cond = $2;
2453
- var l1 = $4;
2454
- var exp = $5;
2455
- var l2 = $6;
2456
- let openParens = { $loc: l1.$loc, token: "(!(" };
2457
- let closingParens = { $loc: l2.$loc, token: "))" };
2458
- let space = { $loc: l2.$loc, token: " " };
2459
- let openingBrace = { $loc: l2.$loc, token: "{" };
2460
- if (cond.token === "if") {
2461
- cond.token = "if";
2462
- closingParens.token = ")";
2463
- openParens.token = "(";
2464
- } else {
2465
- cond.token = "if";
2466
- }
2467
- return [ws, cond, openParens, exp, closingParens, space, openingBrace];
2468
- });
2469
- function PostfixConditional(state) {
2470
- if (state.verbose)
2471
- console.log("ENTER:", "PostfixConditional");
2466
+ var PostfixStatement$0 = ForClause;
2467
+ var PostfixStatement$1 = IfClause;
2468
+ var PostfixStatement$2 = LoopClause;
2469
+ var PostfixStatement$3 = UnlessClause;
2470
+ var PostfixStatement$4 = WhileClause;
2471
+ function PostfixStatement(state) {
2472
2472
  if (state.tokenize) {
2473
- return $TOKEN("PostfixConditional", state, PostfixConditional$0(state));
2473
+ return $TOKEN("PostfixStatement", state, PostfixStatement$0(state) || PostfixStatement$1(state) || PostfixStatement$2(state) || PostfixStatement$3(state) || PostfixStatement$4(state));
2474
2474
  } else {
2475
- return PostfixConditional$0(state);
2475
+ return PostfixStatement$0(state) || PostfixStatement$1(state) || PostfixStatement$2(state) || PostfixStatement$3(state) || PostfixStatement$4(state);
2476
2476
  }
2477
2477
  }
2478
2478
  var Statement$0 = KeywordStatement;
@@ -2491,7 +2491,7 @@ var require_parser = __commonJS({
2491
2491
  return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
2492
2492
  }
2493
2493
  }
2494
- var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
2494
+ var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L71, fail, 'EmptyStatement ";"'))), function(value) {
2495
2495
  return { "type": "EmptyStatement", "children": value[0] };
2496
2496
  });
2497
2497
  function EmptyStatement(state) {
@@ -2516,13 +2516,43 @@ var require_parser = __commonJS({
2516
2516
  return BlockStatement$0(state);
2517
2517
  }
2518
2518
  }
2519
- var IfStatement$0 = $T($S(If, Condition, Block, $E($S(__, Else, Block))), function(value) {
2519
+ var IfStatement$0 = $TS($S(IfClause, Block, $E($S(__, Else, Block))), function($skip, $loc, $0, $1, $2, $3) {
2520
+ var clause = $1;
2521
+ var block = $2;
2522
+ var e = $3;
2523
+ clause.children.push(block);
2524
+ if (e)
2525
+ clause.children.push(e);
2526
+ return clause;
2527
+ });
2528
+ var IfStatement$1 = $TS($S(UnlessClause, Block), function($skip, $loc, $0, $1, $2) {
2529
+ var clause = $1;
2530
+ var block = $2;
2531
+ clause.children.push(block);
2532
+ return clause;
2533
+ });
2534
+ function IfStatement(state) {
2535
+ if (state.tokenize) {
2536
+ return $TOKEN("IfStatement", state, IfStatement$0(state) || IfStatement$1(state));
2537
+ } else {
2538
+ return IfStatement$0(state) || IfStatement$1(state);
2539
+ }
2540
+ }
2541
+ var IfClause$0 = $T($S(If, Condition), function(value) {
2520
2542
  return { "type": "IfStatement", "children": value };
2521
2543
  });
2522
- var IfStatement$1 = $TS($S(Unless, Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2544
+ function IfClause(state) {
2545
+ if (state.verbose)
2546
+ console.log("ENTER:", "IfClause");
2547
+ if (state.tokenize) {
2548
+ return $TOKEN("IfClause", state, IfClause$0(state));
2549
+ } else {
2550
+ return IfClause$0(state);
2551
+ }
2552
+ }
2553
+ var UnlessClause$0 = $TS($S(Unless, Condition), function($skip, $loc, $0, $1, $2) {
2523
2554
  var kind = $1;
2524
2555
  var condition = $2;
2525
- var block = $3;
2526
2556
  condition.forEach((c) => {
2527
2557
  if (!c)
2528
2558
  return;
@@ -2534,34 +2564,34 @@ var require_parser = __commonJS({
2534
2564
  kind.token = "if";
2535
2565
  return {
2536
2566
  type: "IfStatement",
2537
- children: [kind, condition, block]
2567
+ children: [kind, condition]
2538
2568
  };
2539
2569
  });
2540
- function IfStatement(state) {
2570
+ function UnlessClause(state) {
2571
+ if (state.verbose)
2572
+ console.log("ENTER:", "UnlessClause");
2541
2573
  if (state.tokenize) {
2542
- return $TOKEN("IfStatement", state, IfStatement$0(state) || IfStatement$1(state));
2574
+ return $TOKEN("UnlessClause", state, UnlessClause$0(state));
2543
2575
  } else {
2544
- return IfStatement$0(state) || IfStatement$1(state);
2576
+ return UnlessClause$0(state);
2545
2577
  }
2546
2578
  }
2547
2579
  var IterationStatement$0 = LoopStatement;
2548
2580
  var IterationStatement$1 = DoWhileStatement;
2549
2581
  var IterationStatement$2 = WhileStatement;
2550
- var IterationStatement$3 = $T($S(ForStatement), function(value) {
2551
- return { "type": "IterationStatement", "children": value };
2552
- });
2553
- var IterationStatement$4 = $T($S(ForInOfStatement), function(value) {
2554
- return { "type": "IterationStatement", "children": value };
2555
- });
2582
+ var IterationStatement$3 = ForStatement;
2556
2583
  function IterationStatement(state) {
2557
2584
  if (state.tokenize) {
2558
- return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state));
2585
+ return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state));
2559
2586
  } else {
2560
- return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2587
+ return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state);
2561
2588
  }
2562
2589
  }
2563
- var LoopStatement$0 = $T($S(Loop, Block), function(value) {
2564
- return { "type": "IterationStatement", "children": value };
2590
+ var LoopStatement$0 = $TS($S(LoopClause, Block), function($skip, $loc, $0, $1, $2) {
2591
+ var clause = $1;
2592
+ var block = $2;
2593
+ clause.children.push(block);
2594
+ return clause;
2565
2595
  });
2566
2596
  function LoopStatement(state) {
2567
2597
  if (state.verbose)
@@ -2572,7 +2602,19 @@ var require_parser = __commonJS({
2572
2602
  return LoopStatement$0(state);
2573
2603
  }
2574
2604
  }
2575
- var DoWhileStatement$0 = $T($S($EXPECT($L76, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
2605
+ var LoopClause$0 = $T($S(Loop), function(value) {
2606
+ return { "type": "IterationStatement", "children": value };
2607
+ });
2608
+ function LoopClause(state) {
2609
+ if (state.verbose)
2610
+ console.log("ENTER:", "LoopClause");
2611
+ if (state.tokenize) {
2612
+ return $TOKEN("LoopClause", state, LoopClause$0(state));
2613
+ } else {
2614
+ return LoopClause$0(state);
2615
+ }
2616
+ }
2617
+ var DoWhileStatement$0 = $T($S(Do, BracedBlock, __, WhileClause), function(value) {
2576
2618
  return { "type": "IterationStatement", "children": value };
2577
2619
  });
2578
2620
  function DoWhileStatement(state) {
@@ -2584,8 +2626,11 @@ var require_parser = __commonJS({
2584
2626
  return DoWhileStatement$0(state);
2585
2627
  }
2586
2628
  }
2587
- var WhileStatement$0 = $T($S(WhileClause, Block), function(value) {
2588
- return { "type": "IterationStatement", "children": value };
2629
+ var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
2630
+ var clause = $1;
2631
+ var block = $2;
2632
+ clause.children.push(block);
2633
+ return clause;
2589
2634
  });
2590
2635
  function WhileStatement(state) {
2591
2636
  if (state.verbose)
@@ -2596,15 +2641,19 @@ var require_parser = __commonJS({
2596
2641
  return WhileStatement$0(state);
2597
2642
  }
2598
2643
  }
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) {
2644
+ var WhileClause$0 = $TS($S($C(While, Until), Condition), function($skip, $loc, $0, $1, $2) {
2600
2645
  var kind = $1;
2601
- var cond = $3;
2602
- if (kind === "until") {
2646
+ var cond = $2;
2647
+ if (kind.token === "until") {
2603
2648
  cond[1] = "(!(";
2604
- cond[4] = "))";
2605
- return ["while", cond];
2649
+ cond[cond.length - 1] = "))";
2650
+ kind.token = "while";
2651
+ $0 = [kind, cond];
2606
2652
  }
2607
- return $0;
2653
+ return {
2654
+ type: "IterationStatement",
2655
+ children: $0
2656
+ };
2608
2657
  });
2609
2658
  function WhileClause(state) {
2610
2659
  if (state.verbose)
@@ -2615,7 +2664,12 @@ var require_parser = __commonJS({
2615
2664
  return WhileClause$0(state);
2616
2665
  }
2617
2666
  }
2618
- var ForStatement$0 = $S(For, __, OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), CloseParen, Block);
2667
+ var ForStatement$0 = $TS($S(ForClause, Block), function($skip, $loc, $0, $1, $2) {
2668
+ var clause = $1;
2669
+ var block = $2;
2670
+ clause.children.push(block);
2671
+ return clause;
2672
+ });
2619
2673
  function ForStatement(state) {
2620
2674
  if (state.verbose)
2621
2675
  console.log("ENTER:", "ForStatement");
@@ -2625,25 +2679,48 @@ var require_parser = __commonJS({
2625
2679
  return ForStatement$0(state);
2626
2680
  }
2627
2681
  }
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) {
2682
+ var ForClause$0 = $T($S(For, __, ForStatementControl), function(value) {
2683
+ return { "type": "IterationStatement", "children": value };
2684
+ });
2685
+ function ForClause(state) {
2686
+ if (state.verbose)
2687
+ console.log("ENTER:", "ForClause");
2633
2688
  if (state.tokenize) {
2634
- return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
2689
+ return $TOKEN("ForClause", state, ForClause$0(state));
2635
2690
  } else {
2636
- return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2691
+ return ForClause$0(state);
2637
2692
  }
2638
2693
  }
2639
- var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
2694
+ var ForStatementControl$0 = $S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen);
2695
+ var ForStatementControl$1 = $S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), Expression)), InsertCloseParen);
2696
+ var ForStatementControl$2 = $S(OpenParen, __, ForInOfDeclaration, __, In, Expression, __, CloseParen);
2697
+ var ForStatementControl$3 = $S(InsertOpenParen, ForInOfDeclaration, __, In, Expression, InsertCloseParen);
2698
+ var ForStatementControl$4 = $S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, Of, AssignmentExpression, __, CloseParen);
2699
+ var ForStatementControl$5 = $S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, Of, AssignmentExpression, InsertCloseParen);
2700
+ function ForStatementControl(state) {
2701
+ if (state.tokenize) {
2702
+ return $TOKEN("ForStatementControl", state, ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state) || ForStatementControl$4(state) || ForStatementControl$5(state));
2703
+ } else {
2704
+ return ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state) || ForStatementControl$4(state) || ForStatementControl$5(state);
2705
+ }
2706
+ }
2707
+ var ForInOfDeclaration$0 = $S(Var, ForBinding);
2708
+ var ForInOfDeclaration$1 = ForDeclaration;
2709
+ var ForInOfDeclaration$2 = LeftHandSideExpression;
2710
+ function ForInOfDeclaration(state) {
2711
+ if (state.tokenize) {
2712
+ return $TOKEN("ForInOfDeclaration", state, ForInOfDeclaration$0(state) || ForInOfDeclaration$1(state) || ForInOfDeclaration$2(state));
2713
+ } else {
2714
+ return ForInOfDeclaration$0(state) || ForInOfDeclaration$1(state) || ForInOfDeclaration$2(state);
2715
+ }
2716
+ }
2717
+ var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, ForBinding);
2718
+ var ForDeclaration$1 = $S(InsertConst, ForBinding, $R$0($EXPECT($R3, fail, "ForDeclaration /(?=[\\s\\)])/")));
2640
2719
  function ForDeclaration(state) {
2641
- if (state.verbose)
2642
- console.log("ENTER:", "ForDeclaration");
2643
2720
  if (state.tokenize) {
2644
- return $TOKEN("ForDeclaration", state, ForDeclaration$0(state));
2721
+ return $TOKEN("ForDeclaration", state, ForDeclaration$0(state) || ForDeclaration$1(state));
2645
2722
  } else {
2646
- return ForDeclaration$0(state);
2723
+ return ForDeclaration$0(state) || ForDeclaration$1(state);
2647
2724
  }
2648
2725
  }
2649
2726
  var ForBinding$0 = BindingIdentifier;
@@ -2767,7 +2844,7 @@ var require_parser = __commonJS({
2767
2844
  return CaseExpressionList$0(state);
2768
2845
  }
2769
2846
  }
2770
- var NoExpressions$0 = $T($EXPECT($L1, fail, 'NoExpressions ""'), function(value) {
2847
+ var NoExpressions$0 = $T($EXPECT($L0, fail, 'NoExpressions ""'), function(value) {
2771
2848
  return [];
2772
2849
  });
2773
2850
  function NoExpressions(state) {
@@ -2780,7 +2857,7 @@ var require_parser = __commonJS({
2780
2857
  }
2781
2858
  }
2782
2859
  var ImpliedColon$0 = $S(__, Colon);
2783
- var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
2860
+ var ImpliedColon$1 = $TV($EXPECT($L0, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
2784
2861
  return { $loc, token: ":" };
2785
2862
  });
2786
2863
  function ImpliedColon(state) {
@@ -2834,7 +2911,7 @@ var require_parser = __commonJS({
2834
2911
  return CatchBind$0(state) || CatchBind$1(state);
2835
2912
  }
2836
2913
  }
2837
- var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
2914
+ var Finally$0 = $S(__, $EXPECT($L72, fail, 'Finally "finally"'), BracedBlock);
2838
2915
  function Finally(state) {
2839
2916
  if (state.verbose)
2840
2917
  console.log("ENTER:", "Finally");
@@ -2854,7 +2931,10 @@ var require_parser = __commonJS({
2854
2931
  }
2855
2932
  }
2856
2933
  var Condition$0 = $S(__, OpenParen, Expression, __, CloseParen);
2857
- var Condition$1 = $S($N(EOS), __, InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen);
2934
+ var Condition$1 = $TS($S($N(EOS), __, InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
2935
+ $0.shift();
2936
+ return $0;
2937
+ });
2858
2938
  function Condition(state) {
2859
2939
  if (state.tokenize) {
2860
2940
  return $TOKEN("Condition", state, Condition$0(state) || Condition$1(state));
@@ -2878,7 +2958,7 @@ var require_parser = __commonJS({
2878
2958
  return ExpressionWithIndentedApplicationSuppressed$0(state);
2879
2959
  }
2880
2960
  }
2881
- var SuppressIndentedApplication$0 = $TV($EXPECT($L1, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
2961
+ var SuppressIndentedApplication$0 = $TV($EXPECT($L0, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
2882
2962
  module2.suppressIndentedApplication = true;
2883
2963
  });
2884
2964
  function SuppressIndentedApplication(state) {
@@ -2900,13 +2980,13 @@ var require_parser = __commonJS({
2900
2980
  return ExpressionStatement$0(state);
2901
2981
  }
2902
2982
  }
2903
- var KeywordStatement$0 = $T($S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
2983
+ var KeywordStatement$0 = $T($S($EXPECT($L73, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
2904
2984
  return { "type": "BreakStatement", "children": value };
2905
2985
  });
2906
- var KeywordStatement$1 = $T($S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
2986
+ var KeywordStatement$1 = $T($S($EXPECT($L74, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
2907
2987
  return { "type": "ContinueStatement", "children": value };
2908
2988
  });
2909
- var KeywordStatement$2 = $T($S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
2989
+ var KeywordStatement$2 = $T($S($EXPECT($L75, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
2910
2990
  return { "type": "DebuggerStatement", "children": value };
2911
2991
  });
2912
2992
  var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
@@ -2931,7 +3011,7 @@ var require_parser = __commonJS({
2931
3011
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2932
3012
  }
2933
3013
  }
2934
- var ImportDeclaration$0 = $T($S($EXPECT($L83, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
3014
+ var ImportDeclaration$0 = $T($S($EXPECT($L76, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2935
3015
  return { "ts": true, "children": value };
2936
3016
  });
2937
3017
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2954,7 +3034,7 @@ var require_parser = __commonJS({
2954
3034
  return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
2955
3035
  }
2956
3036
  }
2957
- var ImpliedImport$0 = $TV($EXPECT($L1, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
3037
+ var ImpliedImport$0 = $TV($EXPECT($L0, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
2958
3038
  return { $loc, token: "import " };
2959
3039
  });
2960
3040
  function ImpliedImport(state) {
@@ -3046,7 +3126,7 @@ var require_parser = __commonJS({
3046
3126
  return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
3047
3127
  }
3048
3128
  }
3049
- var UnquotedSpecifier$0 = $TV($EXPECT($R3, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
3129
+ var UnquotedSpecifier$0 = $TV($EXPECT($R4, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
3050
3130
  var spec = $0;
3051
3131
  return { $loc, token: `"${spec}"` };
3052
3132
  });
@@ -3069,7 +3149,7 @@ var require_parser = __commonJS({
3069
3149
  return ImportedBinding$0(state);
3070
3150
  }
3071
3151
  }
3072
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
3152
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L77, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
3073
3153
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
3074
3154
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
3075
3155
  function ExportDeclaration(state) {
@@ -3151,7 +3231,7 @@ var require_parser = __commonJS({
3151
3231
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
3152
3232
  }
3153
3233
  }
3154
- var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
3234
+ var ConstAssignment$0 = $TV($EXPECT($L78, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
3155
3235
  return { $loc, token: "=" };
3156
3236
  });
3157
3237
  function ConstAssignment(state) {
@@ -3237,7 +3317,7 @@ var require_parser = __commonJS({
3237
3317
  return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
3238
3318
  }
3239
3319
  }
3240
- var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R4, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
3320
+ var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
3241
3321
  function DecimalBigIntegerLiteral(state) {
3242
3322
  if (state.verbose)
3243
3323
  console.log("ENTER:", "DecimalBigIntegerLiteral");
@@ -3247,11 +3327,11 @@ var require_parser = __commonJS({
3247
3327
  return DecimalBigIntegerLiteral$0(state);
3248
3328
  }
3249
3329
  }
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) {
3330
+ 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
3331
  return $1 + ".";
3252
3332
  });
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)));
3333
+ var DecimalLiteral$1 = $TEXT($S($EXPECT($R7, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?/"), $E(ExponentPart)));
3334
+ var DecimalLiteral$2 = $TEXT($S($EXPECT($R8, fail, "DecimalLiteral /(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
3255
3335
  function DecimalLiteral(state) {
3256
3336
  if (state.tokenize) {
3257
3337
  return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
@@ -3259,7 +3339,7 @@ var require_parser = __commonJS({
3259
3339
  return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
3260
3340
  }
3261
3341
  }
3262
- var ExponentPart$0 = $R$0($EXPECT($R8, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
3342
+ var ExponentPart$0 = $R$0($EXPECT($R9, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
3263
3343
  function ExponentPart(state) {
3264
3344
  if (state.verbose)
3265
3345
  console.log("ENTER:", "ExponentPart");
@@ -3269,7 +3349,7 @@ var require_parser = __commonJS({
3269
3349
  return ExponentPart$0(state);
3270
3350
  }
3271
3351
  }
3272
- var BinaryIntegerLiteral$0 = $R$0($EXPECT($R9, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
3352
+ var BinaryIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
3273
3353
  function BinaryIntegerLiteral(state) {
3274
3354
  if (state.verbose)
3275
3355
  console.log("ENTER:", "BinaryIntegerLiteral");
@@ -3279,7 +3359,7 @@ var require_parser = __commonJS({
3279
3359
  return BinaryIntegerLiteral$0(state);
3280
3360
  }
3281
3361
  }
3282
- var OctalIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
3362
+ var OctalIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
3283
3363
  function OctalIntegerLiteral(state) {
3284
3364
  if (state.verbose)
3285
3365
  console.log("ENTER:", "OctalIntegerLiteral");
@@ -3289,7 +3369,7 @@ var require_parser = __commonJS({
3289
3369
  return OctalIntegerLiteral$0(state);
3290
3370
  }
3291
3371
  }
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?/"));
3372
+ 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
3373
  function HexLiteral(state) {
3294
3374
  if (state.verbose)
3295
3375
  console.log("ENTER:", "HexLiteral");
@@ -3338,7 +3418,7 @@ var require_parser = __commonJS({
3338
3418
  return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
3339
3419
  }
3340
3420
  }
3341
- var DoubleStringCharacters$0 = $TR($EXPECT($R12, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3421
+ var DoubleStringCharacters$0 = $TR($EXPECT($R13, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3342
3422
  return { $loc, token: $0 };
3343
3423
  });
3344
3424
  function DoubleStringCharacters(state) {
@@ -3350,7 +3430,7 @@ var require_parser = __commonJS({
3350
3430
  return DoubleStringCharacters$0(state);
3351
3431
  }
3352
3432
  }
3353
- var SingleStringCharacters$0 = $TR($EXPECT($R13, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3433
+ var SingleStringCharacters$0 = $TR($EXPECT($R14, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3354
3434
  return { $loc, token: $0 };
3355
3435
  });
3356
3436
  function SingleStringCharacters(state) {
@@ -3362,7 +3442,7 @@ var require_parser = __commonJS({
3362
3442
  return SingleStringCharacters$0(state);
3363
3443
  }
3364
3444
  }
3365
- var TripleDoubleStringCharacters$0 = $TR($EXPECT($R14, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3445
+ var TripleDoubleStringCharacters$0 = $TR($EXPECT($R15, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3366
3446
  return { $loc, token: $0 };
3367
3447
  });
3368
3448
  function TripleDoubleStringCharacters(state) {
@@ -3374,7 +3454,7 @@ var require_parser = __commonJS({
3374
3454
  return TripleDoubleStringCharacters$0(state);
3375
3455
  }
3376
3456
  }
3377
- var TripleSingleStringCharacters$0 = $TR($EXPECT($R15, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3457
+ var TripleSingleStringCharacters$0 = $TR($EXPECT($R16, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3378
3458
  return { $loc, token: $0 };
3379
3459
  });
3380
3460
  function TripleSingleStringCharacters(state) {
@@ -3425,7 +3505,7 @@ var require_parser = __commonJS({
3425
3505
  return CoffeeInterpolatedDoubleQuotedString$0(state);
3426
3506
  }
3427
3507
  }
3428
- var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R16, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3508
+ var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R17, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3429
3509
  return { $loc, token: $0 };
3430
3510
  });
3431
3511
  function CoffeeDoubleQuotedStringCharacters(state) {
@@ -3437,7 +3517,7 @@ var require_parser = __commonJS({
3437
3517
  return CoffeeDoubleQuotedStringCharacters$0(state);
3438
3518
  }
3439
3519
  }
3440
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3520
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3441
3521
  return { $loc, token: $1 };
3442
3522
  });
3443
3523
  function RegularExpressionLiteral(state) {
@@ -3449,7 +3529,7 @@ var require_parser = __commonJS({
3449
3529
  return RegularExpressionLiteral$0(state);
3450
3530
  }
3451
3531
  }
3452
- var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R17, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3532
+ var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R18, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3453
3533
  function RegularExpressionBody(state) {
3454
3534
  if (state.verbose)
3455
3535
  console.log("ENTER:", "RegularExpressionBody");
@@ -3459,7 +3539,7 @@ var require_parser = __commonJS({
3459
3539
  return RegularExpressionBody$0(state);
3460
3540
  }
3461
3541
  }
3462
- var RegExpCharacter$0 = $R$0($EXPECT($R18, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3542
+ var RegExpCharacter$0 = $R$0($EXPECT($R19, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3463
3543
  function RegExpCharacter(state) {
3464
3544
  if (state.verbose)
3465
3545
  console.log("ENTER:", "RegExpCharacter");
@@ -3469,7 +3549,7 @@ var require_parser = __commonJS({
3469
3549
  return RegExpCharacter$0(state);
3470
3550
  }
3471
3551
  }
3472
- var RegularExpressionFlags$0 = $R$0($EXPECT($R19, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3552
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R20, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3473
3553
  function RegularExpressionFlags(state) {
3474
3554
  if (state.verbose)
3475
3555
  console.log("ENTER:", "RegularExpressionFlags");
@@ -3482,7 +3562,7 @@ var require_parser = __commonJS({
3482
3562
  var TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
3483
3563
  return module2.dedentBlockSubstitutions($0);
3484
3564
  });
3485
- var TemplateLiteral$1 = $S($EXPECT($L0, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L0, fail, 'TemplateLiteral "`"'));
3565
+ var TemplateLiteral$1 = $S(Backtick, $Q($C(TemplateCharacters, TemplateSubstitution)), Backtick);
3486
3566
  function TemplateLiteral(state) {
3487
3567
  if (state.tokenize) {
3488
3568
  return $TOKEN("TemplateLiteral", state, TemplateLiteral$0(state) || TemplateLiteral$1(state));
@@ -3500,7 +3580,7 @@ var require_parser = __commonJS({
3500
3580
  return TemplateSubstitution$0(state);
3501
3581
  }
3502
3582
  }
3503
- var TemplateCharacters$0 = $TR($EXPECT($R20, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3583
+ var TemplateCharacters$0 = $TR($EXPECT($R21, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3504
3584
  return { $loc, token: $0 };
3505
3585
  });
3506
3586
  function TemplateCharacters(state) {
@@ -3512,7 +3592,7 @@ var require_parser = __commonJS({
3512
3592
  return TemplateCharacters$0(state);
3513
3593
  }
3514
3594
  }
3515
- var TemplateBlockCharacters$0 = $TR($EXPECT($R21, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3595
+ var TemplateBlockCharacters$0 = $TR($EXPECT($R22, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3516
3596
  return { $loc, token: $0 };
3517
3597
  });
3518
3598
  function TemplateBlockCharacters(state) {
@@ -3524,8 +3604,8 @@ var require_parser = __commonJS({
3524
3604
  return TemplateBlockCharacters$0(state);
3525
3605
  }
3526
3606
  }
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})/"));
3607
+ var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R23, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
3608
+ 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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3529
3609
  function ReservedWord(state) {
3530
3610
  if (state.tokenize) {
3531
3611
  return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
@@ -3542,7 +3622,7 @@ var require_parser = __commonJS({
3542
3622
  return Comment$0(state) || Comment$1(state);
3543
3623
  }
3544
3624
  }
3545
- var SingleLineComment$0 = $TR($EXPECT($R24, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3625
+ var SingleLineComment$0 = $TR($EXPECT($R25, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3546
3626
  return { $loc, token: $0 };
3547
3627
  });
3548
3628
  var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
@@ -3562,7 +3642,7 @@ var require_parser = __commonJS({
3562
3642
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3563
3643
  }
3564
3644
  }
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) {
3645
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L79, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L80, fail, 'JSMultiLineComment "*/"')), $EXPECT($R26, fail, "JSMultiLineComment /./"))), $EXPECT($L80, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3566
3646
  return { $loc, token: $1 };
3567
3647
  });
3568
3648
  function JSMultiLineComment(state) {
@@ -3574,7 +3654,7 @@ var require_parser = __commonJS({
3574
3654
  return JSMultiLineComment$0(state);
3575
3655
  }
3576
3656
  }
3577
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R26, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3657
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R27, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3578
3658
  return { $loc, token: `//${$1}` };
3579
3659
  });
3580
3660
  function CoffeeSingleLineComment(state) {
@@ -3586,7 +3666,7 @@ var require_parser = __commonJS({
3586
3666
  return CoffeeSingleLineComment$0(state);
3587
3667
  }
3588
3668
  }
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) {
3669
+ var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L81, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L81, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L80, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R26, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L81, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3590
3670
  return { $loc, token: `/*${$2}*/` };
3591
3671
  });
3592
3672
  function CoffeeMultiLineComment(state) {
@@ -3598,7 +3678,7 @@ var require_parser = __commonJS({
3598
3678
  return CoffeeMultiLineComment$0(state);
3599
3679
  }
3600
3680
  }
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) {
3681
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L79, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L80, fail, 'InlineComment "*/"')), $EXPECT($R28, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L80, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3602
3682
  return { $loc, token: $1 };
3603
3683
  });
3604
3684
  function InlineComment(state) {
@@ -3640,7 +3720,7 @@ var require_parser = __commonJS({
3640
3720
  return _$0(state);
3641
3721
  }
3642
3722
  }
3643
- var NonNewlineWhitespace$0 = $TR($EXPECT($R28, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3723
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R29, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3644
3724
  return { $loc, token: $0 };
3645
3725
  });
3646
3726
  function NonNewlineWhitespace(state) {
@@ -3662,7 +3742,7 @@ var require_parser = __commonJS({
3662
3742
  return __$0(state);
3663
3743
  }
3664
3744
  }
3665
- var Whitespace$0 = $TR($EXPECT($R29, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3745
+ var Whitespace$0 = $TR($EXPECT($R30, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3666
3746
  return { $loc, token: $0 };
3667
3747
  });
3668
3748
  function Whitespace(state) {
@@ -3683,7 +3763,7 @@ var require_parser = __commonJS({
3683
3763
  return StatementDelimiter$0(state) || StatementDelimiter$1(state);
3684
3764
  }
3685
3765
  }
3686
- var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3766
+ var NonIdContinue$0 = $R$0($EXPECT($R31, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3687
3767
  function NonIdContinue(state) {
3688
3768
  if (state.verbose)
3689
3769
  console.log("ENTER:", "NonIdContinue");
@@ -3693,7 +3773,7 @@ var require_parser = __commonJS({
3693
3773
  return NonIdContinue$0(state);
3694
3774
  }
3695
3775
  }
3696
- var Loc$0 = $TV($EXPECT($L1, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
3776
+ var Loc$0 = $TV($EXPECT($L0, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
3697
3777
  return { $loc, token: "" };
3698
3778
  });
3699
3779
  function Loc(state) {
@@ -3705,7 +3785,7 @@ var require_parser = __commonJS({
3705
3785
  return Loc$0(state);
3706
3786
  }
3707
3787
  }
3708
- var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3788
+ var As$0 = $TS($S($EXPECT($L82, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3709
3789
  return { $loc, token: $1 };
3710
3790
  });
3711
3791
  function As(state) {
@@ -3717,7 +3797,7 @@ var require_parser = __commonJS({
3717
3797
  return As$0(state);
3718
3798
  }
3719
3799
  }
3720
- var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3800
+ var Async$0 = $TV($EXPECT($L83, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3721
3801
  return { $loc, token: $1 };
3722
3802
  });
3723
3803
  function Async(state) {
@@ -3729,7 +3809,7 @@ var require_parser = __commonJS({
3729
3809
  return Async$0(state);
3730
3810
  }
3731
3811
  }
3732
- var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3812
+ var Await$0 = $TS($S($EXPECT($L84, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3733
3813
  return { $loc, token: $1 };
3734
3814
  });
3735
3815
  function Await(state) {
@@ -3741,7 +3821,19 @@ var require_parser = __commonJS({
3741
3821
  return Await$0(state);
3742
3822
  }
3743
3823
  }
3744
- var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3824
+ var Backtick$0 = $TV($EXPECT($L85, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
3825
+ return { $loc, token: $1 };
3826
+ });
3827
+ function Backtick(state) {
3828
+ if (state.verbose)
3829
+ console.log("ENTER:", "Backtick");
3830
+ if (state.tokenize) {
3831
+ return $TOKEN("Backtick", state, Backtick$0(state));
3832
+ } else {
3833
+ return Backtick$0(state);
3834
+ }
3835
+ }
3836
+ var Case$0 = $TS($S($EXPECT($L86, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3745
3837
  return { $loc, token: $1 };
3746
3838
  });
3747
3839
  function Case(state) {
@@ -3753,7 +3845,7 @@ var require_parser = __commonJS({
3753
3845
  return Case$0(state);
3754
3846
  }
3755
3847
  }
3756
- var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3848
+ var Catch$0 = $TV($EXPECT($L87, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3757
3849
  return { $loc, token: $1 };
3758
3850
  });
3759
3851
  function Catch(state) {
@@ -3765,7 +3857,7 @@ var require_parser = __commonJS({
3765
3857
  return Catch$0(state);
3766
3858
  }
3767
3859
  }
3768
- var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3860
+ var Class$0 = $TV($EXPECT($L88, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3769
3861
  return { $loc, token: $1 };
3770
3862
  });
3771
3863
  function Class(state) {
@@ -3777,7 +3869,7 @@ var require_parser = __commonJS({
3777
3869
  return Class$0(state);
3778
3870
  }
3779
3871
  }
3780
- var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3872
+ var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3781
3873
  return { $loc, token: $1 };
3782
3874
  });
3783
3875
  function CloseBrace(state) {
@@ -3789,7 +3881,7 @@ var require_parser = __commonJS({
3789
3881
  return CloseBrace$0(state);
3790
3882
  }
3791
3883
  }
3792
- var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3884
+ var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3793
3885
  return { $loc, token: $1 };
3794
3886
  });
3795
3887
  function CloseBracket(state) {
@@ -3801,7 +3893,7 @@ var require_parser = __commonJS({
3801
3893
  return CloseBracket$0(state);
3802
3894
  }
3803
3895
  }
3804
- var CloseParen$0 = $TV($EXPECT($L16, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3896
+ var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3805
3897
  return { $loc, token: $1 };
3806
3898
  });
3807
3899
  function CloseParen(state) {
@@ -3813,7 +3905,7 @@ var require_parser = __commonJS({
3813
3905
  return CloseParen$0(state);
3814
3906
  }
3815
3907
  }
3816
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3908
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L89, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3817
3909
  return { $loc, token: "${" };
3818
3910
  });
3819
3911
  function CoffeeSubstitutionStart(state) {
@@ -3825,7 +3917,7 @@ var require_parser = __commonJS({
3825
3917
  return CoffeeSubstitutionStart$0(state);
3826
3918
  }
3827
3919
  }
3828
- var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3920
+ var Colon$0 = $TV($EXPECT($L90, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3829
3921
  return { $loc, token: $1 };
3830
3922
  });
3831
3923
  function Colon(state) {
@@ -3837,7 +3929,7 @@ var require_parser = __commonJS({
3837
3929
  return Colon$0(state);
3838
3930
  }
3839
3931
  }
3840
- var ConstructorShorthand$0 = $TV($EXPECT($L9, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
3932
+ var ConstructorShorthand$0 = $TV($EXPECT($L8, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
3841
3933
  return { $loc, token: "constructor" };
3842
3934
  });
3843
3935
  function ConstructorShorthand(state) {
@@ -3849,7 +3941,7 @@ var require_parser = __commonJS({
3849
3941
  return ConstructorShorthand$0(state);
3850
3942
  }
3851
3943
  }
3852
- var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3944
+ var Default$0 = $TS($S($EXPECT($L77, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3853
3945
  return { $loc, token: $1 };
3854
3946
  });
3855
3947
  function Default(state) {
@@ -3861,7 +3953,31 @@ var require_parser = __commonJS({
3861
3953
  return Default$0(state);
3862
3954
  }
3863
3955
  }
3864
- var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3956
+ var Delete$0 = $TS($S($EXPECT($L91, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3957
+ return { $loc, token: $1 };
3958
+ });
3959
+ function Delete(state) {
3960
+ if (state.verbose)
3961
+ console.log("ENTER:", "Delete");
3962
+ if (state.tokenize) {
3963
+ return $TOKEN("Delete", state, Delete$0(state));
3964
+ } else {
3965
+ return Delete$0(state);
3966
+ }
3967
+ }
3968
+ var Do$0 = $TS($S($EXPECT($L92, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3969
+ return { $loc, token: $1 };
3970
+ });
3971
+ function Do(state) {
3972
+ if (state.verbose)
3973
+ console.log("ENTER:", "Do");
3974
+ if (state.tokenize) {
3975
+ return $TOKEN("Do", state, Do$0(state));
3976
+ } else {
3977
+ return Do$0(state);
3978
+ }
3979
+ }
3980
+ var Dot$0 = $TV($EXPECT($L93, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3865
3981
  return { $loc, token: $1 };
3866
3982
  });
3867
3983
  function Dot(state) {
@@ -3873,7 +3989,7 @@ var require_parser = __commonJS({
3873
3989
  return Dot$0(state);
3874
3990
  }
3875
3991
  }
3876
- var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
3992
+ var DotDotDot$0 = $TV($EXPECT($L94, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
3877
3993
  return { $loc, token: $1 };
3878
3994
  });
3879
3995
  function DotDotDot(state) {
@@ -3885,7 +4001,7 @@ var require_parser = __commonJS({
3885
4001
  return DotDotDot$0(state);
3886
4002
  }
3887
4003
  }
3888
- var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
4004
+ var DoubleQuote$0 = $TV($EXPECT($L95, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3889
4005
  return { $loc, token: $1 };
3890
4006
  });
3891
4007
  function DoubleQuote(state) {
@@ -3897,7 +4013,7 @@ var require_parser = __commonJS({
3897
4013
  return DoubleQuote$0(state);
3898
4014
  }
3899
4015
  }
3900
- var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
4016
+ var Else$0 = $TV($EXPECT($L96, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3901
4017
  return { $loc, token: $1 };
3902
4018
  });
3903
4019
  function Else(state) {
@@ -3909,7 +4025,7 @@ var require_parser = __commonJS({
3909
4025
  return Else$0(state);
3910
4026
  }
3911
4027
  }
3912
- var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
4028
+ var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3913
4029
  return { $loc, token: $1 };
3914
4030
  });
3915
4031
  function Equals(state) {
@@ -3921,7 +4037,7 @@ var require_parser = __commonJS({
3921
4037
  return Equals$0(state);
3922
4038
  }
3923
4039
  }
3924
- var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4040
+ var Export$0 = $TS($S($EXPECT($L97, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3925
4041
  return { $loc, token: $1 };
3926
4042
  });
3927
4043
  function Export(state) {
@@ -3933,7 +4049,7 @@ var require_parser = __commonJS({
3933
4049
  return Export$0(state);
3934
4050
  }
3935
4051
  }
3936
- var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4052
+ var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3937
4053
  return { $loc, token: $1 };
3938
4054
  });
3939
4055
  function For(state) {
@@ -3945,7 +4061,7 @@ var require_parser = __commonJS({
3945
4061
  return For$0(state);
3946
4062
  }
3947
4063
  }
3948
- var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4064
+ var From$0 = $TS($S($EXPECT($L99, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3949
4065
  return { $loc, token: $1 };
3950
4066
  });
3951
4067
  function From(state) {
@@ -3957,7 +4073,7 @@ var require_parser = __commonJS({
3957
4073
  return From$0(state);
3958
4074
  }
3959
4075
  }
3960
- var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
4076
+ var Function$0 = $TV($EXPECT($L100, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3961
4077
  return { $loc, token: $1 };
3962
4078
  });
3963
4079
  function Function(state) {
@@ -3969,7 +4085,7 @@ var require_parser = __commonJS({
3969
4085
  return Function$0(state);
3970
4086
  }
3971
4087
  }
3972
- var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4088
+ var GetOrSet$0 = $TS($S($C($EXPECT($L101, fail, 'GetOrSet "get"'), $EXPECT($L102, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3973
4089
  return { $loc, token: $1 };
3974
4090
  });
3975
4091
  function GetOrSet(state) {
@@ -3981,7 +4097,7 @@ var require_parser = __commonJS({
3981
4097
  return GetOrSet$0(state);
3982
4098
  }
3983
4099
  }
3984
- var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
4100
+ var If$0 = $TV($EXPECT($L103, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3985
4101
  return { $loc, token: $1 };
3986
4102
  });
3987
4103
  function If(state) {
@@ -3993,7 +4109,7 @@ var require_parser = __commonJS({
3993
4109
  return If$0(state);
3994
4110
  }
3995
4111
  }
3996
- var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
4112
+ var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R32, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3997
4113
  return { $loc, token: $1 };
3998
4114
  });
3999
4115
  function Import(state) {
@@ -4005,7 +4121,7 @@ var require_parser = __commonJS({
4005
4121
  return Import$0(state);
4006
4122
  }
4007
4123
  }
4008
- var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
4124
+ var In$0 = $TV($EXPECT($L67, fail, 'In "in"'), function($skip, $loc, $0, $1) {
4009
4125
  return { $loc, token: $1 };
4010
4126
  });
4011
4127
  function In(state) {
@@ -4017,7 +4133,7 @@ var require_parser = __commonJS({
4017
4133
  return In$0(state);
4018
4134
  }
4019
4135
  }
4020
- var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
4136
+ var LetOrConst$0 = $TV($C($EXPECT($L104, fail, 'LetOrConst "let"'), $EXPECT($L105, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
4021
4137
  return { $loc, token: $1 };
4022
4138
  });
4023
4139
  function LetOrConst(state) {
@@ -4029,7 +4145,7 @@ var require_parser = __commonJS({
4029
4145
  return LetOrConst$0(state);
4030
4146
  }
4031
4147
  }
4032
- var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4148
+ var Loop$0 = $TS($S($EXPECT($L106, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4033
4149
  return { $loc, token: "while(true)" };
4034
4150
  });
4035
4151
  function Loop(state) {
@@ -4041,7 +4157,7 @@ var require_parser = __commonJS({
4041
4157
  return Loop$0(state);
4042
4158
  }
4043
4159
  }
4044
- var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
4160
+ var New$0 = $TV($EXPECT($L107, fail, 'New "new"'), function($skip, $loc, $0, $1) {
4045
4161
  return { $loc, token: $1 };
4046
4162
  });
4047
4163
  function New(state) {
@@ -4053,7 +4169,7 @@ var require_parser = __commonJS({
4053
4169
  return New$0(state);
4054
4170
  }
4055
4171
  }
4056
- var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
4172
+ var Of$0 = $TV($EXPECT($L108, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
4057
4173
  return { $loc, token: $1 };
4058
4174
  });
4059
4175
  function Of(state) {
@@ -4065,7 +4181,7 @@ var require_parser = __commonJS({
4065
4181
  return Of$0(state);
4066
4182
  }
4067
4183
  }
4068
- var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
4184
+ var OpenBrace$0 = $TV($EXPECT($L109, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
4069
4185
  return { $loc, token: $1 };
4070
4186
  });
4071
4187
  function OpenBrace(state) {
@@ -4077,7 +4193,7 @@ var require_parser = __commonJS({
4077
4193
  return OpenBrace$0(state);
4078
4194
  }
4079
4195
  }
4080
- var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
4196
+ var OpenBracket$0 = $TV($EXPECT($L110, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
4081
4197
  return { $loc, token: $1 };
4082
4198
  });
4083
4199
  function OpenBracket(state) {
@@ -4089,7 +4205,7 @@ var require_parser = __commonJS({
4089
4205
  return OpenBracket$0(state);
4090
4206
  }
4091
4207
  }
4092
- var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4208
+ var OpenParen$0 = $TV($EXPECT($L111, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4093
4209
  return { $loc, token: $1 };
4094
4210
  });
4095
4211
  function OpenParen(state) {
@@ -4101,7 +4217,7 @@ var require_parser = __commonJS({
4101
4217
  return OpenParen$0(state);
4102
4218
  }
4103
4219
  }
4104
- var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4220
+ var QuestionMark$0 = $TV($EXPECT($L112, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4105
4221
  return { $loc, token: $1 };
4106
4222
  });
4107
4223
  function QuestionMark(state) {
@@ -4113,7 +4229,7 @@ var require_parser = __commonJS({
4113
4229
  return QuestionMark$0(state);
4114
4230
  }
4115
4231
  }
4116
- var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4232
+ var Return$0 = $TS($S($EXPECT($L113, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4117
4233
  return { $loc, token: $1 };
4118
4234
  });
4119
4235
  function Return(state) {
@@ -4125,7 +4241,7 @@ var require_parser = __commonJS({
4125
4241
  return Return$0(state);
4126
4242
  }
4127
4243
  }
4128
- var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4244
+ var Semicolon$0 = $TV($EXPECT($L71, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
4129
4245
  return { $loc, token: $1 };
4130
4246
  });
4131
4247
  function Semicolon(state) {
@@ -4137,7 +4253,7 @@ var require_parser = __commonJS({
4137
4253
  return Semicolon$0(state);
4138
4254
  }
4139
4255
  }
4140
- var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4256
+ var SingleQuote$0 = $TV($EXPECT($L114, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
4141
4257
  return { $loc, token: $1 };
4142
4258
  });
4143
4259
  function SingleQuote(state) {
@@ -4149,7 +4265,7 @@ var require_parser = __commonJS({
4149
4265
  return SingleQuote$0(state);
4150
4266
  }
4151
4267
  }
4152
- var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4268
+ var Star$0 = $TV($EXPECT($L45, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
4153
4269
  return { $loc, token: $1 };
4154
4270
  });
4155
4271
  function Star(state) {
@@ -4161,10 +4277,10 @@ var require_parser = __commonJS({
4161
4277
  return Star$0(state);
4162
4278
  }
4163
4279
  }
4164
- var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4280
+ var Static$0 = $TV($EXPECT($L115, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
4165
4281
  return { $loc, token: $1 };
4166
4282
  });
4167
- var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4283
+ var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($L111, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
4168
4284
  return { $loc, token: "static " };
4169
4285
  });
4170
4286
  function Static(state) {
@@ -4174,7 +4290,7 @@ var require_parser = __commonJS({
4174
4290
  return Static$0(state) || Static$1(state);
4175
4291
  }
4176
4292
  }
4177
- var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4293
+ var SubstitutionStart$0 = $TV($EXPECT($L116, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
4178
4294
  return { $loc, token: $1 };
4179
4295
  });
4180
4296
  function SubstitutionStart(state) {
@@ -4186,7 +4302,7 @@ var require_parser = __commonJS({
4186
4302
  return SubstitutionStart$0(state);
4187
4303
  }
4188
4304
  }
4189
- var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4305
+ var Switch$0 = $TS($S($EXPECT($L117, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4190
4306
  return { $loc, token: $1 };
4191
4307
  });
4192
4308
  function Switch(state) {
@@ -4198,7 +4314,7 @@ var require_parser = __commonJS({
4198
4314
  return Switch$0(state);
4199
4315
  }
4200
4316
  }
4201
- var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4317
+ var Target$0 = $TV($EXPECT($L118, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
4202
4318
  return { $loc, token: $1 };
4203
4319
  });
4204
4320
  function Target(state) {
@@ -4210,7 +4326,7 @@ var require_parser = __commonJS({
4210
4326
  return Target$0(state);
4211
4327
  }
4212
4328
  }
4213
- var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4329
+ var Throw$0 = $TS($S($EXPECT($L119, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4214
4330
  return { $loc, token: $1 };
4215
4331
  });
4216
4332
  function Throw(state) {
@@ -4222,7 +4338,7 @@ var require_parser = __commonJS({
4222
4338
  return Throw$0(state);
4223
4339
  }
4224
4340
  }
4225
- var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4341
+ var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
4226
4342
  return { $loc, token: "`" };
4227
4343
  });
4228
4344
  function TripleDoubleQuote(state) {
@@ -4234,7 +4350,7 @@ var require_parser = __commonJS({
4234
4350
  return TripleDoubleQuote$0(state);
4235
4351
  }
4236
4352
  }
4237
- var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4353
+ var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
4238
4354
  return { $loc, token: "`" };
4239
4355
  });
4240
4356
  function TripleSingleQuote(state) {
@@ -4246,7 +4362,7 @@ var require_parser = __commonJS({
4246
4362
  return TripleSingleQuote$0(state);
4247
4363
  }
4248
4364
  }
4249
- var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4365
+ var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
4250
4366
  return { $loc, token: "`" };
4251
4367
  });
4252
4368
  function TripleTick(state) {
@@ -4258,7 +4374,7 @@ var require_parser = __commonJS({
4258
4374
  return TripleTick$0(state);
4259
4375
  }
4260
4376
  }
4261
- var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4377
+ var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
4262
4378
  return { $loc, token: $1 };
4263
4379
  });
4264
4380
  function Try(state) {
@@ -4270,7 +4386,19 @@ var require_parser = __commonJS({
4270
4386
  return Try$0(state);
4271
4387
  }
4272
4388
  }
4273
- var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4389
+ var Typeof$0 = $TS($S($EXPECT($L124, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4390
+ return { $loc, token: $1 };
4391
+ });
4392
+ function Typeof(state) {
4393
+ if (state.verbose)
4394
+ console.log("ENTER:", "Typeof");
4395
+ if (state.tokenize) {
4396
+ return $TOKEN("Typeof", state, Typeof$0(state));
4397
+ } else {
4398
+ return Typeof$0(state);
4399
+ }
4400
+ }
4401
+ var Unless$0 = $TV($EXPECT($L125, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
4274
4402
  return { $loc, token: $1 };
4275
4403
  });
4276
4404
  function Unless(state) {
@@ -4282,7 +4410,19 @@ var require_parser = __commonJS({
4282
4410
  return Unless$0(state);
4283
4411
  }
4284
4412
  }
4285
- var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4413
+ var Until$0 = $TS($S($EXPECT($L126, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4414
+ return { $loc, token: $1 };
4415
+ });
4416
+ function Until(state) {
4417
+ if (state.verbose)
4418
+ console.log("ENTER:", "Until");
4419
+ if (state.tokenize) {
4420
+ return $TOKEN("Until", state, Until$0(state));
4421
+ } else {
4422
+ return Until$0(state);
4423
+ }
4424
+ }
4425
+ var Var$0 = $TV($EXPECT($L127, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
4286
4426
  return { $loc, token: $1 };
4287
4427
  });
4288
4428
  function Var(state) {
@@ -4294,7 +4434,19 @@ var require_parser = __commonJS({
4294
4434
  return Var$0(state);
4295
4435
  }
4296
4436
  }
4297
- var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4437
+ var Void$0 = $TS($S($EXPECT($L128, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4438
+ return { $loc, token: $1 };
4439
+ });
4440
+ function Void(state) {
4441
+ if (state.verbose)
4442
+ console.log("ENTER:", "Void");
4443
+ if (state.tokenize) {
4444
+ return $TOKEN("Void", state, Void$0(state));
4445
+ } else {
4446
+ return Void$0(state);
4447
+ }
4448
+ }
4449
+ var When$0 = $TS($S($EXPECT($L129, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4298
4450
  return { $loc, token: "case" };
4299
4451
  });
4300
4452
  function When(state) {
@@ -4306,6 +4458,18 @@ var require_parser = __commonJS({
4306
4458
  return When$0(state);
4307
4459
  }
4308
4460
  }
4461
+ var While$0 = $TS($S($EXPECT($L130, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4462
+ return { $loc, token: $1 };
4463
+ });
4464
+ function While(state) {
4465
+ if (state.verbose)
4466
+ console.log("ENTER:", "While");
4467
+ if (state.tokenize) {
4468
+ return $TOKEN("While", state, While$0(state));
4469
+ } else {
4470
+ return While$0(state);
4471
+ }
4472
+ }
4309
4473
  var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4310
4474
  return { $loc, token: $1 };
4311
4475
  });
@@ -4332,7 +4496,7 @@ var require_parser = __commonJS({
4332
4496
  return JSXElement$0(state) || JSXElement$1(state);
4333
4497
  }
4334
4498
  }
4335
- var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
4499
+ var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
4336
4500
  function JSXSelfClosingElement(state) {
4337
4501
  if (state.verbose)
4338
4502
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -4342,7 +4506,7 @@ var require_parser = __commonJS({
4342
4506
  return JSXSelfClosingElement$0(state);
4343
4507
  }
4344
4508
  }
4345
- var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
4509
+ var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L55, fail, 'JSXOpeningElement ">"'));
4346
4510
  function JSXOpeningElement(state) {
4347
4511
  if (state.verbose)
4348
4512
  console.log("ENTER:", "JSXOpeningElement");
@@ -4352,7 +4516,7 @@ var require_parser = __commonJS({
4352
4516
  return JSXOpeningElement$0(state);
4353
4517
  }
4354
4518
  }
4355
- var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
4519
+ var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L55, fail, 'JSXClosingElement ">"'));
4356
4520
  function JSXClosingElement(state) {
4357
4521
  if (state.verbose)
4358
4522
  console.log("ENTER:", "JSXClosingElement");
@@ -4382,7 +4546,7 @@ var require_parser = __commonJS({
4382
4546
  return JSXElementName$0(state);
4383
4547
  }
4384
4548
  }
4385
- var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4549
+ var JSXIdentifierName$0 = $R$0($EXPECT($R33, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
4386
4550
  function JSXIdentifierName(state) {
4387
4551
  if (state.verbose)
4388
4552
  console.log("ENTER:", "JSXIdentifierName");
@@ -4431,8 +4595,8 @@ var require_parser = __commonJS({
4431
4595
  return JSXAttributeInitializer$0(state);
4432
4596
  }
4433
4597
  }
4434
- var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
4435
- var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
4598
+ var JSXAttributeValue$0 = $R$0($EXPECT($R34, fail, 'JSXAttributeValue /"[^"]*"/'));
4599
+ var JSXAttributeValue$1 = $R$0($EXPECT($R35, fail, "JSXAttributeValue /'[^']*'/"));
4436
4600
  var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
4437
4601
  var JSXAttributeValue$3 = JSXElement;
4438
4602
  var JSXAttributeValue$4 = JSXFragment;
@@ -4464,7 +4628,7 @@ var require_parser = __commonJS({
4464
4628
  return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
4465
4629
  }
4466
4630
  }
4467
- var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
4631
+ var JSXText$0 = $R$0($EXPECT($R36, fail, "JSXText /[^{}<>]+/"));
4468
4632
  function JSXText(state) {
4469
4633
  if (state.verbose)
4470
4634
  console.log("ENTER:", "JSXText");
@@ -4636,7 +4800,7 @@ var require_parser = __commonJS({
4636
4800
  return NestedTypeDeclaration$0(state);
4637
4801
  }
4638
4802
  }
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)));
4803
+ 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
4804
  function TypeIndexSignature(state) {
4641
4805
  if (state.verbose)
4642
4806
  console.log("ENTER:", "TypeIndexSignature");
@@ -4687,7 +4851,7 @@ var require_parser = __commonJS({
4687
4851
  return ReturnTypeSuffix$0(state);
4688
4852
  }
4689
4853
  }
4690
- var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4854
+ var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L58, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
4691
4855
  if (!$2)
4692
4856
  return $1;
4693
4857
  return $0;
@@ -4751,7 +4915,7 @@ var require_parser = __commonJS({
4751
4915
  }
4752
4916
  }
4753
4917
  var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
4754
- var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
4918
+ var TypeUnaryOp$1 = $EXPECT($L124, fail, 'TypeUnaryOp "typeof"');
4755
4919
  var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
4756
4920
  function TypeUnaryOp(state) {
4757
4921
  if (state.tokenize) {
@@ -4827,7 +4991,7 @@ var require_parser = __commonJS({
4827
4991
  return NestedType$0(state);
4828
4992
  }
4829
4993
  }
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) {
4994
+ 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
4995
  if ($2)
4832
4996
  return $0;
4833
4997
  return $1;
@@ -4842,7 +5006,7 @@ var require_parser = __commonJS({
4842
5006
  }
4843
5007
  }
4844
5008
  var TypeLiteral$0 = Literal;
4845
- var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
5009
+ var TypeLiteral$1 = $TV($EXPECT($L128, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
4846
5010
  return { $loc, token: "void" };
4847
5011
  });
4848
5012
  var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
@@ -4855,10 +5019,10 @@ var require_parser = __commonJS({
4855
5019
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
4856
5020
  }
4857
5021
  }
4858
- var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
5022
+ var TypeBinaryOp$0 = $TV($EXPECT($L70, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
4859
5023
  return { $loc, token: "|" };
4860
5024
  });
4861
- var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
5025
+ var TypeBinaryOp$1 = $TV($EXPECT($L68, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
4862
5026
  return { $loc, token: "&" };
4863
5027
  });
4864
5028
  function TypeBinaryOp(state) {
@@ -4868,7 +5032,7 @@ var require_parser = __commonJS({
4868
5032
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
4869
5033
  }
4870
5034
  }
4871
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
5035
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L3, fail, 'FunctionType "=>"'), Type);
4872
5036
  function FunctionType(state) {
4873
5037
  if (state.verbose)
4874
5038
  console.log("ENTER:", "FunctionType");
@@ -4878,7 +5042,7 @@ var require_parser = __commonJS({
4878
5042
  return FunctionType$0(state);
4879
5043
  }
4880
5044
  }
4881
- var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
5045
+ var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeArguments ">"'));
4882
5046
  function TypeArguments(state) {
4883
5047
  if (state.verbose)
4884
5048
  console.log("ENTER:", "TypeArguments");
@@ -4888,7 +5052,7 @@ var require_parser = __commonJS({
4888
5052
  return TypeArguments$0(state);
4889
5053
  }
4890
5054
  }
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) {
5055
+ 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
5056
  return { ts: true, children: $0 };
4893
5057
  });
4894
5058
  function TypeParameters(state) {
@@ -4910,7 +5074,7 @@ var require_parser = __commonJS({
4910
5074
  return TypeParameter$0(state);
4911
5075
  }
4912
5076
  }
4913
- var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
5077
+ var TypeConstraint$0 = $S(__, $EXPECT($L5, fail, 'TypeConstraint "extends"'), Type);
4914
5078
  function TypeConstraint(state) {
4915
5079
  if (state.verbose)
4916
5080
  console.log("ENTER:", "TypeConstraint");
@@ -4921,8 +5085,8 @@ var require_parser = __commonJS({
4921
5085
  }
4922
5086
  }
4923
5087
  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) {
5088
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L55, fail, 'TypeParameterDelimiter ">"')));
5089
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L55, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4926
5090
  return { $loc, token: "," };
4927
5091
  });
4928
5092
  var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -4935,7 +5099,7 @@ var require_parser = __commonJS({
4935
5099
  return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
4936
5100
  }
4937
5101
  }
4938
- var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
5102
+ var Shebang$0 = $S($R$0($EXPECT($R39, fail, "Shebang /#![^\\r\\n]*/")), EOL);
4939
5103
  function Shebang(state) {
4940
5104
  if (state.verbose)
4941
5105
  console.log("ENTER:", "Shebang");
@@ -4945,11 +5109,11 @@ var require_parser = __commonJS({
4945
5109
  return Shebang$0(state);
4946
5110
  }
4947
5111
  }
4948
- var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
5112
+ var CivetPrologue$0 = $T($S($EXPECT($R40, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4949
5113
  var content = value[2];
4950
5114
  return content;
4951
5115
  });
4952
- var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
5116
+ var CivetPrologue$1 = $T($S($EXPECT($R40, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
4953
5117
  var content = value[2];
4954
5118
  return content;
4955
5119
  });
@@ -4960,7 +5124,7 @@ var require_parser = __commonJS({
4960
5124
  return CivetPrologue$0(state) || CivetPrologue$1(state);
4961
5125
  }
4962
5126
  }
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) {
5127
+ 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
5128
  var options = $2;
4965
5129
  return {
4966
5130
  type: "CivetPrologue",
@@ -4977,7 +5141,7 @@ var require_parser = __commonJS({
4977
5141
  return CivetPrologueContent$0(state);
4978
5142
  }
4979
5143
  }
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) {
5144
+ 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
5145
  const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
4982
5146
  if (l)
4983
5147
  return l.toUpperCase();
@@ -4995,7 +5159,7 @@ var require_parser = __commonJS({
4995
5159
  return CivetOption$0(state);
4996
5160
  }
4997
5161
  }
4998
- var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
5162
+ var UnknownPrologue$0 = $S($R$0($EXPECT($R40, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
4999
5163
  function UnknownPrologue(state) {
5000
5164
  if (state.verbose)
5001
5165
  console.log("ENTER:", "UnknownPrologue");
@@ -5024,7 +5188,9 @@ var require_parser = __commonJS({
5024
5188
  return EOS$0(state);
5025
5189
  }
5026
5190
  }
5027
- var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
5191
+ 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) {
5192
+ return { $loc, token: $0 };
5193
+ });
5028
5194
  function EOL(state) {
5029
5195
  if (state.verbose)
5030
5196
  console.log("ENTER:", "EOL");
@@ -5034,17 +5200,7 @@ var require_parser = __commonJS({
5034
5200
  return EOL$0(state);
5035
5201
  }
5036
5202
  }
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) {
5203
+ var Debugger$0 = $TV($EXPECT($L0, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
5048
5204
  debugger;
5049
5205
  });
5050
5206
  function Debugger(state) {
@@ -5056,7 +5212,7 @@ var require_parser = __commonJS({
5056
5212
  return Debugger$0(state);
5057
5213
  }
5058
5214
  }
5059
- var InsertOpenParen$0 = $TV($EXPECT($L1, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
5215
+ var InsertOpenParen$0 = $TV($EXPECT($L0, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
5060
5216
  return { $loc, token: "(" };
5061
5217
  });
5062
5218
  function InsertOpenParen(state) {
@@ -5068,7 +5224,7 @@ var require_parser = __commonJS({
5068
5224
  return InsertOpenParen$0(state);
5069
5225
  }
5070
5226
  }
5071
- var InsertCloseParen$0 = $TV($EXPECT($L1, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
5227
+ var InsertCloseParen$0 = $TV($EXPECT($L0, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
5072
5228
  return { $loc, token: ")" };
5073
5229
  });
5074
5230
  function InsertCloseParen(state) {
@@ -5080,7 +5236,7 @@ var require_parser = __commonJS({
5080
5236
  return InsertCloseParen$0(state);
5081
5237
  }
5082
5238
  }
5083
- var InsertOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
5239
+ var InsertOpenBrace$0 = $TV($EXPECT($L0, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
5084
5240
  return [{ $loc, token: " " }, { $loc, token: "{" }];
5085
5241
  });
5086
5242
  function InsertOpenBrace(state) {
@@ -5092,7 +5248,7 @@ var require_parser = __commonJS({
5092
5248
  return InsertOpenBrace$0(state);
5093
5249
  }
5094
5250
  }
5095
- var InsertCloseBrace$0 = $TV($EXPECT($L1, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
5251
+ var InsertCloseBrace$0 = $TV($EXPECT($L0, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
5096
5252
  return { $loc, token: "}" };
5097
5253
  });
5098
5254
  function InsertCloseBrace(state) {
@@ -5104,7 +5260,7 @@ var require_parser = __commonJS({
5104
5260
  return InsertCloseBrace$0(state);
5105
5261
  }
5106
5262
  }
5107
- var InsertConst$0 = $TV($EXPECT($L1, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
5263
+ var InsertConst$0 = $TV($EXPECT($L0, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
5108
5264
  return { $loc, token: "const " };
5109
5265
  });
5110
5266
  function InsertConst(state) {
@@ -5116,7 +5272,7 @@ var require_parser = __commonJS({
5116
5272
  return InsertConst$0(state);
5117
5273
  }
5118
5274
  }
5119
- var InsertReadonly$0 = $TV($EXPECT($L1, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
5275
+ var InsertReadonly$0 = $TV($EXPECT($L0, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
5120
5276
  return { ts: true, children: [{ $loc, token: "readonly " }] };
5121
5277
  });
5122
5278
  function InsertReadonly(state) {
@@ -5128,7 +5284,7 @@ var require_parser = __commonJS({
5128
5284
  return InsertReadonly$0(state);
5129
5285
  }
5130
5286
  }
5131
- var InsertNewline$0 = $TV($EXPECT($L1, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
5287
+ var InsertNewline$0 = $TV($EXPECT($L0, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
5132
5288
  return "\n";
5133
5289
  });
5134
5290
  function InsertNewline(state) {
@@ -5140,7 +5296,7 @@ var require_parser = __commonJS({
5140
5296
  return InsertNewline$0(state);
5141
5297
  }
5142
5298
  }
5143
- var InsertIndent$0 = $TV($EXPECT($L1, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
5299
+ var InsertIndent$0 = $TV($EXPECT($L0, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
5144
5300
  return "".padStart(module2.currentIndent * 2);
5145
5301
  });
5146
5302
  function InsertIndent(state) {
@@ -5152,7 +5308,7 @@ var require_parser = __commonJS({
5152
5308
  return InsertIndent$0(state);
5153
5309
  }
5154
5310
  }
5155
- var InsertSpace$0 = $TV($EXPECT($L1, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
5311
+ var InsertSpace$0 = $TV($EXPECT($L0, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
5156
5312
  return { $loc, token: " " };
5157
5313
  });
5158
5314
  function InsertSpace(state) {
@@ -5164,7 +5320,7 @@ var require_parser = __commonJS({
5164
5320
  return InsertSpace$0(state);
5165
5321
  }
5166
5322
  }
5167
- var InsertDot$0 = $TV($EXPECT($L1, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
5323
+ var InsertDot$0 = $TV($EXPECT($L0, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
5168
5324
  return { $loc, token: "." };
5169
5325
  });
5170
5326
  function InsertDot(state) {
@@ -5176,7 +5332,7 @@ var require_parser = __commonJS({
5176
5332
  return InsertDot$0(state);
5177
5333
  }
5178
5334
  }
5179
- var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
5335
+ var InsertBreak$0 = $TV($EXPECT($L0, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
5180
5336
  return { $loc, token: ";break;" };
5181
5337
  });
5182
5338
  function InsertBreak(state) {
@@ -5188,7 +5344,7 @@ var require_parser = __commonJS({
5188
5344
  return InsertBreak$0(state);
5189
5345
  }
5190
5346
  }
5191
- var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
5347
+ var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
5192
5348
  if (module2.config.coffeeComment)
5193
5349
  return;
5194
5350
  return $skip;
@@ -5202,7 +5358,7 @@ var require_parser = __commonJS({
5202
5358
  return CoffeeCommentEnabled$0(state);
5203
5359
  }
5204
5360
  }
5205
- var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
5361
+ var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
5206
5362
  if (module2.config.coffeeBooleans)
5207
5363
  return;
5208
5364
  return $skip;
@@ -5216,7 +5372,7 @@ var require_parser = __commonJS({
5216
5372
  return CoffeeBooleansEnabled$0(state);
5217
5373
  }
5218
5374
  }
5219
- var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
5375
+ var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
5220
5376
  if (module2.config.coffeeInterpolation)
5221
5377
  return;
5222
5378
  return $skip;
@@ -5230,7 +5386,7 @@ var require_parser = __commonJS({
5230
5386
  return CoffeeInterpolationEnabled$0(state);
5231
5387
  }
5232
5388
  }
5233
- var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
5389
+ var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
5234
5390
  module2.currentIndent = 0;
5235
5391
  module2.indentLevels = [0];
5236
5392
  module2.verbose = false;
@@ -5274,26 +5430,13 @@ var require_parser = __commonJS({
5274
5430
  return Reset$0(state);
5275
5431
  }
5276
5432
  }
5277
- var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
5433
+ var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L0, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
5278
5434
  var directives = $2;
5279
5435
  directives.forEach((directive) => {
5280
5436
  if (directive.type === "CivetPrologue") {
5281
5437
  Object.assign(module2.config, directive.config);
5282
5438
  }
5283
5439
  });
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
5440
  function insertReturn(node) {
5298
5441
  if (!node)
5299
5442
  return;
@@ -5324,7 +5467,10 @@ var require_parser = __commonJS({
5324
5467
  }
5325
5468
  if (!Array.isArray(node))
5326
5469
  return;
5327
- const [indent, exp] = node;
5470
+ const [, exp] = node;
5471
+ let indent = node[0];
5472
+ if (Array.isArray(indent))
5473
+ indent = indent[indent.length - 1];
5328
5474
  if (!exp)
5329
5475
  return;
5330
5476
  switch (exp.type) {
@@ -5333,6 +5479,7 @@ var require_parser = __commonJS({
5333
5479
  case "DebuggerStatement":
5334
5480
  case "EmptyStatement":
5335
5481
  case "IterationStatement":
5482
+ case "ReturnStatement":
5336
5483
  case "ThrowStatement":
5337
5484
  case "VariableDeclaration":
5338
5485
  return;
@@ -5357,11 +5504,19 @@ var require_parser = __commonJS({
5357
5504
  node.splice(1, 0, "return ");
5358
5505
  }
5359
5506
  module2.addImplicitReturns = function(block) {
5360
- if (hasReturnStatement(block))
5361
- return block;
5362
5507
  insertReturn(block);
5363
5508
  return block;
5364
5509
  };
5510
+ module2.isWhitespaceOrEmpty = function(node) {
5511
+ if (!node)
5512
+ return true;
5513
+ if (!node.length)
5514
+ return true;
5515
+ if (typeof node === "string")
5516
+ return node.match(/^\s*$/);
5517
+ if (Array.isArray(node))
5518
+ return node.every(module2.isWhitespaceOrEmpty);
5519
+ };
5365
5520
  module2.expandChainedComparisons = function([first, binops]) {
5366
5521
  const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
5367
5522
  const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
@@ -5519,7 +5674,7 @@ var require_parser = __commonJS({
5519
5674
  return Indent$0(state);
5520
5675
  }
5521
5676
  }
5522
- var TrackIndent$0 = $TV($EXPECT($L1, fail, 'TrackIndent ""'), function($skip, $loc, $0, $1) {
5677
+ var TrackIndent$0 = $TV($EXPECT($L0, fail, 'TrackIndent ""'), function($skip, $loc, $0, $1) {
5523
5678
  module2.indentLevels.push(module2.currentIndent);
5524
5679
  });
5525
5680
  function TrackIndent(state) {
@@ -5567,7 +5722,7 @@ var require_parser = __commonJS({
5567
5722
  return IndentedFurther$0(state);
5568
5723
  }
5569
5724
  }
5570
- var PushIndent$0 = $TV($EXPECT($L1, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
5725
+ var PushIndent$0 = $TV($EXPECT($L0, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
5571
5726
  module2.currentIndent++;
5572
5727
  if (module2.verbose) {
5573
5728
  console.log("pushing indent", module2.currentIndent);
@@ -5583,7 +5738,7 @@ var require_parser = __commonJS({
5583
5738
  return PushIndent$0(state);
5584
5739
  }
5585
5740
  }
5586
- var PopIndent$0 = $TV($EXPECT($L1, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
5741
+ var PopIndent$0 = $TV($EXPECT($L0, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
5587
5742
  if (module2.verbose) {
5588
5743
  console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
5589
5744
  }