@danielx/civet 0.4.18 → 0.4.19-pre.1
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.
- package/README.md +6 -1
- package/dist/browser.js +528 -300
- package/dist/civet +40 -12
- package/dist/main.js +528 -300
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -435,6 +435,7 @@ var Civet = (() => {
|
|
|
435
435
|
ConditionalExpression,
|
|
436
436
|
ShortCircuitExpression,
|
|
437
437
|
PrimaryExpression,
|
|
438
|
+
ParenthesizedExpression,
|
|
438
439
|
ClassDeclaration,
|
|
439
440
|
ClassExpression,
|
|
440
441
|
ClassHeritage,
|
|
@@ -652,6 +653,7 @@ var Civet = (() => {
|
|
|
652
653
|
Async,
|
|
653
654
|
Await,
|
|
654
655
|
Backtick,
|
|
656
|
+
By,
|
|
655
657
|
Case,
|
|
656
658
|
Catch,
|
|
657
659
|
Class,
|
|
@@ -784,8 +786,9 @@ var Civet = (() => {
|
|
|
784
786
|
InsertSpace,
|
|
785
787
|
InsertDot,
|
|
786
788
|
InsertBreak,
|
|
787
|
-
CoffeeCommentEnabled,
|
|
788
789
|
CoffeeBooleansEnabled,
|
|
790
|
+
CoffeeCommentEnabled,
|
|
791
|
+
CoffeeDoEnabled,
|
|
789
792
|
CoffeeForLoopsEnabled,
|
|
790
793
|
CoffeeInterpolationEnabled,
|
|
791
794
|
CoffeeIsntEnabled,
|
|
@@ -891,115 +894,119 @@ var Civet = (() => {
|
|
|
891
894
|
var $L87 = $L("async");
|
|
892
895
|
var $L88 = $L("await");
|
|
893
896
|
var $L89 = $L("`");
|
|
894
|
-
var $L90 = $L("
|
|
895
|
-
var $L91 = $L("
|
|
896
|
-
var $L92 = $L("
|
|
897
|
-
var $L93 = $L("
|
|
898
|
-
var $L94 = $L("
|
|
899
|
-
var $L95 = $L("
|
|
900
|
-
var $L96 = $L("
|
|
901
|
-
var $L97 = $L("
|
|
902
|
-
var $L98 = $L("
|
|
903
|
-
var $L99 = $L(
|
|
904
|
-
var $L100 = $L("
|
|
905
|
-
var $L101 = $L("
|
|
906
|
-
var $L102 = $L("
|
|
907
|
-
var $L103 = $L("
|
|
908
|
-
var $L104 = $L("
|
|
909
|
-
var $L105 = $L("
|
|
910
|
-
var $L106 = $L("
|
|
911
|
-
var $L107 = $L("
|
|
912
|
-
var $L108 = $L("
|
|
913
|
-
var $L109 = $L("
|
|
914
|
-
var $L110 = $L("
|
|
915
|
-
var $L111 = $L("
|
|
916
|
-
var $L112 = $L("
|
|
917
|
-
var $L113 = $L("
|
|
918
|
-
var $L114 = $L("
|
|
919
|
-
var $L115 = $L("
|
|
920
|
-
var $L116 = $L("
|
|
921
|
-
var $L117 = $L("
|
|
922
|
-
var $L118 = $L("
|
|
923
|
-
var $L119 = $L("
|
|
924
|
-
var $L120 = $L("
|
|
925
|
-
var $L121 = $L("
|
|
926
|
-
var $L122 = $L("
|
|
927
|
-
var $L123 = $L("
|
|
928
|
-
var $L124 = $L("
|
|
929
|
-
var $L125 = $L("
|
|
930
|
-
var $L126 = $L(
|
|
931
|
-
var $L127 = $L("'
|
|
932
|
-
var $L128 = $L("
|
|
933
|
-
var $L129 = $L("
|
|
934
|
-
var $L130 = $L("
|
|
935
|
-
var $L131 = $L("
|
|
936
|
-
var $L132 = $L("
|
|
937
|
-
var $L133 = $L("
|
|
938
|
-
var $L134 = $L("
|
|
939
|
-
var $L135 = $L("
|
|
940
|
-
var $L136 = $L("
|
|
941
|
-
var $L137 = $L("
|
|
942
|
-
var $L138 = $L("
|
|
943
|
-
var $L139 = $L("
|
|
944
|
-
var $L140 = $L("
|
|
945
|
-
var $L141 = $L("
|
|
946
|
-
var $L142 = $L("
|
|
947
|
-
var $L143 = $L("
|
|
948
|
-
var $L144 = $L("
|
|
949
|
-
var $L145 = $L("
|
|
950
|
-
var $L146 = $L("
|
|
951
|
-
var $L147 = $L("
|
|
952
|
-
var $L148 = $L("
|
|
953
|
-
var $L149 = $L("
|
|
954
|
-
var $L150 = $L("
|
|
955
|
-
var $L151 = $L("
|
|
956
|
-
var $L152 = $L("
|
|
957
|
-
var $L153 = $L("
|
|
897
|
+
var $L90 = $L("by");
|
|
898
|
+
var $L91 = $L("case");
|
|
899
|
+
var $L92 = $L("catch");
|
|
900
|
+
var $L93 = $L("class");
|
|
901
|
+
var $L94 = $L("#{");
|
|
902
|
+
var $L95 = $L(":");
|
|
903
|
+
var $L96 = $L("delete");
|
|
904
|
+
var $L97 = $L("do");
|
|
905
|
+
var $L98 = $L("..");
|
|
906
|
+
var $L99 = $L("...");
|
|
907
|
+
var $L100 = $L('"');
|
|
908
|
+
var $L101 = $L("else");
|
|
909
|
+
var $L102 = $L("export");
|
|
910
|
+
var $L103 = $L("for");
|
|
911
|
+
var $L104 = $L("from");
|
|
912
|
+
var $L105 = $L("function");
|
|
913
|
+
var $L106 = $L("get");
|
|
914
|
+
var $L107 = $L("set");
|
|
915
|
+
var $L108 = $L("if");
|
|
916
|
+
var $L109 = $L(" ");
|
|
917
|
+
var $L110 = $L("let");
|
|
918
|
+
var $L111 = $L("const");
|
|
919
|
+
var $L112 = $L("loop");
|
|
920
|
+
var $L113 = $L("new");
|
|
921
|
+
var $L114 = $L("not");
|
|
922
|
+
var $L115 = $L("{");
|
|
923
|
+
var $L116 = $L("[");
|
|
924
|
+
var $L117 = $L("(");
|
|
925
|
+
var $L118 = $L("?");
|
|
926
|
+
var $L119 = $L("return");
|
|
927
|
+
var $L120 = $L("'");
|
|
928
|
+
var $L121 = $L("static");
|
|
929
|
+
var $L122 = $L("${");
|
|
930
|
+
var $L123 = $L("switch");
|
|
931
|
+
var $L124 = $L("target");
|
|
932
|
+
var $L125 = $L("then");
|
|
933
|
+
var $L126 = $L("throw");
|
|
934
|
+
var $L127 = $L('"""');
|
|
935
|
+
var $L128 = $L("'''");
|
|
936
|
+
var $L129 = $L("```");
|
|
937
|
+
var $L130 = $L("try");
|
|
938
|
+
var $L131 = $L("typeof");
|
|
939
|
+
var $L132 = $L("unless");
|
|
940
|
+
var $L133 = $L("until");
|
|
941
|
+
var $L134 = $L("var");
|
|
942
|
+
var $L135 = $L("void");
|
|
943
|
+
var $L136 = $L("when");
|
|
944
|
+
var $L137 = $L("while");
|
|
945
|
+
var $L138 = $L("yield");
|
|
946
|
+
var $L139 = $L("/>");
|
|
947
|
+
var $L140 = $L("</");
|
|
948
|
+
var $L141 = $L("<>");
|
|
949
|
+
var $L142 = $L("</>");
|
|
950
|
+
var $L143 = $L("declare");
|
|
951
|
+
var $L144 = $L("type");
|
|
952
|
+
var $L145 = $L("interface");
|
|
953
|
+
var $L146 = $L("namespace");
|
|
954
|
+
var $L147 = $L("readonly");
|
|
955
|
+
var $L148 = $L("asserts");
|
|
956
|
+
var $L149 = $L("keyof");
|
|
957
|
+
var $L150 = $L("infer");
|
|
958
|
+
var $L151 = $L("[]");
|
|
959
|
+
var $L152 = $L("civet");
|
|
960
|
+
var $L153 = $L(" ");
|
|
961
|
+
var $L154 = $L(" ");
|
|
958
962
|
var $R0 = $R(new RegExp("(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
959
|
-
var $R1 = $R(new RegExp("
|
|
960
|
-
var $R2 = $R(new RegExp("[!~+-]
|
|
961
|
-
var $R3 = $R(new RegExp("(
|
|
962
|
-
var $R4 = $R(new RegExp(
|
|
963
|
-
var $R5 = $R(new RegExp("(
|
|
964
|
-
var $R6 = $R(new RegExp("
|
|
965
|
-
var $R7 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
966
|
-
var $R8 = $R(new RegExp("(
|
|
967
|
-
var $R9 = $R(new RegExp("(?:[
|
|
968
|
-
var $R10 = $R(new RegExp("0
|
|
969
|
-
var $R11 = $R(new RegExp("
|
|
970
|
-
var $R12 = $R(new RegExp("0[
|
|
971
|
-
var $R13 = $R(new RegExp(
|
|
972
|
-
var $R14 = $R(new RegExp("(
|
|
973
|
-
var $R15 = $R(new RegExp('(
|
|
974
|
-
var $R16 = $R(new RegExp("(
|
|
975
|
-
var $R17 = $R(new RegExp('(
|
|
976
|
-
var $R18 = $R(new RegExp("[
|
|
977
|
-
var $R19 = $R(new RegExp(
|
|
978
|
-
var $R20 = $R(new RegExp("
|
|
979
|
-
var $R21 = $R(new RegExp("(
|
|
980
|
-
var $R22 = $R(new RegExp("(
|
|
981
|
-
var $R23 = $R(new RegExp("(
|
|
982
|
-
var $R24 = $R(new RegExp("(
|
|
983
|
-
var $R25 = $R(new RegExp("(?:
|
|
984
|
-
var $R26 = $R(new RegExp("
|
|
985
|
-
var $R27 = $R(new RegExp("
|
|
986
|
-
var $R28 = $R(new RegExp("
|
|
987
|
-
var $R29 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
988
|
-
var $R30 = $R(new RegExp("
|
|
989
|
-
var $R31 = $R(new RegExp("[\\
|
|
990
|
-
var $R32 = $R(new RegExp("
|
|
991
|
-
var $R33 = $R(new RegExp("\\
|
|
992
|
-
var $R34 = $R(new RegExp("
|
|
993
|
-
var $R35 = $R(new RegExp(
|
|
994
|
-
var $R36 = $R(new RegExp("
|
|
995
|
-
var $R37 = $R(new RegExp("[
|
|
996
|
-
var $R38 = $R(new RegExp("[
|
|
997
|
-
var $R39 = $R(new RegExp("[
|
|
998
|
-
var $R40 = $R(new RegExp("
|
|
999
|
-
var $R41 = $R(new RegExp("[
|
|
1000
|
-
var $R42 = $R(new RegExp("[
|
|
1001
|
-
var $R43 = $R(new RegExp("\\
|
|
1002
|
-
var $R44 = $R(new RegExp("\\
|
|
963
|
+
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
964
|
+
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
965
|
+
var $R3 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
966
|
+
var $R4 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
967
|
+
var $R5 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
968
|
+
var $R6 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
969
|
+
var $R7 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
970
|
+
var $R8 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
971
|
+
var $R9 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
972
|
+
var $R10 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
973
|
+
var $R11 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
974
|
+
var $R12 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
975
|
+
var $R13 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
976
|
+
var $R14 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
977
|
+
var $R15 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
978
|
+
var $R16 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
979
|
+
var $R17 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
980
|
+
var $R18 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
981
|
+
var $R19 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
982
|
+
var $R20 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
983
|
+
var $R21 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
984
|
+
var $R22 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
985
|
+
var $R23 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
986
|
+
var $R24 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
987
|
+
var $R25 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
988
|
+
var $R26 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
989
|
+
var $R27 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
990
|
+
var $R28 = $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"));
|
|
991
|
+
var $R29 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
992
|
+
var $R30 = $R(new RegExp(".", "suy"));
|
|
993
|
+
var $R31 = $R(new RegExp("#(?!##)([^\\r\\n]*)", "suy"));
|
|
994
|
+
var $R32 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
995
|
+
var $R33 = $R(new RegExp("[ \\t]+", "suy"));
|
|
996
|
+
var $R34 = $R(new RegExp("[\\s]+", "suy"));
|
|
997
|
+
var $R35 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
998
|
+
var $R36 = $R(new RegExp("\\s", "suy"));
|
|
999
|
+
var $R37 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1000
|
+
var $R38 = $R(new RegExp('"[^"]*"', "suy"));
|
|
1001
|
+
var $R39 = $R(new RegExp("'[^']*'", "suy"));
|
|
1002
|
+
var $R40 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
1003
|
+
var $R41 = $R(new RegExp("[+-]?", "suy"));
|
|
1004
|
+
var $R42 = $R(new RegExp("[+-]", "suy"));
|
|
1005
|
+
var $R43 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1006
|
+
var $R44 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1007
|
+
var $R45 = $R(new RegExp("[\\s]*", "suy"));
|
|
1008
|
+
var $R46 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
|
|
1009
|
+
var $R47 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1003
1010
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1004
1011
|
var statements = $4;
|
|
1005
1012
|
module.processProgram(statements);
|
|
@@ -1172,25 +1179,9 @@ var Civet = (() => {
|
|
|
1172
1179
|
return IndentedApplicationAllowed$0(state);
|
|
1173
1180
|
}
|
|
1174
1181
|
}
|
|
1175
|
-
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2) {
|
|
1182
|
+
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, $C(UnaryExpression, ExpressionizedStatement)))), function($skip, $loc, $0, $1, $2) {
|
|
1176
1183
|
if ($2.length) {
|
|
1177
|
-
|
|
1178
|
-
let i = 2;
|
|
1179
|
-
while (i < expandedOps.length) {
|
|
1180
|
-
const op = expandedOps[i];
|
|
1181
|
-
if (op.type === "Ref") {
|
|
1182
|
-
const [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
|
|
1183
|
-
module.insertTrimmingSpace(wsOp, "");
|
|
1184
|
-
module.insertTrimmingSpace(wsB, "");
|
|
1185
|
-
expandedOps.splice(i - 2, 5, {
|
|
1186
|
-
type: "Call",
|
|
1187
|
-
children: [wsOp, op2, ".call(", wsB, b, ", ", a, ") >= 0"]
|
|
1188
|
-
});
|
|
1189
|
-
} else {
|
|
1190
|
-
i += 4;
|
|
1191
|
-
}
|
|
1192
|
-
}
|
|
1193
|
-
return expandedOps;
|
|
1184
|
+
return module.processBinaryOpExpression($0);
|
|
1194
1185
|
}
|
|
1195
1186
|
return $1;
|
|
1196
1187
|
});
|
|
@@ -1210,22 +1201,43 @@ var Civet = (() => {
|
|
|
1210
1201
|
if (post?.token === "?") {
|
|
1211
1202
|
return ["(", pre, "(", exp, ") != null)"];
|
|
1212
1203
|
}
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1204
|
+
if (exp.type === "Literal") {
|
|
1205
|
+
if (pre.length === 1 && pre[0].token === "-") {
|
|
1206
|
+
exp.raw = `-${exp.raw}`;
|
|
1207
|
+
exp.children.unshift(pre[0]);
|
|
1208
|
+
if (post)
|
|
1209
|
+
exp.children.push(post);
|
|
1210
|
+
return exp;
|
|
1211
|
+
}
|
|
1212
|
+
}
|
|
1213
|
+
if (exp.children) {
|
|
1214
|
+
exp.children.unshift(...pre);
|
|
1215
|
+
if (post)
|
|
1216
|
+
exp.children.push(post);
|
|
1217
|
+
return exp;
|
|
1218
|
+
} else if (Array.isArray(exp)) {
|
|
1219
|
+
exp.unshift(...pre);
|
|
1220
|
+
if (post)
|
|
1221
|
+
exp.push(post);
|
|
1222
|
+
return exp;
|
|
1223
|
+
} else {
|
|
1224
|
+
const result = [...pre, exp];
|
|
1225
|
+
if (post)
|
|
1226
|
+
result.push(post);
|
|
1227
|
+
return result;
|
|
1228
|
+
}
|
|
1229
|
+
});
|
|
1230
|
+
var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1231
|
+
var ws = $3;
|
|
1232
|
+
var exp = $4;
|
|
1233
|
+
module.insertTrimmingSpace(ws, "");
|
|
1234
|
+
return ["(", ws, exp, ")()"];
|
|
1221
1235
|
});
|
|
1222
1236
|
function UnaryExpression(state) {
|
|
1223
|
-
if (state.verbose)
|
|
1224
|
-
console.log("ENTER:", "UnaryExpression");
|
|
1225
1237
|
if (state.tokenize) {
|
|
1226
|
-
return $TOKEN("UnaryExpression", state, UnaryExpression$0(state));
|
|
1238
|
+
return $TOKEN("UnaryExpression", state, UnaryExpression$0(state) || UnaryExpression$1(state));
|
|
1227
1239
|
} else {
|
|
1228
|
-
return UnaryExpression$0(state);
|
|
1240
|
+
return UnaryExpression$0(state) || UnaryExpression$1(state);
|
|
1229
1241
|
}
|
|
1230
1242
|
}
|
|
1231
1243
|
var UnaryPostfix$0 = QuestionMark;
|
|
@@ -1469,7 +1481,7 @@ var Civet = (() => {
|
|
|
1469
1481
|
var PrimaryExpression$6 = ClassExpression;
|
|
1470
1482
|
var PrimaryExpression$7 = RegularExpressionLiteral;
|
|
1471
1483
|
var PrimaryExpression$8 = TemplateLiteral;
|
|
1472
|
-
var PrimaryExpression$9 =
|
|
1484
|
+
var PrimaryExpression$9 = ParenthesizedExpression;
|
|
1473
1485
|
var PrimaryExpression$10 = JSXElement;
|
|
1474
1486
|
var PrimaryExpression$11 = JSXFragment;
|
|
1475
1487
|
function PrimaryExpression(state) {
|
|
@@ -1479,6 +1491,23 @@ var Civet = (() => {
|
|
|
1479
1491
|
return PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state) || PrimaryExpression$10(state) || PrimaryExpression$11(state);
|
|
1480
1492
|
}
|
|
1481
1493
|
}
|
|
1494
|
+
var ParenthesizedExpression$0 = $TS($S(OpenParen, ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1495
|
+
var exp = $2;
|
|
1496
|
+
return {
|
|
1497
|
+
type: "ParenthesizedExpression",
|
|
1498
|
+
expression: exp,
|
|
1499
|
+
children: $0
|
|
1500
|
+
};
|
|
1501
|
+
});
|
|
1502
|
+
function ParenthesizedExpression(state) {
|
|
1503
|
+
if (state.verbose)
|
|
1504
|
+
console.log("ENTER:", "ParenthesizedExpression");
|
|
1505
|
+
if (state.tokenize) {
|
|
1506
|
+
return $TOKEN("ParenthesizedExpression", state, ParenthesizedExpression$0(state));
|
|
1507
|
+
} else {
|
|
1508
|
+
return ParenthesizedExpression$0(state);
|
|
1509
|
+
}
|
|
1510
|
+
}
|
|
1482
1511
|
var ClassDeclaration$0 = ClassExpression;
|
|
1483
1512
|
function ClassDeclaration(state) {
|
|
1484
1513
|
if (state.verbose)
|
|
@@ -1720,10 +1749,10 @@ var Civet = (() => {
|
|
|
1720
1749
|
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
|
|
1721
1750
|
}
|
|
1722
1751
|
}
|
|
1723
|
-
var MemberBracketContent$0 = $TS($S(OpenBracket, ExtendedExpression, $E($S($C(DotDotDot, DotDot), $E(ExtendedExpression))), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1752
|
+
var MemberBracketContent$0 = $TS($S(OpenBracket, ExtendedExpression, $E($S(__, $C(DotDotDot, DotDot), $E(ExtendedExpression))), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1724
1753
|
if ($3) {
|
|
1725
|
-
const sep = $3[
|
|
1726
|
-
const end = $3[
|
|
1754
|
+
const sep = $3[1];
|
|
1755
|
+
const end = $3[2];
|
|
1727
1756
|
const inclusive = sep.token === "..";
|
|
1728
1757
|
sep.token = ", ";
|
|
1729
1758
|
$1.token = ".slice(";
|
|
@@ -1737,6 +1766,7 @@ var Civet = (() => {
|
|
|
1737
1766
|
};
|
|
1738
1767
|
}
|
|
1739
1768
|
if (inclusive) {
|
|
1769
|
+
module.insertTrimmingSpace(end, "");
|
|
1740
1770
|
return {
|
|
1741
1771
|
type: "SliceExpression",
|
|
1742
1772
|
start: $2,
|
|
@@ -2196,18 +2226,33 @@ var Civet = (() => {
|
|
|
2196
2226
|
$1.type = "FunctionExpression";
|
|
2197
2227
|
return $1;
|
|
2198
2228
|
});
|
|
2199
|
-
var FunctionExpression$1 = $TS($S(Ampersand, $P(
|
|
2229
|
+
var FunctionExpression$1 = $TS($S(Ampersand, $N(_), $P(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2230
|
+
$1.token = "$ => $";
|
|
2231
|
+
return {
|
|
2232
|
+
type: "FunctionExpression",
|
|
2233
|
+
children: [$1, $3]
|
|
2234
|
+
};
|
|
2235
|
+
});
|
|
2236
|
+
var FunctionExpression$2 = $TS($S(Ampersand, $N($EXPECT($R1, fail, "FunctionExpression /[&]/")), $P($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2, $3) {
|
|
2237
|
+
$0.splice(1, 1);
|
|
2200
2238
|
$1.token = "$ => $";
|
|
2239
|
+
const exp = module.processBinaryOpExpression($0);
|
|
2240
|
+
return {
|
|
2241
|
+
type: "FunctionExpression",
|
|
2242
|
+
children: exp
|
|
2243
|
+
};
|
|
2244
|
+
});
|
|
2245
|
+
var FunctionExpression$3 = $TS($S($EXPECT($R2, fail, "FunctionExpression /[!~+-]+/"), Ampersand), function($skip, $loc, $0, $1, $2) {
|
|
2201
2246
|
return {
|
|
2202
2247
|
type: "FunctionExpression",
|
|
2203
|
-
children: [$1, $
|
|
2248
|
+
children: ["$ => ", $1, "$"]
|
|
2204
2249
|
};
|
|
2205
2250
|
});
|
|
2206
2251
|
function FunctionExpression(state) {
|
|
2207
2252
|
if (state.tokenize) {
|
|
2208
|
-
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
2253
|
+
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state));
|
|
2209
2254
|
} else {
|
|
2210
|
-
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
2255
|
+
return FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state);
|
|
2211
2256
|
}
|
|
2212
2257
|
}
|
|
2213
2258
|
var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
@@ -2307,8 +2352,18 @@ var Civet = (() => {
|
|
|
2307
2352
|
var exps = value[2];
|
|
2308
2353
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
2309
2354
|
});
|
|
2310
|
-
var BracedBlock$2 = $TS($S(InsertOpenBrace, $
|
|
2355
|
+
var BracedBlock$2 = $TS($S(InsertOpenBrace, $Y(EOS), ObjectLiteral, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2356
|
+
var s = $3;
|
|
2357
|
+
$0.splice(1, 1);
|
|
2358
|
+
return {
|
|
2359
|
+
type: "BlockStatement",
|
|
2360
|
+
expressions: [s],
|
|
2361
|
+
children: $0
|
|
2362
|
+
};
|
|
2363
|
+
});
|
|
2364
|
+
var BracedBlock$3 = $TS($S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2311
2365
|
var s = $4;
|
|
2366
|
+
$0.splice(1, 1);
|
|
2312
2367
|
return {
|
|
2313
2368
|
type: "BlockStatement",
|
|
2314
2369
|
expressions: [s],
|
|
@@ -2317,9 +2372,9 @@ var Civet = (() => {
|
|
|
2317
2372
|
});
|
|
2318
2373
|
function BracedBlock(state) {
|
|
2319
2374
|
if (state.tokenize) {
|
|
2320
|
-
return $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state));
|
|
2375
|
+
return $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state) || BracedBlock$3(state));
|
|
2321
2376
|
} else {
|
|
2322
|
-
return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
|
|
2377
|
+
return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state) || BracedBlock$3(state);
|
|
2323
2378
|
}
|
|
2324
2379
|
}
|
|
2325
2380
|
var BracedContent$0 = $T($S($Y(EOS), NestedBlockStatements), function(value) {
|
|
@@ -2361,7 +2416,8 @@ var Civet = (() => {
|
|
|
2361
2416
|
var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
|
|
2362
2417
|
return {
|
|
2363
2418
|
type: "Literal",
|
|
2364
|
-
children: $0
|
|
2419
|
+
children: $0,
|
|
2420
|
+
raw: $1.token
|
|
2365
2421
|
};
|
|
2366
2422
|
});
|
|
2367
2423
|
function Literal(state) {
|
|
@@ -2444,7 +2500,7 @@ var Civet = (() => {
|
|
|
2444
2500
|
return Identifier$0(state);
|
|
2445
2501
|
}
|
|
2446
2502
|
}
|
|
2447
|
-
var IdentifierName$0 = $TR($EXPECT($
|
|
2503
|
+
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) {
|
|
2448
2504
|
return {
|
|
2449
2505
|
type: "Identifier",
|
|
2450
2506
|
name: $0,
|
|
@@ -2475,11 +2531,16 @@ var Civet = (() => {
|
|
|
2475
2531
|
}
|
|
2476
2532
|
}
|
|
2477
2533
|
var ArrayLiteral$0 = $TS($S(OpenBracket, ArrayLiteralContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2534
|
+
var content = $2;
|
|
2535
|
+
if (content.type === "RangeExpression") {
|
|
2536
|
+
content.children.push(...$3);
|
|
2537
|
+
return content;
|
|
2538
|
+
}
|
|
2478
2539
|
let children;
|
|
2479
|
-
if (Array.isArray(
|
|
2480
|
-
children = [$1,
|
|
2540
|
+
if (Array.isArray(content)) {
|
|
2541
|
+
children = [$1, ...content, ...$3, $4];
|
|
2481
2542
|
} else {
|
|
2482
|
-
children = [$1,
|
|
2543
|
+
children = [$1, content, ...$3, $4];
|
|
2483
2544
|
}
|
|
2484
2545
|
const names = children.flatMap((c) => {
|
|
2485
2546
|
return c.names || [];
|
|
@@ -2499,13 +2560,39 @@ var Civet = (() => {
|
|
|
2499
2560
|
return ArrayLiteral$0(state);
|
|
2500
2561
|
}
|
|
2501
2562
|
}
|
|
2502
|
-
var ArrayLiteralContent$0 =
|
|
2503
|
-
|
|
2563
|
+
var ArrayLiteralContent$0 = $TS($S(ExtendedExpression, __, $C(DotDotDot, DotDot), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2564
|
+
var s = $1;
|
|
2565
|
+
var ws = $2;
|
|
2566
|
+
var range = $3;
|
|
2567
|
+
var e = $4;
|
|
2568
|
+
const inclusive = range.token === "..";
|
|
2569
|
+
range.token = ",";
|
|
2570
|
+
if (s.type === "Literal" && e.type === "Literal") {
|
|
2571
|
+
const start = JSON.parse(s.raw);
|
|
2572
|
+
const end = JSON.parse(e.raw);
|
|
2573
|
+
const step = end > start ? 1 : -1;
|
|
2574
|
+
const length = Math.abs(end - start) + (inclusive ? 1 : 0);
|
|
2575
|
+
if (length <= 20) {
|
|
2576
|
+
return Array.from({ length }, (_2, i) => start + i * step).join(", ");
|
|
2577
|
+
}
|
|
2578
|
+
}
|
|
2579
|
+
const inclusiveAdjust = inclusive ? " + 1" : "";
|
|
2580
|
+
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, ")"];
|
|
2581
|
+
return {
|
|
2582
|
+
type: "RangeExpression",
|
|
2583
|
+
children,
|
|
2584
|
+
inclusive,
|
|
2585
|
+
start: s,
|
|
2586
|
+
end: e
|
|
2587
|
+
};
|
|
2588
|
+
});
|
|
2589
|
+
var ArrayLiteralContent$1 = NestedElementList;
|
|
2590
|
+
var ArrayLiteralContent$2 = ElementList;
|
|
2504
2591
|
function ArrayLiteralContent(state) {
|
|
2505
2592
|
if (state.tokenize) {
|
|
2506
|
-
return $TOKEN("ArrayLiteralContent", state, ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state));
|
|
2593
|
+
return $TOKEN("ArrayLiteralContent", state, ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state) || ArrayLiteralContent$2(state));
|
|
2507
2594
|
} else {
|
|
2508
|
-
return ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state);
|
|
2595
|
+
return ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state) || ArrayLiteralContent$2(state);
|
|
2509
2596
|
}
|
|
2510
2597
|
}
|
|
2511
2598
|
var NestedElementList$0 = $TS($S(PushIndent, $Q(NestedElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
@@ -2661,7 +2748,10 @@ var Civet = (() => {
|
|
|
2661
2748
|
var NestedObjectLiteral$0 = $TS($S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2662
2749
|
$3.unshift($1);
|
|
2663
2750
|
$3.push($4, $5, $6);
|
|
2664
|
-
return
|
|
2751
|
+
return {
|
|
2752
|
+
type: "ObjectExpression",
|
|
2753
|
+
children: $3
|
|
2754
|
+
};
|
|
2665
2755
|
});
|
|
2666
2756
|
function NestedObjectLiteral(state) {
|
|
2667
2757
|
if (state.verbose)
|
|
@@ -2969,7 +3059,7 @@ var Civet = (() => {
|
|
|
2969
3059
|
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);
|
|
2970
3060
|
}
|
|
2971
3061
|
}
|
|
2972
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
3062
|
+
var UnaryOp$0 = $TR($EXPECT($R4, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2973
3063
|
return { $loc, token: $0 };
|
|
2974
3064
|
});
|
|
2975
3065
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -3108,14 +3198,8 @@ var Civet = (() => {
|
|
|
3108
3198
|
var UnlessClause$0 = $TS($S(Unless, Condition), function($skip, $loc, $0, $1, $2) {
|
|
3109
3199
|
var kind = $1;
|
|
3110
3200
|
var condition = $2;
|
|
3111
|
-
condition.
|
|
3112
|
-
|
|
3113
|
-
return;
|
|
3114
|
-
if (c.token === "(")
|
|
3115
|
-
c.token = "(!(";
|
|
3116
|
-
if (c.token === ")")
|
|
3117
|
-
c.token = "))";
|
|
3118
|
-
});
|
|
3201
|
+
condition.children.unshift("(!");
|
|
3202
|
+
condition.children.push(")");
|
|
3119
3203
|
kind.token = "if";
|
|
3120
3204
|
return {
|
|
3121
3205
|
type: "IfStatement",
|
|
@@ -3198,7 +3282,9 @@ var Civet = (() => {
|
|
|
3198
3282
|
}
|
|
3199
3283
|
}
|
|
3200
3284
|
var IterationStatement$0 = LoopStatement;
|
|
3201
|
-
var IterationStatement$1 = DoWhileStatement
|
|
3285
|
+
var IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
|
|
3286
|
+
return value[1];
|
|
3287
|
+
});
|
|
3202
3288
|
var IterationStatement$2 = WhileStatement;
|
|
3203
3289
|
var IterationStatement$3 = ForStatement;
|
|
3204
3290
|
function IterationStatement(state) {
|
|
@@ -3262,14 +3348,14 @@ var Civet = (() => {
|
|
|
3262
3348
|
return WhileStatement$0(state);
|
|
3263
3349
|
}
|
|
3264
3350
|
}
|
|
3265
|
-
var WhileClause$0 = $TS($S($C(While, Until), Condition), function($skip, $loc, $0, $1, $2) {
|
|
3351
|
+
var WhileClause$0 = $TS($S($C(While, Until), $Q(TrailingComment), Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
3266
3352
|
var kind = $1;
|
|
3267
|
-
var
|
|
3353
|
+
var ws = $2;
|
|
3354
|
+
var cond = $3;
|
|
3268
3355
|
if (kind.token === "until") {
|
|
3269
|
-
cond[1] = "(!(";
|
|
3270
|
-
cond[cond.length - 1] = "))";
|
|
3271
3356
|
kind.token = "while";
|
|
3272
|
-
|
|
3357
|
+
cond.children.unshift("(!");
|
|
3358
|
+
cond.children.push(")");
|
|
3273
3359
|
}
|
|
3274
3360
|
return {
|
|
3275
3361
|
type: "IterationStatement",
|
|
@@ -3359,20 +3445,30 @@ var Civet = (() => {
|
|
|
3359
3445
|
return WhenCondition$0(state);
|
|
3360
3446
|
}
|
|
3361
3447
|
}
|
|
3362
|
-
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) {
|
|
3448
|
+
var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, __, $C(In, Of, From), ExtendedExpression, $E($S(__, By, ExtendedExpression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
3449
|
+
var open = $2;
|
|
3363
3450
|
var declaration = $3;
|
|
3364
3451
|
var kind = $5;
|
|
3365
3452
|
var exp = $6;
|
|
3453
|
+
var step = $7;
|
|
3454
|
+
var close = $8;
|
|
3366
3455
|
let blockPrefix = [];
|
|
3456
|
+
const indent = "".padStart((module.currentIndent + 1) * 2);
|
|
3367
3457
|
if (kind.token === "from") {
|
|
3458
|
+
if (step) {
|
|
3459
|
+
throw new Error("Can't use 'by' with 'from' in CoffeeScript for loops");
|
|
3460
|
+
}
|
|
3368
3461
|
kind.token = "of";
|
|
3369
3462
|
} else if (kind.token === "of") {
|
|
3463
|
+
if (step) {
|
|
3464
|
+
throw new Error("Can't use 'by' with 'of' in CoffeeScript for loops");
|
|
3465
|
+
}
|
|
3370
3466
|
module.insertTrimmingSpace(declaration, "");
|
|
3371
3467
|
module.insertTrimmingSpace(exp, "");
|
|
3372
3468
|
if (declaration.own) {
|
|
3373
|
-
const
|
|
3469
|
+
const indent2 = "".padStart((module.currentIndent + 1) * 2);
|
|
3374
3470
|
const hasPropRef = module.getHasPropRef();
|
|
3375
|
-
blockPrefix.push([
|
|
3471
|
+
blockPrefix.push([indent2, "if (!", hasPropRef, ".call(", exp, ", ", declaration, ")) continue\n"]);
|
|
3376
3472
|
}
|
|
3377
3473
|
kind.token = "in ";
|
|
3378
3474
|
} else if (kind.token === "in") {
|
|
@@ -3384,10 +3480,79 @@ var Civet = (() => {
|
|
|
3384
3480
|
type: "Ref",
|
|
3385
3481
|
base: "len"
|
|
3386
3482
|
};
|
|
3387
|
-
|
|
3388
|
-
|
|
3389
|
-
|
|
3390
|
-
|
|
3483
|
+
let expRef;
|
|
3484
|
+
switch (exp.type) {
|
|
3485
|
+
case "Identifier":
|
|
3486
|
+
expRef = exp;
|
|
3487
|
+
break;
|
|
3488
|
+
case "RangeExpression": {
|
|
3489
|
+
const { start, end, inclusive } = exp;
|
|
3490
|
+
const stepExp = step?.[2];
|
|
3491
|
+
let stepRef;
|
|
3492
|
+
if (stepExp) {
|
|
3493
|
+
module.insertTrimmingSpace(stepExp, "");
|
|
3494
|
+
if (stepExp.type === "Literal") {
|
|
3495
|
+
stepRef = stepExp;
|
|
3496
|
+
} else {
|
|
3497
|
+
stepRef = {
|
|
3498
|
+
type: "Ref",
|
|
3499
|
+
base: "step"
|
|
3500
|
+
};
|
|
3501
|
+
}
|
|
3502
|
+
}
|
|
3503
|
+
let startRef, endRef;
|
|
3504
|
+
if (start.type === "Literal") {
|
|
3505
|
+
startRef = start;
|
|
3506
|
+
} else if (start.type === "Identifier") {
|
|
3507
|
+
startRef = start;
|
|
3508
|
+
} else {
|
|
3509
|
+
startRef = {
|
|
3510
|
+
type: "Ref",
|
|
3511
|
+
base: "ref"
|
|
3512
|
+
};
|
|
3513
|
+
}
|
|
3514
|
+
if (end.type === "Literal") {
|
|
3515
|
+
endRef = end;
|
|
3516
|
+
} else if (end.type === "Identifier") {
|
|
3517
|
+
endRef = end;
|
|
3518
|
+
} else {
|
|
3519
|
+
endRef = {
|
|
3520
|
+
type: "Ref",
|
|
3521
|
+
base: "ref"
|
|
3522
|
+
};
|
|
3523
|
+
}
|
|
3524
|
+
const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
|
|
3525
|
+
const endRefDec = endRef !== end ? [endRef, " = ", end, ", "] : [];
|
|
3526
|
+
const varRef2 = declaration;
|
|
3527
|
+
const ascDec = stepRef ? stepRef !== stepExp ? [", step = ", stepExp] : [] : [", asc = ", startRef, " <= ", endRef];
|
|
3528
|
+
declaration = {
|
|
3529
|
+
type: "Declaration",
|
|
3530
|
+
children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", varRef2, " = ", startRef, ...ascDec],
|
|
3531
|
+
names: []
|
|
3532
|
+
};
|
|
3533
|
+
blockPrefix.push([{
|
|
3534
|
+
type: "AssignmentExpression",
|
|
3535
|
+
children: [],
|
|
3536
|
+
names: varRef2.names
|
|
3537
|
+
}]);
|
|
3538
|
+
const counterPart = inclusive ? [counterRef, " <= ", endRef, " : ", counterRef, " >= ", endRef] : [counterRef, " < ", endRef, " : ", counterRef, " > ", endRef];
|
|
3539
|
+
const condition = stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ["asc ? ", ...counterPart];
|
|
3540
|
+
const increment = stepRef ? [varRef2, " = ", counterRef, " += ", stepRef] : [varRef2, " = asc ? ++", counterRef, " : --", counterRef];
|
|
3541
|
+
return {
|
|
3542
|
+
declaration,
|
|
3543
|
+
children: [$1, open, declaration, "; ", ...condition, "; ", ...increment, close],
|
|
3544
|
+
blockPrefix
|
|
3545
|
+
};
|
|
3546
|
+
}
|
|
3547
|
+
default:
|
|
3548
|
+
expRef = {
|
|
3549
|
+
type: "Ref",
|
|
3550
|
+
base: "ref"
|
|
3551
|
+
};
|
|
3552
|
+
}
|
|
3553
|
+
if (step) {
|
|
3554
|
+
throw new Error("by clause not yet implement in non-range for in loops");
|
|
3555
|
+
}
|
|
3391
3556
|
const varRef = declaration;
|
|
3392
3557
|
module.insertTrimmingSpace(exp, "");
|
|
3393
3558
|
const expRefDec = expRef !== exp ? [expRef, " = ", exp, ", "] : [];
|
|
@@ -3396,7 +3561,6 @@ var Civet = (() => {
|
|
|
3396
3561
|
children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
|
|
3397
3562
|
names: []
|
|
3398
3563
|
};
|
|
3399
|
-
const indent = "".padStart((module.currentIndent + 1) * 2);
|
|
3400
3564
|
blockPrefix.push([{
|
|
3401
3565
|
type: "AssignmentExpression",
|
|
3402
3566
|
children: [indent, varRef, " = ", expRef, "[", counterRef, "]\n"],
|
|
@@ -3404,7 +3568,7 @@ var Civet = (() => {
|
|
|
3404
3568
|
}]);
|
|
3405
3569
|
return {
|
|
3406
3570
|
declaration,
|
|
3407
|
-
children: [$1,
|
|
3571
|
+
children: [$1, open, declaration, "; ", counterRef, " < ", lenRef, "; ", counterRef, "++", close],
|
|
3408
3572
|
blockPrefix
|
|
3409
3573
|
};
|
|
3410
3574
|
}
|
|
@@ -3502,7 +3666,7 @@ var Civet = (() => {
|
|
|
3502
3666
|
names: binding.names
|
|
3503
3667
|
};
|
|
3504
3668
|
});
|
|
3505
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
3669
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R5, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
3506
3670
|
var c = $1;
|
|
3507
3671
|
var binding = $2;
|
|
3508
3672
|
return {
|
|
@@ -3741,10 +3905,18 @@ var Civet = (() => {
|
|
|
3741
3905
|
return CatchParameter$0(state) || CatchParameter$1(state);
|
|
3742
3906
|
}
|
|
3743
3907
|
}
|
|
3744
|
-
var Condition$0 = $S(
|
|
3745
|
-
|
|
3746
|
-
|
|
3747
|
-
|
|
3908
|
+
var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp)))), function(value) {
|
|
3909
|
+
return value[0];
|
|
3910
|
+
});
|
|
3911
|
+
var Condition$1 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
|
|
3912
|
+
var exp = $2;
|
|
3913
|
+
if (exp.type === "ParenthesizedExpression")
|
|
3914
|
+
return exp;
|
|
3915
|
+
module.insertTrimmingSpace(exp, "");
|
|
3916
|
+
return {
|
|
3917
|
+
type: "ParenthesizedExpression",
|
|
3918
|
+
children: $0
|
|
3919
|
+
};
|
|
3748
3920
|
});
|
|
3749
3921
|
function Condition(state) {
|
|
3750
3922
|
if (state.tokenize) {
|
|
@@ -4012,7 +4184,7 @@ var Civet = (() => {
|
|
|
4012
4184
|
return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
|
|
4013
4185
|
}
|
|
4014
4186
|
}
|
|
4015
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
4187
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R6, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
4016
4188
|
var spec = $0;
|
|
4017
4189
|
return { $loc, token: `"${spec}"` };
|
|
4018
4190
|
});
|
|
@@ -4264,7 +4436,7 @@ var Civet = (() => {
|
|
|
4264
4436
|
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
4265
4437
|
}
|
|
4266
4438
|
}
|
|
4267
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
4439
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
4268
4440
|
function DecimalBigIntegerLiteral(state) {
|
|
4269
4441
|
if (state.verbose)
|
|
4270
4442
|
console.log("ENTER:", "DecimalBigIntegerLiteral");
|
|
@@ -4274,11 +4446,11 @@ var Civet = (() => {
|
|
|
4274
4446
|
return DecimalBigIntegerLiteral$0(state);
|
|
4275
4447
|
}
|
|
4276
4448
|
}
|
|
4277
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
4449
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R8, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
4278
4450
|
return $1 + ".";
|
|
4279
4451
|
});
|
|
4280
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
4281
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
4452
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R9, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
4453
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R10, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
4282
4454
|
function DecimalLiteral(state) {
|
|
4283
4455
|
if (state.tokenize) {
|
|
4284
4456
|
return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
|
|
@@ -4286,7 +4458,7 @@ var Civet = (() => {
|
|
|
4286
4458
|
return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
|
|
4287
4459
|
}
|
|
4288
4460
|
}
|
|
4289
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
4461
|
+
var ExponentPart$0 = $R$0($EXPECT($R11, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
4290
4462
|
function ExponentPart(state) {
|
|
4291
4463
|
if (state.verbose)
|
|
4292
4464
|
console.log("ENTER:", "ExponentPart");
|
|
@@ -4296,7 +4468,7 @@ var Civet = (() => {
|
|
|
4296
4468
|
return ExponentPart$0(state);
|
|
4297
4469
|
}
|
|
4298
4470
|
}
|
|
4299
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
4471
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R12, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
4300
4472
|
function BinaryIntegerLiteral(state) {
|
|
4301
4473
|
if (state.verbose)
|
|
4302
4474
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -4306,7 +4478,7 @@ var Civet = (() => {
|
|
|
4306
4478
|
return BinaryIntegerLiteral$0(state);
|
|
4307
4479
|
}
|
|
4308
4480
|
}
|
|
4309
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
4481
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R13, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
4310
4482
|
function OctalIntegerLiteral(state) {
|
|
4311
4483
|
if (state.verbose)
|
|
4312
4484
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -4316,7 +4488,7 @@ var Civet = (() => {
|
|
|
4316
4488
|
return OctalIntegerLiteral$0(state);
|
|
4317
4489
|
}
|
|
4318
4490
|
}
|
|
4319
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
4491
|
+
var HexLiteral$0 = $R$0($EXPECT($R14, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
4320
4492
|
function HexLiteral(state) {
|
|
4321
4493
|
if (state.verbose)
|
|
4322
4494
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -4365,7 +4537,7 @@ var Civet = (() => {
|
|
|
4365
4537
|
return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
|
|
4366
4538
|
}
|
|
4367
4539
|
}
|
|
4368
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
4540
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R15, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4369
4541
|
return { $loc, token: $0 };
|
|
4370
4542
|
});
|
|
4371
4543
|
function DoubleStringCharacters(state) {
|
|
@@ -4377,7 +4549,7 @@ var Civet = (() => {
|
|
|
4377
4549
|
return DoubleStringCharacters$0(state);
|
|
4378
4550
|
}
|
|
4379
4551
|
}
|
|
4380
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
4552
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R16, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4381
4553
|
return { $loc, token: $0 };
|
|
4382
4554
|
});
|
|
4383
4555
|
function SingleStringCharacters(state) {
|
|
@@ -4389,7 +4561,7 @@ var Civet = (() => {
|
|
|
4389
4561
|
return SingleStringCharacters$0(state);
|
|
4390
4562
|
}
|
|
4391
4563
|
}
|
|
4392
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
4564
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R17, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4393
4565
|
return { $loc, token: $0 };
|
|
4394
4566
|
});
|
|
4395
4567
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -4401,7 +4573,7 @@ var Civet = (() => {
|
|
|
4401
4573
|
return TripleDoubleStringCharacters$0(state);
|
|
4402
4574
|
}
|
|
4403
4575
|
}
|
|
4404
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
4576
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R18, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4405
4577
|
return { $loc, token: $0 };
|
|
4406
4578
|
});
|
|
4407
4579
|
function TripleSingleStringCharacters(state) {
|
|
@@ -4452,7 +4624,7 @@ var Civet = (() => {
|
|
|
4452
4624
|
return CoffeeInterpolatedDoubleQuotedString$0(state);
|
|
4453
4625
|
}
|
|
4454
4626
|
}
|
|
4455
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
4627
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R19, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4456
4628
|
return { $loc, token: $0 };
|
|
4457
4629
|
});
|
|
4458
4630
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -4476,7 +4648,7 @@ var Civet = (() => {
|
|
|
4476
4648
|
return RegularExpressionLiteral$0(state);
|
|
4477
4649
|
}
|
|
4478
4650
|
}
|
|
4479
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
4651
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R20, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
4480
4652
|
function RegularExpressionBody(state) {
|
|
4481
4653
|
if (state.verbose)
|
|
4482
4654
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -4486,7 +4658,7 @@ var Civet = (() => {
|
|
|
4486
4658
|
return RegularExpressionBody$0(state);
|
|
4487
4659
|
}
|
|
4488
4660
|
}
|
|
4489
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
4661
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R21, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
4490
4662
|
function RegExpCharacter(state) {
|
|
4491
4663
|
if (state.verbose)
|
|
4492
4664
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -4496,7 +4668,7 @@ var Civet = (() => {
|
|
|
4496
4668
|
return RegExpCharacter$0(state);
|
|
4497
4669
|
}
|
|
4498
4670
|
}
|
|
4499
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
4671
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R22, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
4500
4672
|
function RegularExpressionFlags(state) {
|
|
4501
4673
|
if (state.verbose)
|
|
4502
4674
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -4527,7 +4699,7 @@ var Civet = (() => {
|
|
|
4527
4699
|
return TemplateSubstitution$0(state);
|
|
4528
4700
|
}
|
|
4529
4701
|
}
|
|
4530
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
4702
|
+
var TemplateCharacters$0 = $TR($EXPECT($R23, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4531
4703
|
return { $loc, token: $0 };
|
|
4532
4704
|
});
|
|
4533
4705
|
function TemplateCharacters(state) {
|
|
@@ -4539,7 +4711,7 @@ var Civet = (() => {
|
|
|
4539
4711
|
return TemplateCharacters$0(state);
|
|
4540
4712
|
}
|
|
4541
4713
|
}
|
|
4542
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
4714
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R24, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4543
4715
|
return { $loc, token: $0 };
|
|
4544
4716
|
});
|
|
4545
4717
|
function TemplateBlockCharacters(state) {
|
|
@@ -4551,14 +4723,15 @@ var Civet = (() => {
|
|
|
4551
4723
|
return TemplateBlockCharacters$0(state);
|
|
4552
4724
|
}
|
|
4553
4725
|
}
|
|
4554
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
4555
|
-
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($
|
|
4556
|
-
var ReservedWord$2 = $R$0($EXPECT($
|
|
4726
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R25, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
4727
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R26, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
4728
|
+
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R27, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
4729
|
+
var ReservedWord$3 = $R$0($EXPECT($R28, 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})/"));
|
|
4557
4730
|
function ReservedWord(state) {
|
|
4558
4731
|
if (state.tokenize) {
|
|
4559
|
-
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state));
|
|
4732
|
+
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state) || ReservedWord$3(state));
|
|
4560
4733
|
} else {
|
|
4561
|
-
return ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state);
|
|
4734
|
+
return ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state) || ReservedWord$3(state);
|
|
4562
4735
|
}
|
|
4563
4736
|
}
|
|
4564
4737
|
var Comment$0 = MultiLineComment;
|
|
@@ -4570,7 +4743,7 @@ var Civet = (() => {
|
|
|
4570
4743
|
return Comment$0(state) || Comment$1(state);
|
|
4571
4744
|
}
|
|
4572
4745
|
}
|
|
4573
|
-
var SingleLineComment$0 = $TR($EXPECT($
|
|
4746
|
+
var SingleLineComment$0 = $TR($EXPECT($R29, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4574
4747
|
return { $loc, token: $0 };
|
|
4575
4748
|
});
|
|
4576
4749
|
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
@@ -4590,7 +4763,7 @@ var Civet = (() => {
|
|
|
4590
4763
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
4591
4764
|
}
|
|
4592
4765
|
}
|
|
4593
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L84, fail, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
4766
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L84, fail, 'JSMultiLineComment "*/"')), $EXPECT($R30, fail, "JSMultiLineComment /./"))), $EXPECT($L84, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
4594
4767
|
return { $loc, token: $1 };
|
|
4595
4768
|
});
|
|
4596
4769
|
function JSMultiLineComment(state) {
|
|
@@ -4602,7 +4775,7 @@ var Civet = (() => {
|
|
|
4602
4775
|
return JSMultiLineComment$0(state);
|
|
4603
4776
|
}
|
|
4604
4777
|
}
|
|
4605
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
4778
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R31, fail, "CoffeeSingleLineComment /#(?!##)([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4606
4779
|
return { $loc, token: `//${$1}` };
|
|
4607
4780
|
});
|
|
4608
4781
|
function CoffeeSingleLineComment(state) {
|
|
@@ -4614,7 +4787,7 @@ var Civet = (() => {
|
|
|
4614
4787
|
return CoffeeSingleLineComment$0(state);
|
|
4615
4788
|
}
|
|
4616
4789
|
}
|
|
4617
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L84, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($
|
|
4790
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L84, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R30, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L85, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
4618
4791
|
return { $loc, token: `/*${$2}*/` };
|
|
4619
4792
|
});
|
|
4620
4793
|
function CoffeeMultiLineComment(state) {
|
|
@@ -4626,7 +4799,7 @@ var Civet = (() => {
|
|
|
4626
4799
|
return CoffeeMultiLineComment$0(state);
|
|
4627
4800
|
}
|
|
4628
4801
|
}
|
|
4629
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L84, fail, 'InlineComment "*/"')), $EXPECT($
|
|
4802
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L84, fail, 'InlineComment "*/"')), $EXPECT($R32, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L84, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
4630
4803
|
return { $loc, token: $1 };
|
|
4631
4804
|
});
|
|
4632
4805
|
function InlineComment(state) {
|
|
@@ -4668,7 +4841,7 @@ var Civet = (() => {
|
|
|
4668
4841
|
return _$0(state);
|
|
4669
4842
|
}
|
|
4670
4843
|
}
|
|
4671
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
4844
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R33, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4672
4845
|
return { $loc, token: $0 };
|
|
4673
4846
|
});
|
|
4674
4847
|
function NonNewlineWhitespace(state) {
|
|
@@ -4690,7 +4863,7 @@ var Civet = (() => {
|
|
|
4690
4863
|
return __$0(state);
|
|
4691
4864
|
}
|
|
4692
4865
|
}
|
|
4693
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
4866
|
+
var Whitespace$0 = $TR($EXPECT($R34, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4694
4867
|
return { $loc, token: $0 };
|
|
4695
4868
|
});
|
|
4696
4869
|
function Whitespace(state) {
|
|
@@ -4725,7 +4898,7 @@ var Civet = (() => {
|
|
|
4725
4898
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
4726
4899
|
}
|
|
4727
4900
|
}
|
|
4728
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
4901
|
+
var NonIdContinue$0 = $R$0($EXPECT($R35, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
4729
4902
|
function NonIdContinue(state) {
|
|
4730
4903
|
if (state.verbose)
|
|
4731
4904
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -4807,7 +4980,19 @@ var Civet = (() => {
|
|
|
4807
4980
|
return Backtick$0(state);
|
|
4808
4981
|
}
|
|
4809
4982
|
}
|
|
4810
|
-
var
|
|
4983
|
+
var By$0 = $TS($S($EXPECT($L90, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4984
|
+
return { $loc, token: $1 };
|
|
4985
|
+
});
|
|
4986
|
+
function By(state) {
|
|
4987
|
+
if (state.verbose)
|
|
4988
|
+
console.log("ENTER:", "By");
|
|
4989
|
+
if (state.tokenize) {
|
|
4990
|
+
return $TOKEN("By", state, By$0(state));
|
|
4991
|
+
} else {
|
|
4992
|
+
return By$0(state);
|
|
4993
|
+
}
|
|
4994
|
+
}
|
|
4995
|
+
var Case$0 = $TS($S($EXPECT($L91, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4811
4996
|
return { $loc, token: $1 };
|
|
4812
4997
|
});
|
|
4813
4998
|
function Case(state) {
|
|
@@ -4819,7 +5004,7 @@ var Civet = (() => {
|
|
|
4819
5004
|
return Case$0(state);
|
|
4820
5005
|
}
|
|
4821
5006
|
}
|
|
4822
|
-
var Catch$0 = $TV($EXPECT($
|
|
5007
|
+
var Catch$0 = $TV($EXPECT($L92, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
4823
5008
|
return { $loc, token: $1 };
|
|
4824
5009
|
});
|
|
4825
5010
|
function Catch(state) {
|
|
@@ -4831,7 +5016,7 @@ var Civet = (() => {
|
|
|
4831
5016
|
return Catch$0(state);
|
|
4832
5017
|
}
|
|
4833
5018
|
}
|
|
4834
|
-
var Class$0 = $TV($EXPECT($
|
|
5019
|
+
var Class$0 = $TV($EXPECT($L93, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
4835
5020
|
return { $loc, token: $1 };
|
|
4836
5021
|
});
|
|
4837
5022
|
function Class(state) {
|
|
@@ -4879,7 +5064,7 @@ var Civet = (() => {
|
|
|
4879
5064
|
return CloseParen$0(state);
|
|
4880
5065
|
}
|
|
4881
5066
|
}
|
|
4882
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
5067
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L94, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
4883
5068
|
return { $loc, token: "${" };
|
|
4884
5069
|
});
|
|
4885
5070
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -4891,7 +5076,7 @@ var Civet = (() => {
|
|
|
4891
5076
|
return CoffeeSubstitutionStart$0(state);
|
|
4892
5077
|
}
|
|
4893
5078
|
}
|
|
4894
|
-
var Colon$0 = $TV($EXPECT($
|
|
5079
|
+
var Colon$0 = $TV($EXPECT($L95, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
4895
5080
|
return { $loc, token: $1 };
|
|
4896
5081
|
});
|
|
4897
5082
|
function Colon(state) {
|
|
@@ -4927,7 +5112,7 @@ var Civet = (() => {
|
|
|
4927
5112
|
return Default$0(state);
|
|
4928
5113
|
}
|
|
4929
5114
|
}
|
|
4930
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
5115
|
+
var Delete$0 = $TS($S($EXPECT($L96, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4931
5116
|
return { $loc, token: $1 };
|
|
4932
5117
|
});
|
|
4933
5118
|
function Delete(state) {
|
|
@@ -4939,7 +5124,7 @@ var Civet = (() => {
|
|
|
4939
5124
|
return Delete$0(state);
|
|
4940
5125
|
}
|
|
4941
5126
|
}
|
|
4942
|
-
var Do$0 = $TS($S($EXPECT($
|
|
5127
|
+
var Do$0 = $TS($S($EXPECT($L97, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4943
5128
|
return { $loc, token: $1 };
|
|
4944
5129
|
});
|
|
4945
5130
|
function Do(state) {
|
|
@@ -4963,7 +5148,7 @@ var Civet = (() => {
|
|
|
4963
5148
|
return Dot$0(state);
|
|
4964
5149
|
}
|
|
4965
5150
|
}
|
|
4966
|
-
var DotDot$0 = $TV($EXPECT($
|
|
5151
|
+
var DotDot$0 = $TV($EXPECT($L98, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
4967
5152
|
return { $loc, token: $1 };
|
|
4968
5153
|
});
|
|
4969
5154
|
function DotDot(state) {
|
|
@@ -4975,7 +5160,7 @@ var Civet = (() => {
|
|
|
4975
5160
|
return DotDot$0(state);
|
|
4976
5161
|
}
|
|
4977
5162
|
}
|
|
4978
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
5163
|
+
var DotDotDot$0 = $TV($EXPECT($L99, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
4979
5164
|
return { $loc, token: $1 };
|
|
4980
5165
|
});
|
|
4981
5166
|
function DotDotDot(state) {
|
|
@@ -4987,7 +5172,7 @@ var Civet = (() => {
|
|
|
4987
5172
|
return DotDotDot$0(state);
|
|
4988
5173
|
}
|
|
4989
5174
|
}
|
|
4990
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
5175
|
+
var DoubleQuote$0 = $TV($EXPECT($L100, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4991
5176
|
return { $loc, token: $1 };
|
|
4992
5177
|
});
|
|
4993
5178
|
function DoubleQuote(state) {
|
|
@@ -4999,7 +5184,7 @@ var Civet = (() => {
|
|
|
4999
5184
|
return DoubleQuote$0(state);
|
|
5000
5185
|
}
|
|
5001
5186
|
}
|
|
5002
|
-
var Else$0 = $TV($EXPECT($
|
|
5187
|
+
var Else$0 = $TV($EXPECT($L101, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
5003
5188
|
return { $loc, token: $1 };
|
|
5004
5189
|
});
|
|
5005
5190
|
function Else(state) {
|
|
@@ -5023,7 +5208,7 @@ var Civet = (() => {
|
|
|
5023
5208
|
return Equals$0(state);
|
|
5024
5209
|
}
|
|
5025
5210
|
}
|
|
5026
|
-
var Export$0 = $TS($S($EXPECT($
|
|
5211
|
+
var Export$0 = $TS($S($EXPECT($L102, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5027
5212
|
return { $loc, token: $1 };
|
|
5028
5213
|
});
|
|
5029
5214
|
function Export(state) {
|
|
@@ -5035,7 +5220,7 @@ var Civet = (() => {
|
|
|
5035
5220
|
return Export$0(state);
|
|
5036
5221
|
}
|
|
5037
5222
|
}
|
|
5038
|
-
var For$0 = $TS($S($EXPECT($
|
|
5223
|
+
var For$0 = $TS($S($EXPECT($L103, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5039
5224
|
return { $loc, token: $1 };
|
|
5040
5225
|
});
|
|
5041
5226
|
function For(state) {
|
|
@@ -5047,7 +5232,7 @@ var Civet = (() => {
|
|
|
5047
5232
|
return For$0(state);
|
|
5048
5233
|
}
|
|
5049
5234
|
}
|
|
5050
|
-
var From$0 = $TS($S($EXPECT($
|
|
5235
|
+
var From$0 = $TS($S($EXPECT($L104, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5051
5236
|
return { $loc, token: $1 };
|
|
5052
5237
|
});
|
|
5053
5238
|
function From(state) {
|
|
@@ -5059,7 +5244,7 @@ var Civet = (() => {
|
|
|
5059
5244
|
return From$0(state);
|
|
5060
5245
|
}
|
|
5061
5246
|
}
|
|
5062
|
-
var Function$0 = $TV($EXPECT($
|
|
5247
|
+
var Function$0 = $TV($EXPECT($L105, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
5063
5248
|
return { $loc, token: $1 };
|
|
5064
5249
|
});
|
|
5065
5250
|
function Function(state) {
|
|
@@ -5071,7 +5256,7 @@ var Civet = (() => {
|
|
|
5071
5256
|
return Function$0(state);
|
|
5072
5257
|
}
|
|
5073
5258
|
}
|
|
5074
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
5259
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L106, fail, 'GetOrSet "get"'), $EXPECT($L107, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5075
5260
|
return { $loc, token: $1 };
|
|
5076
5261
|
});
|
|
5077
5262
|
function GetOrSet(state) {
|
|
@@ -5083,7 +5268,7 @@ var Civet = (() => {
|
|
|
5083
5268
|
return GetOrSet$0(state);
|
|
5084
5269
|
}
|
|
5085
5270
|
}
|
|
5086
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
5271
|
+
var If$0 = $TV($TEXT($S($EXPECT($L108, fail, 'If "if"'), $E($EXPECT($L109, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
5087
5272
|
return { $loc, token: $1 };
|
|
5088
5273
|
});
|
|
5089
5274
|
function If(state) {
|
|
@@ -5095,7 +5280,7 @@ var Civet = (() => {
|
|
|
5095
5280
|
return If$0(state);
|
|
5096
5281
|
}
|
|
5097
5282
|
}
|
|
5098
|
-
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($
|
|
5283
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R36, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
5099
5284
|
return { $loc, token: $1 };
|
|
5100
5285
|
});
|
|
5101
5286
|
function Import(state) {
|
|
@@ -5119,7 +5304,7 @@ var Civet = (() => {
|
|
|
5119
5304
|
return In$0(state);
|
|
5120
5305
|
}
|
|
5121
5306
|
}
|
|
5122
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
5307
|
+
var LetOrConst$0 = $TV($C($EXPECT($L110, fail, 'LetOrConst "let"'), $EXPECT($L111, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
5123
5308
|
return { $loc, token: $1 };
|
|
5124
5309
|
});
|
|
5125
5310
|
function LetOrConst(state) {
|
|
@@ -5131,7 +5316,7 @@ var Civet = (() => {
|
|
|
5131
5316
|
return LetOrConst$0(state);
|
|
5132
5317
|
}
|
|
5133
5318
|
}
|
|
5134
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
5319
|
+
var Loop$0 = $TS($S($EXPECT($L112, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5135
5320
|
return { $loc, token: "while(true)" };
|
|
5136
5321
|
});
|
|
5137
5322
|
function Loop(state) {
|
|
@@ -5143,7 +5328,7 @@ var Civet = (() => {
|
|
|
5143
5328
|
return Loop$0(state);
|
|
5144
5329
|
}
|
|
5145
5330
|
}
|
|
5146
|
-
var New$0 = $TV($EXPECT($
|
|
5331
|
+
var New$0 = $TV($EXPECT($L113, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
5147
5332
|
return { $loc, token: $1 };
|
|
5148
5333
|
});
|
|
5149
5334
|
function New(state) {
|
|
@@ -5155,7 +5340,7 @@ var Civet = (() => {
|
|
|
5155
5340
|
return New$0(state);
|
|
5156
5341
|
}
|
|
5157
5342
|
}
|
|
5158
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
5343
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L114, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L109, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5159
5344
|
return { $loc, token: "!" };
|
|
5160
5345
|
});
|
|
5161
5346
|
function Not(state) {
|
|
@@ -5179,7 +5364,7 @@ var Civet = (() => {
|
|
|
5179
5364
|
return Of$0(state);
|
|
5180
5365
|
}
|
|
5181
5366
|
}
|
|
5182
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
5367
|
+
var OpenBrace$0 = $TV($EXPECT($L115, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
5183
5368
|
return { $loc, token: $1 };
|
|
5184
5369
|
});
|
|
5185
5370
|
function OpenBrace(state) {
|
|
@@ -5191,7 +5376,7 @@ var Civet = (() => {
|
|
|
5191
5376
|
return OpenBrace$0(state);
|
|
5192
5377
|
}
|
|
5193
5378
|
}
|
|
5194
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
5379
|
+
var OpenBracket$0 = $TV($EXPECT($L116, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
5195
5380
|
return { $loc, token: $1 };
|
|
5196
5381
|
});
|
|
5197
5382
|
function OpenBracket(state) {
|
|
@@ -5203,7 +5388,7 @@ var Civet = (() => {
|
|
|
5203
5388
|
return OpenBracket$0(state);
|
|
5204
5389
|
}
|
|
5205
5390
|
}
|
|
5206
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
5391
|
+
var OpenParen$0 = $TV($EXPECT($L117, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
5207
5392
|
return { $loc, token: $1 };
|
|
5208
5393
|
});
|
|
5209
5394
|
function OpenParen(state) {
|
|
@@ -5215,7 +5400,7 @@ var Civet = (() => {
|
|
|
5215
5400
|
return OpenParen$0(state);
|
|
5216
5401
|
}
|
|
5217
5402
|
}
|
|
5218
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
5403
|
+
var QuestionMark$0 = $TV($EXPECT($L118, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
5219
5404
|
return { $loc, token: $1 };
|
|
5220
5405
|
});
|
|
5221
5406
|
function QuestionMark(state) {
|
|
@@ -5227,7 +5412,7 @@ var Civet = (() => {
|
|
|
5227
5412
|
return QuestionMark$0(state);
|
|
5228
5413
|
}
|
|
5229
5414
|
}
|
|
5230
|
-
var Return$0 = $TS($S($EXPECT($
|
|
5415
|
+
var Return$0 = $TS($S($EXPECT($L119, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5231
5416
|
return { $loc, token: $1 };
|
|
5232
5417
|
});
|
|
5233
5418
|
function Return(state) {
|
|
@@ -5251,7 +5436,7 @@ var Civet = (() => {
|
|
|
5251
5436
|
return Semicolon$0(state);
|
|
5252
5437
|
}
|
|
5253
5438
|
}
|
|
5254
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
5439
|
+
var SingleQuote$0 = $TV($EXPECT($L120, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
5255
5440
|
return { $loc, token: $1 };
|
|
5256
5441
|
});
|
|
5257
5442
|
function SingleQuote(state) {
|
|
@@ -5275,10 +5460,10 @@ var Civet = (() => {
|
|
|
5275
5460
|
return Star$0(state);
|
|
5276
5461
|
}
|
|
5277
5462
|
}
|
|
5278
|
-
var Static$0 = $TV($EXPECT($
|
|
5463
|
+
var Static$0 = $TV($EXPECT($L121, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
5279
5464
|
return { $loc, token: $1 };
|
|
5280
5465
|
});
|
|
5281
|
-
var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($
|
|
5466
|
+
var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($L117, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
5282
5467
|
return { $loc, token: "static " };
|
|
5283
5468
|
});
|
|
5284
5469
|
function Static(state) {
|
|
@@ -5288,7 +5473,7 @@ var Civet = (() => {
|
|
|
5288
5473
|
return Static$0(state) || Static$1(state);
|
|
5289
5474
|
}
|
|
5290
5475
|
}
|
|
5291
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
5476
|
+
var SubstitutionStart$0 = $TV($EXPECT($L122, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
5292
5477
|
return { $loc, token: $1 };
|
|
5293
5478
|
});
|
|
5294
5479
|
function SubstitutionStart(state) {
|
|
@@ -5300,7 +5485,7 @@ var Civet = (() => {
|
|
|
5300
5485
|
return SubstitutionStart$0(state);
|
|
5301
5486
|
}
|
|
5302
5487
|
}
|
|
5303
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
5488
|
+
var Switch$0 = $TS($S($EXPECT($L123, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5304
5489
|
return { $loc, token: $1 };
|
|
5305
5490
|
});
|
|
5306
5491
|
function Switch(state) {
|
|
@@ -5312,7 +5497,7 @@ var Civet = (() => {
|
|
|
5312
5497
|
return Switch$0(state);
|
|
5313
5498
|
}
|
|
5314
5499
|
}
|
|
5315
|
-
var Target$0 = $TV($EXPECT($
|
|
5500
|
+
var Target$0 = $TV($EXPECT($L124, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
5316
5501
|
return { $loc, token: $1 };
|
|
5317
5502
|
});
|
|
5318
5503
|
function Target(state) {
|
|
@@ -5324,7 +5509,7 @@ var Civet = (() => {
|
|
|
5324
5509
|
return Target$0(state);
|
|
5325
5510
|
}
|
|
5326
5511
|
}
|
|
5327
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
5512
|
+
var Then$0 = $TS($S(__, $EXPECT($L125, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5328
5513
|
return { $loc, token: "" };
|
|
5329
5514
|
});
|
|
5330
5515
|
function Then(state) {
|
|
@@ -5336,7 +5521,7 @@ var Civet = (() => {
|
|
|
5336
5521
|
return Then$0(state);
|
|
5337
5522
|
}
|
|
5338
5523
|
}
|
|
5339
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
5524
|
+
var Throw$0 = $TS($S($EXPECT($L126, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5340
5525
|
return { $loc, token: $1 };
|
|
5341
5526
|
});
|
|
5342
5527
|
function Throw(state) {
|
|
@@ -5348,7 +5533,7 @@ var Civet = (() => {
|
|
|
5348
5533
|
return Throw$0(state);
|
|
5349
5534
|
}
|
|
5350
5535
|
}
|
|
5351
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
5536
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L127, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
5352
5537
|
return { $loc, token: "`" };
|
|
5353
5538
|
});
|
|
5354
5539
|
function TripleDoubleQuote(state) {
|
|
@@ -5360,7 +5545,7 @@ var Civet = (() => {
|
|
|
5360
5545
|
return TripleDoubleQuote$0(state);
|
|
5361
5546
|
}
|
|
5362
5547
|
}
|
|
5363
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
5548
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L128, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
5364
5549
|
return { $loc, token: "`" };
|
|
5365
5550
|
});
|
|
5366
5551
|
function TripleSingleQuote(state) {
|
|
@@ -5372,7 +5557,7 @@ var Civet = (() => {
|
|
|
5372
5557
|
return TripleSingleQuote$0(state);
|
|
5373
5558
|
}
|
|
5374
5559
|
}
|
|
5375
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
5560
|
+
var TripleTick$0 = $TV($EXPECT($L129, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
5376
5561
|
return { $loc, token: "`" };
|
|
5377
5562
|
});
|
|
5378
5563
|
function TripleTick(state) {
|
|
@@ -5384,7 +5569,7 @@ var Civet = (() => {
|
|
|
5384
5569
|
return TripleTick$0(state);
|
|
5385
5570
|
}
|
|
5386
5571
|
}
|
|
5387
|
-
var Try$0 = $TV($EXPECT($
|
|
5572
|
+
var Try$0 = $TV($EXPECT($L130, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
5388
5573
|
return { $loc, token: $1 };
|
|
5389
5574
|
});
|
|
5390
5575
|
function Try(state) {
|
|
@@ -5396,7 +5581,7 @@ var Civet = (() => {
|
|
|
5396
5581
|
return Try$0(state);
|
|
5397
5582
|
}
|
|
5398
5583
|
}
|
|
5399
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
5584
|
+
var Typeof$0 = $TS($S($EXPECT($L131, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5400
5585
|
return { $loc, token: $1 };
|
|
5401
5586
|
});
|
|
5402
5587
|
function Typeof(state) {
|
|
@@ -5408,7 +5593,7 @@ var Civet = (() => {
|
|
|
5408
5593
|
return Typeof$0(state);
|
|
5409
5594
|
}
|
|
5410
5595
|
}
|
|
5411
|
-
var Unless$0 = $TV($EXPECT($
|
|
5596
|
+
var Unless$0 = $TV($EXPECT($L132, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
5412
5597
|
return { $loc, token: $1 };
|
|
5413
5598
|
});
|
|
5414
5599
|
function Unless(state) {
|
|
@@ -5420,7 +5605,7 @@ var Civet = (() => {
|
|
|
5420
5605
|
return Unless$0(state);
|
|
5421
5606
|
}
|
|
5422
5607
|
}
|
|
5423
|
-
var Until$0 = $TS($S($EXPECT($
|
|
5608
|
+
var Until$0 = $TS($S($EXPECT($L133, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5424
5609
|
return { $loc, token: $1 };
|
|
5425
5610
|
});
|
|
5426
5611
|
function Until(state) {
|
|
@@ -5432,7 +5617,7 @@ var Civet = (() => {
|
|
|
5432
5617
|
return Until$0(state);
|
|
5433
5618
|
}
|
|
5434
5619
|
}
|
|
5435
|
-
var Var$0 = $TV($EXPECT($
|
|
5620
|
+
var Var$0 = $TV($EXPECT($L134, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
5436
5621
|
return { $loc, token: $1 };
|
|
5437
5622
|
});
|
|
5438
5623
|
function Var(state) {
|
|
@@ -5444,7 +5629,7 @@ var Civet = (() => {
|
|
|
5444
5629
|
return Var$0(state);
|
|
5445
5630
|
}
|
|
5446
5631
|
}
|
|
5447
|
-
var Void$0 = $TS($S($EXPECT($
|
|
5632
|
+
var Void$0 = $TS($S($EXPECT($L135, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5448
5633
|
return { $loc, token: $1 };
|
|
5449
5634
|
});
|
|
5450
5635
|
function Void(state) {
|
|
@@ -5456,7 +5641,7 @@ var Civet = (() => {
|
|
|
5456
5641
|
return Void$0(state);
|
|
5457
5642
|
}
|
|
5458
5643
|
}
|
|
5459
|
-
var When$0 = $TS($S($EXPECT($
|
|
5644
|
+
var When$0 = $TS($S($EXPECT($L136, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5460
5645
|
return { $loc, token: "case" };
|
|
5461
5646
|
});
|
|
5462
5647
|
function When(state) {
|
|
@@ -5468,7 +5653,7 @@ var Civet = (() => {
|
|
|
5468
5653
|
return When$0(state);
|
|
5469
5654
|
}
|
|
5470
5655
|
}
|
|
5471
|
-
var While$0 = $TS($S($EXPECT($
|
|
5656
|
+
var While$0 = $TS($S($EXPECT($L137, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5472
5657
|
return { $loc, token: $1 };
|
|
5473
5658
|
});
|
|
5474
5659
|
function While(state) {
|
|
@@ -5480,7 +5665,7 @@ var Civet = (() => {
|
|
|
5480
5665
|
return While$0(state);
|
|
5481
5666
|
}
|
|
5482
5667
|
}
|
|
5483
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
5668
|
+
var Yield$0 = $TS($S($EXPECT($L138, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5484
5669
|
return { $loc, token: $1 };
|
|
5485
5670
|
});
|
|
5486
5671
|
function Yield(state) {
|
|
@@ -5506,7 +5691,7 @@ var Civet = (() => {
|
|
|
5506
5691
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
5507
5692
|
}
|
|
5508
5693
|
}
|
|
5509
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
5694
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L139, fail, 'JSXSelfClosingElement "/>"'));
|
|
5510
5695
|
function JSXSelfClosingElement(state) {
|
|
5511
5696
|
if (state.verbose)
|
|
5512
5697
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -5526,7 +5711,7 @@ var Civet = (() => {
|
|
|
5526
5711
|
return JSXOpeningElement$0(state);
|
|
5527
5712
|
}
|
|
5528
5713
|
}
|
|
5529
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
5714
|
+
var JSXClosingElement$0 = $S($EXPECT($L140, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
|
|
5530
5715
|
function JSXClosingElement(state) {
|
|
5531
5716
|
if (state.verbose)
|
|
5532
5717
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -5536,7 +5721,7 @@ var Civet = (() => {
|
|
|
5536
5721
|
return JSXClosingElement$0(state);
|
|
5537
5722
|
}
|
|
5538
5723
|
}
|
|
5539
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
5724
|
+
var JSXFragment$0 = $S($EXPECT($L141, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L142, fail, 'JSXFragment "</>"'));
|
|
5540
5725
|
function JSXFragment(state) {
|
|
5541
5726
|
if (state.verbose)
|
|
5542
5727
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -5556,7 +5741,7 @@ var Civet = (() => {
|
|
|
5556
5741
|
return JSXElementName$0(state);
|
|
5557
5742
|
}
|
|
5558
5743
|
}
|
|
5559
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
5744
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R37, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
5560
5745
|
function JSXIdentifierName(state) {
|
|
5561
5746
|
if (state.verbose)
|
|
5562
5747
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -5605,8 +5790,8 @@ var Civet = (() => {
|
|
|
5605
5790
|
return JSXAttributeInitializer$0(state);
|
|
5606
5791
|
}
|
|
5607
5792
|
}
|
|
5608
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
5609
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
5793
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R38, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
5794
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R39, fail, "JSXAttributeValue /'[^']*'/"));
|
|
5610
5795
|
var JSXAttributeValue$2 = $S(OpenBrace, ExtendedExpression, __, CloseBrace);
|
|
5611
5796
|
var JSXAttributeValue$3 = JSXElement;
|
|
5612
5797
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -5638,7 +5823,7 @@ var Civet = (() => {
|
|
|
5638
5823
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
5639
5824
|
}
|
|
5640
5825
|
}
|
|
5641
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
5826
|
+
var JSXText$0 = $R$0($EXPECT($R40, fail, "JSXText /[^{}<>]+/"));
|
|
5642
5827
|
function JSXText(state) {
|
|
5643
5828
|
if (state.verbose)
|
|
5644
5829
|
console.log("ENTER:", "JSXText");
|
|
@@ -5670,7 +5855,7 @@ var Civet = (() => {
|
|
|
5670
5855
|
return TypeDeclaration$0(state);
|
|
5671
5856
|
}
|
|
5672
5857
|
}
|
|
5673
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
5858
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L143, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
5674
5859
|
var TypeDeclarationModifier$1 = Export;
|
|
5675
5860
|
function TypeDeclarationModifier(state) {
|
|
5676
5861
|
if (state.tokenize) {
|
|
@@ -5690,7 +5875,7 @@ var Civet = (() => {
|
|
|
5690
5875
|
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
5691
5876
|
}
|
|
5692
5877
|
}
|
|
5693
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
5878
|
+
var TypeKeyword$0 = $S($EXPECT($L144, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
5694
5879
|
function TypeKeyword(state) {
|
|
5695
5880
|
if (state.verbose)
|
|
5696
5881
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -5700,7 +5885,7 @@ var Civet = (() => {
|
|
|
5700
5885
|
return TypeKeyword$0(state);
|
|
5701
5886
|
}
|
|
5702
5887
|
}
|
|
5703
|
-
var Interface$0 = $S($EXPECT($
|
|
5888
|
+
var Interface$0 = $S($EXPECT($L145, fail, 'Interface "interface"'), NonIdContinue);
|
|
5704
5889
|
function Interface(state) {
|
|
5705
5890
|
if (state.verbose)
|
|
5706
5891
|
console.log("ENTER:", "Interface");
|
|
@@ -5710,7 +5895,7 @@ var Civet = (() => {
|
|
|
5710
5895
|
return Interface$0(state);
|
|
5711
5896
|
}
|
|
5712
5897
|
}
|
|
5713
|
-
var Namespace$0 = $S($EXPECT($
|
|
5898
|
+
var Namespace$0 = $S($EXPECT($L146, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
5714
5899
|
function Namespace(state) {
|
|
5715
5900
|
if (state.verbose)
|
|
5716
5901
|
console.log("ENTER:", "Namespace");
|
|
@@ -5810,7 +5995,7 @@ var Civet = (() => {
|
|
|
5810
5995
|
return NestedTypeDeclaration$0(state);
|
|
5811
5996
|
}
|
|
5812
5997
|
}
|
|
5813
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
5998
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R41, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L147, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R42, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
5814
5999
|
function TypeIndexSignature(state) {
|
|
5815
6000
|
if (state.verbose)
|
|
5816
6001
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -5841,7 +6026,7 @@ var Civet = (() => {
|
|
|
5841
6026
|
return TypeSuffix$0(state);
|
|
5842
6027
|
}
|
|
5843
6028
|
}
|
|
5844
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
6029
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L148, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5845
6030
|
if (!$3)
|
|
5846
6031
|
$0.splice(2, 1);
|
|
5847
6032
|
if ($1.length === 0)
|
|
@@ -5924,9 +6109,9 @@ var Civet = (() => {
|
|
|
5924
6109
|
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
5925
6110
|
}
|
|
5926
6111
|
}
|
|
5927
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
5928
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
5929
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
6112
|
+
var TypeUnaryOp$0 = $EXPECT($L149, fail, 'TypeUnaryOp "keyof"');
|
|
6113
|
+
var TypeUnaryOp$1 = $EXPECT($L131, fail, 'TypeUnaryOp "typeof"');
|
|
6114
|
+
var TypeUnaryOp$2 = $EXPECT($L150, fail, 'TypeUnaryOp "infer"');
|
|
5930
6115
|
function TypeUnaryOp(state) {
|
|
5931
6116
|
if (state.tokenize) {
|
|
5932
6117
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -6016,10 +6201,10 @@ var Civet = (() => {
|
|
|
6016
6201
|
}
|
|
6017
6202
|
}
|
|
6018
6203
|
var TypeLiteral$0 = Literal;
|
|
6019
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
6204
|
+
var TypeLiteral$1 = $TV($EXPECT($L135, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
6020
6205
|
return { $loc, token: "void" };
|
|
6021
6206
|
});
|
|
6022
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
6207
|
+
var TypeLiteral$2 = $TV($EXPECT($L151, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
6023
6208
|
return { $loc, token: "[]" };
|
|
6024
6209
|
});
|
|
6025
6210
|
function TypeLiteral(state) {
|
|
@@ -6109,7 +6294,7 @@ var Civet = (() => {
|
|
|
6109
6294
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
6110
6295
|
}
|
|
6111
6296
|
}
|
|
6112
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
6297
|
+
var Shebang$0 = $S($R$0($EXPECT($R43, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
6113
6298
|
function Shebang(state) {
|
|
6114
6299
|
if (state.verbose)
|
|
6115
6300
|
console.log("ENTER:", "Shebang");
|
|
@@ -6119,11 +6304,11 @@ var Civet = (() => {
|
|
|
6119
6304
|
return Shebang$0(state);
|
|
6120
6305
|
}
|
|
6121
6306
|
}
|
|
6122
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
6307
|
+
var CivetPrologue$0 = $T($S($EXPECT($R44, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
6123
6308
|
var content = value[2];
|
|
6124
6309
|
return content;
|
|
6125
6310
|
});
|
|
6126
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
6311
|
+
var CivetPrologue$1 = $T($S($EXPECT($R44, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
6127
6312
|
var content = value[2];
|
|
6128
6313
|
return content;
|
|
6129
6314
|
});
|
|
@@ -6134,7 +6319,7 @@ var Civet = (() => {
|
|
|
6134
6319
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
6135
6320
|
}
|
|
6136
6321
|
}
|
|
6137
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
6322
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L152, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R45, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
6138
6323
|
var options = $2;
|
|
6139
6324
|
return {
|
|
6140
6325
|
type: "CivetPrologue",
|
|
@@ -6151,7 +6336,7 @@ var Civet = (() => {
|
|
|
6151
6336
|
return CivetPrologueContent$0(state);
|
|
6152
6337
|
}
|
|
6153
6338
|
}
|
|
6154
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
6339
|
+
var CivetOption$0 = $TR($EXPECT($R46, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6155
6340
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
6156
6341
|
if (l)
|
|
6157
6342
|
return l.toUpperCase();
|
|
@@ -6169,7 +6354,7 @@ var Civet = (() => {
|
|
|
6169
6354
|
return CivetOption$0(state);
|
|
6170
6355
|
}
|
|
6171
6356
|
}
|
|
6172
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
6357
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R44, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
6173
6358
|
function UnknownPrologue(state) {
|
|
6174
6359
|
if (state.verbose)
|
|
6175
6360
|
console.log("ENTER:", "UnknownPrologue");
|
|
@@ -6198,7 +6383,7 @@ var Civet = (() => {
|
|
|
6198
6383
|
return EOS$0(state);
|
|
6199
6384
|
}
|
|
6200
6385
|
}
|
|
6201
|
-
var EOL$0 = $TR($EXPECT($
|
|
6386
|
+
var EOL$0 = $TR($EXPECT($R47, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6202
6387
|
return { $loc, token: $0 };
|
|
6203
6388
|
});
|
|
6204
6389
|
function EOL(state) {
|
|
@@ -6354,6 +6539,20 @@ var Civet = (() => {
|
|
|
6354
6539
|
return InsertBreak$0(state);
|
|
6355
6540
|
}
|
|
6356
6541
|
}
|
|
6542
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6543
|
+
if (module.config.coffeeBooleans)
|
|
6544
|
+
return;
|
|
6545
|
+
return $skip;
|
|
6546
|
+
});
|
|
6547
|
+
function CoffeeBooleansEnabled(state) {
|
|
6548
|
+
if (state.verbose)
|
|
6549
|
+
console.log("ENTER:", "CoffeeBooleansEnabled");
|
|
6550
|
+
if (state.tokenize) {
|
|
6551
|
+
return $TOKEN("CoffeeBooleansEnabled", state, CoffeeBooleansEnabled$0(state));
|
|
6552
|
+
} else {
|
|
6553
|
+
return CoffeeBooleansEnabled$0(state);
|
|
6554
|
+
}
|
|
6555
|
+
}
|
|
6357
6556
|
var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6358
6557
|
if (module.config.coffeeComment)
|
|
6359
6558
|
return;
|
|
@@ -6368,18 +6567,18 @@ var Civet = (() => {
|
|
|
6368
6567
|
return CoffeeCommentEnabled$0(state);
|
|
6369
6568
|
}
|
|
6370
6569
|
}
|
|
6371
|
-
var
|
|
6372
|
-
if (module.config.
|
|
6570
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6571
|
+
if (module.config.coffeeDo)
|
|
6373
6572
|
return;
|
|
6374
6573
|
return $skip;
|
|
6375
6574
|
});
|
|
6376
|
-
function
|
|
6575
|
+
function CoffeeDoEnabled(state) {
|
|
6377
6576
|
if (state.verbose)
|
|
6378
|
-
console.log("ENTER:", "
|
|
6577
|
+
console.log("ENTER:", "CoffeeDoEnabled");
|
|
6379
6578
|
if (state.tokenize) {
|
|
6380
|
-
return $TOKEN("
|
|
6579
|
+
return $TOKEN("CoffeeDoEnabled", state, CoffeeDoEnabled$0(state));
|
|
6381
6580
|
} else {
|
|
6382
|
-
return
|
|
6581
|
+
return CoffeeDoEnabled$0(state);
|
|
6383
6582
|
}
|
|
6384
6583
|
}
|
|
6385
6584
|
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
@@ -6460,6 +6659,7 @@ var Civet = (() => {
|
|
|
6460
6659
|
autoVar: false,
|
|
6461
6660
|
coffeeBooleans: false,
|
|
6462
6661
|
coffeeComment: false,
|
|
6662
|
+
coffeeDo: false,
|
|
6463
6663
|
coffeeEq: false,
|
|
6464
6664
|
coffeeForLoops: false,
|
|
6465
6665
|
coffeeInterpolation: false,
|
|
@@ -6512,6 +6712,7 @@ var Civet = (() => {
|
|
|
6512
6712
|
this.autoVar = true;
|
|
6513
6713
|
this.coffeeBooleans = true;
|
|
6514
6714
|
this.coffeeComment = true;
|
|
6715
|
+
this.coffeeDo = true;
|
|
6515
6716
|
this.coffeeEq = true;
|
|
6516
6717
|
this.coffeeForLoops = true;
|
|
6517
6718
|
this.coffeeInterpolation = true;
|
|
@@ -6522,6 +6723,7 @@ var Civet = (() => {
|
|
|
6522
6723
|
this.autoVar = false;
|
|
6523
6724
|
this.coffeeBooleans = false;
|
|
6524
6725
|
this.coffeeComment = false;
|
|
6726
|
+
this.coffeeDo = false;
|
|
6525
6727
|
this.coffeeEq = false;
|
|
6526
6728
|
this.coffeeForLoops = false;
|
|
6527
6729
|
this.coffeeInterpolation = false;
|
|
@@ -6564,6 +6766,10 @@ var Civet = (() => {
|
|
|
6564
6766
|
case "BlockStatement":
|
|
6565
6767
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
6566
6768
|
return;
|
|
6769
|
+
case "ObjectExpression":
|
|
6770
|
+
module.insertTrimmingSpace(node.children[0], "");
|
|
6771
|
+
node.children.unshift("return ");
|
|
6772
|
+
return;
|
|
6567
6773
|
case "CaseBlock":
|
|
6568
6774
|
node.clauses.forEach((clause) => {
|
|
6569
6775
|
insertReturn(clause);
|
|
@@ -6632,6 +6838,25 @@ var Civet = (() => {
|
|
|
6632
6838
|
if (Array.isArray(node))
|
|
6633
6839
|
return node.every(module.isWhitespaceOrEmpty);
|
|
6634
6840
|
};
|
|
6841
|
+
module.processBinaryOpExpression = function($02) {
|
|
6842
|
+
const expandedOps = module.expandChainedComparisons($02);
|
|
6843
|
+
let i = 2;
|
|
6844
|
+
while (i < expandedOps.length) {
|
|
6845
|
+
const op = expandedOps[i];
|
|
6846
|
+
if (op.type === "Ref") {
|
|
6847
|
+
const [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
|
|
6848
|
+
module.insertTrimmingSpace(wsOp, "");
|
|
6849
|
+
module.insertTrimmingSpace(wsB, "");
|
|
6850
|
+
expandedOps.splice(i - 2, 5, {
|
|
6851
|
+
type: "Call",
|
|
6852
|
+
children: [wsOp, op2, ".call(", wsB, b, ", ", a, ") >= 0"]
|
|
6853
|
+
});
|
|
6854
|
+
} else {
|
|
6855
|
+
i += 4;
|
|
6856
|
+
}
|
|
6857
|
+
}
|
|
6858
|
+
return expandedOps;
|
|
6859
|
+
};
|
|
6635
6860
|
module.expandChainedComparisons = function([first, binops]) {
|
|
6636
6861
|
const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
|
|
6637
6862
|
const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
|
|
@@ -6907,7 +7132,7 @@ var Civet = (() => {
|
|
|
6907
7132
|
return Init$0(state);
|
|
6908
7133
|
}
|
|
6909
7134
|
}
|
|
6910
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
7135
|
+
var Indent$0 = $TV($Q($C($EXPECT($L153, fail, 'Indent " "'), $EXPECT($L154, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
6911
7136
|
const level = $1.length;
|
|
6912
7137
|
return {
|
|
6913
7138
|
$loc,
|
|
@@ -7039,6 +7264,7 @@ var Civet = (() => {
|
|
|
7039
7264
|
// source/generate.coffee
|
|
7040
7265
|
var require_generate = __commonJS({
|
|
7041
7266
|
"source/generate.coffee"(exports, module) {
|
|
7267
|
+
"civet coffeeCompat";
|
|
7042
7268
|
var gen;
|
|
7043
7269
|
var prune;
|
|
7044
7270
|
gen = function(node, options) {
|
|
@@ -7116,6 +7342,7 @@ var Civet = (() => {
|
|
|
7116
7342
|
var require_util = __commonJS({
|
|
7117
7343
|
"source/util.coffee"(exports, module) {
|
|
7118
7344
|
"use strict";
|
|
7345
|
+
"civet coffeeCompat";
|
|
7119
7346
|
var BASE64_CHARS;
|
|
7120
7347
|
var SourceMap;
|
|
7121
7348
|
var VLQ_CONTINUATION_BIT;
|
|
@@ -7440,6 +7667,7 @@ var Civet = (() => {
|
|
|
7440
7667
|
// source/main.coffee
|
|
7441
7668
|
var require_main = __commonJS({
|
|
7442
7669
|
"source/main.coffee"(exports, module) {
|
|
7670
|
+
"civet coffeeCompat";
|
|
7443
7671
|
var SourceMap;
|
|
7444
7672
|
var base64Encode;
|
|
7445
7673
|
var defaultOptions;
|