@danielx/civet 0.4.11 → 0.4.13

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