@danielx/civet 0.4.17 → 0.4.19-pre.0

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 +16 -23
  2. package/dist/browser.js +782 -351
  3. package/dist/civet +40 -12
  4. package/dist/main.js +782 -351
  5. package/package.json +1 -1
package/dist/main.js CHANGED
@@ -549,6 +549,10 @@ var require_parser = __commonJS({
549
549
  ForStatement,
550
550
  ForClause,
551
551
  ForStatementControl,
552
+ WhenCondition,
553
+ CoffeeForStatementParameters,
554
+ CoffeeForDeclaration,
555
+ ForStatementParameters,
552
556
  ForInOfDeclaration,
553
557
  ForDeclaration,
554
558
  ForBinding,
@@ -642,6 +646,7 @@ var require_parser = __commonJS({
642
646
  StatementDelimiter,
643
647
  NonIdContinue,
644
648
  Loc,
649
+ Ampersand,
645
650
  As,
646
651
  Async,
647
652
  Await,
@@ -780,9 +785,11 @@ var require_parser = __commonJS({
780
785
  InsertBreak,
781
786
  CoffeeCommentEnabled,
782
787
  CoffeeBooleansEnabled,
788
+ CoffeeForLoopsEnabled,
783
789
  CoffeeInterpolationEnabled,
784
790
  CoffeeIsntEnabled,
785
791
  CoffeeNotEnabled,
792
+ CoffeeOfEnabled,
786
793
  Reset,
787
794
  Init,
788
795
  Indent,
@@ -858,139 +865,142 @@ var require_parser = __commonJS({
858
865
  var $L62 = $L("==");
859
866
  var $L63 = $L("and");
860
867
  var $L64 = $L("&&");
861
- var $L65 = $L("or");
862
- var $L66 = $L("||");
863
- var $L67 = $L("??");
864
- var $L68 = $L("instanceof");
865
- var $L69 = $L("in");
866
- var $L70 = $L("&");
867
- var $L71 = $L("^");
868
- var $L72 = $L("|");
869
- var $L73 = $L(";");
870
- var $L74 = $L("finally");
871
- var $L75 = $L("break");
872
- var $L76 = $L("continue");
873
- var $L77 = $L("debugger");
874
- var $L78 = $L("import type");
875
- var $L79 = $L("default");
876
- var $L80 = $L(":=");
877
- var $L81 = $L("/*");
878
- var $L82 = $L("*/");
879
- var $L83 = $L("###");
880
- var $L84 = $L("as");
881
- var $L85 = $L("async");
882
- var $L86 = $L("await");
883
- var $L87 = $L("`");
884
- var $L88 = $L("case");
885
- var $L89 = $L("catch");
886
- var $L90 = $L("class");
887
- var $L91 = $L("#{");
888
- var $L92 = $L(":");
889
- var $L93 = $L("delete");
890
- var $L94 = $L("do");
891
- var $L95 = $L("..");
892
- var $L96 = $L("...");
893
- var $L97 = $L('"');
894
- var $L98 = $L("else");
895
- var $L99 = $L("export");
896
- var $L100 = $L("for");
897
- var $L101 = $L("from");
898
- var $L102 = $L("function");
899
- var $L103 = $L("get");
900
- var $L104 = $L("set");
901
- var $L105 = $L("if");
902
- var $L106 = $L(" ");
903
- var $L107 = $L("let");
904
- var $L108 = $L("const");
905
- var $L109 = $L("loop");
906
- var $L110 = $L("new");
907
- var $L111 = $L("not");
908
- var $L112 = $L("of");
909
- var $L113 = $L("{");
910
- var $L114 = $L("[");
911
- var $L115 = $L("(");
912
- var $L116 = $L("?");
913
- var $L117 = $L("return");
914
- var $L118 = $L("'");
915
- var $L119 = $L("static");
916
- var $L120 = $L("${");
917
- var $L121 = $L("switch");
918
- var $L122 = $L("target");
919
- var $L123 = $L("then");
920
- var $L124 = $L("throw");
921
- var $L125 = $L('"""');
922
- var $L126 = $L("'''");
923
- var $L127 = $L("```");
924
- var $L128 = $L("try");
925
- var $L129 = $L("typeof");
926
- var $L130 = $L("unless");
927
- var $L131 = $L("until");
928
- var $L132 = $L("var");
929
- var $L133 = $L("void");
930
- var $L134 = $L("when");
931
- var $L135 = $L("while");
932
- var $L136 = $L("yield");
933
- var $L137 = $L("/>");
934
- var $L138 = $L("</");
935
- var $L139 = $L("<>");
936
- var $L140 = $L("</>");
937
- var $L141 = $L("declare");
938
- var $L142 = $L("type");
939
- var $L143 = $L("interface");
940
- var $L144 = $L("namespace");
941
- var $L145 = $L("readonly");
942
- var $L146 = $L("asserts");
943
- var $L147 = $L("keyof");
944
- var $L148 = $L("infer");
945
- var $L149 = $L("[]");
946
- var $L150 = $L("civet");
947
- var $L151 = $L(" ");
948
- var $L152 = $L(" ");
949
- var $R0 = $R(new RegExp("(of|then)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
950
- var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
951
- var $R2 = $R(new RegExp("[!~+-](?!\\s)", "suy"));
952
- var $R3 = $R(new RegExp("(?=[\\s\\)])", "suy"));
953
- var $R4 = $R(new RegExp('[^;"\\s]+', "suy"));
954
- var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
955
- var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
956
- var $R7 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
957
- var $R8 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
958
- var $R9 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
959
- var $R10 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
960
- var $R11 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
961
- var $R12 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
962
- var $R13 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
963
- var $R14 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
964
- var $R15 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
965
- var $R16 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
966
- var $R17 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
967
- var $R18 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
968
- var $R19 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
969
- var $R20 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
970
- var $R21 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
971
- var $R22 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
972
- var $R23 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
973
- var $R24 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
974
- var $R25 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
975
- var $R26 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
976
- var $R27 = $R(new RegExp(".", "suy"));
977
- var $R28 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
978
- var $R29 = $R(new RegExp("[^\\r\\n]", "suy"));
979
- var $R30 = $R(new RegExp("[ \\t]+", "suy"));
980
- var $R31 = $R(new RegExp("[\\s]+", "suy"));
981
- var $R32 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
982
- var $R33 = $R(new RegExp("\\s", "suy"));
983
- var $R34 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
984
- var $R35 = $R(new RegExp('"[^"]*"', "suy"));
985
- var $R36 = $R(new RegExp("'[^']*'", "suy"));
986
- var $R37 = $R(new RegExp("[^{}<>]+", "suy"));
987
- var $R38 = $R(new RegExp("[+-]?", "suy"));
988
- var $R39 = $R(new RegExp("[+-]", "suy"));
989
- var $R40 = $R(new RegExp("#![^\\r\\n]*", "suy"));
990
- var $R41 = $R(new RegExp("[\\t ]*", "suy"));
991
- var $R42 = $R(new RegExp("[\\s]*", "suy"));
992
- var $R43 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
993
- var $R44 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
868
+ var $L65 = $L("of");
869
+ var $L66 = $L("or");
870
+ var $L67 = $L("||");
871
+ var $L68 = $L("??");
872
+ var $L69 = $L("instanceof");
873
+ var $L70 = $L("in");
874
+ var $L71 = $L("&");
875
+ var $L72 = $L("^");
876
+ var $L73 = $L("|");
877
+ var $L74 = $L(";");
878
+ var $L75 = $L("own");
879
+ var $L76 = $L("finally");
880
+ var $L77 = $L("break");
881
+ var $L78 = $L("continue");
882
+ var $L79 = $L("debugger");
883
+ var $L80 = $L("import type");
884
+ var $L81 = $L("default");
885
+ var $L82 = $L(":=");
886
+ var $L83 = $L("/*");
887
+ var $L84 = $L("*/");
888
+ var $L85 = $L("###");
889
+ var $L86 = $L("as");
890
+ var $L87 = $L("async");
891
+ var $L88 = $L("await");
892
+ var $L89 = $L("`");
893
+ var $L90 = $L("case");
894
+ var $L91 = $L("catch");
895
+ var $L92 = $L("class");
896
+ var $L93 = $L("#{");
897
+ var $L94 = $L(":");
898
+ var $L95 = $L("delete");
899
+ var $L96 = $L("do");
900
+ var $L97 = $L("..");
901
+ var $L98 = $L("...");
902
+ var $L99 = $L('"');
903
+ var $L100 = $L("else");
904
+ var $L101 = $L("export");
905
+ var $L102 = $L("for");
906
+ var $L103 = $L("from");
907
+ var $L104 = $L("function");
908
+ var $L105 = $L("get");
909
+ var $L106 = $L("set");
910
+ var $L107 = $L("if");
911
+ var $L108 = $L(" ");
912
+ var $L109 = $L("let");
913
+ var $L110 = $L("const");
914
+ var $L111 = $L("loop");
915
+ var $L112 = $L("new");
916
+ var $L113 = $L("not");
917
+ var $L114 = $L("{");
918
+ var $L115 = $L("[");
919
+ var $L116 = $L("(");
920
+ var $L117 = $L("?");
921
+ var $L118 = $L("return");
922
+ var $L119 = $L("'");
923
+ var $L120 = $L("static");
924
+ var $L121 = $L("${");
925
+ var $L122 = $L("switch");
926
+ var $L123 = $L("target");
927
+ var $L124 = $L("then");
928
+ var $L125 = $L("throw");
929
+ var $L126 = $L('"""');
930
+ var $L127 = $L("'''");
931
+ var $L128 = $L("```");
932
+ var $L129 = $L("try");
933
+ var $L130 = $L("typeof");
934
+ var $L131 = $L("unless");
935
+ var $L132 = $L("until");
936
+ var $L133 = $L("var");
937
+ var $L134 = $L("void");
938
+ var $L135 = $L("when");
939
+ var $L136 = $L("while");
940
+ var $L137 = $L("yield");
941
+ var $L138 = $L("/>");
942
+ var $L139 = $L("</");
943
+ var $L140 = $L("<>");
944
+ var $L141 = $L("</>");
945
+ var $L142 = $L("declare");
946
+ var $L143 = $L("type");
947
+ var $L144 = $L("interface");
948
+ var $L145 = $L("namespace");
949
+ var $L146 = $L("readonly");
950
+ var $L147 = $L("asserts");
951
+ var $L148 = $L("keyof");
952
+ var $L149 = $L("infer");
953
+ var $L150 = $L("[]");
954
+ var $L151 = $L("civet");
955
+ var $L152 = $L(" ");
956
+ var $L153 = $L(" ");
957
+ var $R0 = $R(new RegExp("(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
958
+ var $R1 = $R(new RegExp("[&]", "suy"));
959
+ var $R2 = $R(new RegExp("[!~+-]+", "suy"));
960
+ var $R3 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
961
+ var $R4 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
962
+ var $R5 = $R(new RegExp("(?=[\\s\\)])", "suy"));
963
+ var $R6 = $R(new RegExp('[^;"\\s]+', "suy"));
964
+ var $R7 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
965
+ var $R8 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
966
+ var $R9 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
967
+ var $R10 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
968
+ var $R11 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
969
+ var $R12 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
970
+ var $R13 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
971
+ var $R14 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
972
+ var $R15 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
973
+ var $R16 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
974
+ var $R17 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
975
+ var $R18 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
976
+ var $R19 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
977
+ var $R20 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
978
+ var $R21 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
979
+ var $R22 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
980
+ var $R23 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
981
+ var $R24 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
982
+ var $R25 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
983
+ var $R26 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
984
+ var $R27 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
985
+ var $R28 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
986
+ var $R29 = $R(new RegExp(".", "suy"));
987
+ var $R30 = $R(new RegExp("#(?!##)([^\\r\\n]*)", "suy"));
988
+ var $R31 = $R(new RegExp("[^\\r\\n]", "suy"));
989
+ var $R32 = $R(new RegExp("[ \\t]+", "suy"));
990
+ var $R33 = $R(new RegExp("[\\s]+", "suy"));
991
+ var $R34 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
992
+ var $R35 = $R(new RegExp("\\s", "suy"));
993
+ var $R36 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
994
+ var $R37 = $R(new RegExp('"[^"]*"', "suy"));
995
+ var $R38 = $R(new RegExp("'[^']*'", "suy"));
996
+ var $R39 = $R(new RegExp("[^{}<>]+", "suy"));
997
+ var $R40 = $R(new RegExp("[+-]?", "suy"));
998
+ var $R41 = $R(new RegExp("[+-]", "suy"));
999
+ var $R42 = $R(new RegExp("#![^\\r\\n]*", "suy"));
1000
+ var $R43 = $R(new RegExp("[\\t ]*", "suy"));
1001
+ var $R44 = $R(new RegExp("[\\s]*", "suy"));
1002
+ var $R45 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
1003
+ var $R46 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
994
1004
  var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
995
1005
  var statements = $4;
996
1006
  module2.processProgram(statements);
@@ -1015,7 +1025,12 @@ var require_parser = __commonJS({
1015
1025
  return TopLevelStatement$0(state);
1016
1026
  }
1017
1027
  }
1018
- var ExtendedExpression$0 = $S(__, ExpressionizedStatement);
1028
+ var ExtendedExpression$0 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
1029
+ if ($1.length) {
1030
+ $2.children.splice(0, 0, ...$1);
1031
+ }
1032
+ return $2;
1033
+ });
1019
1034
  var ExtendedExpression$1 = AssignmentExpression;
1020
1035
  function ExtendedExpression(state) {
1021
1036
  if (state.tokenize) {
@@ -1158,9 +1173,9 @@ var require_parser = __commonJS({
1158
1173
  return IndentedApplicationAllowed$0(state);
1159
1174
  }
1160
1175
  }
1161
- var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2) {
1176
+ var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, $C(UnaryExpression, ExpressionizedStatement)))), function($skip, $loc, $0, $1, $2) {
1162
1177
  if ($2.length) {
1163
- return module2.expandChainedComparisons($0);
1178
+ return module2.processBinaryOpExpression($0);
1164
1179
  }
1165
1180
  return $1;
1166
1181
  });
@@ -1180,14 +1195,31 @@ var require_parser = __commonJS({
1180
1195
  if (post?.token === "?") {
1181
1196
  return ["(", pre, "(", exp, ") != null)"];
1182
1197
  }
1183
- const result = [pre, exp, post];
1184
- if (!post)
1185
- result.pop();
1186
- if (!pre.length)
1187
- result.shift();
1188
- if (result.length === 1)
1189
- return result[0];
1190
- return result;
1198
+ if (exp.type === "Literal") {
1199
+ if (pre.length === 1 && pre[0].token === "-") {
1200
+ exp.raw = `-${exp.raw}`;
1201
+ exp.children.unshift(pre[0]);
1202
+ if (post)
1203
+ exp.children.push(post);
1204
+ return exp;
1205
+ }
1206
+ }
1207
+ if (exp.children) {
1208
+ exp.children.unshift(...pre);
1209
+ if (post)
1210
+ exp.children.push(post);
1211
+ return exp;
1212
+ } else if (Array.isArray(exp)) {
1213
+ exp.unshift(...pre);
1214
+ if (post)
1215
+ exp.push(post);
1216
+ return exp;
1217
+ } else {
1218
+ const result = [...pre, exp];
1219
+ if (post)
1220
+ result.push(post);
1221
+ return result;
1222
+ }
1191
1223
  });
1192
1224
  function UnaryExpression(state) {
1193
1225
  if (state.verbose)
@@ -1255,40 +1287,56 @@ var require_parser = __commonJS({
1255
1287
  var AssignmentExpressionTail$0 = YieldExpression;
1256
1288
  var AssignmentExpressionTail$1 = ArrowFunction;
1257
1289
  var AssignmentExpressionTail$2 = $TS($S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
1258
- const lastAssignment = $1[$1.length - 1];
1259
- let tail = [];
1260
- if (lastAssignment[3].token === "=") {
1261
- const lhs = lastAssignment[1];
1290
+ let tail = [], i = 0, len = $1.length;
1291
+ while (i < len) {
1292
+ const lastAssignment = $1[i++];
1293
+ const [, lhs, , op] = lastAssignment;
1294
+ if (op.token !== "=")
1295
+ continue;
1262
1296
  if (lhs.type === "ObjectExpression") {
1263
1297
  lhs.children.splice(0, 0, "(");
1264
1298
  tail.push(")");
1299
+ break;
1265
1300
  }
1266
- if (Array.isArray(lhs) && lhs.length > 1) {
1267
- const props = lhs[lhs.length - 1];
1268
- if (Array.isArray(props)) {
1269
- const lastProp = props[props.length - 1];
1270
- if (lastProp.type === "SliceExpression") {
1271
- const { start, end, children: c } = lastProp;
1272
- c[0].token = ".splice(";
1273
- c[1] = start;
1274
- c[2] = ", ";
1275
- if (end)
1276
- c[3] = [end, " - ", start];
1277
- else
1278
- c[3] = ["1/0"];
1279
- c[4] = [", ...", $2];
1280
- c[5] = ")";
1281
- lastAssignment.pop();
1282
- if (module2.isWhitespaceOrEmpty(lastAssignment[2]))
1301
+ }
1302
+ i = len - 1;
1303
+ while (i >= 0) {
1304
+ const lastAssignment = $1[i];
1305
+ if (lastAssignment[3].token === "=") {
1306
+ const lhs = lastAssignment[1];
1307
+ if (Array.isArray(lhs) && lhs.length > 1) {
1308
+ const props = lhs[lhs.length - 1];
1309
+ if (Array.isArray(props)) {
1310
+ const lastProp = props[props.length - 1];
1311
+ if (lastProp.type === "SliceExpression") {
1312
+ const { start, end, children: c } = lastProp;
1313
+ c[0].token = ".splice(";
1314
+ c[1] = start;
1315
+ c[2] = ", ";
1316
+ if (end)
1317
+ c[3] = [end, " - ", start];
1318
+ else
1319
+ c[3] = ["1/0"];
1320
+ c[4] = [", ...", $2];
1321
+ c[5] = ")";
1283
1322
  lastAssignment.pop();
1284
- return $1;
1323
+ if (module2.isWhitespaceOrEmpty(lastAssignment[2]))
1324
+ lastAssignment.pop();
1325
+ if ($1.length > 1) {
1326
+ throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
1327
+ }
1328
+ return $1;
1329
+ }
1285
1330
  }
1286
1331
  }
1287
1332
  }
1333
+ i--;
1288
1334
  }
1335
+ const names = $1.flatMap(([, l]) => l.names || []);
1289
1336
  return {
1290
1337
  type: "AssignmentExpression",
1291
- children: [...$0, ...tail]
1338
+ children: [...$0, ...tail],
1339
+ names
1292
1340
  };
1293
1341
  });
1294
1342
  var AssignmentExpressionTail$3 = ConditionalExpression;
@@ -1622,7 +1670,7 @@ var require_parser = __commonJS({
1622
1670
  return NonNullAssertion$0(state);
1623
1671
  }
1624
1672
  }
1625
- var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of|then)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
1673
+ var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
1626
1674
  function AdditionalReservedWords(state) {
1627
1675
  if (state.verbose)
1628
1676
  console.log("ENTER:", "AdditionalReservedWords");
@@ -1647,11 +1695,19 @@ var require_parser = __commonJS({
1647
1695
  }
1648
1696
  }
1649
1697
  var MemberExpressionRest$0 = $TS($S($E($C(OptionalShorthand, NonNullAssertion)), MemberBracketContent), function($skip, $loc, $0, $1, $2) {
1650
- if ($1)
1698
+ if ($1) {
1699
+ if ($1.length === 2 && $2.type === "SliceExpression") {
1700
+ $1.pop();
1701
+ }
1651
1702
  return $0;
1703
+ }
1704
+ return $2;
1705
+ });
1706
+ var MemberExpressionRest$1 = $TS($S($E($S($Y(EOS), IndentedFurther)), PropertyAccess), function($skip, $loc, $0, $1, $2) {
1707
+ if ($1)
1708
+ $2.children.unshift($1[1]);
1652
1709
  return $2;
1653
1710
  });
1654
- var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
1655
1711
  var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1656
1712
  var id = $3;
1657
1713
  if (id)
@@ -1666,10 +1722,10 @@ var require_parser = __commonJS({
1666
1722
  return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
1667
1723
  }
1668
1724
  }
1669
- var MemberBracketContent$0 = $TS($S(OpenBracket, ExtendedExpression, $E($S($C(DotDotDot, DotDot), $E(ExtendedExpression))), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
1725
+ var MemberBracketContent$0 = $TS($S(OpenBracket, ExtendedExpression, $E($S(__, $C(DotDotDot, DotDot), $E(ExtendedExpression))), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
1670
1726
  if ($3) {
1671
- const sep = $3[0];
1672
- const end = $3[1];
1727
+ const sep = $3[1];
1728
+ const end = $3[2];
1673
1729
  const inclusive = sep.token === "..";
1674
1730
  sep.token = ", ";
1675
1731
  $1.token = ".slice(";
@@ -1683,6 +1739,7 @@ var require_parser = __commonJS({
1683
1739
  };
1684
1740
  }
1685
1741
  if (inclusive) {
1742
+ module2.insertTrimmingSpace(end, "");
1686
1743
  return {
1687
1744
  type: "SliceExpression",
1688
1745
  start: $2,
@@ -1708,7 +1765,14 @@ var require_parser = __commonJS({
1708
1765
  return MemberBracketContent$0(state);
1709
1766
  }
1710
1767
  }
1711
- var PropertyAccess$0 = $S($E($C(QuestionMark, NonNullAssertion)), Dot, $C(IdentifierName, PrivateIdentifier));
1768
+ var PropertyAccess$0 = $TS($S($E($C(QuestionMark, NonNullAssertion)), Dot, $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3) {
1769
+ var id = $3;
1770
+ id.type = "PropertyAccess";
1771
+ id.children.unshift($2);
1772
+ if ($1)
1773
+ id.children.unshift($1);
1774
+ return id;
1775
+ });
1712
1776
  function PropertyAccess(state) {
1713
1777
  if (state.verbose)
1714
1778
  console.log("ENTER:", "PropertyAccess");
@@ -2135,13 +2199,33 @@ var require_parser = __commonJS({
2135
2199
  $1.type = "FunctionExpression";
2136
2200
  return $1;
2137
2201
  });
2202
+ var FunctionExpression$1 = $TS($S(Ampersand, $N(_), $P(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
2203
+ $1.token = "$ => $";
2204
+ return {
2205
+ type: "FunctionExpression",
2206
+ children: [$1, $3]
2207
+ };
2208
+ });
2209
+ var FunctionExpression$2 = $TS($S(Ampersand, $N($EXPECT($R1, fail, "FunctionExpression /[&]/")), $P($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2, $3) {
2210
+ $0.splice(1, 1);
2211
+ $1.token = "$ => $";
2212
+ const exp = module2.processBinaryOpExpression($0);
2213
+ return {
2214
+ type: "FunctionExpression",
2215
+ children: exp
2216
+ };
2217
+ });
2218
+ var FunctionExpression$3 = $TS($S($EXPECT($R2, fail, "FunctionExpression /[!~+-]+/"), Ampersand), function($skip, $loc, $0, $1, $2) {
2219
+ return {
2220
+ type: "FunctionExpression",
2221
+ children: ["$ => ", $1, "$"]
2222
+ };
2223
+ });
2138
2224
  function FunctionExpression(state) {
2139
- if (state.verbose)
2140
- console.log("ENTER:", "FunctionExpression");
2141
2225
  if (state.tokenize) {
2142
- return $TOKEN("FunctionExpression", state, FunctionExpression$0(state));
2226
+ return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state));
2143
2227
  } else {
2144
- return FunctionExpression$0(state);
2228
+ return FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state);
2145
2229
  }
2146
2230
  }
2147
2231
  var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
@@ -2241,8 +2325,18 @@ var require_parser = __commonJS({
2241
2325
  var exps = value[2];
2242
2326
  return { "type": "BlockStatement", "expressions": exps, "children": value };
2243
2327
  });
2244
- var BracedBlock$2 = $TS($S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
2328
+ var BracedBlock$2 = $TS($S(InsertOpenBrace, $Y(EOS), ObjectLiteral, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
2329
+ var s = $3;
2330
+ $0.splice(1, 1);
2331
+ return {
2332
+ type: "BlockStatement",
2333
+ expressions: [s],
2334
+ children: $0
2335
+ };
2336
+ });
2337
+ var BracedBlock$3 = $TS($S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
2245
2338
  var s = $4;
2339
+ $0.splice(1, 1);
2246
2340
  return {
2247
2341
  type: "BlockStatement",
2248
2342
  expressions: [s],
@@ -2251,9 +2345,9 @@ var require_parser = __commonJS({
2251
2345
  });
2252
2346
  function BracedBlock(state) {
2253
2347
  if (state.tokenize) {
2254
- return $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state));
2348
+ return $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state) || BracedBlock$3(state));
2255
2349
  } else {
2256
- return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
2350
+ return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state) || BracedBlock$3(state);
2257
2351
  }
2258
2352
  }
2259
2353
  var BracedContent$0 = $T($S($Y(EOS), NestedBlockStatements), function(value) {
@@ -2295,7 +2389,8 @@ var require_parser = __commonJS({
2295
2389
  var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
2296
2390
  return {
2297
2391
  type: "Literal",
2298
- children: $0
2392
+ children: $0,
2393
+ raw: $1.token
2299
2394
  };
2300
2395
  });
2301
2396
  function Literal(state) {
@@ -2378,7 +2473,7 @@ var require_parser = __commonJS({
2378
2473
  return Identifier$0(state);
2379
2474
  }
2380
2475
  }
2381
- var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2476
+ var IdentifierName$0 = $TR($EXPECT($R3, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2382
2477
  return {
2383
2478
  type: "Identifier",
2384
2479
  name: $0,
@@ -2409,11 +2504,16 @@ var require_parser = __commonJS({
2409
2504
  }
2410
2505
  }
2411
2506
  var ArrayLiteral$0 = $TS($S(OpenBracket, ArrayLiteralContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
2507
+ var content = $2;
2508
+ if (content.type === "RangeExpression") {
2509
+ content.children.push(...$3);
2510
+ return content;
2511
+ }
2412
2512
  let children;
2413
- if (Array.isArray($2)) {
2414
- children = [$1, ...$2, ...$3, $4];
2513
+ if (Array.isArray(content)) {
2514
+ children = [$1, ...content, ...$3, $4];
2415
2515
  } else {
2416
- children = [$1, $2, ...$3, $4];
2516
+ children = [$1, content, ...$3, $4];
2417
2517
  }
2418
2518
  const names = children.flatMap((c) => {
2419
2519
  return c.names || [];
@@ -2433,13 +2533,39 @@ var require_parser = __commonJS({
2433
2533
  return ArrayLiteral$0(state);
2434
2534
  }
2435
2535
  }
2436
- var ArrayLiteralContent$0 = NestedElementList;
2437
- var ArrayLiteralContent$1 = ElementList;
2536
+ var ArrayLiteralContent$0 = $TS($S(ExtendedExpression, __, $C(DotDotDot, DotDot), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
2537
+ var s = $1;
2538
+ var ws = $2;
2539
+ var range = $3;
2540
+ var e = $4;
2541
+ const inclusive = range.token === "..";
2542
+ range.token = ",";
2543
+ if (s.type === "Literal" && e.type === "Literal") {
2544
+ const start = JSON.parse(s.raw);
2545
+ const end = JSON.parse(e.raw);
2546
+ const step = end > start ? 1 : -1;
2547
+ const length = Math.abs(end - start) + (inclusive ? 1 : 0);
2548
+ if (length <= 20) {
2549
+ return Array.from({ length }, (_2, i) => start + i * step).join(", ");
2550
+ }
2551
+ }
2552
+ const inclusiveAdjust = inclusive ? " + 1" : "";
2553
+ const children = ["((s, e) => {let step = e > s ? 1 : -1; return Array.from({length: Math.abs(e - s)", inclusiveAdjust, "}, (_, i) => s + i * step)})(", s, ws, range, e, ")"];
2554
+ return {
2555
+ type: "RangeExpression",
2556
+ children,
2557
+ inclusive,
2558
+ start: s,
2559
+ end: e
2560
+ };
2561
+ });
2562
+ var ArrayLiteralContent$1 = NestedElementList;
2563
+ var ArrayLiteralContent$2 = ElementList;
2438
2564
  function ArrayLiteralContent(state) {
2439
2565
  if (state.tokenize) {
2440
- return $TOKEN("ArrayLiteralContent", state, ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state));
2566
+ return $TOKEN("ArrayLiteralContent", state, ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state) || ArrayLiteralContent$2(state));
2441
2567
  } else {
2442
- return ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state);
2568
+ return ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state) || ArrayLiteralContent$2(state);
2443
2569
  }
2444
2570
  }
2445
2571
  var NestedElementList$0 = $TS($S(PushIndent, $Q(NestedElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
@@ -2595,7 +2721,10 @@ var require_parser = __commonJS({
2595
2721
  var NestedObjectLiteral$0 = $TS($S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
2596
2722
  $3.unshift($1);
2597
2723
  $3.push($4, $5, $6);
2598
- return $3;
2724
+ return {
2725
+ type: "ObjectExpression",
2726
+ children: $3
2727
+ };
2599
2728
  });
2600
2729
  function NestedObjectLiteral(state) {
2601
2730
  if (state.verbose)
@@ -2769,8 +2898,13 @@ var require_parser = __commonJS({
2769
2898
  }
2770
2899
  var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L7, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
2771
2900
  return {
2772
- $loc,
2773
- token: $1
2901
+ type: "Identifier",
2902
+ name: $0,
2903
+ names: [$0],
2904
+ children: [{
2905
+ $loc,
2906
+ token: $0
2907
+ }]
2774
2908
  };
2775
2909
  });
2776
2910
  function PrivateIdentifier(state) {
@@ -2821,7 +2955,9 @@ var require_parser = __commonJS({
2821
2955
  }
2822
2956
  }
2823
2957
  var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
2824
- return { $loc, token: $1 };
2958
+ if (typeof $1 === "string")
2959
+ return { $loc, token: $1 };
2960
+ return $1;
2825
2961
  });
2826
2962
  function BinaryOp(state) {
2827
2963
  if (state.verbose)
@@ -2869,28 +3005,34 @@ var require_parser = __commonJS({
2869
3005
  return "&&";
2870
3006
  });
2871
3007
  var BinaryOpSymbol$20 = $EXPECT($L64, fail, 'BinaryOpSymbol "&&"');
2872
- var BinaryOpSymbol$21 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
3008
+ var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L65, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
3009
+ return "in";
3010
+ });
3011
+ var BinaryOpSymbol$22 = $T($S($EXPECT($L66, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2873
3012
  return "||";
2874
3013
  });
2875
- var BinaryOpSymbol$22 = $EXPECT($L66, fail, 'BinaryOpSymbol "||"');
2876
- var BinaryOpSymbol$23 = $EXPECT($L67, fail, 'BinaryOpSymbol "??"');
2877
- var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3014
+ var BinaryOpSymbol$23 = $EXPECT($L67, fail, 'BinaryOpSymbol "||"');
3015
+ var BinaryOpSymbol$24 = $EXPECT($L68, fail, 'BinaryOpSymbol "??"');
3016
+ var BinaryOpSymbol$25 = $TS($S($EXPECT($L69, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2878
3017
  return $1;
2879
3018
  });
2880
- var BinaryOpSymbol$25 = $TS($S($EXPECT($L69, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3019
+ var BinaryOpSymbol$26 = $TS($S(CoffeeOfEnabled, $EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
3020
+ return module2.getIndexOfRef();
3021
+ });
3022
+ var BinaryOpSymbol$27 = $TS($S($EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2881
3023
  return $1;
2882
3024
  });
2883
- var BinaryOpSymbol$26 = $EXPECT($L70, fail, 'BinaryOpSymbol "&"');
2884
- var BinaryOpSymbol$27 = $EXPECT($L71, fail, 'BinaryOpSymbol "^"');
2885
- var BinaryOpSymbol$28 = $EXPECT($L72, fail, 'BinaryOpSymbol "|"');
3025
+ var BinaryOpSymbol$28 = $EXPECT($L71, fail, 'BinaryOpSymbol "&"');
3026
+ var BinaryOpSymbol$29 = $EXPECT($L72, fail, 'BinaryOpSymbol "^"');
3027
+ var BinaryOpSymbol$30 = $EXPECT($L73, fail, 'BinaryOpSymbol "|"');
2886
3028
  function BinaryOpSymbol(state) {
2887
3029
  if (state.tokenize) {
2888
- 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) || BinaryOpSymbol$28(state));
3030
+ 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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state));
2889
3031
  } else {
2890
- 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) || BinaryOpSymbol$28(state);
3032
+ 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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state);
2891
3033
  }
2892
3034
  }
2893
- var UnaryOp$0 = $TR($EXPECT($R2, fail, "UnaryOp /[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3035
+ var UnaryOp$0 = $TR($EXPECT($R4, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2894
3036
  return { $loc, token: $0 };
2895
3037
  });
2896
3038
  var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
@@ -2918,7 +3060,18 @@ var require_parser = __commonJS({
2918
3060
  var ws = $2;
2919
3061
  var post = $3;
2920
3062
  if (post) {
2921
- post.children.push(statement);
3063
+ let block;
3064
+ if (post.type === "ForStatement") {
3065
+ if (post.blockPrefix?.length) {
3066
+ block = [" {", ...post.blockPrefix, ...statement, " }"];
3067
+ } else {
3068
+ block = statement;
3069
+ }
3070
+ } else {
3071
+ block = statement;
3072
+ }
3073
+ post.block = block;
3074
+ post.children.push(block);
2922
3075
  if (!module2.isWhitespaceOrEmpty(ws))
2923
3076
  post.children.push(ws);
2924
3077
  return post;
@@ -2960,7 +3113,7 @@ var require_parser = __commonJS({
2960
3113
  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);
2961
3114
  }
2962
3115
  }
2963
- var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L73, fail, 'EmptyStatement ";"'))), function(value) {
3116
+ var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L74, fail, 'EmptyStatement ";"'))), function(value) {
2964
3117
  return { "type": "EmptyStatement", "children": value[0] };
2965
3118
  });
2966
3119
  function EmptyStatement(state) {
@@ -3200,6 +3353,9 @@ var require_parser = __commonJS({
3200
3353
  var block = $2;
3201
3354
  clause.children.push(block);
3202
3355
  clause.block = block;
3356
+ if (clause.blockPrefix) {
3357
+ block.expressions.splice(0, 0, ...clause.blockPrefix);
3358
+ }
3203
3359
  return clause;
3204
3360
  });
3205
3361
  function ForStatement(state) {
@@ -3219,7 +3375,8 @@ var require_parser = __commonJS({
3219
3375
  type: "ForStatement",
3220
3376
  children,
3221
3377
  declaration,
3222
- block: null
3378
+ block: null,
3379
+ blockPrefix: c.blockPrefix
3223
3380
  };
3224
3381
  });
3225
3382
  function ForClause(state) {
@@ -3231,39 +3388,155 @@ var require_parser = __commonJS({
3231
3388
  return ForClause$0(state);
3232
3389
  }
3233
3390
  }
3234
- var ForStatementControl$0 = $TS($S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
3391
+ var ForStatementControl$0 = $T($S($N(CoffeeForLoopsEnabled), ForStatementParameters), function(value) {
3392
+ return value[1];
3393
+ });
3394
+ var ForStatementControl$1 = $TS($S(CoffeeForLoopsEnabled, CoffeeForStatementParameters, $E(WhenCondition)), function($skip, $loc, $0, $1, $2, $3) {
3395
+ if ($3) {
3396
+ const indent = "".padStart((module2.currentIndent + 1) * 2);
3397
+ module2.insertTrimmingSpace($3, "");
3398
+ $2.blockPrefix.push({
3399
+ type: "IfStatement",
3400
+ children: [indent, "if (!(", $3, ")) continue\n"]
3401
+ });
3402
+ }
3403
+ return $2;
3404
+ });
3405
+ function ForStatementControl(state) {
3406
+ if (state.tokenize) {
3407
+ return $TOKEN("ForStatementControl", state, ForStatementControl$0(state) || ForStatementControl$1(state));
3408
+ } else {
3409
+ return ForStatementControl$0(state) || ForStatementControl$1(state);
3410
+ }
3411
+ }
3412
+ var WhenCondition$0 = $T($S(__, When, ExtendedExpression), function(value) {
3413
+ var exp = value[2];
3414
+ return exp;
3415
+ });
3416
+ function WhenCondition(state) {
3417
+ if (state.verbose)
3418
+ console.log("ENTER:", "WhenCondition");
3419
+ if (state.tokenize) {
3420
+ return $TOKEN("WhenCondition", state, WhenCondition$0(state));
3421
+ } else {
3422
+ return WhenCondition$0(state);
3423
+ }
3424
+ }
3425
+ var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, __, $C(In, Of, From), ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
3426
+ var declaration = $3;
3427
+ var kind = $5;
3428
+ var exp = $6;
3429
+ let blockPrefix = [];
3430
+ if (kind.token === "from") {
3431
+ kind.token = "of";
3432
+ } else if (kind.token === "of") {
3433
+ module2.insertTrimmingSpace(declaration, "");
3434
+ module2.insertTrimmingSpace(exp, "");
3435
+ if (declaration.own) {
3436
+ const indent = "".padStart((module2.currentIndent + 1) * 2);
3437
+ const hasPropRef = module2.getHasPropRef();
3438
+ blockPrefix.push([indent, "if (!", hasPropRef, ".call(", exp, ", ", declaration, ")) continue\n"]);
3439
+ }
3440
+ kind.token = "in ";
3441
+ } else if (kind.token === "in") {
3442
+ const counterRef = {
3443
+ type: "Ref",
3444
+ base: "i"
3445
+ };
3446
+ const lenRef = {
3447
+ type: "Ref",
3448
+ base: "len"
3449
+ };
3450
+ const expRef = exp.type === "Identifier" ? exp : {
3451
+ type: "Ref",
3452
+ base: "ref"
3453
+ };
3454
+ const varRef = declaration;
3455
+ module2.insertTrimmingSpace(exp, "");
3456
+ const expRefDec = expRef !== exp ? [expRef, " = ", exp, ", "] : [];
3457
+ declaration = {
3458
+ type: "Declaration",
3459
+ children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
3460
+ names: []
3461
+ };
3462
+ const indent = "".padStart((module2.currentIndent + 1) * 2);
3463
+ blockPrefix.push([{
3464
+ type: "AssignmentExpression",
3465
+ children: [indent, varRef, " = ", expRef, "[", counterRef, "]\n"],
3466
+ names: varRef.names
3467
+ }]);
3468
+ return {
3469
+ declaration,
3470
+ children: [$1, $2, declaration, "; ", counterRef, " < ", lenRef, "; ", counterRef, "++", $7],
3471
+ blockPrefix
3472
+ };
3473
+ }
3474
+ return {
3475
+ declaration,
3476
+ children: $0,
3477
+ blockPrefix
3478
+ };
3479
+ });
3480
+ function CoffeeForStatementParameters(state) {
3481
+ if (state.verbose)
3482
+ console.log("ENTER:", "CoffeeForStatementParameters");
3483
+ if (state.tokenize) {
3484
+ return $TOKEN("CoffeeForStatementParameters", state, CoffeeForStatementParameters$0(state));
3485
+ } else {
3486
+ return CoffeeForStatementParameters$0(state);
3487
+ }
3488
+ }
3489
+ var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L75, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
3490
+ var own = $1;
3491
+ var binding = $2;
3492
+ if (own) {
3493
+ binding.own = true;
3494
+ }
3495
+ binding.type = "AssignmentExpression";
3496
+ return binding;
3497
+ });
3498
+ function CoffeeForDeclaration(state) {
3499
+ if (state.verbose)
3500
+ console.log("ENTER:", "CoffeeForDeclaration");
3501
+ if (state.tokenize) {
3502
+ return $TOKEN("CoffeeForDeclaration", state, CoffeeForDeclaration$0(state));
3503
+ } else {
3504
+ return CoffeeForDeclaration$0(state);
3505
+ }
3506
+ }
3507
+ var ForStatementParameters$0 = $TS($S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
3235
3508
  var declaration = $3;
3236
3509
  return {
3237
3510
  declaration,
3238
3511
  children: $0
3239
3512
  };
3240
3513
  });
3241
- var ForStatementControl$1 = $TS($S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), Expression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3514
+ var ForStatementParameters$1 = $TS($S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), Expression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3242
3515
  var declaration = $3;
3243
3516
  return {
3244
3517
  declaration,
3245
3518
  children: $0
3246
3519
  };
3247
3520
  });
3248
- var ForStatementControl$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3521
+ var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3249
3522
  var declaration = $4;
3250
3523
  return {
3251
3524
  declaration,
3252
3525
  children: $0
3253
3526
  };
3254
3527
  });
3255
- var ForStatementControl$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
3528
+ var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
3256
3529
  var declaration = $3;
3257
3530
  return {
3258
3531
  declaration,
3259
3532
  children: $0
3260
3533
  };
3261
3534
  });
3262
- function ForStatementControl(state) {
3535
+ function ForStatementParameters(state) {
3263
3536
  if (state.tokenize) {
3264
- return $TOKEN("ForStatementControl", state, ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state));
3537
+ return $TOKEN("ForStatementParameters", state, ForStatementParameters$0(state) || ForStatementParameters$1(state) || ForStatementParameters$2(state) || ForStatementParameters$3(state));
3265
3538
  } else {
3266
- return ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state);
3539
+ return ForStatementParameters$0(state) || ForStatementParameters$1(state) || ForStatementParameters$2(state) || ForStatementParameters$3(state);
3267
3540
  }
3268
3541
  }
3269
3542
  var ForInOfDeclaration$0 = $TS($S(Var, ForBinding), function($skip, $loc, $0, $1, $2) {
@@ -3292,7 +3565,7 @@ var require_parser = __commonJS({
3292
3565
  names: binding.names
3293
3566
  };
3294
3567
  });
3295
- var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R3, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
3568
+ var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R5, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
3296
3569
  var c = $1;
3297
3570
  var binding = $2;
3298
3571
  return {
@@ -3512,7 +3785,7 @@ var require_parser = __commonJS({
3512
3785
  return CatchBind$0(state) || CatchBind$1(state);
3513
3786
  }
3514
3787
  }
3515
- var Finally$0 = $S(__, $EXPECT($L74, fail, 'Finally "finally"'), BracedBlock);
3788
+ var Finally$0 = $S(__, $EXPECT($L76, fail, 'Finally "finally"'), BracedBlock);
3516
3789
  function Finally(state) {
3517
3790
  if (state.verbose)
3518
3791
  console.log("ENTER:", "Finally");
@@ -3581,13 +3854,13 @@ var require_parser = __commonJS({
3581
3854
  return ExpressionStatement$0(state);
3582
3855
  }
3583
3856
  }
3584
- var KeywordStatement$0 = $T($S($EXPECT($L75, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
3857
+ var KeywordStatement$0 = $T($S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
3585
3858
  return { "type": "BreakStatement", "children": value };
3586
3859
  });
3587
- var KeywordStatement$1 = $T($S($EXPECT($L76, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
3860
+ var KeywordStatement$1 = $T($S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
3588
3861
  return { "type": "ContinueStatement", "children": value };
3589
3862
  });
3590
- var KeywordStatement$2 = $T($S($EXPECT($L77, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
3863
+ var KeywordStatement$2 = $T($S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
3591
3864
  return { "type": "DebuggerStatement", "children": value };
3592
3865
  });
3593
3866
  var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
@@ -3603,7 +3876,7 @@ var require_parser = __commonJS({
3603
3876
  return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
3604
3877
  }
3605
3878
  }
3606
- var DebuggerExpression$0 = $TS($S($EXPECT($L77, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3879
+ var DebuggerExpression$0 = $TS($S($EXPECT($L79, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3607
3880
  return {
3608
3881
  type: "DebuggerExpression",
3609
3882
  children: ["($=>{", $1, "})()"]
@@ -3646,7 +3919,7 @@ var require_parser = __commonJS({
3646
3919
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
3647
3920
  }
3648
3921
  }
3649
- var ImportDeclaration$0 = $T($S($EXPECT($L78, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
3922
+ var ImportDeclaration$0 = $T($S($EXPECT($L80, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
3650
3923
  return { "ts": true, "children": value };
3651
3924
  });
3652
3925
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -3802,7 +4075,7 @@ var require_parser = __commonJS({
3802
4075
  return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
3803
4076
  }
3804
4077
  }
3805
- var UnquotedSpecifier$0 = $TV($EXPECT($R4, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
4078
+ var UnquotedSpecifier$0 = $TV($EXPECT($R6, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
3806
4079
  var spec = $0;
3807
4080
  return { $loc, token: `"${spec}"` };
3808
4081
  });
@@ -3825,7 +4098,7 @@ var require_parser = __commonJS({
3825
4098
  return ImportedBinding$0(state);
3826
4099
  }
3827
4100
  }
3828
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L79, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
4101
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L81, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
3829
4102
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
3830
4103
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
3831
4104
  function ExportDeclaration(state) {
@@ -3932,7 +4205,7 @@ var require_parser = __commonJS({
3932
4205
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
3933
4206
  }
3934
4207
  }
3935
- var ConstAssignment$0 = $TV($EXPECT($L80, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
4208
+ var ConstAssignment$0 = $TV($EXPECT($L82, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
3936
4209
  return { $loc, token: "=" };
3937
4210
  });
3938
4211
  function ConstAssignment(state) {
@@ -4054,7 +4327,7 @@ var require_parser = __commonJS({
4054
4327
  return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
4055
4328
  }
4056
4329
  }
4057
- var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
4330
+ var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
4058
4331
  function DecimalBigIntegerLiteral(state) {
4059
4332
  if (state.verbose)
4060
4333
  console.log("ENTER:", "DecimalBigIntegerLiteral");
@@ -4064,11 +4337,11 @@ var require_parser = __commonJS({
4064
4337
  return DecimalBigIntegerLiteral$0(state);
4065
4338
  }
4066
4339
  }
4067
- var DecimalLiteral$0 = $TV($TEXT($EXPECT($R6, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
4340
+ var DecimalLiteral$0 = $TV($TEXT($EXPECT($R8, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
4068
4341
  return $1 + ".";
4069
4342
  });
4070
- var DecimalLiteral$1 = $TEXT($S($EXPECT($R7, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
4071
- var DecimalLiteral$2 = $TEXT($S($EXPECT($R8, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
4343
+ var DecimalLiteral$1 = $TEXT($S($EXPECT($R9, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
4344
+ var DecimalLiteral$2 = $TEXT($S($EXPECT($R10, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
4072
4345
  function DecimalLiteral(state) {
4073
4346
  if (state.tokenize) {
4074
4347
  return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
@@ -4076,7 +4349,7 @@ var require_parser = __commonJS({
4076
4349
  return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
4077
4350
  }
4078
4351
  }
4079
- var ExponentPart$0 = $R$0($EXPECT($R9, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
4352
+ var ExponentPart$0 = $R$0($EXPECT($R11, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
4080
4353
  function ExponentPart(state) {
4081
4354
  if (state.verbose)
4082
4355
  console.log("ENTER:", "ExponentPart");
@@ -4086,7 +4359,7 @@ var require_parser = __commonJS({
4086
4359
  return ExponentPart$0(state);
4087
4360
  }
4088
4361
  }
4089
- var BinaryIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
4362
+ var BinaryIntegerLiteral$0 = $R$0($EXPECT($R12, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
4090
4363
  function BinaryIntegerLiteral(state) {
4091
4364
  if (state.verbose)
4092
4365
  console.log("ENTER:", "BinaryIntegerLiteral");
@@ -4096,7 +4369,7 @@ var require_parser = __commonJS({
4096
4369
  return BinaryIntegerLiteral$0(state);
4097
4370
  }
4098
4371
  }
4099
- var OctalIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
4372
+ var OctalIntegerLiteral$0 = $R$0($EXPECT($R13, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
4100
4373
  function OctalIntegerLiteral(state) {
4101
4374
  if (state.verbose)
4102
4375
  console.log("ENTER:", "OctalIntegerLiteral");
@@ -4106,7 +4379,7 @@ var require_parser = __commonJS({
4106
4379
  return OctalIntegerLiteral$0(state);
4107
4380
  }
4108
4381
  }
4109
- var HexLiteral$0 = $R$0($EXPECT($R12, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
4382
+ var HexLiteral$0 = $R$0($EXPECT($R14, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
4110
4383
  function HexLiteral(state) {
4111
4384
  if (state.verbose)
4112
4385
  console.log("ENTER:", "HexLiteral");
@@ -4155,7 +4428,7 @@ var require_parser = __commonJS({
4155
4428
  return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
4156
4429
  }
4157
4430
  }
4158
- var DoubleStringCharacters$0 = $TR($EXPECT($R13, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4431
+ var DoubleStringCharacters$0 = $TR($EXPECT($R15, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4159
4432
  return { $loc, token: $0 };
4160
4433
  });
4161
4434
  function DoubleStringCharacters(state) {
@@ -4167,7 +4440,7 @@ var require_parser = __commonJS({
4167
4440
  return DoubleStringCharacters$0(state);
4168
4441
  }
4169
4442
  }
4170
- var SingleStringCharacters$0 = $TR($EXPECT($R14, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4443
+ var SingleStringCharacters$0 = $TR($EXPECT($R16, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4171
4444
  return { $loc, token: $0 };
4172
4445
  });
4173
4446
  function SingleStringCharacters(state) {
@@ -4179,7 +4452,7 @@ var require_parser = __commonJS({
4179
4452
  return SingleStringCharacters$0(state);
4180
4453
  }
4181
4454
  }
4182
- var TripleDoubleStringCharacters$0 = $TR($EXPECT($R15, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4455
+ var TripleDoubleStringCharacters$0 = $TR($EXPECT($R17, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4183
4456
  return { $loc, token: $0 };
4184
4457
  });
4185
4458
  function TripleDoubleStringCharacters(state) {
@@ -4191,7 +4464,7 @@ var require_parser = __commonJS({
4191
4464
  return TripleDoubleStringCharacters$0(state);
4192
4465
  }
4193
4466
  }
4194
- var TripleSingleStringCharacters$0 = $TR($EXPECT($R16, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4467
+ var TripleSingleStringCharacters$0 = $TR($EXPECT($R18, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4195
4468
  return { $loc, token: $0 };
4196
4469
  });
4197
4470
  function TripleSingleStringCharacters(state) {
@@ -4242,7 +4515,7 @@ var require_parser = __commonJS({
4242
4515
  return CoffeeInterpolatedDoubleQuotedString$0(state);
4243
4516
  }
4244
4517
  }
4245
- var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R17, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4518
+ var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R19, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4246
4519
  return { $loc, token: $0 };
4247
4520
  });
4248
4521
  function CoffeeDoubleQuotedStringCharacters(state) {
@@ -4266,7 +4539,7 @@ var require_parser = __commonJS({
4266
4539
  return RegularExpressionLiteral$0(state);
4267
4540
  }
4268
4541
  }
4269
- var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R18, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
4542
+ var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R20, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
4270
4543
  function RegularExpressionBody(state) {
4271
4544
  if (state.verbose)
4272
4545
  console.log("ENTER:", "RegularExpressionBody");
@@ -4276,7 +4549,7 @@ var require_parser = __commonJS({
4276
4549
  return RegularExpressionBody$0(state);
4277
4550
  }
4278
4551
  }
4279
- var RegExpCharacter$0 = $R$0($EXPECT($R19, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
4552
+ var RegExpCharacter$0 = $R$0($EXPECT($R21, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
4280
4553
  function RegExpCharacter(state) {
4281
4554
  if (state.verbose)
4282
4555
  console.log("ENTER:", "RegExpCharacter");
@@ -4286,7 +4559,7 @@ var require_parser = __commonJS({
4286
4559
  return RegExpCharacter$0(state);
4287
4560
  }
4288
4561
  }
4289
- var RegularExpressionFlags$0 = $R$0($EXPECT($R20, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
4562
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R22, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
4290
4563
  function RegularExpressionFlags(state) {
4291
4564
  if (state.verbose)
4292
4565
  console.log("ENTER:", "RegularExpressionFlags");
@@ -4317,7 +4590,7 @@ var require_parser = __commonJS({
4317
4590
  return TemplateSubstitution$0(state);
4318
4591
  }
4319
4592
  }
4320
- var TemplateCharacters$0 = $TR($EXPECT($R21, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4593
+ var TemplateCharacters$0 = $TR($EXPECT($R23, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4321
4594
  return { $loc, token: $0 };
4322
4595
  });
4323
4596
  function TemplateCharacters(state) {
@@ -4329,7 +4602,7 @@ var require_parser = __commonJS({
4329
4602
  return TemplateCharacters$0(state);
4330
4603
  }
4331
4604
  }
4332
- var TemplateBlockCharacters$0 = $TR($EXPECT($R22, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4605
+ var TemplateBlockCharacters$0 = $TR($EXPECT($R24, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4333
4606
  return { $loc, token: $0 };
4334
4607
  });
4335
4608
  function TemplateBlockCharacters(state) {
@@ -4341,9 +4614,9 @@ var require_parser = __commonJS({
4341
4614
  return TemplateBlockCharacters$0(state);
4342
4615
  }
4343
4616
  }
4344
- var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R23, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
4345
- var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R24, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
4346
- var ReservedWord$2 = $R$0($EXPECT($R25, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
4617
+ var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R25, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
4618
+ var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R26, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
4619
+ var ReservedWord$2 = $R$0($EXPECT($R27, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
4347
4620
  function ReservedWord(state) {
4348
4621
  if (state.tokenize) {
4349
4622
  return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state));
@@ -4360,7 +4633,7 @@ var require_parser = __commonJS({
4360
4633
  return Comment$0(state) || Comment$1(state);
4361
4634
  }
4362
4635
  }
4363
- var SingleLineComment$0 = $TR($EXPECT($R26, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4636
+ var SingleLineComment$0 = $TR($EXPECT($R28, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4364
4637
  return { $loc, token: $0 };
4365
4638
  });
4366
4639
  var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
@@ -4380,7 +4653,7 @@ var require_parser = __commonJS({
4380
4653
  return MultiLineComment$0(state) || MultiLineComment$1(state);
4381
4654
  }
4382
4655
  }
4383
- var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L81, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L82, fail, 'JSMultiLineComment "*/"')), $EXPECT($R27, fail, "JSMultiLineComment /./"))), $EXPECT($L82, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
4656
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L84, fail, 'JSMultiLineComment "*/"')), $EXPECT($R29, fail, "JSMultiLineComment /./"))), $EXPECT($L84, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
4384
4657
  return { $loc, token: $1 };
4385
4658
  });
4386
4659
  function JSMultiLineComment(state) {
@@ -4392,7 +4665,7 @@ var require_parser = __commonJS({
4392
4665
  return JSMultiLineComment$0(state);
4393
4666
  }
4394
4667
  }
4395
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R28, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4668
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R30, fail, "CoffeeSingleLineComment /#(?!##)([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4396
4669
  return { $loc, token: `//${$1}` };
4397
4670
  });
4398
4671
  function CoffeeSingleLineComment(state) {
@@ -4404,7 +4677,7 @@ var require_parser = __commonJS({
4404
4677
  return CoffeeSingleLineComment$0(state);
4405
4678
  }
4406
4679
  }
4407
- var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L83, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L83, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L82, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R27, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L83, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
4680
+ var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L84, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R29, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L85, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
4408
4681
  return { $loc, token: `/*${$2}*/` };
4409
4682
  });
4410
4683
  function CoffeeMultiLineComment(state) {
@@ -4416,7 +4689,7 @@ var require_parser = __commonJS({
4416
4689
  return CoffeeMultiLineComment$0(state);
4417
4690
  }
4418
4691
  }
4419
- var InlineComment$0 = $TV($TEXT($S($EXPECT($L81, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L82, fail, 'InlineComment "*/"')), $EXPECT($R29, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L82, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
4692
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L84, fail, 'InlineComment "*/"')), $EXPECT($R31, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L84, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
4420
4693
  return { $loc, token: $1 };
4421
4694
  });
4422
4695
  function InlineComment(state) {
@@ -4458,7 +4731,7 @@ var require_parser = __commonJS({
4458
4731
  return _$0(state);
4459
4732
  }
4460
4733
  }
4461
- var NonNewlineWhitespace$0 = $TR($EXPECT($R30, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4734
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R32, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4462
4735
  return { $loc, token: $0 };
4463
4736
  });
4464
4737
  function NonNewlineWhitespace(state) {
@@ -4480,7 +4753,7 @@ var require_parser = __commonJS({
4480
4753
  return __$0(state);
4481
4754
  }
4482
4755
  }
4483
- var Whitespace$0 = $TR($EXPECT($R31, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4756
+ var Whitespace$0 = $TR($EXPECT($R33, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
4484
4757
  return { $loc, token: $0 };
4485
4758
  });
4486
4759
  function Whitespace(state) {
@@ -4515,7 +4788,7 @@ var require_parser = __commonJS({
4515
4788
  return StatementDelimiter$0(state) || StatementDelimiter$1(state);
4516
4789
  }
4517
4790
  }
4518
- var NonIdContinue$0 = $R$0($EXPECT($R32, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
4791
+ var NonIdContinue$0 = $R$0($EXPECT($R34, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
4519
4792
  function NonIdContinue(state) {
4520
4793
  if (state.verbose)
4521
4794
  console.log("ENTER:", "NonIdContinue");
@@ -4537,7 +4810,19 @@ var require_parser = __commonJS({
4537
4810
  return Loc$0(state);
4538
4811
  }
4539
4812
  }
4540
- var As$0 = $TS($S($EXPECT($L84, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4813
+ var Ampersand$0 = $TV($EXPECT($L71, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
4814
+ return { $loc, token: $1 };
4815
+ });
4816
+ function Ampersand(state) {
4817
+ if (state.verbose)
4818
+ console.log("ENTER:", "Ampersand");
4819
+ if (state.tokenize) {
4820
+ return $TOKEN("Ampersand", state, Ampersand$0(state));
4821
+ } else {
4822
+ return Ampersand$0(state);
4823
+ }
4824
+ }
4825
+ var As$0 = $TS($S($EXPECT($L86, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4541
4826
  return { $loc, token: $1 };
4542
4827
  });
4543
4828
  function As(state) {
@@ -4549,7 +4834,7 @@ var require_parser = __commonJS({
4549
4834
  return As$0(state);
4550
4835
  }
4551
4836
  }
4552
- var Async$0 = $TV($EXPECT($L85, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
4837
+ var Async$0 = $TV($EXPECT($L87, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
4553
4838
  return { $loc, token: $1 };
4554
4839
  });
4555
4840
  function Async(state) {
@@ -4561,7 +4846,7 @@ var require_parser = __commonJS({
4561
4846
  return Async$0(state);
4562
4847
  }
4563
4848
  }
4564
- var Await$0 = $TS($S($EXPECT($L86, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4849
+ var Await$0 = $TS($S($EXPECT($L88, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4565
4850
  return { $loc, token: $1 };
4566
4851
  });
4567
4852
  function Await(state) {
@@ -4573,7 +4858,7 @@ var require_parser = __commonJS({
4573
4858
  return Await$0(state);
4574
4859
  }
4575
4860
  }
4576
- var Backtick$0 = $TV($EXPECT($L87, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
4861
+ var Backtick$0 = $TV($EXPECT($L89, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
4577
4862
  return { $loc, token: $1 };
4578
4863
  });
4579
4864
  function Backtick(state) {
@@ -4585,7 +4870,7 @@ var require_parser = __commonJS({
4585
4870
  return Backtick$0(state);
4586
4871
  }
4587
4872
  }
4588
- var Case$0 = $TS($S($EXPECT($L88, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4873
+ var Case$0 = $TS($S($EXPECT($L90, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4589
4874
  return { $loc, token: $1 };
4590
4875
  });
4591
4876
  function Case(state) {
@@ -4597,7 +4882,7 @@ var require_parser = __commonJS({
4597
4882
  return Case$0(state);
4598
4883
  }
4599
4884
  }
4600
- var Catch$0 = $TV($EXPECT($L89, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
4885
+ var Catch$0 = $TV($EXPECT($L91, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
4601
4886
  return { $loc, token: $1 };
4602
4887
  });
4603
4888
  function Catch(state) {
@@ -4609,7 +4894,7 @@ var require_parser = __commonJS({
4609
4894
  return Catch$0(state);
4610
4895
  }
4611
4896
  }
4612
- var Class$0 = $TV($EXPECT($L90, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
4897
+ var Class$0 = $TV($EXPECT($L92, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
4613
4898
  return { $loc, token: $1 };
4614
4899
  });
4615
4900
  function Class(state) {
@@ -4657,7 +4942,7 @@ var require_parser = __commonJS({
4657
4942
  return CloseParen$0(state);
4658
4943
  }
4659
4944
  }
4660
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L91, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
4945
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L93, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
4661
4946
  return { $loc, token: "${" };
4662
4947
  });
4663
4948
  function CoffeeSubstitutionStart(state) {
@@ -4669,7 +4954,7 @@ var require_parser = __commonJS({
4669
4954
  return CoffeeSubstitutionStart$0(state);
4670
4955
  }
4671
4956
  }
4672
- var Colon$0 = $TV($EXPECT($L92, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
4957
+ var Colon$0 = $TV($EXPECT($L94, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
4673
4958
  return { $loc, token: $1 };
4674
4959
  });
4675
4960
  function Colon(state) {
@@ -4693,7 +4978,7 @@ var require_parser = __commonJS({
4693
4978
  return ConstructorShorthand$0(state);
4694
4979
  }
4695
4980
  }
4696
- var Default$0 = $TS($S($EXPECT($L79, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4981
+ var Default$0 = $TS($S($EXPECT($L81, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4697
4982
  return { $loc, token: $1 };
4698
4983
  });
4699
4984
  function Default(state) {
@@ -4705,7 +4990,7 @@ var require_parser = __commonJS({
4705
4990
  return Default$0(state);
4706
4991
  }
4707
4992
  }
4708
- var Delete$0 = $TS($S($EXPECT($L93, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4993
+ var Delete$0 = $TS($S($EXPECT($L95, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4709
4994
  return { $loc, token: $1 };
4710
4995
  });
4711
4996
  function Delete(state) {
@@ -4717,7 +5002,7 @@ var require_parser = __commonJS({
4717
5002
  return Delete$0(state);
4718
5003
  }
4719
5004
  }
4720
- var Do$0 = $TS($S($EXPECT($L94, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5005
+ var Do$0 = $TS($S($EXPECT($L96, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4721
5006
  return { $loc, token: $1 };
4722
5007
  });
4723
5008
  function Do(state) {
@@ -4741,7 +5026,7 @@ var require_parser = __commonJS({
4741
5026
  return Dot$0(state);
4742
5027
  }
4743
5028
  }
4744
- var DotDot$0 = $TV($EXPECT($L95, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
5029
+ var DotDot$0 = $TV($EXPECT($L97, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
4745
5030
  return { $loc, token: $1 };
4746
5031
  });
4747
5032
  function DotDot(state) {
@@ -4753,7 +5038,7 @@ var require_parser = __commonJS({
4753
5038
  return DotDot$0(state);
4754
5039
  }
4755
5040
  }
4756
- var DotDotDot$0 = $TV($EXPECT($L96, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
5041
+ var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
4757
5042
  return { $loc, token: $1 };
4758
5043
  });
4759
5044
  function DotDotDot(state) {
@@ -4765,7 +5050,7 @@ var require_parser = __commonJS({
4765
5050
  return DotDotDot$0(state);
4766
5051
  }
4767
5052
  }
4768
- var DoubleQuote$0 = $TV($EXPECT($L97, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
5053
+ var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
4769
5054
  return { $loc, token: $1 };
4770
5055
  });
4771
5056
  function DoubleQuote(state) {
@@ -4777,7 +5062,7 @@ var require_parser = __commonJS({
4777
5062
  return DoubleQuote$0(state);
4778
5063
  }
4779
5064
  }
4780
- var Else$0 = $TV($EXPECT($L98, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
5065
+ var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
4781
5066
  return { $loc, token: $1 };
4782
5067
  });
4783
5068
  function Else(state) {
@@ -4801,7 +5086,7 @@ var require_parser = __commonJS({
4801
5086
  return Equals$0(state);
4802
5087
  }
4803
5088
  }
4804
- var Export$0 = $TS($S($EXPECT($L99, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5089
+ var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4805
5090
  return { $loc, token: $1 };
4806
5091
  });
4807
5092
  function Export(state) {
@@ -4813,7 +5098,7 @@ var require_parser = __commonJS({
4813
5098
  return Export$0(state);
4814
5099
  }
4815
5100
  }
4816
- var For$0 = $TS($S($EXPECT($L100, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5101
+ var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4817
5102
  return { $loc, token: $1 };
4818
5103
  });
4819
5104
  function For(state) {
@@ -4825,7 +5110,7 @@ var require_parser = __commonJS({
4825
5110
  return For$0(state);
4826
5111
  }
4827
5112
  }
4828
- var From$0 = $TS($S($EXPECT($L101, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5113
+ var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4829
5114
  return { $loc, token: $1 };
4830
5115
  });
4831
5116
  function From(state) {
@@ -4837,7 +5122,7 @@ var require_parser = __commonJS({
4837
5122
  return From$0(state);
4838
5123
  }
4839
5124
  }
4840
- var Function$0 = $TV($EXPECT($L102, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
5125
+ var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
4841
5126
  return { $loc, token: $1 };
4842
5127
  });
4843
5128
  function Function(state) {
@@ -4849,7 +5134,7 @@ var require_parser = __commonJS({
4849
5134
  return Function$0(state);
4850
5135
  }
4851
5136
  }
4852
- var GetOrSet$0 = $TS($S($C($EXPECT($L103, fail, 'GetOrSet "get"'), $EXPECT($L104, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5137
+ var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4853
5138
  return { $loc, token: $1 };
4854
5139
  });
4855
5140
  function GetOrSet(state) {
@@ -4861,7 +5146,7 @@ var require_parser = __commonJS({
4861
5146
  return GetOrSet$0(state);
4862
5147
  }
4863
5148
  }
4864
- var If$0 = $TV($TEXT($S($EXPECT($L105, fail, 'If "if"'), $E($EXPECT($L106, fail, 'If " "')))), function($skip, $loc, $0, $1) {
5149
+ var If$0 = $TV($TEXT($S($EXPECT($L107, fail, 'If "if"'), $E($EXPECT($L108, fail, 'If " "')))), function($skip, $loc, $0, $1) {
4865
5150
  return { $loc, token: $1 };
4866
5151
  });
4867
5152
  function If(state) {
@@ -4873,7 +5158,7 @@ var require_parser = __commonJS({
4873
5158
  return If$0(state);
4874
5159
  }
4875
5160
  }
4876
- var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R33, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
5161
+ var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R35, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
4877
5162
  return { $loc, token: $1 };
4878
5163
  });
4879
5164
  function Import(state) {
@@ -4885,7 +5170,7 @@ var require_parser = __commonJS({
4885
5170
  return Import$0(state);
4886
5171
  }
4887
5172
  }
4888
- var In$0 = $TV($EXPECT($L69, fail, 'In "in"'), function($skip, $loc, $0, $1) {
5173
+ var In$0 = $TV($EXPECT($L70, fail, 'In "in"'), function($skip, $loc, $0, $1) {
4889
5174
  return { $loc, token: $1 };
4890
5175
  });
4891
5176
  function In(state) {
@@ -4897,7 +5182,7 @@ var require_parser = __commonJS({
4897
5182
  return In$0(state);
4898
5183
  }
4899
5184
  }
4900
- var LetOrConst$0 = $TV($C($EXPECT($L107, fail, 'LetOrConst "let"'), $EXPECT($L108, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
5185
+ var LetOrConst$0 = $TV($C($EXPECT($L109, fail, 'LetOrConst "let"'), $EXPECT($L110, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
4901
5186
  return { $loc, token: $1 };
4902
5187
  });
4903
5188
  function LetOrConst(state) {
@@ -4909,7 +5194,7 @@ var require_parser = __commonJS({
4909
5194
  return LetOrConst$0(state);
4910
5195
  }
4911
5196
  }
4912
- var Loop$0 = $TS($S($EXPECT($L109, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5197
+ var Loop$0 = $TS($S($EXPECT($L111, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4913
5198
  return { $loc, token: "while(true)" };
4914
5199
  });
4915
5200
  function Loop(state) {
@@ -4921,7 +5206,7 @@ var require_parser = __commonJS({
4921
5206
  return Loop$0(state);
4922
5207
  }
4923
5208
  }
4924
- var New$0 = $TV($EXPECT($L110, fail, 'New "new"'), function($skip, $loc, $0, $1) {
5209
+ var New$0 = $TV($EXPECT($L112, fail, 'New "new"'), function($skip, $loc, $0, $1) {
4925
5210
  return { $loc, token: $1 };
4926
5211
  });
4927
5212
  function New(state) {
@@ -4933,7 +5218,7 @@ var require_parser = __commonJS({
4933
5218
  return New$0(state);
4934
5219
  }
4935
5220
  }
4936
- var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L111, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L106, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
5221
+ var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L113, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L108, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
4937
5222
  return { $loc, token: "!" };
4938
5223
  });
4939
5224
  function Not(state) {
@@ -4945,7 +5230,7 @@ var require_parser = __commonJS({
4945
5230
  return Not$0(state);
4946
5231
  }
4947
5232
  }
4948
- var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
5233
+ var Of$0 = $TV($EXPECT($L65, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
4949
5234
  return { $loc, token: $1 };
4950
5235
  });
4951
5236
  function Of(state) {
@@ -4957,7 +5242,7 @@ var require_parser = __commonJS({
4957
5242
  return Of$0(state);
4958
5243
  }
4959
5244
  }
4960
- var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
5245
+ var OpenBrace$0 = $TV($EXPECT($L114, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
4961
5246
  return { $loc, token: $1 };
4962
5247
  });
4963
5248
  function OpenBrace(state) {
@@ -4969,7 +5254,7 @@ var require_parser = __commonJS({
4969
5254
  return OpenBrace$0(state);
4970
5255
  }
4971
5256
  }
4972
- var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
5257
+ var OpenBracket$0 = $TV($EXPECT($L115, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
4973
5258
  return { $loc, token: $1 };
4974
5259
  });
4975
5260
  function OpenBracket(state) {
@@ -4981,7 +5266,7 @@ var require_parser = __commonJS({
4981
5266
  return OpenBracket$0(state);
4982
5267
  }
4983
5268
  }
4984
- var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
5269
+ var OpenParen$0 = $TV($EXPECT($L116, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
4985
5270
  return { $loc, token: $1 };
4986
5271
  });
4987
5272
  function OpenParen(state) {
@@ -4993,7 +5278,7 @@ var require_parser = __commonJS({
4993
5278
  return OpenParen$0(state);
4994
5279
  }
4995
5280
  }
4996
- var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
5281
+ var QuestionMark$0 = $TV($EXPECT($L117, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
4997
5282
  return { $loc, token: $1 };
4998
5283
  });
4999
5284
  function QuestionMark(state) {
@@ -5005,7 +5290,7 @@ var require_parser = __commonJS({
5005
5290
  return QuestionMark$0(state);
5006
5291
  }
5007
5292
  }
5008
- var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5293
+ var Return$0 = $TS($S($EXPECT($L118, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5009
5294
  return { $loc, token: $1 };
5010
5295
  });
5011
5296
  function Return(state) {
@@ -5017,7 +5302,7 @@ var require_parser = __commonJS({
5017
5302
  return Return$0(state);
5018
5303
  }
5019
5304
  }
5020
- var Semicolon$0 = $TV($EXPECT($L73, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
5305
+ var Semicolon$0 = $TV($EXPECT($L74, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
5021
5306
  return { $loc, token: $1 };
5022
5307
  });
5023
5308
  function Semicolon(state) {
@@ -5029,7 +5314,7 @@ var require_parser = __commonJS({
5029
5314
  return Semicolon$0(state);
5030
5315
  }
5031
5316
  }
5032
- var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
5317
+ var SingleQuote$0 = $TV($EXPECT($L119, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
5033
5318
  return { $loc, token: $1 };
5034
5319
  });
5035
5320
  function SingleQuote(state) {
@@ -5053,10 +5338,10 @@ var require_parser = __commonJS({
5053
5338
  return Star$0(state);
5054
5339
  }
5055
5340
  }
5056
- var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
5341
+ var Static$0 = $TV($EXPECT($L120, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
5057
5342
  return { $loc, token: $1 };
5058
5343
  });
5059
- var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
5344
+ var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($L116, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
5060
5345
  return { $loc, token: "static " };
5061
5346
  });
5062
5347
  function Static(state) {
@@ -5066,7 +5351,7 @@ var require_parser = __commonJS({
5066
5351
  return Static$0(state) || Static$1(state);
5067
5352
  }
5068
5353
  }
5069
- var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
5354
+ var SubstitutionStart$0 = $TV($EXPECT($L121, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
5070
5355
  return { $loc, token: $1 };
5071
5356
  });
5072
5357
  function SubstitutionStart(state) {
@@ -5078,7 +5363,7 @@ var require_parser = __commonJS({
5078
5363
  return SubstitutionStart$0(state);
5079
5364
  }
5080
5365
  }
5081
- var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5366
+ var Switch$0 = $TS($S($EXPECT($L122, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5082
5367
  return { $loc, token: $1 };
5083
5368
  });
5084
5369
  function Switch(state) {
@@ -5090,7 +5375,7 @@ var require_parser = __commonJS({
5090
5375
  return Switch$0(state);
5091
5376
  }
5092
5377
  }
5093
- var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
5378
+ var Target$0 = $TV($EXPECT($L123, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
5094
5379
  return { $loc, token: $1 };
5095
5380
  });
5096
5381
  function Target(state) {
@@ -5102,7 +5387,7 @@ var require_parser = __commonJS({
5102
5387
  return Target$0(state);
5103
5388
  }
5104
5389
  }
5105
- var Then$0 = $TS($S(__, $EXPECT($L123, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
5390
+ var Then$0 = $TS($S(__, $EXPECT($L124, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
5106
5391
  return { $loc, token: "" };
5107
5392
  });
5108
5393
  function Then(state) {
@@ -5114,7 +5399,7 @@ var require_parser = __commonJS({
5114
5399
  return Then$0(state);
5115
5400
  }
5116
5401
  }
5117
- var Throw$0 = $TS($S($EXPECT($L124, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5402
+ var Throw$0 = $TS($S($EXPECT($L125, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5118
5403
  return { $loc, token: $1 };
5119
5404
  });
5120
5405
  function Throw(state) {
@@ -5126,7 +5411,7 @@ var require_parser = __commonJS({
5126
5411
  return Throw$0(state);
5127
5412
  }
5128
5413
  }
5129
- var TripleDoubleQuote$0 = $TV($EXPECT($L125, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
5414
+ var TripleDoubleQuote$0 = $TV($EXPECT($L126, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
5130
5415
  return { $loc, token: "`" };
5131
5416
  });
5132
5417
  function TripleDoubleQuote(state) {
@@ -5138,7 +5423,7 @@ var require_parser = __commonJS({
5138
5423
  return TripleDoubleQuote$0(state);
5139
5424
  }
5140
5425
  }
5141
- var TripleSingleQuote$0 = $TV($EXPECT($L126, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
5426
+ var TripleSingleQuote$0 = $TV($EXPECT($L127, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
5142
5427
  return { $loc, token: "`" };
5143
5428
  });
5144
5429
  function TripleSingleQuote(state) {
@@ -5150,7 +5435,7 @@ var require_parser = __commonJS({
5150
5435
  return TripleSingleQuote$0(state);
5151
5436
  }
5152
5437
  }
5153
- var TripleTick$0 = $TV($EXPECT($L127, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
5438
+ var TripleTick$0 = $TV($EXPECT($L128, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
5154
5439
  return { $loc, token: "`" };
5155
5440
  });
5156
5441
  function TripleTick(state) {
@@ -5162,7 +5447,7 @@ var require_parser = __commonJS({
5162
5447
  return TripleTick$0(state);
5163
5448
  }
5164
5449
  }
5165
- var Try$0 = $TV($EXPECT($L128, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
5450
+ var Try$0 = $TV($EXPECT($L129, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
5166
5451
  return { $loc, token: $1 };
5167
5452
  });
5168
5453
  function Try(state) {
@@ -5174,7 +5459,7 @@ var require_parser = __commonJS({
5174
5459
  return Try$0(state);
5175
5460
  }
5176
5461
  }
5177
- var Typeof$0 = $TS($S($EXPECT($L129, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5462
+ var Typeof$0 = $TS($S($EXPECT($L130, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5178
5463
  return { $loc, token: $1 };
5179
5464
  });
5180
5465
  function Typeof(state) {
@@ -5186,7 +5471,7 @@ var require_parser = __commonJS({
5186
5471
  return Typeof$0(state);
5187
5472
  }
5188
5473
  }
5189
- var Unless$0 = $TV($EXPECT($L130, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
5474
+ var Unless$0 = $TV($EXPECT($L131, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
5190
5475
  return { $loc, token: $1 };
5191
5476
  });
5192
5477
  function Unless(state) {
@@ -5198,7 +5483,7 @@ var require_parser = __commonJS({
5198
5483
  return Unless$0(state);
5199
5484
  }
5200
5485
  }
5201
- var Until$0 = $TS($S($EXPECT($L131, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5486
+ var Until$0 = $TS($S($EXPECT($L132, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5202
5487
  return { $loc, token: $1 };
5203
5488
  });
5204
5489
  function Until(state) {
@@ -5210,7 +5495,7 @@ var require_parser = __commonJS({
5210
5495
  return Until$0(state);
5211
5496
  }
5212
5497
  }
5213
- var Var$0 = $TV($EXPECT($L132, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
5498
+ var Var$0 = $TV($EXPECT($L133, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
5214
5499
  return { $loc, token: $1 };
5215
5500
  });
5216
5501
  function Var(state) {
@@ -5222,7 +5507,7 @@ var require_parser = __commonJS({
5222
5507
  return Var$0(state);
5223
5508
  }
5224
5509
  }
5225
- var Void$0 = $TS($S($EXPECT($L133, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5510
+ var Void$0 = $TS($S($EXPECT($L134, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5226
5511
  return { $loc, token: $1 };
5227
5512
  });
5228
5513
  function Void(state) {
@@ -5234,7 +5519,7 @@ var require_parser = __commonJS({
5234
5519
  return Void$0(state);
5235
5520
  }
5236
5521
  }
5237
- var When$0 = $TS($S($EXPECT($L134, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5522
+ var When$0 = $TS($S($EXPECT($L135, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5238
5523
  return { $loc, token: "case" };
5239
5524
  });
5240
5525
  function When(state) {
@@ -5246,7 +5531,7 @@ var require_parser = __commonJS({
5246
5531
  return When$0(state);
5247
5532
  }
5248
5533
  }
5249
- var While$0 = $TS($S($EXPECT($L135, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5534
+ var While$0 = $TS($S($EXPECT($L136, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5250
5535
  return { $loc, token: $1 };
5251
5536
  });
5252
5537
  function While(state) {
@@ -5258,7 +5543,7 @@ var require_parser = __commonJS({
5258
5543
  return While$0(state);
5259
5544
  }
5260
5545
  }
5261
- var Yield$0 = $TS($S($EXPECT($L136, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5546
+ var Yield$0 = $TS($S($EXPECT($L137, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5262
5547
  return { $loc, token: $1 };
5263
5548
  });
5264
5549
  function Yield(state) {
@@ -5284,7 +5569,7 @@ var require_parser = __commonJS({
5284
5569
  return JSXElement$0(state) || JSXElement$1(state);
5285
5570
  }
5286
5571
  }
5287
- var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L137, fail, 'JSXSelfClosingElement "/>"'));
5572
+ var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L138, fail, 'JSXSelfClosingElement "/>"'));
5288
5573
  function JSXSelfClosingElement(state) {
5289
5574
  if (state.verbose)
5290
5575
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -5304,7 +5589,7 @@ var require_parser = __commonJS({
5304
5589
  return JSXOpeningElement$0(state);
5305
5590
  }
5306
5591
  }
5307
- var JSXClosingElement$0 = $S($EXPECT($L138, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
5592
+ var JSXClosingElement$0 = $S($EXPECT($L139, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
5308
5593
  function JSXClosingElement(state) {
5309
5594
  if (state.verbose)
5310
5595
  console.log("ENTER:", "JSXClosingElement");
@@ -5314,7 +5599,7 @@ var require_parser = __commonJS({
5314
5599
  return JSXClosingElement$0(state);
5315
5600
  }
5316
5601
  }
5317
- var JSXFragment$0 = $S($EXPECT($L139, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L140, fail, 'JSXFragment "</>"'));
5602
+ var JSXFragment$0 = $S($EXPECT($L140, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L141, fail, 'JSXFragment "</>"'));
5318
5603
  function JSXFragment(state) {
5319
5604
  if (state.verbose)
5320
5605
  console.log("ENTER:", "JSXFragment");
@@ -5334,7 +5619,7 @@ var require_parser = __commonJS({
5334
5619
  return JSXElementName$0(state);
5335
5620
  }
5336
5621
  }
5337
- var JSXIdentifierName$0 = $R$0($EXPECT($R34, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
5622
+ var JSXIdentifierName$0 = $R$0($EXPECT($R36, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
5338
5623
  function JSXIdentifierName(state) {
5339
5624
  if (state.verbose)
5340
5625
  console.log("ENTER:", "JSXIdentifierName");
@@ -5383,8 +5668,8 @@ var require_parser = __commonJS({
5383
5668
  return JSXAttributeInitializer$0(state);
5384
5669
  }
5385
5670
  }
5386
- var JSXAttributeValue$0 = $R$0($EXPECT($R35, fail, 'JSXAttributeValue /"[^"]*"/'));
5387
- var JSXAttributeValue$1 = $R$0($EXPECT($R36, fail, "JSXAttributeValue /'[^']*'/"));
5671
+ var JSXAttributeValue$0 = $R$0($EXPECT($R37, fail, 'JSXAttributeValue /"[^"]*"/'));
5672
+ var JSXAttributeValue$1 = $R$0($EXPECT($R38, fail, "JSXAttributeValue /'[^']*'/"));
5388
5673
  var JSXAttributeValue$2 = $S(OpenBrace, ExtendedExpression, __, CloseBrace);
5389
5674
  var JSXAttributeValue$3 = JSXElement;
5390
5675
  var JSXAttributeValue$4 = JSXFragment;
@@ -5416,7 +5701,7 @@ var require_parser = __commonJS({
5416
5701
  return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
5417
5702
  }
5418
5703
  }
5419
- var JSXText$0 = $R$0($EXPECT($R37, fail, "JSXText /[^{}<>]+/"));
5704
+ var JSXText$0 = $R$0($EXPECT($R39, fail, "JSXText /[^{}<>]+/"));
5420
5705
  function JSXText(state) {
5421
5706
  if (state.verbose)
5422
5707
  console.log("ENTER:", "JSXText");
@@ -5448,7 +5733,7 @@ var require_parser = __commonJS({
5448
5733
  return TypeDeclaration$0(state);
5449
5734
  }
5450
5735
  }
5451
- var TypeDeclarationModifier$0 = $S($EXPECT($L141, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
5736
+ var TypeDeclarationModifier$0 = $S($EXPECT($L142, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
5452
5737
  var TypeDeclarationModifier$1 = Export;
5453
5738
  function TypeDeclarationModifier(state) {
5454
5739
  if (state.tokenize) {
@@ -5468,7 +5753,7 @@ var require_parser = __commonJS({
5468
5753
  return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
5469
5754
  }
5470
5755
  }
5471
- var TypeKeyword$0 = $S($EXPECT($L142, fail, 'TypeKeyword "type"'), NonIdContinue);
5756
+ var TypeKeyword$0 = $S($EXPECT($L143, fail, 'TypeKeyword "type"'), NonIdContinue);
5472
5757
  function TypeKeyword(state) {
5473
5758
  if (state.verbose)
5474
5759
  console.log("ENTER:", "TypeKeyword");
@@ -5478,7 +5763,7 @@ var require_parser = __commonJS({
5478
5763
  return TypeKeyword$0(state);
5479
5764
  }
5480
5765
  }
5481
- var Interface$0 = $S($EXPECT($L143, fail, 'Interface "interface"'), NonIdContinue);
5766
+ var Interface$0 = $S($EXPECT($L144, fail, 'Interface "interface"'), NonIdContinue);
5482
5767
  function Interface(state) {
5483
5768
  if (state.verbose)
5484
5769
  console.log("ENTER:", "Interface");
@@ -5488,7 +5773,7 @@ var require_parser = __commonJS({
5488
5773
  return Interface$0(state);
5489
5774
  }
5490
5775
  }
5491
- var Namespace$0 = $S($EXPECT($L144, fail, 'Namespace "namespace"'), NonIdContinue);
5776
+ var Namespace$0 = $S($EXPECT($L145, fail, 'Namespace "namespace"'), NonIdContinue);
5492
5777
  function Namespace(state) {
5493
5778
  if (state.verbose)
5494
5779
  console.log("ENTER:", "Namespace");
@@ -5588,7 +5873,7 @@ var require_parser = __commonJS({
5588
5873
  return NestedTypeDeclaration$0(state);
5589
5874
  }
5590
5875
  }
5591
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R38, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L145, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R39, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
5876
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R40, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L146, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R41, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
5592
5877
  function TypeIndexSignature(state) {
5593
5878
  if (state.verbose)
5594
5879
  console.log("ENTER:", "TypeIndexSignature");
@@ -5619,7 +5904,7 @@ var require_parser = __commonJS({
5619
5904
  return TypeSuffix$0(state);
5620
5905
  }
5621
5906
  }
5622
- var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L146, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
5907
+ var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L147, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
5623
5908
  if (!$3)
5624
5909
  $0.splice(2, 1);
5625
5910
  if ($1.length === 0)
@@ -5702,9 +5987,9 @@ var require_parser = __commonJS({
5702
5987
  return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
5703
5988
  }
5704
5989
  }
5705
- var TypeUnaryOp$0 = $EXPECT($L147, fail, 'TypeUnaryOp "keyof"');
5706
- var TypeUnaryOp$1 = $EXPECT($L129, fail, 'TypeUnaryOp "typeof"');
5707
- var TypeUnaryOp$2 = $EXPECT($L148, fail, 'TypeUnaryOp "infer"');
5990
+ var TypeUnaryOp$0 = $EXPECT($L148, fail, 'TypeUnaryOp "keyof"');
5991
+ var TypeUnaryOp$1 = $EXPECT($L130, fail, 'TypeUnaryOp "typeof"');
5992
+ var TypeUnaryOp$2 = $EXPECT($L149, fail, 'TypeUnaryOp "infer"');
5708
5993
  function TypeUnaryOp(state) {
5709
5994
  if (state.tokenize) {
5710
5995
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -5794,10 +6079,10 @@ var require_parser = __commonJS({
5794
6079
  }
5795
6080
  }
5796
6081
  var TypeLiteral$0 = Literal;
5797
- var TypeLiteral$1 = $TV($EXPECT($L133, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
6082
+ var TypeLiteral$1 = $TV($EXPECT($L134, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
5798
6083
  return { $loc, token: "void" };
5799
6084
  });
5800
- var TypeLiteral$2 = $TV($EXPECT($L149, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
6085
+ var TypeLiteral$2 = $TV($EXPECT($L150, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
5801
6086
  return { $loc, token: "[]" };
5802
6087
  });
5803
6088
  function TypeLiteral(state) {
@@ -5807,10 +6092,10 @@ var require_parser = __commonJS({
5807
6092
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
5808
6093
  }
5809
6094
  }
5810
- var TypeBinaryOp$0 = $TV($EXPECT($L72, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
6095
+ var TypeBinaryOp$0 = $TV($EXPECT($L73, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
5811
6096
  return { $loc, token: "|" };
5812
6097
  });
5813
- var TypeBinaryOp$1 = $TV($EXPECT($L70, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
6098
+ var TypeBinaryOp$1 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
5814
6099
  return { $loc, token: "&" };
5815
6100
  });
5816
6101
  function TypeBinaryOp(state) {
@@ -5887,7 +6172,7 @@ var require_parser = __commonJS({
5887
6172
  return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
5888
6173
  }
5889
6174
  }
5890
- var Shebang$0 = $S($R$0($EXPECT($R40, fail, "Shebang /#![^\\r\\n]*/")), EOL);
6175
+ var Shebang$0 = $S($R$0($EXPECT($R42, fail, "Shebang /#![^\\r\\n]*/")), EOL);
5891
6176
  function Shebang(state) {
5892
6177
  if (state.verbose)
5893
6178
  console.log("ENTER:", "Shebang");
@@ -5897,11 +6182,11 @@ var require_parser = __commonJS({
5897
6182
  return Shebang$0(state);
5898
6183
  }
5899
6184
  }
5900
- var CivetPrologue$0 = $T($S($EXPECT($R41, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
6185
+ var CivetPrologue$0 = $T($S($EXPECT($R43, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
5901
6186
  var content = value[2];
5902
6187
  return content;
5903
6188
  });
5904
- var CivetPrologue$1 = $T($S($EXPECT($R41, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
6189
+ var CivetPrologue$1 = $T($S($EXPECT($R43, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
5905
6190
  var content = value[2];
5906
6191
  return content;
5907
6192
  });
@@ -5912,7 +6197,7 @@ var require_parser = __commonJS({
5912
6197
  return CivetPrologue$0(state) || CivetPrologue$1(state);
5913
6198
  }
5914
6199
  }
5915
- var CivetPrologueContent$0 = $TS($S($EXPECT($L150, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R42, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
6200
+ var CivetPrologueContent$0 = $TS($S($EXPECT($L151, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R44, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
5916
6201
  var options = $2;
5917
6202
  return {
5918
6203
  type: "CivetPrologue",
@@ -5929,7 +6214,7 @@ var require_parser = __commonJS({
5929
6214
  return CivetPrologueContent$0(state);
5930
6215
  }
5931
6216
  }
5932
- var CivetOption$0 = $TR($EXPECT($R43, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
6217
+ var CivetOption$0 = $TR($EXPECT($R45, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
5933
6218
  const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
5934
6219
  if (l)
5935
6220
  return l.toUpperCase();
@@ -5947,7 +6232,7 @@ var require_parser = __commonJS({
5947
6232
  return CivetOption$0(state);
5948
6233
  }
5949
6234
  }
5950
- var UnknownPrologue$0 = $S($R$0($EXPECT($R41, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
6235
+ var UnknownPrologue$0 = $S($R$0($EXPECT($R43, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
5951
6236
  function UnknownPrologue(state) {
5952
6237
  if (state.verbose)
5953
6238
  console.log("ENTER:", "UnknownPrologue");
@@ -5976,7 +6261,7 @@ var require_parser = __commonJS({
5976
6261
  return EOS$0(state);
5977
6262
  }
5978
6263
  }
5979
- var EOL$0 = $TR($EXPECT($R44, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
6264
+ var EOL$0 = $TR($EXPECT($R46, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
5980
6265
  return { $loc, token: $0 };
5981
6266
  });
5982
6267
  function EOL(state) {
@@ -6160,6 +6445,20 @@ var require_parser = __commonJS({
6160
6445
  return CoffeeBooleansEnabled$0(state);
6161
6446
  }
6162
6447
  }
6448
+ var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
6449
+ if (module2.config.coffeeForLoops)
6450
+ return;
6451
+ return $skip;
6452
+ });
6453
+ function CoffeeForLoopsEnabled(state) {
6454
+ if (state.verbose)
6455
+ console.log("ENTER:", "CoffeeForLoopsEnabled");
6456
+ if (state.tokenize) {
6457
+ return $TOKEN("CoffeeForLoopsEnabled", state, CoffeeForLoopsEnabled$0(state));
6458
+ } else {
6459
+ return CoffeeForLoopsEnabled$0(state);
6460
+ }
6461
+ }
6163
6462
  var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
6164
6463
  if (module2.config.coffeeInterpolation)
6165
6464
  return;
@@ -6202,6 +6501,20 @@ var require_parser = __commonJS({
6202
6501
  return CoffeeNotEnabled$0(state);
6203
6502
  }
6204
6503
  }
6504
+ var CoffeeOfEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
6505
+ if (module2.config.coffeeOf)
6506
+ return;
6507
+ return $skip;
6508
+ });
6509
+ function CoffeeOfEnabled(state) {
6510
+ if (state.verbose)
6511
+ console.log("ENTER:", "CoffeeOfEnabled");
6512
+ if (state.tokenize) {
6513
+ return $TOKEN("CoffeeOfEnabled", state, CoffeeOfEnabled$0(state));
6514
+ } else {
6515
+ return CoffeeOfEnabled$0(state);
6516
+ }
6517
+ }
6205
6518
  var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
6206
6519
  module2.currentIndent = 0;
6207
6520
  module2.indentLevels = [0];
@@ -6211,11 +6524,51 @@ var require_parser = __commonJS({
6211
6524
  coffeeBooleans: false,
6212
6525
  coffeeComment: false,
6213
6526
  coffeeEq: false,
6527
+ coffeeForLoops: false,
6214
6528
  coffeeInterpolation: false,
6215
6529
  coffeeIsnt: false,
6216
6530
  coffeeNot: false,
6531
+ coffeeOf: false,
6217
6532
  implicitReturns: true
6218
6533
  };
6534
+ let indexOfRef, hasPropRef;
6535
+ module2.prelude = [];
6536
+ module2.getIndexOfRef = function() {
6537
+ if (indexOfRef)
6538
+ return indexOfRef;
6539
+ indexOfRef = {
6540
+ type: "Ref",
6541
+ base: "indexOf"
6542
+ };
6543
+ const typeSuffix = {
6544
+ ts: true,
6545
+ children: [": <T>(this: T[], searchElement: T) => boolean"]
6546
+ };
6547
+ const asAny = {
6548
+ ts: true,
6549
+ children: [" as any"]
6550
+ };
6551
+ module2.prelude.push(["", "const ", indexOfRef, typeSuffix, " = [].indexOf", asAny, "\n"]);
6552
+ return indexOfRef;
6553
+ };
6554
+ module2.getHasPropRef = function() {
6555
+ if (hasPropRef)
6556
+ return hasPropRef;
6557
+ hasPropRef = {
6558
+ type: "Ref",
6559
+ base: "hasProp"
6560
+ };
6561
+ const typeSuffix = {
6562
+ ts: true,
6563
+ children: [": <T>(this: T, prop: keyof T) => boolean"]
6564
+ };
6565
+ const asAny = {
6566
+ ts: true,
6567
+ children: [" as any"]
6568
+ };
6569
+ module2.prelude.push(["", "const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", asAny, "\n"]);
6570
+ return hasPropRef;
6571
+ };
6219
6572
  Object.defineProperty(module2.config, "coffeeCompat", {
6220
6573
  set(b) {
6221
6574
  if (b) {
@@ -6223,17 +6576,21 @@ var require_parser = __commonJS({
6223
6576
  this.coffeeBooleans = true;
6224
6577
  this.coffeeComment = true;
6225
6578
  this.coffeeEq = true;
6579
+ this.coffeeForLoops = true;
6226
6580
  this.coffeeInterpolation = true;
6227
6581
  this.coffeeIsnt = true;
6228
6582
  this.coffeeNot = true;
6583
+ this.coffeeOf = true;
6229
6584
  } else {
6230
6585
  this.autoVar = false;
6231
6586
  this.coffeeBooleans = false;
6232
6587
  this.coffeeComment = false;
6233
6588
  this.coffeeEq = false;
6589
+ this.coffeeForLoops = false;
6234
6590
  this.coffeeInterpolation = false;
6235
6591
  this.coffeeIsnt = false;
6236
6592
  this.coffeeNot = false;
6593
+ this.coffeeOf = false;
6237
6594
  }
6238
6595
  }
6239
6596
  });
@@ -6270,6 +6627,10 @@ var require_parser = __commonJS({
6270
6627
  case "BlockStatement":
6271
6628
  insertReturn(node.expressions[node.expressions.length - 1]);
6272
6629
  return;
6630
+ case "ObjectExpression":
6631
+ module2.insertTrimmingSpace(node.children[0], "");
6632
+ node.children.unshift("return ");
6633
+ return;
6273
6634
  case "CaseBlock":
6274
6635
  node.clauses.forEach((clause) => {
6275
6636
  insertReturn(clause);
@@ -6338,6 +6699,25 @@ var require_parser = __commonJS({
6338
6699
  if (Array.isArray(node))
6339
6700
  return node.every(module2.isWhitespaceOrEmpty);
6340
6701
  };
6702
+ module2.processBinaryOpExpression = function($02) {
6703
+ const expandedOps = module2.expandChainedComparisons($02);
6704
+ let i = 2;
6705
+ while (i < expandedOps.length) {
6706
+ const op = expandedOps[i];
6707
+ if (op.type === "Ref") {
6708
+ const [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
6709
+ module2.insertTrimmingSpace(wsOp, "");
6710
+ module2.insertTrimmingSpace(wsB, "");
6711
+ expandedOps.splice(i - 2, 5, {
6712
+ type: "Call",
6713
+ children: [wsOp, op2, ".call(", wsB, b, ", ", a, ") >= 0"]
6714
+ });
6715
+ } else {
6716
+ i += 4;
6717
+ }
6718
+ }
6719
+ return expandedOps;
6720
+ };
6341
6721
  module2.expandChainedComparisons = function([first, binops]) {
6342
6722
  const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
6343
6723
  const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
@@ -6348,7 +6728,7 @@ var require_parser = __commonJS({
6348
6728
  let chains = [];
6349
6729
  while (i < l) {
6350
6730
  const [, op] = binops[i];
6351
- if (relationalOps.includes(op.token)) {
6731
+ if (relationalOps.includes(op.token) || op.type === "Ref") {
6352
6732
  chains.push(i);
6353
6733
  } else if (lowerPrecedenceOps.includes(op.token)) {
6354
6734
  processChains();
@@ -6362,7 +6742,7 @@ var require_parser = __commonJS({
6362
6742
  if (chains.length > 1) {
6363
6743
  chains.forEach((index, k) => {
6364
6744
  if (k > 0) {
6365
- results.push(" && ");
6745
+ results.push(" ", "&&", " ");
6366
6746
  }
6367
6747
  const [pre, op, post, exp] = binops[index];
6368
6748
  let endIndex;
@@ -6410,6 +6790,8 @@ var require_parser = __commonJS({
6410
6790
  };
6411
6791
  module2.insertTrimmingSpace = function(spacing, c) {
6412
6792
  let target = spacing;
6793
+ if (!target)
6794
+ return;
6413
6795
  if (Array.isArray(target))
6414
6796
  return module2.insertTrimmingSpace(target[0], c);
6415
6797
  if (target.children)
@@ -6482,18 +6864,34 @@ var require_parser = __commonJS({
6482
6864
  case "BlockStatement":
6483
6865
  return [];
6484
6866
  case "ForStatement":
6485
- if (node.declaration.type === "Declaration")
6486
- return [];
6487
- return gatherNodes(node.declaration, predicate);
6867
+ const isDec = node.declaration?.type === "Declaration";
6868
+ return node.children.flatMap((n) => {
6869
+ if (isDec && n === node.declaration)
6870
+ return [];
6871
+ return gatherNodes(n, predicate);
6872
+ });
6488
6873
  default:
6489
6874
  return gatherNodes(node.children, predicate);
6490
6875
  }
6491
6876
  return [];
6492
6877
  }
6878
+ function gatherRecursive(node, predicate) {
6879
+ if (node == null)
6880
+ return [];
6881
+ if (Array.isArray(node)) {
6882
+ return node.flatMap((n) => gatherNodes(n, predicate));
6883
+ }
6884
+ if (predicate(node)) {
6885
+ return [node];
6886
+ }
6887
+ return gatherNodes(node.children, predicate);
6888
+ }
6493
6889
  module2.processProgram = function(statements) {
6890
+ statements.unshift(...module2.prelude);
6494
6891
  if (module2.config.autoVar) {
6495
- module2.autoVar(statements, []);
6892
+ createVarDecs(statements, []);
6496
6893
  }
6894
+ populateRefs(statements);
6497
6895
  };
6498
6896
  function findDecs(statements) {
6499
6897
  const declarationNames = gatherNodes(statements, (node) => {
@@ -6503,7 +6901,39 @@ var require_parser = __commonJS({
6503
6901
  }).flatMap((d) => d.names);
6504
6902
  return new Set(declarationNames);
6505
6903
  }
6506
- module2.autoVar = function(statements, scopes, pushVar) {
6904
+ function populateRefs(statements) {
6905
+ const refNodes = gatherNodes(statements, ({ type }) => type === "Ref");
6906
+ const blockNodes = new Set(gatherNodes(statements, ({ type }) => type === "BlockStatement"));
6907
+ const forNodes = gatherNodes(statements, ({ type }) => type === "ForStatement");
6908
+ forNodes.forEach(({ declaration, block }) => {
6909
+ if (block.type === "BlockStatement") {
6910
+ populateRefs([declaration, ...block.children]);
6911
+ } else {
6912
+ populateRefs([declaration, ...block]);
6913
+ }
6914
+ blockNodes.delete(block);
6915
+ });
6916
+ blockNodes.forEach(({ expressions }) => populateRefs(expressions));
6917
+ if (refNodes.length) {
6918
+ const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
6919
+ const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
6920
+ refNodes.forEach((ref) => {
6921
+ const { type, base } = ref;
6922
+ if (type !== "Ref")
6923
+ return;
6924
+ ref.type = "Identifier";
6925
+ let n = 0;
6926
+ let name = base;
6927
+ while (names.has(name)) {
6928
+ n++;
6929
+ name = `${base}${n}`;
6930
+ }
6931
+ names.add(name);
6932
+ ref.children = ref.names = [name];
6933
+ });
6934
+ }
6935
+ }
6936
+ function createVarDecs(statements, scopes, pushVar) {
6507
6937
  function hasDec(name) {
6508
6938
  return scopes.some((s) => s.has(name));
6509
6939
  }
@@ -6512,9 +6942,7 @@ var require_parser = __commonJS({
6512
6942
  return node.type === "AssignmentExpression";
6513
6943
  });
6514
6944
  const undeclaredIdentifiers = assignmentStatements.flatMap((a) => {
6515
- return a.children[0].flatMap((x) => {
6516
- return x[1].names || [];
6517
- });
6945
+ return a.names;
6518
6946
  });
6519
6947
  return undeclaredIdentifiers.filter((x, i, a) => {
6520
6948
  if (!hasDec(x))
@@ -6537,23 +6965,23 @@ var require_parser = __commonJS({
6537
6965
  fnNodes.forEach(({ block }) => blockNodes.delete(block));
6538
6966
  forNodes.forEach(({ block }) => blockNodes.delete(block));
6539
6967
  blockNodes.forEach((block) => {
6540
- module2.autoVar(block.expressions, scopes, pushVar);
6968
+ createVarDecs(block.expressions, scopes, pushVar);
6541
6969
  });
6542
6970
  forNodes.forEach(({ block, declaration }) => {
6543
6971
  scopes.push(new Set(declaration.names));
6544
- module2.autoVar(block.expressions, scopes, pushVar);
6972
+ createVarDecs(block.expressions, scopes, pushVar);
6545
6973
  scopes.pop();
6546
6974
  });
6547
6975
  fnNodes.forEach(({ block, parameters }) => {
6548
6976
  scopes.push(new Set(parameters.names));
6549
- module2.autoVar(block.expressions, scopes);
6977
+ createVarDecs(block.expressions, scopes);
6550
6978
  scopes.pop();
6551
6979
  });
6552
6980
  if (varIds.length) {
6553
6981
  const indent = statements[0][0];
6554
6982
  statements.unshift([indent, "var ", varIds.join(", "), "\n"]);
6555
6983
  }
6556
- };
6984
+ }
6557
6985
  return $0;
6558
6986
  });
6559
6987
  function Init(state) {
@@ -6565,7 +6993,7 @@ var require_parser = __commonJS({
6565
6993
  return Init$0(state);
6566
6994
  }
6567
6995
  }
6568
- var Indent$0 = $TV($Q($C($EXPECT($L151, fail, 'Indent " "'), $EXPECT($L152, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
6996
+ var Indent$0 = $TV($Q($C($EXPECT($L152, fail, 'Indent " "'), $EXPECT($L153, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
6569
6997
  const level = $1.length;
6570
6998
  return {
6571
6999
  $loc,
@@ -6697,6 +7125,7 @@ var require_parser = __commonJS({
6697
7125
  // source/generate.coffee
6698
7126
  var require_generate = __commonJS({
6699
7127
  "source/generate.coffee"(exports2, module2) {
7128
+ "civet coffeeCompat";
6700
7129
  var gen2;
6701
7130
  var prune2;
6702
7131
  gen2 = function(node, options) {
@@ -6774,6 +7203,7 @@ var require_generate = __commonJS({
6774
7203
  var require_util = __commonJS({
6775
7204
  "source/util.coffee"(exports2, module2) {
6776
7205
  "use strict";
7206
+ "civet coffeeCompat";
6777
7207
  var BASE64_CHARS;
6778
7208
  var SourceMap2;
6779
7209
  var VLQ_CONTINUATION_BIT;
@@ -7096,6 +7526,7 @@ var require_util = __commonJS({
7096
7526
  });
7097
7527
 
7098
7528
  // source/main.coffee
7529
+ "civet coffeeCompat";
7099
7530
  var SourceMap;
7100
7531
  var base64Encode;
7101
7532
  var defaultOptions;