@danielx/civet 0.4.19-pre.11 → 0.4.19-pre.12
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 +12 -2
- package/dist/browser.js +650 -375
- package/dist/esbuild-plugin.js +2 -2
- package/dist/esm.mjs +1 -1
- package/dist/main.js +650 -375
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -399,15 +399,14 @@ ${input.slice(result.pos)}
|
|
|
399
399
|
ExpressionizedStatement,
|
|
400
400
|
Expression,
|
|
401
401
|
Arguments,
|
|
402
|
+
ApplicationStart,
|
|
402
403
|
ArgumentsWithTrailingCallExpressions,
|
|
403
404
|
ArgumentList,
|
|
404
405
|
NestedArgumentList,
|
|
405
406
|
NestedArgument,
|
|
406
407
|
InlineArgumentExpressions,
|
|
408
|
+
SingleLineArgumentExpressions,
|
|
407
409
|
ArgumentPart,
|
|
408
|
-
ImplicitApplication,
|
|
409
|
-
ApplicationStart,
|
|
410
|
-
IndentedApplicationAllowed,
|
|
411
410
|
BinaryOpExpression,
|
|
412
411
|
BinaryOpRHS,
|
|
413
412
|
ParenthesizedAssignment,
|
|
@@ -449,6 +448,7 @@ ${input.slice(result.pos)}
|
|
|
449
448
|
MemberExpression,
|
|
450
449
|
MemberExpressionRest,
|
|
451
450
|
MemberBracketContent,
|
|
451
|
+
SliceParameters,
|
|
452
452
|
PropertyAccess,
|
|
453
453
|
SuperProperty,
|
|
454
454
|
MetaProperty,
|
|
@@ -509,7 +509,9 @@ ${input.slice(result.pos)}
|
|
|
509
509
|
ObjectLiteral,
|
|
510
510
|
BracedObjectLiteral,
|
|
511
511
|
BracedObjectLiteralContent,
|
|
512
|
-
|
|
512
|
+
NestedImplicitObjectLiteral,
|
|
513
|
+
NestedImplicitPropertyDefinitions,
|
|
514
|
+
NestedImplicitPropertyDefinition,
|
|
513
515
|
NestedPropertyDefinitions,
|
|
514
516
|
NestedPropertyDefinition,
|
|
515
517
|
InlineObjectLiteral,
|
|
@@ -580,8 +582,6 @@ ${input.slice(result.pos)}
|
|
|
580
582
|
Finally,
|
|
581
583
|
CatchParameter,
|
|
582
584
|
Condition,
|
|
583
|
-
ExpressionWithIndentedApplicationSuppressed,
|
|
584
|
-
SuppressIndentedApplication,
|
|
585
585
|
ExpressionStatement,
|
|
586
586
|
KeywordStatement,
|
|
587
587
|
DebuggerExpression,
|
|
@@ -630,6 +630,12 @@ ${input.slice(result.pos)}
|
|
|
630
630
|
CoffeeInterpolatedDoubleQuotedString,
|
|
631
631
|
CoffeeDoubleQuotedStringCharacters,
|
|
632
632
|
RegularExpressionLiteral,
|
|
633
|
+
RegularExpressionClass,
|
|
634
|
+
RegularExpressionClassCharacters,
|
|
635
|
+
HeregexLiteral,
|
|
636
|
+
HeregexBody,
|
|
637
|
+
HeregexPart,
|
|
638
|
+
HeregexComment,
|
|
633
639
|
RegularExpressionBody,
|
|
634
640
|
RegExpCharacter,
|
|
635
641
|
RegularExpressionFlags,
|
|
@@ -640,6 +646,7 @@ ${input.slice(result.pos)}
|
|
|
640
646
|
ReservedWord,
|
|
641
647
|
Comment,
|
|
642
648
|
SingleLineComment,
|
|
649
|
+
JSSingleLineComment,
|
|
643
650
|
MultiLineComment,
|
|
644
651
|
JSMultiLineComment,
|
|
645
652
|
CoffeeSingleLineComment,
|
|
@@ -710,6 +717,7 @@ ${input.slice(result.pos)}
|
|
|
710
717
|
Throw,
|
|
711
718
|
TripleDoubleQuote,
|
|
712
719
|
TripleSingleQuote,
|
|
720
|
+
TripleSlash,
|
|
713
721
|
TripleTick,
|
|
714
722
|
Try,
|
|
715
723
|
Typeof,
|
|
@@ -816,31 +824,31 @@ ${input.slice(result.pos)}
|
|
|
816
824
|
PopIndent,
|
|
817
825
|
Nested
|
|
818
826
|
});
|
|
819
|
-
var $L0 = $L("
|
|
820
|
-
var $L1 = $L("");
|
|
821
|
-
var $L2 = $L("
|
|
822
|
-
var $L3 = $L("
|
|
823
|
-
var $L4 = $L("
|
|
824
|
-
var $L5 = $L("
|
|
825
|
-
var $L6 = $L("
|
|
826
|
-
var $L7 = $L("
|
|
827
|
-
var $L8 = $L("
|
|
828
|
-
var $L9 = $L("
|
|
829
|
-
var $L10 = $L("
|
|
830
|
-
var $L11 = $L("
|
|
831
|
-
var $L12 = $L("
|
|
832
|
-
var $L13 = $L("
|
|
833
|
-
var $L14 = $L("
|
|
834
|
-
var $L15 = $L("
|
|
835
|
-
var $L16 = $L("
|
|
836
|
-
var $L17 = $L("
|
|
837
|
-
var $L18 = $L("
|
|
838
|
-
var $L19 = $L("
|
|
839
|
-
var $L20 = $L("
|
|
840
|
-
var $L21 = $L("
|
|
841
|
-
var $L22 = $L("
|
|
842
|
-
var $L23 = $L("
|
|
843
|
-
var $L24 = $L("
|
|
827
|
+
var $L0 = $L("++");
|
|
828
|
+
var $L1 = $L("--");
|
|
829
|
+
var $L2 = $L("=>");
|
|
830
|
+
var $L3 = $L(" ");
|
|
831
|
+
var $L4 = $L("<");
|
|
832
|
+
var $L5 = $L("extends");
|
|
833
|
+
var $L6 = $L("this");
|
|
834
|
+
var $L7 = $L("#");
|
|
835
|
+
var $L8 = $L(".");
|
|
836
|
+
var $L9 = $L("super");
|
|
837
|
+
var $L10 = $L("import");
|
|
838
|
+
var $L11 = $L("!");
|
|
839
|
+
var $L12 = $L("super[");
|
|
840
|
+
var $L13 = $L("import.meta");
|
|
841
|
+
var $L14 = $L("");
|
|
842
|
+
var $L15 = $L(")");
|
|
843
|
+
var $L16 = $L("->");
|
|
844
|
+
var $L17 = $L("null");
|
|
845
|
+
var $L18 = $L("true");
|
|
846
|
+
var $L19 = $L("false");
|
|
847
|
+
var $L20 = $L("yes");
|
|
848
|
+
var $L21 = $L("on");
|
|
849
|
+
var $L22 = $L("no");
|
|
850
|
+
var $L23 = $L("off");
|
|
851
|
+
var $L24 = $L(",");
|
|
844
852
|
var $L25 = $L("]");
|
|
845
853
|
var $L26 = $L("}");
|
|
846
854
|
var $L27 = $L("**=");
|
|
@@ -946,32 +954,33 @@ ${input.slice(result.pos)}
|
|
|
946
954
|
var $L127 = $L("throw");
|
|
947
955
|
var $L128 = $L('"""');
|
|
948
956
|
var $L129 = $L("'''");
|
|
949
|
-
var $L130 = $L("
|
|
950
|
-
var $L131 = $L("
|
|
951
|
-
var $L132 = $L("
|
|
952
|
-
var $L133 = $L("
|
|
953
|
-
var $L134 = $L("
|
|
954
|
-
var $L135 = $L("
|
|
955
|
-
var $L136 = $L("
|
|
956
|
-
var $L137 = $L("
|
|
957
|
-
var $L138 = $L("
|
|
958
|
-
var $L139 = $L("
|
|
959
|
-
var $L140 = $L("
|
|
960
|
-
var $L141 = $L("
|
|
961
|
-
var $L142 = $L("
|
|
962
|
-
var $L143 = $L("
|
|
963
|
-
var $L144 = $L("
|
|
964
|
-
var $L145 = $L("
|
|
965
|
-
var $L146 = $L("
|
|
966
|
-
var $L147 = $L("
|
|
967
|
-
var $L148 = $L("
|
|
968
|
-
var $L149 = $L("
|
|
969
|
-
var $L150 = $L("
|
|
970
|
-
var $L151 = $L("
|
|
971
|
-
var $L152 = $L("
|
|
972
|
-
var $L153 = $L("
|
|
973
|
-
var $L154 = $L("
|
|
974
|
-
var $L155 = $L("
|
|
957
|
+
var $L130 = $L("///");
|
|
958
|
+
var $L131 = $L("```");
|
|
959
|
+
var $L132 = $L("try");
|
|
960
|
+
var $L133 = $L("typeof");
|
|
961
|
+
var $L134 = $L("unless");
|
|
962
|
+
var $L135 = $L("until");
|
|
963
|
+
var $L136 = $L("var");
|
|
964
|
+
var $L137 = $L("void");
|
|
965
|
+
var $L138 = $L("when");
|
|
966
|
+
var $L139 = $L("while");
|
|
967
|
+
var $L140 = $L("yield");
|
|
968
|
+
var $L141 = $L("/>");
|
|
969
|
+
var $L142 = $L("</");
|
|
970
|
+
var $L143 = $L("<>");
|
|
971
|
+
var $L144 = $L("</>");
|
|
972
|
+
var $L145 = $L("declare");
|
|
973
|
+
var $L146 = $L("type");
|
|
974
|
+
var $L147 = $L("interface");
|
|
975
|
+
var $L148 = $L("namespace");
|
|
976
|
+
var $L149 = $L("readonly");
|
|
977
|
+
var $L150 = $L("asserts");
|
|
978
|
+
var $L151 = $L("keyof");
|
|
979
|
+
var $L152 = $L("infer");
|
|
980
|
+
var $L153 = $L("[]");
|
|
981
|
+
var $L154 = $L("civet");
|
|
982
|
+
var $L155 = $L(" ");
|
|
983
|
+
var $L156 = $L(" ");
|
|
975
984
|
var $R0 = $R(new RegExp("(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
976
985
|
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
977
986
|
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
@@ -992,34 +1001,38 @@ ${input.slice(result.pos)}
|
|
|
992
1001
|
var $R17 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
993
1002
|
var $R18 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
994
1003
|
var $R19 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
995
|
-
var $R20 = $R(new RegExp("[
|
|
996
|
-
var $R21 = $R(new RegExp("(
|
|
997
|
-
var $R22 = $R(new RegExp("
|
|
998
|
-
var $R23 = $R(new RegExp("(
|
|
999
|
-
var $R24 = $R(new RegExp("
|
|
1000
|
-
var $R25 = $R(new RegExp("
|
|
1001
|
-
var $R26 = $R(new RegExp("(
|
|
1002
|
-
var $R27 = $R(new RegExp("(
|
|
1003
|
-
var $R28 = $R(new RegExp("(
|
|
1004
|
-
var $R29 = $R(new RegExp("
|
|
1005
|
-
var $R30 = $R(new RegExp("
|
|
1006
|
-
var $R31 = $R(new RegExp("
|
|
1007
|
-
var $R32 = $R(new RegExp("
|
|
1008
|
-
var $R33 = $R(new RegExp("
|
|
1009
|
-
var $R34 = $R(new RegExp("[\\
|
|
1010
|
-
var $R35 = $R(new RegExp("
|
|
1011
|
-
var $R36 = $R(new RegExp("\\
|
|
1012
|
-
var $R37 = $R(new RegExp("
|
|
1013
|
-
var $R38 = $R(new RegExp(
|
|
1014
|
-
var $R39 = $R(new RegExp("
|
|
1015
|
-
var $R40 = $R(new RegExp("
|
|
1016
|
-
var $R41 = $R(new RegExp("[
|
|
1017
|
-
var $R42 = $R(new RegExp("[
|
|
1018
|
-
var $R43 = $R(new RegExp("
|
|
1019
|
-
var $R44 = $R(new RegExp("[
|
|
1020
|
-
var $R45 = $R(new RegExp("[
|
|
1021
|
-
var $R46 = $R(new RegExp("
|
|
1022
|
-
var $R47 = $R(new RegExp("
|
|
1004
|
+
var $R20 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
1005
|
+
var $R21 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
1006
|
+
var $R22 = $R(new RegExp("[\\s]+", "suy"));
|
|
1007
|
+
var $R23 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
1008
|
+
var $R24 = $R(new RegExp("[^\\/\\s#\\\\]+", "suy"));
|
|
1009
|
+
var $R25 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
1010
|
+
var $R26 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
1011
|
+
var $R27 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1012
|
+
var $R28 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
1013
|
+
var $R29 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
1014
|
+
var $R30 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1015
|
+
var $R31 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1016
|
+
var $R32 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1017
|
+
var $R33 = $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"));
|
|
1018
|
+
var $R34 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1019
|
+
var $R35 = $R(new RegExp(".", "suy"));
|
|
1020
|
+
var $R36 = $R(new RegExp("#(?!##)([^\\r\\n]*)", "suy"));
|
|
1021
|
+
var $R37 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
1022
|
+
var $R38 = $R(new RegExp("[ \\t]+", "suy"));
|
|
1023
|
+
var $R39 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
1024
|
+
var $R40 = $R(new RegExp("\\s", "suy"));
|
|
1025
|
+
var $R41 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1026
|
+
var $R42 = $R(new RegExp('"[^"]*"', "suy"));
|
|
1027
|
+
var $R43 = $R(new RegExp("'[^']*'", "suy"));
|
|
1028
|
+
var $R44 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
1029
|
+
var $R45 = $R(new RegExp("[+-]?", "suy"));
|
|
1030
|
+
var $R46 = $R(new RegExp("[+-]", "suy"));
|
|
1031
|
+
var $R47 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1032
|
+
var $R48 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1033
|
+
var $R49 = $R(new RegExp("[\\s]*", "suy"));
|
|
1034
|
+
var $R50 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
|
|
1035
|
+
var $R51 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1023
1036
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1024
1037
|
var statements = $4;
|
|
1025
1038
|
module2.processProgram(statements);
|
|
@@ -1134,7 +1147,13 @@ ${input.slice(result.pos)}
|
|
|
1134
1147
|
}
|
|
1135
1148
|
}
|
|
1136
1149
|
var Arguments$0 = $S(OpenParen, $E(ArgumentList), $E($S(__, Comma)), __, CloseParen);
|
|
1137
|
-
var Arguments$1 =
|
|
1150
|
+
var Arguments$1 = $TS($S(ApplicationStart, InsertOpenParen, $Q(_), ArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1151
|
+
var open = $2;
|
|
1152
|
+
var ws = $3;
|
|
1153
|
+
var args = $4;
|
|
1154
|
+
var close = $5;
|
|
1155
|
+
return [open, module2.insertTrimmingSpace(ws, ""), args, close];
|
|
1156
|
+
});
|
|
1138
1157
|
function Arguments(state) {
|
|
1139
1158
|
if (state.events) {
|
|
1140
1159
|
const result = state.events.enter?.("Arguments", state);
|
|
@@ -1153,6 +1172,26 @@ ${input.slice(result.pos)}
|
|
|
1153
1172
|
return result;
|
|
1154
1173
|
}
|
|
1155
1174
|
}
|
|
1175
|
+
var ApplicationStart$0 = $Y(NestedImplicitObjectLiteral);
|
|
1176
|
+
var ApplicationStart$1 = $S($N(EOS), $Y($S($P(_), $N(AdditionalReservedWords))));
|
|
1177
|
+
function ApplicationStart(state) {
|
|
1178
|
+
if (state.events) {
|
|
1179
|
+
const result = state.events.enter?.("ApplicationStart", state);
|
|
1180
|
+
if (result)
|
|
1181
|
+
return result.cache;
|
|
1182
|
+
}
|
|
1183
|
+
if (state.tokenize) {
|
|
1184
|
+
const result = $TOKEN("ApplicationStart", state, ApplicationStart$0(state) || ApplicationStart$1(state));
|
|
1185
|
+
if (state.events)
|
|
1186
|
+
state.events.exit?.("ApplicationStart", state, result);
|
|
1187
|
+
return result;
|
|
1188
|
+
} else {
|
|
1189
|
+
const result = ApplicationStart$0(state) || ApplicationStart$1(state);
|
|
1190
|
+
if (state.events)
|
|
1191
|
+
state.events.exit?.("ApplicationStart", state, result);
|
|
1192
|
+
return result;
|
|
1193
|
+
}
|
|
1194
|
+
}
|
|
1156
1195
|
var ArgumentsWithTrailingCallExpressions$0 = $S(Arguments, $Q($S(Samedent, $N(Backtick), CallExpressionRest)));
|
|
1157
1196
|
function ArgumentsWithTrailingCallExpressions(state) {
|
|
1158
1197
|
if (state.events) {
|
|
@@ -1172,8 +1211,9 @@ ${input.slice(result.pos)}
|
|
|
1172
1211
|
return result;
|
|
1173
1212
|
}
|
|
1174
1213
|
}
|
|
1175
|
-
var ArgumentList$0 = NestedArgumentList;
|
|
1176
|
-
var ArgumentList$1 =
|
|
1214
|
+
var ArgumentList$0 = $S(ArgumentPart, $P($S(__, Comma, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
|
|
1215
|
+
var ArgumentList$1 = NestedArgumentList;
|
|
1216
|
+
var ArgumentList$2 = InlineArgumentExpressions;
|
|
1177
1217
|
function ArgumentList(state) {
|
|
1178
1218
|
if (state.events) {
|
|
1179
1219
|
const result = state.events.enter?.("ArgumentList", state);
|
|
@@ -1181,12 +1221,12 @@ ${input.slice(result.pos)}
|
|
|
1181
1221
|
return result.cache;
|
|
1182
1222
|
}
|
|
1183
1223
|
if (state.tokenize) {
|
|
1184
|
-
const result = $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
|
|
1224
|
+
const result = $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state) || ArgumentList$2(state));
|
|
1185
1225
|
if (state.events)
|
|
1186
1226
|
state.events.exit?.("ArgumentList", state, result);
|
|
1187
1227
|
return result;
|
|
1188
1228
|
} else {
|
|
1189
|
-
const result = ArgumentList$0(state) || ArgumentList$1(state);
|
|
1229
|
+
const result = ArgumentList$0(state) || ArgumentList$1(state) || ArgumentList$2(state);
|
|
1190
1230
|
if (state.events)
|
|
1191
1231
|
state.events.exit?.("ArgumentList", state, result);
|
|
1192
1232
|
return result;
|
|
@@ -1216,7 +1256,7 @@ ${input.slice(result.pos)}
|
|
|
1216
1256
|
return result;
|
|
1217
1257
|
}
|
|
1218
1258
|
}
|
|
1219
|
-
var NestedArgument$0 = $S(Nested,
|
|
1259
|
+
var NestedArgument$0 = $S(Nested, SingleLineArgumentExpressions, ParameterElementDelimiter);
|
|
1220
1260
|
function NestedArgument(state) {
|
|
1221
1261
|
if (state.events) {
|
|
1222
1262
|
const result = state.events.enter?.("NestedArgument", state);
|
|
@@ -1235,10 +1275,8 @@ ${input.slice(result.pos)}
|
|
|
1235
1275
|
return result;
|
|
1236
1276
|
}
|
|
1237
1277
|
}
|
|
1238
|
-
var InlineArgumentExpressions$0 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(__, Comma, $Q(TrailingComment),
|
|
1239
|
-
|
|
1240
|
-
return $1;
|
|
1241
|
-
return $0;
|
|
1278
|
+
var InlineArgumentExpressions$0 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(__, Comma, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
|
|
1279
|
+
return [...$1, $2, ...$3];
|
|
1242
1280
|
});
|
|
1243
1281
|
function InlineArgumentExpressions(state) {
|
|
1244
1282
|
if (state.events) {
|
|
@@ -1258,93 +1296,47 @@ ${input.slice(result.pos)}
|
|
|
1258
1296
|
return result;
|
|
1259
1297
|
}
|
|
1260
1298
|
}
|
|
1261
|
-
var
|
|
1262
|
-
|
|
1263
|
-
if ($2) {
|
|
1264
|
-
return [$2, $1];
|
|
1265
|
-
}
|
|
1266
|
-
return $1;
|
|
1267
|
-
});
|
|
1268
|
-
function ArgumentPart(state) {
|
|
1299
|
+
var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
|
|
1300
|
+
function SingleLineArgumentExpressions(state) {
|
|
1269
1301
|
if (state.events) {
|
|
1270
|
-
const result = state.events.enter?.("
|
|
1302
|
+
const result = state.events.enter?.("SingleLineArgumentExpressions", state);
|
|
1271
1303
|
if (result)
|
|
1272
1304
|
return result.cache;
|
|
1273
1305
|
}
|
|
1274
1306
|
if (state.tokenize) {
|
|
1275
|
-
const result = $TOKEN("
|
|
1307
|
+
const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
|
|
1276
1308
|
if (state.events)
|
|
1277
|
-
state.events.exit?.("
|
|
1309
|
+
state.events.exit?.("SingleLineArgumentExpressions", state, result);
|
|
1278
1310
|
return result;
|
|
1279
1311
|
} else {
|
|
1280
|
-
const result =
|
|
1312
|
+
const result = SingleLineArgumentExpressions$0(state);
|
|
1281
1313
|
if (state.events)
|
|
1282
|
-
state.events.exit?.("
|
|
1314
|
+
state.events.exit?.("SingleLineArgumentExpressions", state, result);
|
|
1283
1315
|
return result;
|
|
1284
1316
|
}
|
|
1285
1317
|
}
|
|
1286
|
-
var
|
|
1287
|
-
var
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
const result = state.events.enter?.("ImplicitApplication", state);
|
|
1291
|
-
if (result)
|
|
1292
|
-
return result.cache;
|
|
1293
|
-
}
|
|
1294
|
-
if (state.tokenize) {
|
|
1295
|
-
const result = $TOKEN("ImplicitApplication", state, ImplicitApplication$0(state) || ImplicitApplication$1(state));
|
|
1296
|
-
if (state.events)
|
|
1297
|
-
state.events.exit?.("ImplicitApplication", state, result);
|
|
1298
|
-
return result;
|
|
1299
|
-
} else {
|
|
1300
|
-
const result = ImplicitApplication$0(state) || ImplicitApplication$1(state);
|
|
1301
|
-
if (state.events)
|
|
1302
|
-
state.events.exit?.("ImplicitApplication", state, result);
|
|
1303
|
-
return result;
|
|
1304
|
-
}
|
|
1305
|
-
}
|
|
1306
|
-
var ApplicationStart$0 = $TS($S($N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1307
|
-
var spacing = $2;
|
|
1308
|
-
return module2.insertTrimmingSpace(spacing, "(");
|
|
1309
|
-
});
|
|
1310
|
-
function ApplicationStart(state) {
|
|
1311
|
-
if (state.events) {
|
|
1312
|
-
const result = state.events.enter?.("ApplicationStart", state);
|
|
1313
|
-
if (result)
|
|
1314
|
-
return result.cache;
|
|
1315
|
-
}
|
|
1316
|
-
if (state.tokenize) {
|
|
1317
|
-
const result = $TOKEN("ApplicationStart", state, ApplicationStart$0(state));
|
|
1318
|
-
if (state.events)
|
|
1319
|
-
state.events.exit?.("ApplicationStart", state, result);
|
|
1320
|
-
return result;
|
|
1321
|
-
} else {
|
|
1322
|
-
const result = ApplicationStart$0(state);
|
|
1323
|
-
if (state.events)
|
|
1324
|
-
state.events.exit?.("ApplicationStart", state, result);
|
|
1325
|
-
return result;
|
|
1318
|
+
var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
|
|
1319
|
+
var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
|
|
1320
|
+
if ($2) {
|
|
1321
|
+
return [$2, $1];
|
|
1326
1322
|
}
|
|
1327
|
-
|
|
1328
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($L1, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
1329
|
-
if (module2.suppressIndentedApplication)
|
|
1330
|
-
return $skip;
|
|
1331
|
-
return;
|
|
1323
|
+
return $1;
|
|
1332
1324
|
});
|
|
1333
|
-
function
|
|
1325
|
+
function ArgumentPart(state) {
|
|
1334
1326
|
if (state.events) {
|
|
1335
|
-
const result = state.events.enter?.("
|
|
1327
|
+
const result = state.events.enter?.("ArgumentPart", state);
|
|
1336
1328
|
if (result)
|
|
1337
1329
|
return result.cache;
|
|
1338
1330
|
}
|
|
1339
1331
|
if (state.tokenize) {
|
|
1340
|
-
const result = $TOKEN("
|
|
1332
|
+
const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
|
|
1341
1333
|
if (state.events)
|
|
1342
|
-
state.events.exit?.("
|
|
1334
|
+
state.events.exit?.("ArgumentPart", state, result);
|
|
1343
1335
|
return result;
|
|
1344
1336
|
} else {
|
|
1345
|
-
const result =
|
|
1337
|
+
const result = ArgumentPart$0(state) || ArgumentPart$1(state);
|
|
1346
1338
|
if (state.events)
|
|
1347
|
-
state.events.exit?.("
|
|
1339
|
+
state.events.exit?.("ArgumentPart", state, result);
|
|
1348
1340
|
return result;
|
|
1349
1341
|
}
|
|
1350
1342
|
}
|
|
@@ -1531,7 +1523,7 @@ ${input.slice(result.pos)}
|
|
|
1531
1523
|
return result;
|
|
1532
1524
|
}
|
|
1533
1525
|
}
|
|
1534
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
1526
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L0, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L1, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
1535
1527
|
return { $loc, token: $1 };
|
|
1536
1528
|
});
|
|
1537
1529
|
function UpdateExpressionSymbol(state) {
|
|
@@ -1773,7 +1765,7 @@ ${input.slice(result.pos)}
|
|
|
1773
1765
|
return result;
|
|
1774
1766
|
}
|
|
1775
1767
|
}
|
|
1776
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1768
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L2, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1777
1769
|
var ws = $1;
|
|
1778
1770
|
if (!ws.length)
|
|
1779
1771
|
return " =>";
|
|
@@ -1844,7 +1836,7 @@ ${input.slice(result.pos)}
|
|
|
1844
1836
|
}
|
|
1845
1837
|
}
|
|
1846
1838
|
var TernaryRest$0 = NestedTernaryRest;
|
|
1847
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
1839
|
+
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($L3, fail, 'TernaryRest " "')), $Q(TrailingComment), QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
1848
1840
|
return $0.slice(2);
|
|
1849
1841
|
});
|
|
1850
1842
|
function TernaryRest(state) {
|
|
@@ -2037,10 +2029,10 @@ ${input.slice(result.pos)}
|
|
|
2037
2029
|
return result;
|
|
2038
2030
|
}
|
|
2039
2031
|
}
|
|
2040
|
-
var ExtendsToken$0 = $TV($EXPECT($
|
|
2032
|
+
var ExtendsToken$0 = $TV($EXPECT($L4, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
2041
2033
|
return { $loc, token: "extends" };
|
|
2042
2034
|
});
|
|
2043
|
-
var ExtendsToken$1 = $TV($EXPECT($
|
|
2035
|
+
var ExtendsToken$1 = $TV($EXPECT($L5, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
2044
2036
|
return { $loc, token: $1 };
|
|
2045
2037
|
});
|
|
2046
2038
|
function ExtendsToken(state) {
|
|
@@ -2185,10 +2177,10 @@ ${input.slice(result.pos)}
|
|
|
2185
2177
|
return result;
|
|
2186
2178
|
}
|
|
2187
2179
|
}
|
|
2188
|
-
var This$0 = $TV($EXPECT($
|
|
2180
|
+
var This$0 = $TV($EXPECT($L6, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
2189
2181
|
return { $loc, token: $1 };
|
|
2190
2182
|
});
|
|
2191
|
-
var This$1 = $TS($S(At, $S($E($EXPECT($
|
|
2183
|
+
var This$1 = $TS($S(At, $S($E($EXPECT($L7, fail, 'This "#"')), IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
2192
2184
|
$1.token = "this.";
|
|
2193
2185
|
return $0;
|
|
2194
2186
|
});
|
|
@@ -2214,7 +2206,7 @@ ${input.slice(result.pos)}
|
|
|
2214
2206
|
return result;
|
|
2215
2207
|
}
|
|
2216
2208
|
}
|
|
2217
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($
|
|
2209
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L8, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
2218
2210
|
if ($1.length)
|
|
2219
2211
|
return $0;
|
|
2220
2212
|
return $2;
|
|
@@ -2237,8 +2229,8 @@ ${input.slice(result.pos)}
|
|
|
2237
2229
|
return result;
|
|
2238
2230
|
}
|
|
2239
2231
|
}
|
|
2240
|
-
var CallExpression$0 = $S($EXPECT($
|
|
2241
|
-
var CallExpression$1 = $S($EXPECT($
|
|
2232
|
+
var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
2233
|
+
var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
|
|
2242
2234
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
2243
2235
|
if ($2.length)
|
|
2244
2236
|
return $0;
|
|
@@ -2302,7 +2294,7 @@ ${input.slice(result.pos)}
|
|
|
2302
2294
|
return result;
|
|
2303
2295
|
}
|
|
2304
2296
|
}
|
|
2305
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
2297
|
+
var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
|
|
2306
2298
|
return { "ts": true, "children": value };
|
|
2307
2299
|
});
|
|
2308
2300
|
function NonNullAssertion(state) {
|
|
@@ -2402,36 +2394,22 @@ ${input.slice(result.pos)}
|
|
|
2402
2394
|
return result;
|
|
2403
2395
|
}
|
|
2404
2396
|
}
|
|
2405
|
-
var MemberBracketContent$0 = $TS($S(OpenBracket,
|
|
2406
|
-
|
|
2407
|
-
|
|
2408
|
-
|
|
2409
|
-
|
|
2410
|
-
|
|
2411
|
-
|
|
2412
|
-
$5.token = ")";
|
|
2413
|
-
if (!end) {
|
|
2414
|
-
return {
|
|
2415
|
-
type: "SliceExpression",
|
|
2416
|
-
start: $2,
|
|
2417
|
-
end: void 0,
|
|
2418
|
-
children: [$1, $2, $4, $5]
|
|
2419
|
-
};
|
|
2420
|
-
}
|
|
2421
|
-
if (inclusive) {
|
|
2422
|
-
end = module2.insertTrimmingSpace(end, "");
|
|
2423
|
-
return {
|
|
2424
|
-
type: "SliceExpression",
|
|
2425
|
-
start: $2,
|
|
2426
|
-
end: ["1 + ", end],
|
|
2427
|
-
children: [$1, $2, sep, ["1 + ", end, " || 1/0"], $4, $5]
|
|
2428
|
-
};
|
|
2429
|
-
}
|
|
2397
|
+
var MemberBracketContent$0 = $TS($S(OpenBracket, $C(SliceParameters, ExtendedExpression), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2398
|
+
var open = $1;
|
|
2399
|
+
var exp = $2;
|
|
2400
|
+
var ws = $3;
|
|
2401
|
+
var close = $4;
|
|
2402
|
+
if (exp.type === "SliceParameters") {
|
|
2403
|
+
const { start, end, children } = exp;
|
|
2430
2404
|
return {
|
|
2431
2405
|
type: "SliceExpression",
|
|
2432
|
-
start
|
|
2406
|
+
start,
|
|
2433
2407
|
end,
|
|
2434
|
-
children: [
|
|
2408
|
+
children: [
|
|
2409
|
+
{ ...open, token: ".slice(" },
|
|
2410
|
+
...children,
|
|
2411
|
+
[...ws, { ...close, token: ")" }]
|
|
2412
|
+
]
|
|
2435
2413
|
};
|
|
2436
2414
|
}
|
|
2437
2415
|
return $0;
|
|
@@ -2454,6 +2432,70 @@ ${input.slice(result.pos)}
|
|
|
2454
2432
|
return result;
|
|
2455
2433
|
}
|
|
2456
2434
|
}
|
|
2435
|
+
var SliceParameters$0 = $TS($S(ExtendedExpression, __, $C(DotDotDot, DotDot), $E(ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2436
|
+
var start = $1;
|
|
2437
|
+
var ws = $2;
|
|
2438
|
+
var sep = $3;
|
|
2439
|
+
var end = $4;
|
|
2440
|
+
const inclusive = sep.token === "..";
|
|
2441
|
+
let children;
|
|
2442
|
+
if (end) {
|
|
2443
|
+
const inc = [];
|
|
2444
|
+
if (inclusive) {
|
|
2445
|
+
end = ["1 + ", end];
|
|
2446
|
+
inc.push(" || 1/0");
|
|
2447
|
+
}
|
|
2448
|
+
children = [start, [...ws, { ...sep, token: ", " }], [end, ...inc]];
|
|
2449
|
+
} else {
|
|
2450
|
+
children = [start, ws];
|
|
2451
|
+
}
|
|
2452
|
+
return {
|
|
2453
|
+
type: "SliceParameters",
|
|
2454
|
+
start,
|
|
2455
|
+
end,
|
|
2456
|
+
children
|
|
2457
|
+
};
|
|
2458
|
+
});
|
|
2459
|
+
var SliceParameters$1 = $TS($S(Loc, __, $C(DotDotDot, DotDot), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2460
|
+
var l = $1;
|
|
2461
|
+
var ws = $2;
|
|
2462
|
+
var sep = $3;
|
|
2463
|
+
var end = $4;
|
|
2464
|
+
const inclusive = sep.token === "..";
|
|
2465
|
+
const inc = [];
|
|
2466
|
+
if (inclusive) {
|
|
2467
|
+
end = ["1 + ", end];
|
|
2468
|
+
inc.push(" || 1/0");
|
|
2469
|
+
}
|
|
2470
|
+
const start = {
|
|
2471
|
+
$loc: l.$loc,
|
|
2472
|
+
token: "0"
|
|
2473
|
+
};
|
|
2474
|
+
return {
|
|
2475
|
+
type: "SliceParameters",
|
|
2476
|
+
start,
|
|
2477
|
+
end,
|
|
2478
|
+
children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
|
|
2479
|
+
};
|
|
2480
|
+
});
|
|
2481
|
+
function SliceParameters(state) {
|
|
2482
|
+
if (state.events) {
|
|
2483
|
+
const result = state.events.enter?.("SliceParameters", state);
|
|
2484
|
+
if (result)
|
|
2485
|
+
return result.cache;
|
|
2486
|
+
}
|
|
2487
|
+
if (state.tokenize) {
|
|
2488
|
+
const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
|
|
2489
|
+
if (state.events)
|
|
2490
|
+
state.events.exit?.("SliceParameters", state, result);
|
|
2491
|
+
return result;
|
|
2492
|
+
} else {
|
|
2493
|
+
const result = SliceParameters$0(state) || SliceParameters$1(state);
|
|
2494
|
+
if (state.events)
|
|
2495
|
+
state.events.exit?.("SliceParameters", state, result);
|
|
2496
|
+
return result;
|
|
2497
|
+
}
|
|
2498
|
+
}
|
|
2457
2499
|
var PropertyAccess$0 = $TS($S($E($C(QuestionMark, NonNullAssertion)), Dot, $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2458
2500
|
var id = $3;
|
|
2459
2501
|
const children = [$2, ...id.children];
|
|
@@ -2492,7 +2534,7 @@ ${input.slice(result.pos)}
|
|
|
2492
2534
|
return result;
|
|
2493
2535
|
}
|
|
2494
2536
|
}
|
|
2495
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
2537
|
+
var SuperProperty$0 = $S($EXPECT($L12, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
2496
2538
|
function SuperProperty(state) {
|
|
2497
2539
|
if (state.events) {
|
|
2498
2540
|
const result = state.events.enter?.("SuperProperty", state);
|
|
@@ -2512,7 +2554,7 @@ ${input.slice(result.pos)}
|
|
|
2512
2554
|
}
|
|
2513
2555
|
}
|
|
2514
2556
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
2515
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
2557
|
+
var MetaProperty$1 = $TV($EXPECT($L13, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
2516
2558
|
return { $loc, token: $1 };
|
|
2517
2559
|
});
|
|
2518
2560
|
function MetaProperty(state) {
|
|
@@ -2534,7 +2576,7 @@ ${input.slice(result.pos)}
|
|
|
2534
2576
|
}
|
|
2535
2577
|
}
|
|
2536
2578
|
var Parameters$0 = NonEmptyParameters;
|
|
2537
|
-
var Parameters$1 = $TV($EXPECT($
|
|
2579
|
+
var Parameters$1 = $TV($EXPECT($L14, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
2538
2580
|
return {
|
|
2539
2581
|
type: "Parameters",
|
|
2540
2582
|
children: [{ $loc, token: "()" }],
|
|
@@ -2629,7 +2671,7 @@ ${input.slice(result.pos)}
|
|
|
2629
2671
|
}
|
|
2630
2672
|
}
|
|
2631
2673
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
2632
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2674
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
|
|
2633
2675
|
var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2634
2676
|
return { $loc, token: "," };
|
|
2635
2677
|
});
|
|
@@ -3163,10 +3205,9 @@ ${input.slice(result.pos)}
|
|
|
3163
3205
|
children: [$1, $3]
|
|
3164
3206
|
};
|
|
3165
3207
|
});
|
|
3166
|
-
var FunctionExpression$2 = $TS($S(Ampersand, $N($EXPECT($R1, fail, "FunctionExpression /[&]/")), $P(
|
|
3167
|
-
$0.splice(1, 1);
|
|
3208
|
+
var FunctionExpression$2 = $TS($S(Ampersand, $N($EXPECT($R1, fail, "FunctionExpression /[&]/")), $P(BinaryOpRHS)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3168
3209
|
$1.token = "$ => $";
|
|
3169
|
-
const exp = module2.processBinaryOpExpression($
|
|
3210
|
+
const exp = module2.processBinaryOpExpression([$1, $3]);
|
|
3170
3211
|
return {
|
|
3171
3212
|
type: "ArrowFunction",
|
|
3172
3213
|
children: exp
|
|
@@ -3234,7 +3275,7 @@ ${input.slice(result.pos)}
|
|
|
3234
3275
|
return result;
|
|
3235
3276
|
}
|
|
3236
3277
|
}
|
|
3237
|
-
var Arrow$0 = $TV($EXPECT($
|
|
3278
|
+
var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
3238
3279
|
return { $loc, token: $1 };
|
|
3239
3280
|
});
|
|
3240
3281
|
function Arrow(state) {
|
|
@@ -3608,7 +3649,7 @@ ${input.slice(result.pos)}
|
|
|
3608
3649
|
return result;
|
|
3609
3650
|
}
|
|
3610
3651
|
}
|
|
3611
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
3652
|
+
var NullLiteral$0 = $TV($EXPECT($L17, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
3612
3653
|
return { $loc, token: $1 };
|
|
3613
3654
|
});
|
|
3614
3655
|
function NullLiteral(state) {
|
|
@@ -3632,7 +3673,7 @@ ${input.slice(result.pos)}
|
|
|
3632
3673
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
3633
3674
|
return value[1];
|
|
3634
3675
|
});
|
|
3635
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
3676
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3636
3677
|
return { $loc, token: $1 };
|
|
3637
3678
|
});
|
|
3638
3679
|
function BooleanLiteral(state) {
|
|
@@ -3653,10 +3694,10 @@ ${input.slice(result.pos)}
|
|
|
3653
3694
|
return result;
|
|
3654
3695
|
}
|
|
3655
3696
|
}
|
|
3656
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
3697
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3657
3698
|
return { $loc, token: "true" };
|
|
3658
3699
|
});
|
|
3659
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
3700
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3660
3701
|
return { $loc, token: "false" };
|
|
3661
3702
|
});
|
|
3662
3703
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -3677,7 +3718,7 @@ ${input.slice(result.pos)}
|
|
|
3677
3718
|
return result;
|
|
3678
3719
|
}
|
|
3679
3720
|
}
|
|
3680
|
-
var Comma$0 = $TV($EXPECT($
|
|
3721
|
+
var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
3681
3722
|
return { $loc, token: $1 };
|
|
3682
3723
|
});
|
|
3683
3724
|
function Comma(state) {
|
|
@@ -4024,7 +4065,13 @@ ${input.slice(result.pos)}
|
|
|
4024
4065
|
return result;
|
|
4025
4066
|
}
|
|
4026
4067
|
}
|
|
4027
|
-
var ArrayElementExpression$0 = $
|
|
4068
|
+
var ArrayElementExpression$0 = $TS($S(ExtendedExpression, __, DotDotDot, $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4069
|
+
var exp = $1;
|
|
4070
|
+
var ws = $2;
|
|
4071
|
+
var dots = $3;
|
|
4072
|
+
return [...ws, dots, exp];
|
|
4073
|
+
});
|
|
4074
|
+
var ArrayElementExpression$1 = $TV($E($S($E($S(DotDotDot, __)), ExtendedExpression)), function($skip, $loc, $0, $1) {
|
|
4028
4075
|
if ($1 && !$1[0]) {
|
|
4029
4076
|
return $1[1];
|
|
4030
4077
|
}
|
|
@@ -4037,19 +4084,19 @@ ${input.slice(result.pos)}
|
|
|
4037
4084
|
return result.cache;
|
|
4038
4085
|
}
|
|
4039
4086
|
if (state.tokenize) {
|
|
4040
|
-
const result = $TOKEN("ArrayElementExpression", state, ArrayElementExpression$0(state));
|
|
4087
|
+
const result = $TOKEN("ArrayElementExpression", state, ArrayElementExpression$0(state) || ArrayElementExpression$1(state));
|
|
4041
4088
|
if (state.events)
|
|
4042
4089
|
state.events.exit?.("ArrayElementExpression", state, result);
|
|
4043
4090
|
return result;
|
|
4044
4091
|
} else {
|
|
4045
|
-
const result = ArrayElementExpression$0(state);
|
|
4092
|
+
const result = ArrayElementExpression$0(state) || ArrayElementExpression$1(state);
|
|
4046
4093
|
if (state.events)
|
|
4047
4094
|
state.events.exit?.("ArrayElementExpression", state, result);
|
|
4048
4095
|
return result;
|
|
4049
4096
|
}
|
|
4050
4097
|
}
|
|
4051
4098
|
var ObjectLiteral$0 = BracedObjectLiteral;
|
|
4052
|
-
var ObjectLiteral$1 =
|
|
4099
|
+
var ObjectLiteral$1 = NestedImplicitObjectLiteral;
|
|
4053
4100
|
var ObjectLiteral$2 = InlineObjectLiteral;
|
|
4054
4101
|
function ObjectLiteral(state) {
|
|
4055
4102
|
if (state.events) {
|
|
@@ -4130,27 +4177,76 @@ ${input.slice(result.pos)}
|
|
|
4130
4177
|
return result;
|
|
4131
4178
|
}
|
|
4132
4179
|
}
|
|
4133
|
-
var
|
|
4180
|
+
var NestedImplicitObjectLiteral$0 = $TS($S(InsertOpenBrace, NestedImplicitPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4134
4181
|
return {
|
|
4135
4182
|
type: "ObjectExpression",
|
|
4136
4183
|
children: [$1, ...$2, $3, $4, $5]
|
|
4137
4184
|
};
|
|
4138
4185
|
});
|
|
4139
|
-
function
|
|
4186
|
+
function NestedImplicitObjectLiteral(state) {
|
|
4187
|
+
if (state.events) {
|
|
4188
|
+
const result = state.events.enter?.("NestedImplicitObjectLiteral", state);
|
|
4189
|
+
if (result)
|
|
4190
|
+
return result.cache;
|
|
4191
|
+
}
|
|
4192
|
+
if (state.tokenize) {
|
|
4193
|
+
const result = $TOKEN("NestedImplicitObjectLiteral", state, NestedImplicitObjectLiteral$0(state));
|
|
4194
|
+
if (state.events)
|
|
4195
|
+
state.events.exit?.("NestedImplicitObjectLiteral", state, result);
|
|
4196
|
+
return result;
|
|
4197
|
+
} else {
|
|
4198
|
+
const result = NestedImplicitObjectLiteral$0(state);
|
|
4199
|
+
if (state.events)
|
|
4200
|
+
state.events.exit?.("NestedImplicitObjectLiteral", state, result);
|
|
4201
|
+
return result;
|
|
4202
|
+
}
|
|
4203
|
+
}
|
|
4204
|
+
var NestedImplicitPropertyDefinitions$0 = $TS($S(PushIndent, $Q(NestedImplicitPropertyDefinition), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
4205
|
+
var defs = $2;
|
|
4206
|
+
if (!defs.length)
|
|
4207
|
+
return $skip;
|
|
4208
|
+
return defs.flat();
|
|
4209
|
+
});
|
|
4210
|
+
function NestedImplicitPropertyDefinitions(state) {
|
|
4140
4211
|
if (state.events) {
|
|
4141
|
-
const result = state.events.enter?.("
|
|
4212
|
+
const result = state.events.enter?.("NestedImplicitPropertyDefinitions", state);
|
|
4142
4213
|
if (result)
|
|
4143
4214
|
return result.cache;
|
|
4144
4215
|
}
|
|
4145
4216
|
if (state.tokenize) {
|
|
4146
|
-
const result = $TOKEN("
|
|
4217
|
+
const result = $TOKEN("NestedImplicitPropertyDefinitions", state, NestedImplicitPropertyDefinitions$0(state));
|
|
4147
4218
|
if (state.events)
|
|
4148
|
-
state.events.exit?.("
|
|
4219
|
+
state.events.exit?.("NestedImplicitPropertyDefinitions", state, result);
|
|
4149
4220
|
return result;
|
|
4150
4221
|
} else {
|
|
4151
|
-
const result =
|
|
4222
|
+
const result = NestedImplicitPropertyDefinitions$0(state);
|
|
4152
4223
|
if (state.events)
|
|
4153
|
-
state.events.exit?.("
|
|
4224
|
+
state.events.exit?.("NestedImplicitPropertyDefinitions", state, result);
|
|
4225
|
+
return result;
|
|
4226
|
+
}
|
|
4227
|
+
}
|
|
4228
|
+
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, NamedProperty, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
4229
|
+
const result = [...$1, $2];
|
|
4230
|
+
if ($3) {
|
|
4231
|
+
result.push($3);
|
|
4232
|
+
}
|
|
4233
|
+
return result;
|
|
4234
|
+
});
|
|
4235
|
+
function NestedImplicitPropertyDefinition(state) {
|
|
4236
|
+
if (state.events) {
|
|
4237
|
+
const result = state.events.enter?.("NestedImplicitPropertyDefinition", state);
|
|
4238
|
+
if (result)
|
|
4239
|
+
return result.cache;
|
|
4240
|
+
}
|
|
4241
|
+
if (state.tokenize) {
|
|
4242
|
+
const result = $TOKEN("NestedImplicitPropertyDefinition", state, NestedImplicitPropertyDefinition$0(state));
|
|
4243
|
+
if (state.events)
|
|
4244
|
+
state.events.exit?.("NestedImplicitPropertyDefinition", state, result);
|
|
4245
|
+
return result;
|
|
4246
|
+
} else {
|
|
4247
|
+
const result = NestedImplicitPropertyDefinition$0(state);
|
|
4248
|
+
if (state.events)
|
|
4249
|
+
state.events.exit?.("NestedImplicitPropertyDefinition", state, result);
|
|
4154
4250
|
return result;
|
|
4155
4251
|
}
|
|
4156
4252
|
}
|
|
@@ -4490,7 +4586,7 @@ ${input.slice(result.pos)}
|
|
|
4490
4586
|
return result;
|
|
4491
4587
|
}
|
|
4492
4588
|
}
|
|
4493
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
4589
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L7, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
4494
4590
|
return {
|
|
4495
4591
|
type: "Identifier",
|
|
4496
4592
|
name: $0,
|
|
@@ -4615,7 +4711,7 @@ ${input.slice(result.pos)}
|
|
|
4615
4711
|
var BinaryOpSymbol$6 = $EXPECT($L50, fail, 'BinaryOpSymbol "<="');
|
|
4616
4712
|
var BinaryOpSymbol$7 = $EXPECT($L51, fail, 'BinaryOpSymbol ">="');
|
|
4617
4713
|
var BinaryOpSymbol$8 = $EXPECT($L52, fail, 'BinaryOpSymbol "<<"');
|
|
4618
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
4714
|
+
var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
|
|
4619
4715
|
var BinaryOpSymbol$10 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>>"');
|
|
4620
4716
|
var BinaryOpSymbol$11 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>"');
|
|
4621
4717
|
var BinaryOpSymbol$12 = $EXPECT($L55, fail, 'BinaryOpSymbol ">"');
|
|
@@ -5652,14 +5748,14 @@ ${input.slice(result.pos)}
|
|
|
5652
5748
|
children: $0
|
|
5653
5749
|
};
|
|
5654
5750
|
});
|
|
5655
|
-
var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of),
|
|
5751
|
+
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) {
|
|
5656
5752
|
var declaration = $4;
|
|
5657
5753
|
return {
|
|
5658
5754
|
declaration,
|
|
5659
5755
|
children: $0
|
|
5660
5756
|
};
|
|
5661
5757
|
});
|
|
5662
|
-
var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of),
|
|
5758
|
+
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) {
|
|
5663
5759
|
var declaration = $3;
|
|
5664
5760
|
return {
|
|
5665
5761
|
declaration,
|
|
@@ -6004,7 +6100,7 @@ ${input.slice(result.pos)}
|
|
|
6004
6100
|
return result;
|
|
6005
6101
|
}
|
|
6006
6102
|
}
|
|
6007
|
-
var CaseExpressionList$0 = $TS($S($S($Q(_),
|
|
6103
|
+
var CaseExpressionList$0 = $TS($S($S($Q(_), ExtendedExpression, ImpliedColon), $Q($S(__, Comma, ExtendedExpression, ImpliedColon))), function($skip, $loc, $0, $1, $2) {
|
|
6008
6104
|
const result = $2.map(([ws, _comma, exp, col]) => {
|
|
6009
6105
|
exp = module2.insertTrimmingSpace(exp, "");
|
|
6010
6106
|
if (ws.length)
|
|
@@ -6032,7 +6128,7 @@ ${input.slice(result.pos)}
|
|
|
6032
6128
|
return result;
|
|
6033
6129
|
}
|
|
6034
6130
|
}
|
|
6035
|
-
var NoExpressions$0 = $T($EXPECT($
|
|
6131
|
+
var NoExpressions$0 = $T($EXPECT($L14, fail, 'NoExpressions ""'), function(value) {
|
|
6036
6132
|
return [];
|
|
6037
6133
|
});
|
|
6038
6134
|
function NoExpressions(state) {
|
|
@@ -6054,7 +6150,7 @@ ${input.slice(result.pos)}
|
|
|
6054
6150
|
}
|
|
6055
6151
|
}
|
|
6056
6152
|
var ImpliedColon$0 = $S(__, Colon);
|
|
6057
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
6153
|
+
var ImpliedColon$1 = $TV($EXPECT($L14, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
6058
6154
|
return { $loc, token: ":" };
|
|
6059
6155
|
});
|
|
6060
6156
|
function ImpliedColon(state) {
|
|
@@ -6190,7 +6286,7 @@ ${input.slice(result.pos)}
|
|
|
6190
6286
|
var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp)))), function(value) {
|
|
6191
6287
|
return value[0];
|
|
6192
6288
|
});
|
|
6193
|
-
var Condition$1 = $TS($S(InsertOpenParen,
|
|
6289
|
+
var Condition$1 = $TS($S(InsertOpenParen, ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
|
|
6194
6290
|
var open = $1;
|
|
6195
6291
|
var exp = $2;
|
|
6196
6292
|
var close = $3;
|
|
@@ -6219,52 +6315,6 @@ ${input.slice(result.pos)}
|
|
|
6219
6315
|
return result;
|
|
6220
6316
|
}
|
|
6221
6317
|
}
|
|
6222
|
-
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(ExtendedExpression)), function($skip, $loc, $0, $1, $2) {
|
|
6223
|
-
var exp = $2;
|
|
6224
|
-
module2.suppressIndentedApplication = false;
|
|
6225
|
-
if (exp)
|
|
6226
|
-
return exp;
|
|
6227
|
-
return $skip;
|
|
6228
|
-
});
|
|
6229
|
-
function ExpressionWithIndentedApplicationSuppressed(state) {
|
|
6230
|
-
if (state.events) {
|
|
6231
|
-
const result = state.events.enter?.("ExpressionWithIndentedApplicationSuppressed", state);
|
|
6232
|
-
if (result)
|
|
6233
|
-
return result.cache;
|
|
6234
|
-
}
|
|
6235
|
-
if (state.tokenize) {
|
|
6236
|
-
const result = $TOKEN("ExpressionWithIndentedApplicationSuppressed", state, ExpressionWithIndentedApplicationSuppressed$0(state));
|
|
6237
|
-
if (state.events)
|
|
6238
|
-
state.events.exit?.("ExpressionWithIndentedApplicationSuppressed", state, result);
|
|
6239
|
-
return result;
|
|
6240
|
-
} else {
|
|
6241
|
-
const result = ExpressionWithIndentedApplicationSuppressed$0(state);
|
|
6242
|
-
if (state.events)
|
|
6243
|
-
state.events.exit?.("ExpressionWithIndentedApplicationSuppressed", state, result);
|
|
6244
|
-
return result;
|
|
6245
|
-
}
|
|
6246
|
-
}
|
|
6247
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($L1, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
6248
|
-
module2.suppressIndentedApplication = true;
|
|
6249
|
-
});
|
|
6250
|
-
function SuppressIndentedApplication(state) {
|
|
6251
|
-
if (state.events) {
|
|
6252
|
-
const result = state.events.enter?.("SuppressIndentedApplication", state);
|
|
6253
|
-
if (result)
|
|
6254
|
-
return result.cache;
|
|
6255
|
-
}
|
|
6256
|
-
if (state.tokenize) {
|
|
6257
|
-
const result = $TOKEN("SuppressIndentedApplication", state, SuppressIndentedApplication$0(state));
|
|
6258
|
-
if (state.events)
|
|
6259
|
-
state.events.exit?.("SuppressIndentedApplication", state, result);
|
|
6260
|
-
return result;
|
|
6261
|
-
} else {
|
|
6262
|
-
const result = SuppressIndentedApplication$0(state);
|
|
6263
|
-
if (state.events)
|
|
6264
|
-
state.events.exit?.("SuppressIndentedApplication", state, result);
|
|
6265
|
-
return result;
|
|
6266
|
-
}
|
|
6267
|
-
}
|
|
6268
6318
|
var ExpressionStatement$0 = Expression;
|
|
6269
6319
|
function ExpressionStatement(state) {
|
|
6270
6320
|
if (state.events) {
|
|
@@ -6423,7 +6473,7 @@ ${input.slice(result.pos)}
|
|
|
6423
6473
|
return result;
|
|
6424
6474
|
}
|
|
6425
6475
|
}
|
|
6426
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
6476
|
+
var ImpliedImport$0 = $TV($EXPECT($L14, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
6427
6477
|
return { $loc, token: "import " };
|
|
6428
6478
|
});
|
|
6429
6479
|
function ImpliedImport(state) {
|
|
@@ -7432,7 +7482,8 @@ ${input.slice(result.pos)}
|
|
|
7432
7482
|
return result;
|
|
7433
7483
|
}
|
|
7434
7484
|
}
|
|
7435
|
-
var RegularExpressionLiteral$0 =
|
|
7485
|
+
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
7486
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
7436
7487
|
return { $loc, token: $1 };
|
|
7437
7488
|
});
|
|
7438
7489
|
function RegularExpressionLiteral(state) {
|
|
@@ -7442,18 +7493,200 @@ ${input.slice(result.pos)}
|
|
|
7442
7493
|
return result.cache;
|
|
7443
7494
|
}
|
|
7444
7495
|
if (state.tokenize) {
|
|
7445
|
-
const result = $TOKEN("RegularExpressionLiteral", state, RegularExpressionLiteral$0(state));
|
|
7496
|
+
const result = $TOKEN("RegularExpressionLiteral", state, RegularExpressionLiteral$0(state) || RegularExpressionLiteral$1(state));
|
|
7446
7497
|
if (state.events)
|
|
7447
7498
|
state.events.exit?.("RegularExpressionLiteral", state, result);
|
|
7448
7499
|
return result;
|
|
7449
7500
|
} else {
|
|
7450
|
-
const result = RegularExpressionLiteral$0(state);
|
|
7501
|
+
const result = RegularExpressionLiteral$0(state) || RegularExpressionLiteral$1(state);
|
|
7451
7502
|
if (state.events)
|
|
7452
7503
|
state.events.exit?.("RegularExpressionLiteral", state, result);
|
|
7453
7504
|
return result;
|
|
7454
7505
|
}
|
|
7455
7506
|
}
|
|
7456
|
-
var
|
|
7507
|
+
var RegularExpressionClass$0 = $TV($TEXT($S(OpenBracket, RegularExpressionClassCharacters, CloseBracket)), function($skip, $loc, $0, $1) {
|
|
7508
|
+
return { $loc, token: $1 };
|
|
7509
|
+
});
|
|
7510
|
+
function RegularExpressionClass(state) {
|
|
7511
|
+
if (state.events) {
|
|
7512
|
+
const result = state.events.enter?.("RegularExpressionClass", state);
|
|
7513
|
+
if (result)
|
|
7514
|
+
return result.cache;
|
|
7515
|
+
}
|
|
7516
|
+
if (state.tokenize) {
|
|
7517
|
+
const result = $TOKEN("RegularExpressionClass", state, RegularExpressionClass$0(state));
|
|
7518
|
+
if (state.events)
|
|
7519
|
+
state.events.exit?.("RegularExpressionClass", state, result);
|
|
7520
|
+
return result;
|
|
7521
|
+
} else {
|
|
7522
|
+
const result = RegularExpressionClass$0(state);
|
|
7523
|
+
if (state.events)
|
|
7524
|
+
state.events.exit?.("RegularExpressionClass", state, result);
|
|
7525
|
+
return result;
|
|
7526
|
+
}
|
|
7527
|
+
}
|
|
7528
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R20, fail, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7529
|
+
return { $loc, token: $0 };
|
|
7530
|
+
});
|
|
7531
|
+
function RegularExpressionClassCharacters(state) {
|
|
7532
|
+
if (state.events) {
|
|
7533
|
+
const result = state.events.enter?.("RegularExpressionClassCharacters", state);
|
|
7534
|
+
if (result)
|
|
7535
|
+
return result.cache;
|
|
7536
|
+
}
|
|
7537
|
+
if (state.tokenize) {
|
|
7538
|
+
const result = $TOKEN("RegularExpressionClassCharacters", state, RegularExpressionClassCharacters$0(state));
|
|
7539
|
+
if (state.events)
|
|
7540
|
+
state.events.exit?.("RegularExpressionClassCharacters", state, result);
|
|
7541
|
+
return result;
|
|
7542
|
+
} else {
|
|
7543
|
+
const result = RegularExpressionClassCharacters$0(state);
|
|
7544
|
+
if (state.events)
|
|
7545
|
+
state.events.exit?.("RegularExpressionClassCharacters", state, result);
|
|
7546
|
+
return result;
|
|
7547
|
+
}
|
|
7548
|
+
}
|
|
7549
|
+
var HeregexLiteral$0 = $TS($S(TripleSlash, HeregexBody, TripleSlash, RegularExpressionFlags), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7550
|
+
var open = $1;
|
|
7551
|
+
var body = $2;
|
|
7552
|
+
var close = $3;
|
|
7553
|
+
var flags = $4;
|
|
7554
|
+
debugger;
|
|
7555
|
+
let hasSubstitutions = body.some((part) => part.type === "Substitution");
|
|
7556
|
+
if (hasSubstitutions) {
|
|
7557
|
+
const result = [
|
|
7558
|
+
{ ...open, token: "RegExp(`" },
|
|
7559
|
+
body.map(
|
|
7560
|
+
(e) => e.type === "Substitution" ? e : {
|
|
7561
|
+
...e,
|
|
7562
|
+
token: e.token.replace(/`|\\|\$/g, "\\$&")
|
|
7563
|
+
}
|
|
7564
|
+
),
|
|
7565
|
+
"`"
|
|
7566
|
+
];
|
|
7567
|
+
if (flags.length) {
|
|
7568
|
+
result.push(
|
|
7569
|
+
", ",
|
|
7570
|
+
JSON.stringify(flags)
|
|
7571
|
+
);
|
|
7572
|
+
}
|
|
7573
|
+
result.push({ ...close, token: ")" });
|
|
7574
|
+
return result;
|
|
7575
|
+
}
|
|
7576
|
+
return $0;
|
|
7577
|
+
});
|
|
7578
|
+
function HeregexLiteral(state) {
|
|
7579
|
+
if (state.events) {
|
|
7580
|
+
const result = state.events.enter?.("HeregexLiteral", state);
|
|
7581
|
+
if (result)
|
|
7582
|
+
return result.cache;
|
|
7583
|
+
}
|
|
7584
|
+
if (state.tokenize) {
|
|
7585
|
+
const result = $TOKEN("HeregexLiteral", state, HeregexLiteral$0(state));
|
|
7586
|
+
if (state.events)
|
|
7587
|
+
state.events.exit?.("HeregexLiteral", state, result);
|
|
7588
|
+
return result;
|
|
7589
|
+
} else {
|
|
7590
|
+
const result = HeregexLiteral$0(state);
|
|
7591
|
+
if (state.events)
|
|
7592
|
+
state.events.exit?.("HeregexLiteral", state, result);
|
|
7593
|
+
return result;
|
|
7594
|
+
}
|
|
7595
|
+
}
|
|
7596
|
+
var HeregexBody$0 = $T($S($N(TripleSlash), $Q(HeregexPart)), function(value) {
|
|
7597
|
+
return value[1];
|
|
7598
|
+
});
|
|
7599
|
+
function HeregexBody(state) {
|
|
7600
|
+
if (state.events) {
|
|
7601
|
+
const result = state.events.enter?.("HeregexBody", state);
|
|
7602
|
+
if (result)
|
|
7603
|
+
return result.cache;
|
|
7604
|
+
}
|
|
7605
|
+
if (state.tokenize) {
|
|
7606
|
+
const result = $TOKEN("HeregexBody", state, HeregexBody$0(state));
|
|
7607
|
+
if (state.events)
|
|
7608
|
+
state.events.exit?.("HeregexBody", state, result);
|
|
7609
|
+
return result;
|
|
7610
|
+
} else {
|
|
7611
|
+
const result = HeregexBody$0(state);
|
|
7612
|
+
if (state.events)
|
|
7613
|
+
state.events.exit?.("HeregexBody", state, result);
|
|
7614
|
+
return result;
|
|
7615
|
+
}
|
|
7616
|
+
}
|
|
7617
|
+
var HeregexPart$0 = RegularExpressionClass;
|
|
7618
|
+
var HeregexPart$1 = $T($S(CoffeeStringSubstitution), function(value) {
|
|
7619
|
+
return { "type": "Substitution", "children": value[0] };
|
|
7620
|
+
});
|
|
7621
|
+
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
7622
|
+
return { "type": "Substitution", "children": value[0] };
|
|
7623
|
+
});
|
|
7624
|
+
var HeregexPart$3 = $TR($EXPECT($R21, fail, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7625
|
+
let token = $0;
|
|
7626
|
+
switch ($0[1]) {
|
|
7627
|
+
case "\n":
|
|
7628
|
+
token = "\\n";
|
|
7629
|
+
break;
|
|
7630
|
+
case "\r":
|
|
7631
|
+
token = "\\r";
|
|
7632
|
+
break;
|
|
7633
|
+
case " ":
|
|
7634
|
+
token = " ";
|
|
7635
|
+
break;
|
|
7636
|
+
}
|
|
7637
|
+
return { $loc, token };
|
|
7638
|
+
});
|
|
7639
|
+
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
7640
|
+
return { $loc, token: "" };
|
|
7641
|
+
});
|
|
7642
|
+
var HeregexPart$5 = $TR($EXPECT($R22, fail, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7643
|
+
return { $loc, token: "" };
|
|
7644
|
+
});
|
|
7645
|
+
var HeregexPart$6 = $TR($EXPECT($R23, fail, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7646
|
+
return { $loc, token: "\\/" };
|
|
7647
|
+
});
|
|
7648
|
+
var HeregexPart$7 = $TR($EXPECT($R24, fail, "HeregexPart /[^\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7649
|
+
return { $loc, token: $0 };
|
|
7650
|
+
});
|
|
7651
|
+
function HeregexPart(state) {
|
|
7652
|
+
if (state.events) {
|
|
7653
|
+
const result = state.events.enter?.("HeregexPart", state);
|
|
7654
|
+
if (result)
|
|
7655
|
+
return result.cache;
|
|
7656
|
+
}
|
|
7657
|
+
if (state.tokenize) {
|
|
7658
|
+
const result = $TOKEN("HeregexPart", state, HeregexPart$0(state) || HeregexPart$1(state) || HeregexPart$2(state) || HeregexPart$3(state) || HeregexPart$4(state) || HeregexPart$5(state) || HeregexPart$6(state) || HeregexPart$7(state));
|
|
7659
|
+
if (state.events)
|
|
7660
|
+
state.events.exit?.("HeregexPart", state, result);
|
|
7661
|
+
return result;
|
|
7662
|
+
} else {
|
|
7663
|
+
const result = HeregexPart$0(state) || HeregexPart$1(state) || HeregexPart$2(state) || HeregexPart$3(state) || HeregexPart$4(state) || HeregexPart$5(state) || HeregexPart$6(state) || HeregexPart$7(state);
|
|
7664
|
+
if (state.events)
|
|
7665
|
+
state.events.exit?.("HeregexPart", state, result);
|
|
7666
|
+
return result;
|
|
7667
|
+
}
|
|
7668
|
+
}
|
|
7669
|
+
var HeregexComment$0 = JSSingleLineComment;
|
|
7670
|
+
var HeregexComment$1 = CoffeeSingleLineComment;
|
|
7671
|
+
function HeregexComment(state) {
|
|
7672
|
+
if (state.events) {
|
|
7673
|
+
const result = state.events.enter?.("HeregexComment", state);
|
|
7674
|
+
if (result)
|
|
7675
|
+
return result.cache;
|
|
7676
|
+
}
|
|
7677
|
+
if (state.tokenize) {
|
|
7678
|
+
const result = $TOKEN("HeregexComment", state, HeregexComment$0(state) || HeregexComment$1(state));
|
|
7679
|
+
if (state.events)
|
|
7680
|
+
state.events.exit?.("HeregexComment", state, result);
|
|
7681
|
+
return result;
|
|
7682
|
+
} else {
|
|
7683
|
+
const result = HeregexComment$0(state) || HeregexComment$1(state);
|
|
7684
|
+
if (state.events)
|
|
7685
|
+
state.events.exit?.("HeregexComment", state, result);
|
|
7686
|
+
return result;
|
|
7687
|
+
}
|
|
7688
|
+
}
|
|
7689
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R25, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
7457
7690
|
function RegularExpressionBody(state) {
|
|
7458
7691
|
if (state.events) {
|
|
7459
7692
|
const result = state.events.enter?.("RegularExpressionBody", state);
|
|
@@ -7472,7 +7705,7 @@ ${input.slice(result.pos)}
|
|
|
7472
7705
|
return result;
|
|
7473
7706
|
}
|
|
7474
7707
|
}
|
|
7475
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
7708
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R26, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
7476
7709
|
function RegExpCharacter(state) {
|
|
7477
7710
|
if (state.events) {
|
|
7478
7711
|
const result = state.events.enter?.("RegExpCharacter", state);
|
|
@@ -7491,7 +7724,7 @@ ${input.slice(result.pos)}
|
|
|
7491
7724
|
return result;
|
|
7492
7725
|
}
|
|
7493
7726
|
}
|
|
7494
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
7727
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R27, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
7495
7728
|
function RegularExpressionFlags(state) {
|
|
7496
7729
|
if (state.events) {
|
|
7497
7730
|
const result = state.events.enter?.("RegularExpressionFlags", state);
|
|
@@ -7551,7 +7784,7 @@ ${input.slice(result.pos)}
|
|
|
7551
7784
|
return result;
|
|
7552
7785
|
}
|
|
7553
7786
|
}
|
|
7554
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
7787
|
+
var TemplateCharacters$0 = $TR($EXPECT($R28, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7555
7788
|
return { $loc, token: $0 };
|
|
7556
7789
|
});
|
|
7557
7790
|
function TemplateCharacters(state) {
|
|
@@ -7572,7 +7805,7 @@ ${input.slice(result.pos)}
|
|
|
7572
7805
|
return result;
|
|
7573
7806
|
}
|
|
7574
7807
|
}
|
|
7575
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
7808
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R29, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7576
7809
|
return { $loc, token: $0 };
|
|
7577
7810
|
});
|
|
7578
7811
|
function TemplateBlockCharacters(state) {
|
|
@@ -7593,10 +7826,10 @@ ${input.slice(result.pos)}
|
|
|
7593
7826
|
return result;
|
|
7594
7827
|
}
|
|
7595
7828
|
}
|
|
7596
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
7597
|
-
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($
|
|
7598
|
-
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($
|
|
7599
|
-
var ReservedWord$3 = $R$0($EXPECT($
|
|
7829
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R30, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
7830
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R31, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
7831
|
+
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R32, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
7832
|
+
var ReservedWord$3 = $R$0($EXPECT($R33, 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})/"));
|
|
7600
7833
|
function ReservedWord(state) {
|
|
7601
7834
|
if (state.events) {
|
|
7602
7835
|
const result = state.events.enter?.("ReservedWord", state);
|
|
@@ -7635,9 +7868,7 @@ ${input.slice(result.pos)}
|
|
|
7635
7868
|
return result;
|
|
7636
7869
|
}
|
|
7637
7870
|
}
|
|
7638
|
-
var SingleLineComment$0 =
|
|
7639
|
-
return { $loc, token: $0 };
|
|
7640
|
-
});
|
|
7871
|
+
var SingleLineComment$0 = JSSingleLineComment;
|
|
7641
7872
|
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
7642
7873
|
function SingleLineComment(state) {
|
|
7643
7874
|
if (state.events) {
|
|
@@ -7657,6 +7888,27 @@ ${input.slice(result.pos)}
|
|
|
7657
7888
|
return result;
|
|
7658
7889
|
}
|
|
7659
7890
|
}
|
|
7891
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R34, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7892
|
+
return { $loc, token: $0 };
|
|
7893
|
+
});
|
|
7894
|
+
function JSSingleLineComment(state) {
|
|
7895
|
+
if (state.events) {
|
|
7896
|
+
const result = state.events.enter?.("JSSingleLineComment", state);
|
|
7897
|
+
if (result)
|
|
7898
|
+
return result.cache;
|
|
7899
|
+
}
|
|
7900
|
+
if (state.tokenize) {
|
|
7901
|
+
const result = $TOKEN("JSSingleLineComment", state, JSSingleLineComment$0(state));
|
|
7902
|
+
if (state.events)
|
|
7903
|
+
state.events.exit?.("JSSingleLineComment", state, result);
|
|
7904
|
+
return result;
|
|
7905
|
+
} else {
|
|
7906
|
+
const result = JSSingleLineComment$0(state);
|
|
7907
|
+
if (state.events)
|
|
7908
|
+
state.events.exit?.("JSSingleLineComment", state, result);
|
|
7909
|
+
return result;
|
|
7910
|
+
}
|
|
7911
|
+
}
|
|
7660
7912
|
var MultiLineComment$0 = JSMultiLineComment;
|
|
7661
7913
|
var MultiLineComment$1 = CoffeeMultiLineComment;
|
|
7662
7914
|
function MultiLineComment(state) {
|
|
@@ -7677,7 +7929,7 @@ ${input.slice(result.pos)}
|
|
|
7677
7929
|
return result;
|
|
7678
7930
|
}
|
|
7679
7931
|
}
|
|
7680
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
7932
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R35, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
7681
7933
|
return { $loc, token: $1 };
|
|
7682
7934
|
});
|
|
7683
7935
|
function JSMultiLineComment(state) {
|
|
@@ -7698,7 +7950,7 @@ ${input.slice(result.pos)}
|
|
|
7698
7950
|
return result;
|
|
7699
7951
|
}
|
|
7700
7952
|
}
|
|
7701
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
7953
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R36, fail, "CoffeeSingleLineComment /#(?!##)([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7702
7954
|
return { $loc, token: `//${$1}` };
|
|
7703
7955
|
});
|
|
7704
7956
|
function CoffeeSingleLineComment(state) {
|
|
@@ -7719,7 +7971,7 @@ ${input.slice(result.pos)}
|
|
|
7719
7971
|
return result;
|
|
7720
7972
|
}
|
|
7721
7973
|
}
|
|
7722
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($
|
|
7974
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R35, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
7723
7975
|
return { $loc, token: `/*${$2}*/` };
|
|
7724
7976
|
});
|
|
7725
7977
|
function CoffeeMultiLineComment(state) {
|
|
@@ -7740,7 +7992,7 @@ ${input.slice(result.pos)}
|
|
|
7740
7992
|
return result;
|
|
7741
7993
|
}
|
|
7742
7994
|
}
|
|
7743
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($
|
|
7995
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R37, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
7744
7996
|
return { $loc, token: $1 };
|
|
7745
7997
|
});
|
|
7746
7998
|
function InlineComment(state) {
|
|
@@ -7820,7 +8072,7 @@ ${input.slice(result.pos)}
|
|
|
7820
8072
|
return result;
|
|
7821
8073
|
}
|
|
7822
8074
|
}
|
|
7823
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
8075
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R38, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7824
8076
|
return { $loc, token: $0 };
|
|
7825
8077
|
});
|
|
7826
8078
|
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L87, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
@@ -7863,7 +8115,7 @@ ${input.slice(result.pos)}
|
|
|
7863
8115
|
return result;
|
|
7864
8116
|
}
|
|
7865
8117
|
}
|
|
7866
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
8118
|
+
var Whitespace$0 = $TR($EXPECT($R22, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7867
8119
|
return { $loc, token: $0 };
|
|
7868
8120
|
});
|
|
7869
8121
|
function Whitespace(state) {
|
|
@@ -7929,7 +8181,7 @@ ${input.slice(result.pos)}
|
|
|
7929
8181
|
return result;
|
|
7930
8182
|
}
|
|
7931
8183
|
}
|
|
7932
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
8184
|
+
var NonIdContinue$0 = $R$0($EXPECT($R39, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
7933
8185
|
function NonIdContinue(state) {
|
|
7934
8186
|
if (state.events) {
|
|
7935
8187
|
const result = state.events.enter?.("NonIdContinue", state);
|
|
@@ -7948,7 +8200,7 @@ ${input.slice(result.pos)}
|
|
|
7948
8200
|
return result;
|
|
7949
8201
|
}
|
|
7950
8202
|
}
|
|
7951
|
-
var Loc$0 = $TV($EXPECT($
|
|
8203
|
+
var Loc$0 = $TV($EXPECT($L14, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
7952
8204
|
return { $loc, token: "" };
|
|
7953
8205
|
});
|
|
7954
8206
|
function Loc(state) {
|
|
@@ -8221,7 +8473,7 @@ ${input.slice(result.pos)}
|
|
|
8221
8473
|
return result;
|
|
8222
8474
|
}
|
|
8223
8475
|
}
|
|
8224
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
8476
|
+
var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
8225
8477
|
return { $loc, token: $1 };
|
|
8226
8478
|
});
|
|
8227
8479
|
function CloseParen(state) {
|
|
@@ -8368,7 +8620,7 @@ ${input.slice(result.pos)}
|
|
|
8368
8620
|
return result;
|
|
8369
8621
|
}
|
|
8370
8622
|
}
|
|
8371
|
-
var Dot$0 = $TV($EXPECT($
|
|
8623
|
+
var Dot$0 = $TV($EXPECT($L8, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
8372
8624
|
return { $loc, token: $1 };
|
|
8373
8625
|
});
|
|
8374
8626
|
function Dot(state) {
|
|
@@ -8620,7 +8872,7 @@ ${input.slice(result.pos)}
|
|
|
8620
8872
|
return result;
|
|
8621
8873
|
}
|
|
8622
8874
|
}
|
|
8623
|
-
var If$0 = $TV($TEXT($S($EXPECT($L112, fail, 'If "if"'), $E($EXPECT($
|
|
8875
|
+
var If$0 = $TV($TEXT($S($EXPECT($L112, fail, 'If "if"'), $E($EXPECT($L3, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
8624
8876
|
return { $loc, token: $1 };
|
|
8625
8877
|
});
|
|
8626
8878
|
function If(state) {
|
|
@@ -8641,7 +8893,7 @@ ${input.slice(result.pos)}
|
|
|
8641
8893
|
return result;
|
|
8642
8894
|
}
|
|
8643
8895
|
}
|
|
8644
|
-
var Import$0 = $TS($S($EXPECT($
|
|
8896
|
+
var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R40, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
8645
8897
|
return { $loc, token: $1 };
|
|
8646
8898
|
});
|
|
8647
8899
|
function Import(state) {
|
|
@@ -8746,7 +8998,7 @@ ${input.slice(result.pos)}
|
|
|
8746
8998
|
return result;
|
|
8747
8999
|
}
|
|
8748
9000
|
}
|
|
8749
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L71, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($
|
|
9001
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L71, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L3, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8750
9002
|
return { $loc, token: "!" };
|
|
8751
9003
|
});
|
|
8752
9004
|
function Not(state) {
|
|
@@ -9127,7 +9379,28 @@ ${input.slice(result.pos)}
|
|
|
9127
9379
|
return result;
|
|
9128
9380
|
}
|
|
9129
9381
|
}
|
|
9130
|
-
var
|
|
9382
|
+
var TripleSlash$0 = $TV($EXPECT($L130, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
9383
|
+
return { $loc, token: "/" };
|
|
9384
|
+
});
|
|
9385
|
+
function TripleSlash(state) {
|
|
9386
|
+
if (state.events) {
|
|
9387
|
+
const result = state.events.enter?.("TripleSlash", state);
|
|
9388
|
+
if (result)
|
|
9389
|
+
return result.cache;
|
|
9390
|
+
}
|
|
9391
|
+
if (state.tokenize) {
|
|
9392
|
+
const result = $TOKEN("TripleSlash", state, TripleSlash$0(state));
|
|
9393
|
+
if (state.events)
|
|
9394
|
+
state.events.exit?.("TripleSlash", state, result);
|
|
9395
|
+
return result;
|
|
9396
|
+
} else {
|
|
9397
|
+
const result = TripleSlash$0(state);
|
|
9398
|
+
if (state.events)
|
|
9399
|
+
state.events.exit?.("TripleSlash", state, result);
|
|
9400
|
+
return result;
|
|
9401
|
+
}
|
|
9402
|
+
}
|
|
9403
|
+
var TripleTick$0 = $TV($EXPECT($L131, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
9131
9404
|
return { $loc, token: "`" };
|
|
9132
9405
|
});
|
|
9133
9406
|
function TripleTick(state) {
|
|
@@ -9148,7 +9421,7 @@ ${input.slice(result.pos)}
|
|
|
9148
9421
|
return result;
|
|
9149
9422
|
}
|
|
9150
9423
|
}
|
|
9151
|
-
var Try$0 = $TV($EXPECT($
|
|
9424
|
+
var Try$0 = $TV($EXPECT($L132, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
9152
9425
|
return { $loc, token: $1 };
|
|
9153
9426
|
});
|
|
9154
9427
|
function Try(state) {
|
|
@@ -9169,7 +9442,7 @@ ${input.slice(result.pos)}
|
|
|
9169
9442
|
return result;
|
|
9170
9443
|
}
|
|
9171
9444
|
}
|
|
9172
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
9445
|
+
var Typeof$0 = $TS($S($EXPECT($L133, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9173
9446
|
return { $loc, token: $1 };
|
|
9174
9447
|
});
|
|
9175
9448
|
function Typeof(state) {
|
|
@@ -9190,7 +9463,7 @@ ${input.slice(result.pos)}
|
|
|
9190
9463
|
return result;
|
|
9191
9464
|
}
|
|
9192
9465
|
}
|
|
9193
|
-
var Unless$0 = $TV($EXPECT($
|
|
9466
|
+
var Unless$0 = $TV($EXPECT($L134, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
9194
9467
|
return { $loc, token: $1 };
|
|
9195
9468
|
});
|
|
9196
9469
|
function Unless(state) {
|
|
@@ -9211,7 +9484,7 @@ ${input.slice(result.pos)}
|
|
|
9211
9484
|
return result;
|
|
9212
9485
|
}
|
|
9213
9486
|
}
|
|
9214
|
-
var Until$0 = $TS($S($EXPECT($
|
|
9487
|
+
var Until$0 = $TS($S($EXPECT($L135, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9215
9488
|
return { $loc, token: $1 };
|
|
9216
9489
|
});
|
|
9217
9490
|
function Until(state) {
|
|
@@ -9232,7 +9505,7 @@ ${input.slice(result.pos)}
|
|
|
9232
9505
|
return result;
|
|
9233
9506
|
}
|
|
9234
9507
|
}
|
|
9235
|
-
var Var$0 = $TV($EXPECT($
|
|
9508
|
+
var Var$0 = $TV($EXPECT($L136, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
9236
9509
|
return { $loc, token: $1 };
|
|
9237
9510
|
});
|
|
9238
9511
|
function Var(state) {
|
|
@@ -9253,7 +9526,7 @@ ${input.slice(result.pos)}
|
|
|
9253
9526
|
return result;
|
|
9254
9527
|
}
|
|
9255
9528
|
}
|
|
9256
|
-
var Void$0 = $TS($S($EXPECT($
|
|
9529
|
+
var Void$0 = $TS($S($EXPECT($L137, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9257
9530
|
return { $loc, token: $1 };
|
|
9258
9531
|
});
|
|
9259
9532
|
function Void(state) {
|
|
@@ -9274,7 +9547,7 @@ ${input.slice(result.pos)}
|
|
|
9274
9547
|
return result;
|
|
9275
9548
|
}
|
|
9276
9549
|
}
|
|
9277
|
-
var When$0 = $TS($S($EXPECT($
|
|
9550
|
+
var When$0 = $TS($S($EXPECT($L138, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9278
9551
|
return { $loc, token: "case" };
|
|
9279
9552
|
});
|
|
9280
9553
|
function When(state) {
|
|
@@ -9295,7 +9568,7 @@ ${input.slice(result.pos)}
|
|
|
9295
9568
|
return result;
|
|
9296
9569
|
}
|
|
9297
9570
|
}
|
|
9298
|
-
var While$0 = $TS($S($EXPECT($
|
|
9571
|
+
var While$0 = $TS($S($EXPECT($L139, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9299
9572
|
return { $loc, token: $1 };
|
|
9300
9573
|
});
|
|
9301
9574
|
function While(state) {
|
|
@@ -9316,7 +9589,7 @@ ${input.slice(result.pos)}
|
|
|
9316
9589
|
return result;
|
|
9317
9590
|
}
|
|
9318
9591
|
}
|
|
9319
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
9592
|
+
var Yield$0 = $TS($S($EXPECT($L140, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9320
9593
|
return { $loc, token: $1 };
|
|
9321
9594
|
});
|
|
9322
9595
|
function Yield(state) {
|
|
@@ -9362,7 +9635,7 @@ ${input.slice(result.pos)}
|
|
|
9362
9635
|
return result;
|
|
9363
9636
|
}
|
|
9364
9637
|
}
|
|
9365
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
9638
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L141, fail, 'JSXSelfClosingElement "/>"'));
|
|
9366
9639
|
function JSXSelfClosingElement(state) {
|
|
9367
9640
|
if (state.events) {
|
|
9368
9641
|
const result = state.events.enter?.("JSXSelfClosingElement", state);
|
|
@@ -9381,7 +9654,7 @@ ${input.slice(result.pos)}
|
|
|
9381
9654
|
return result;
|
|
9382
9655
|
}
|
|
9383
9656
|
}
|
|
9384
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
9657
|
+
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L55, fail, 'JSXOpeningElement ">"'));
|
|
9385
9658
|
function JSXOpeningElement(state) {
|
|
9386
9659
|
if (state.events) {
|
|
9387
9660
|
const result = state.events.enter?.("JSXOpeningElement", state);
|
|
@@ -9400,7 +9673,7 @@ ${input.slice(result.pos)}
|
|
|
9400
9673
|
return result;
|
|
9401
9674
|
}
|
|
9402
9675
|
}
|
|
9403
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
9676
|
+
var JSXClosingElement$0 = $S($EXPECT($L142, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L55, fail, 'JSXClosingElement ">"'));
|
|
9404
9677
|
function JSXClosingElement(state) {
|
|
9405
9678
|
if (state.events) {
|
|
9406
9679
|
const result = state.events.enter?.("JSXClosingElement", state);
|
|
@@ -9419,7 +9692,7 @@ ${input.slice(result.pos)}
|
|
|
9419
9692
|
return result;
|
|
9420
9693
|
}
|
|
9421
9694
|
}
|
|
9422
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
9695
|
+
var JSXFragment$0 = $S($EXPECT($L143, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L144, fail, 'JSXFragment "</>"'));
|
|
9423
9696
|
function JSXFragment(state) {
|
|
9424
9697
|
if (state.events) {
|
|
9425
9698
|
const result = state.events.enter?.("JSXFragment", state);
|
|
@@ -9457,7 +9730,7 @@ ${input.slice(result.pos)}
|
|
|
9457
9730
|
return result;
|
|
9458
9731
|
}
|
|
9459
9732
|
}
|
|
9460
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
9733
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R41, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
9461
9734
|
function JSXIdentifierName(state) {
|
|
9462
9735
|
if (state.events) {
|
|
9463
9736
|
const result = state.events.enter?.("JSXIdentifierName", state);
|
|
@@ -9553,8 +9826,8 @@ ${input.slice(result.pos)}
|
|
|
9553
9826
|
return result;
|
|
9554
9827
|
}
|
|
9555
9828
|
}
|
|
9556
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
9557
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
9829
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R42, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
9830
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R43, fail, "JSXAttributeValue /'[^']*'/"));
|
|
9558
9831
|
var JSXAttributeValue$2 = $S(OpenBrace, ExtendedExpression, __, CloseBrace);
|
|
9559
9832
|
var JSXAttributeValue$3 = JSXElement;
|
|
9560
9833
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -9617,7 +9890,7 @@ ${input.slice(result.pos)}
|
|
|
9617
9890
|
return result;
|
|
9618
9891
|
}
|
|
9619
9892
|
}
|
|
9620
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
9893
|
+
var JSXText$0 = $R$0($EXPECT($R44, fail, "JSXText /[^{}<>]+/"));
|
|
9621
9894
|
function JSXText(state) {
|
|
9622
9895
|
if (state.events) {
|
|
9623
9896
|
const result = state.events.enter?.("JSXText", state);
|
|
@@ -9676,7 +9949,7 @@ ${input.slice(result.pos)}
|
|
|
9676
9949
|
return result;
|
|
9677
9950
|
}
|
|
9678
9951
|
}
|
|
9679
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
9952
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L145, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
9680
9953
|
var TypeDeclarationModifier$1 = Export;
|
|
9681
9954
|
function TypeDeclarationModifier(state) {
|
|
9682
9955
|
if (state.events) {
|
|
@@ -9718,7 +9991,7 @@ ${input.slice(result.pos)}
|
|
|
9718
9991
|
return result;
|
|
9719
9992
|
}
|
|
9720
9993
|
}
|
|
9721
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
9994
|
+
var TypeKeyword$0 = $S($EXPECT($L146, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
9722
9995
|
function TypeKeyword(state) {
|
|
9723
9996
|
if (state.events) {
|
|
9724
9997
|
const result = state.events.enter?.("TypeKeyword", state);
|
|
@@ -9737,7 +10010,7 @@ ${input.slice(result.pos)}
|
|
|
9737
10010
|
return result;
|
|
9738
10011
|
}
|
|
9739
10012
|
}
|
|
9740
|
-
var Interface$0 = $S($EXPECT($
|
|
10013
|
+
var Interface$0 = $S($EXPECT($L147, fail, 'Interface "interface"'), NonIdContinue);
|
|
9741
10014
|
function Interface(state) {
|
|
9742
10015
|
if (state.events) {
|
|
9743
10016
|
const result = state.events.enter?.("Interface", state);
|
|
@@ -9756,7 +10029,7 @@ ${input.slice(result.pos)}
|
|
|
9756
10029
|
return result;
|
|
9757
10030
|
}
|
|
9758
10031
|
}
|
|
9759
|
-
var Namespace$0 = $S($EXPECT($
|
|
10032
|
+
var Namespace$0 = $S($EXPECT($L148, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
9760
10033
|
function Namespace(state) {
|
|
9761
10034
|
if (state.events) {
|
|
9762
10035
|
const result = state.events.enter?.("Namespace", state);
|
|
@@ -9945,7 +10218,7 @@ ${input.slice(result.pos)}
|
|
|
9945
10218
|
return result;
|
|
9946
10219
|
}
|
|
9947
10220
|
}
|
|
9948
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
10221
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R45, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L149, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R46, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
9949
10222
|
function TypeIndexSignature(state) {
|
|
9950
10223
|
if (state.events) {
|
|
9951
10224
|
const result = state.events.enter?.("TypeIndexSignature", state);
|
|
@@ -10005,7 +10278,7 @@ ${input.slice(result.pos)}
|
|
|
10005
10278
|
return result;
|
|
10006
10279
|
}
|
|
10007
10280
|
}
|
|
10008
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
10281
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L150, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10009
10282
|
const children = [...$1, $2];
|
|
10010
10283
|
if ($3)
|
|
10011
10284
|
children.push($3);
|
|
@@ -10140,9 +10413,9 @@ ${input.slice(result.pos)}
|
|
|
10140
10413
|
return result;
|
|
10141
10414
|
}
|
|
10142
10415
|
}
|
|
10143
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
10144
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
10145
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
10416
|
+
var TypeUnaryOp$0 = $EXPECT($L151, fail, 'TypeUnaryOp "keyof"');
|
|
10417
|
+
var TypeUnaryOp$1 = $EXPECT($L133, fail, 'TypeUnaryOp "typeof"');
|
|
10418
|
+
var TypeUnaryOp$2 = $EXPECT($L152, fail, 'TypeUnaryOp "infer"');
|
|
10146
10419
|
function TypeUnaryOp(state) {
|
|
10147
10420
|
if (state.events) {
|
|
10148
10421
|
const result = state.events.enter?.("TypeUnaryOp", state);
|
|
@@ -10286,7 +10559,7 @@ ${input.slice(result.pos)}
|
|
|
10286
10559
|
return result;
|
|
10287
10560
|
}
|
|
10288
10561
|
}
|
|
10289
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
10562
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L5, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
10290
10563
|
if ($2)
|
|
10291
10564
|
return $0;
|
|
10292
10565
|
return $1;
|
|
@@ -10310,10 +10583,10 @@ ${input.slice(result.pos)}
|
|
|
10310
10583
|
}
|
|
10311
10584
|
}
|
|
10312
10585
|
var TypeLiteral$0 = Literal;
|
|
10313
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
10586
|
+
var TypeLiteral$1 = $TV($EXPECT($L137, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
10314
10587
|
return { $loc, token: "void" };
|
|
10315
10588
|
});
|
|
10316
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
10589
|
+
var TypeLiteral$2 = $TV($EXPECT($L153, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
10317
10590
|
return { $loc, token: "[]" };
|
|
10318
10591
|
});
|
|
10319
10592
|
function TypeLiteral(state) {
|
|
@@ -10358,7 +10631,7 @@ ${input.slice(result.pos)}
|
|
|
10358
10631
|
return result;
|
|
10359
10632
|
}
|
|
10360
10633
|
}
|
|
10361
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
10634
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L2, fail, 'FunctionType "=>"'), Type);
|
|
10362
10635
|
function FunctionType(state) {
|
|
10363
10636
|
if (state.events) {
|
|
10364
10637
|
const result = state.events.enter?.("FunctionType", state);
|
|
@@ -10377,7 +10650,7 @@ ${input.slice(result.pos)}
|
|
|
10377
10650
|
return result;
|
|
10378
10651
|
}
|
|
10379
10652
|
}
|
|
10380
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
10653
|
+
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeArguments ">"'));
|
|
10381
10654
|
function TypeArguments(state) {
|
|
10382
10655
|
if (state.events) {
|
|
10383
10656
|
const result = state.events.enter?.("TypeArguments", state);
|
|
@@ -10396,7 +10669,7 @@ ${input.slice(result.pos)}
|
|
|
10396
10669
|
return result;
|
|
10397
10670
|
}
|
|
10398
10671
|
}
|
|
10399
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
10672
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
10400
10673
|
return { ts: true, children: $0 };
|
|
10401
10674
|
});
|
|
10402
10675
|
function TypeParameters(state) {
|
|
@@ -10436,7 +10709,7 @@ ${input.slice(result.pos)}
|
|
|
10436
10709
|
return result;
|
|
10437
10710
|
}
|
|
10438
10711
|
}
|
|
10439
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
10712
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L5, fail, 'TypeConstraint "extends"'), Type);
|
|
10440
10713
|
function TypeConstraint(state) {
|
|
10441
10714
|
if (state.events) {
|
|
10442
10715
|
const result = state.events.enter?.("TypeConstraint", state);
|
|
@@ -10481,7 +10754,7 @@ ${input.slice(result.pos)}
|
|
|
10481
10754
|
return result;
|
|
10482
10755
|
}
|
|
10483
10756
|
}
|
|
10484
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
10757
|
+
var Shebang$0 = $S($R$0($EXPECT($R47, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
10485
10758
|
function Shebang(state) {
|
|
10486
10759
|
if (state.events) {
|
|
10487
10760
|
const result = state.events.enter?.("Shebang", state);
|
|
@@ -10500,11 +10773,11 @@ ${input.slice(result.pos)}
|
|
|
10500
10773
|
return result;
|
|
10501
10774
|
}
|
|
10502
10775
|
}
|
|
10503
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
10776
|
+
var CivetPrologue$0 = $T($S($EXPECT($R48, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
10504
10777
|
var content = value[2];
|
|
10505
10778
|
return content;
|
|
10506
10779
|
});
|
|
10507
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
10780
|
+
var CivetPrologue$1 = $T($S($EXPECT($R48, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
10508
10781
|
var content = value[2];
|
|
10509
10782
|
return content;
|
|
10510
10783
|
});
|
|
@@ -10526,7 +10799,7 @@ ${input.slice(result.pos)}
|
|
|
10526
10799
|
return result;
|
|
10527
10800
|
}
|
|
10528
10801
|
}
|
|
10529
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
10802
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L154, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R49, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
10530
10803
|
var options = $2;
|
|
10531
10804
|
return {
|
|
10532
10805
|
type: "CivetPrologue",
|
|
@@ -10552,7 +10825,7 @@ ${input.slice(result.pos)}
|
|
|
10552
10825
|
return result;
|
|
10553
10826
|
}
|
|
10554
10827
|
}
|
|
10555
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
10828
|
+
var CivetOption$0 = $TR($EXPECT($R50, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10556
10829
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
10557
10830
|
if (l)
|
|
10558
10831
|
return l.toUpperCase();
|
|
@@ -10579,7 +10852,7 @@ ${input.slice(result.pos)}
|
|
|
10579
10852
|
return result;
|
|
10580
10853
|
}
|
|
10581
10854
|
}
|
|
10582
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
10855
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R48, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
10583
10856
|
function UnknownPrologue(state) {
|
|
10584
10857
|
if (state.events) {
|
|
10585
10858
|
const result = state.events.enter?.("UnknownPrologue", state);
|
|
@@ -10637,7 +10910,7 @@ ${input.slice(result.pos)}
|
|
|
10637
10910
|
return result;
|
|
10638
10911
|
}
|
|
10639
10912
|
}
|
|
10640
|
-
var EOL$0 = $TR($EXPECT($
|
|
10913
|
+
var EOL$0 = $TR($EXPECT($R51, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10641
10914
|
return { $loc, token: $0 };
|
|
10642
10915
|
});
|
|
10643
10916
|
function EOL(state) {
|
|
@@ -10658,7 +10931,7 @@ ${input.slice(result.pos)}
|
|
|
10658
10931
|
return result;
|
|
10659
10932
|
}
|
|
10660
10933
|
}
|
|
10661
|
-
var Debugger$0 = $TV($EXPECT($
|
|
10934
|
+
var Debugger$0 = $TV($EXPECT($L14, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
10662
10935
|
debugger;
|
|
10663
10936
|
});
|
|
10664
10937
|
function Debugger(state) {
|
|
@@ -10679,7 +10952,7 @@ ${input.slice(result.pos)}
|
|
|
10679
10952
|
return result;
|
|
10680
10953
|
}
|
|
10681
10954
|
}
|
|
10682
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
10955
|
+
var InsertOpenParen$0 = $TV($EXPECT($L14, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
10683
10956
|
return { $loc, token: "(" };
|
|
10684
10957
|
});
|
|
10685
10958
|
function InsertOpenParen(state) {
|
|
@@ -10700,7 +10973,7 @@ ${input.slice(result.pos)}
|
|
|
10700
10973
|
return result;
|
|
10701
10974
|
}
|
|
10702
10975
|
}
|
|
10703
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
10976
|
+
var InsertCloseParen$0 = $TV($EXPECT($L14, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
10704
10977
|
return { $loc, token: ")" };
|
|
10705
10978
|
});
|
|
10706
10979
|
function InsertCloseParen(state) {
|
|
@@ -10721,7 +10994,7 @@ ${input.slice(result.pos)}
|
|
|
10721
10994
|
return result;
|
|
10722
10995
|
}
|
|
10723
10996
|
}
|
|
10724
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
10997
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L14, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
10725
10998
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
10726
10999
|
});
|
|
10727
11000
|
function InsertOpenBrace(state) {
|
|
@@ -10742,7 +11015,7 @@ ${input.slice(result.pos)}
|
|
|
10742
11015
|
return result;
|
|
10743
11016
|
}
|
|
10744
11017
|
}
|
|
10745
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
11018
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L14, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
10746
11019
|
return { $loc, token: "}" };
|
|
10747
11020
|
});
|
|
10748
11021
|
function InsertCloseBrace(state) {
|
|
@@ -10763,7 +11036,7 @@ ${input.slice(result.pos)}
|
|
|
10763
11036
|
return result;
|
|
10764
11037
|
}
|
|
10765
11038
|
}
|
|
10766
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
11039
|
+
var InsertConst$0 = $TV($EXPECT($L14, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
10767
11040
|
return { $loc, token: "const " };
|
|
10768
11041
|
});
|
|
10769
11042
|
function InsertConst(state) {
|
|
@@ -10784,7 +11057,7 @@ ${input.slice(result.pos)}
|
|
|
10784
11057
|
return result;
|
|
10785
11058
|
}
|
|
10786
11059
|
}
|
|
10787
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
11060
|
+
var InsertReadonly$0 = $TV($EXPECT($L14, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
10788
11061
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
10789
11062
|
});
|
|
10790
11063
|
function InsertReadonly(state) {
|
|
@@ -10805,7 +11078,7 @@ ${input.slice(result.pos)}
|
|
|
10805
11078
|
return result;
|
|
10806
11079
|
}
|
|
10807
11080
|
}
|
|
10808
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
11081
|
+
var InsertNewline$0 = $TV($EXPECT($L14, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
10809
11082
|
return "\n";
|
|
10810
11083
|
});
|
|
10811
11084
|
function InsertNewline(state) {
|
|
@@ -10826,7 +11099,7 @@ ${input.slice(result.pos)}
|
|
|
10826
11099
|
return result;
|
|
10827
11100
|
}
|
|
10828
11101
|
}
|
|
10829
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
11102
|
+
var InsertIndent$0 = $TV($EXPECT($L14, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
10830
11103
|
return module2.currentIndent.token;
|
|
10831
11104
|
});
|
|
10832
11105
|
function InsertIndent(state) {
|
|
@@ -10847,7 +11120,7 @@ ${input.slice(result.pos)}
|
|
|
10847
11120
|
return result;
|
|
10848
11121
|
}
|
|
10849
11122
|
}
|
|
10850
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
11123
|
+
var InsertSpace$0 = $TV($EXPECT($L14, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
10851
11124
|
return { $loc, token: " " };
|
|
10852
11125
|
});
|
|
10853
11126
|
function InsertSpace(state) {
|
|
@@ -10868,7 +11141,7 @@ ${input.slice(result.pos)}
|
|
|
10868
11141
|
return result;
|
|
10869
11142
|
}
|
|
10870
11143
|
}
|
|
10871
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
11144
|
+
var InsertDot$0 = $TV($EXPECT($L14, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
10872
11145
|
return { $loc, token: "." };
|
|
10873
11146
|
});
|
|
10874
11147
|
function InsertDot(state) {
|
|
@@ -10889,7 +11162,7 @@ ${input.slice(result.pos)}
|
|
|
10889
11162
|
return result;
|
|
10890
11163
|
}
|
|
10891
11164
|
}
|
|
10892
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
11165
|
+
var InsertBreak$0 = $TV($EXPECT($L14, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
10893
11166
|
return { $loc, token: ";break;" };
|
|
10894
11167
|
});
|
|
10895
11168
|
function InsertBreak(state) {
|
|
@@ -10910,7 +11183,7 @@ ${input.slice(result.pos)}
|
|
|
10910
11183
|
return result;
|
|
10911
11184
|
}
|
|
10912
11185
|
}
|
|
10913
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
11186
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
10914
11187
|
if (module2.config.coffeeBinaryExistential)
|
|
10915
11188
|
return;
|
|
10916
11189
|
return $skip;
|
|
@@ -10933,7 +11206,7 @@ ${input.slice(result.pos)}
|
|
|
10933
11206
|
return result;
|
|
10934
11207
|
}
|
|
10935
11208
|
}
|
|
10936
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
11209
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
10937
11210
|
if (module2.config.coffeeBooleans)
|
|
10938
11211
|
return;
|
|
10939
11212
|
return $skip;
|
|
@@ -10956,7 +11229,7 @@ ${input.slice(result.pos)}
|
|
|
10956
11229
|
return result;
|
|
10957
11230
|
}
|
|
10958
11231
|
}
|
|
10959
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
11232
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
10960
11233
|
if (module2.config.coffeeClasses)
|
|
10961
11234
|
return;
|
|
10962
11235
|
return $skip;
|
|
@@ -10979,7 +11252,7 @@ ${input.slice(result.pos)}
|
|
|
10979
11252
|
return result;
|
|
10980
11253
|
}
|
|
10981
11254
|
}
|
|
10982
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
11255
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
10983
11256
|
if (module2.config.coffeeComment)
|
|
10984
11257
|
return;
|
|
10985
11258
|
return $skip;
|
|
@@ -11002,7 +11275,7 @@ ${input.slice(result.pos)}
|
|
|
11002
11275
|
return result;
|
|
11003
11276
|
}
|
|
11004
11277
|
}
|
|
11005
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
11278
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11006
11279
|
if (module2.config.coffeeDo)
|
|
11007
11280
|
return;
|
|
11008
11281
|
return $skip;
|
|
@@ -11025,7 +11298,7 @@ ${input.slice(result.pos)}
|
|
|
11025
11298
|
return result;
|
|
11026
11299
|
}
|
|
11027
11300
|
}
|
|
11028
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
11301
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11029
11302
|
if (module2.config.coffeeForLoops)
|
|
11030
11303
|
return;
|
|
11031
11304
|
return $skip;
|
|
@@ -11048,7 +11321,7 @@ ${input.slice(result.pos)}
|
|
|
11048
11321
|
return result;
|
|
11049
11322
|
}
|
|
11050
11323
|
}
|
|
11051
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
11324
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11052
11325
|
if (module2.config.coffeeInterpolation)
|
|
11053
11326
|
return;
|
|
11054
11327
|
return $skip;
|
|
@@ -11071,7 +11344,7 @@ ${input.slice(result.pos)}
|
|
|
11071
11344
|
return result;
|
|
11072
11345
|
}
|
|
11073
11346
|
}
|
|
11074
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
11347
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11075
11348
|
if (module2.config.coffeeIsnt)
|
|
11076
11349
|
return;
|
|
11077
11350
|
return $skip;
|
|
@@ -11094,7 +11367,7 @@ ${input.slice(result.pos)}
|
|
|
11094
11367
|
return result;
|
|
11095
11368
|
}
|
|
11096
11369
|
}
|
|
11097
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
11370
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11098
11371
|
if (module2.config.coffeeLineContinuation)
|
|
11099
11372
|
return;
|
|
11100
11373
|
return $skip;
|
|
@@ -11117,7 +11390,7 @@ ${input.slice(result.pos)}
|
|
|
11117
11390
|
return result;
|
|
11118
11391
|
}
|
|
11119
11392
|
}
|
|
11120
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
11393
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11121
11394
|
if (module2.config.coffeeNot)
|
|
11122
11395
|
return;
|
|
11123
11396
|
return $skip;
|
|
@@ -11140,7 +11413,7 @@ ${input.slice(result.pos)}
|
|
|
11140
11413
|
return result;
|
|
11141
11414
|
}
|
|
11142
11415
|
}
|
|
11143
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
11416
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11144
11417
|
if (module2.config.coffeeOf)
|
|
11145
11418
|
return;
|
|
11146
11419
|
return $skip;
|
|
@@ -11163,7 +11436,7 @@ ${input.slice(result.pos)}
|
|
|
11163
11436
|
return result;
|
|
11164
11437
|
}
|
|
11165
11438
|
}
|
|
11166
|
-
var Reset$0 = $TV($EXPECT($
|
|
11439
|
+
var Reset$0 = $TV($EXPECT($L14, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
11167
11440
|
module2.indentLevels = [{
|
|
11168
11441
|
level: 0,
|
|
11169
11442
|
token: ""
|
|
@@ -11288,7 +11561,7 @@ ${input.slice(result.pos)}
|
|
|
11288
11561
|
return result;
|
|
11289
11562
|
}
|
|
11290
11563
|
}
|
|
11291
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
11564
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L14, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
11292
11565
|
var directives = $2;
|
|
11293
11566
|
directives.forEach((directive) => {
|
|
11294
11567
|
if (directive.type === "CivetPrologue") {
|
|
@@ -11870,7 +12143,7 @@ ${input.slice(result.pos)}
|
|
|
11870
12143
|
return result;
|
|
11871
12144
|
}
|
|
11872
12145
|
}
|
|
11873
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
12146
|
+
var Indent$0 = $TV($Q($C($EXPECT($L155, fail, 'Indent " "'), $EXPECT($L156, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
11874
12147
|
const level = $1.length;
|
|
11875
12148
|
return {
|
|
11876
12149
|
$loc,
|
|
@@ -11995,7 +12268,7 @@ ${input.slice(result.pos)}
|
|
|
11995
12268
|
return result;
|
|
11996
12269
|
}
|
|
11997
12270
|
}
|
|
11998
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
12271
|
+
var PopIndent$0 = $TV($EXPECT($L14, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
11999
12272
|
if (module2.verbose) {
|
|
12000
12273
|
console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
|
|
12001
12274
|
}
|
|
@@ -12096,10 +12369,12 @@ var require_generate = __commonJS({
|
|
|
12096
12369
|
return token;
|
|
12097
12370
|
}
|
|
12098
12371
|
if (!node.children) {
|
|
12372
|
+
debugger;
|
|
12099
12373
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
12100
12374
|
}
|
|
12101
12375
|
return gen2(node.children, options);
|
|
12102
12376
|
}
|
|
12377
|
+
debugger;
|
|
12103
12378
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
12104
12379
|
};
|
|
12105
12380
|
module2.exports = gen2;
|
|
@@ -12538,8 +12813,6 @@ makeCache = function() {
|
|
|
12538
12813
|
case "InsertIndent":
|
|
12539
12814
|
case "Arguments":
|
|
12540
12815
|
case "ArgumentsWithTrailingCallExpressions":
|
|
12541
|
-
case "ImplicitApplication":
|
|
12542
|
-
case "IndentedApplicationAllowed":
|
|
12543
12816
|
case "ApplicationStart":
|
|
12544
12817
|
case "CallExpression":
|
|
12545
12818
|
case "CallExpressionRest":
|
|
@@ -12553,7 +12826,8 @@ makeCache = function() {
|
|
|
12553
12826
|
case "ShortCircuitExpression":
|
|
12554
12827
|
case "NestedPropertyDefinitions":
|
|
12555
12828
|
case "NestedObject":
|
|
12556
|
-
case "
|
|
12829
|
+
case "NestedImplicitObjectLiteral":
|
|
12830
|
+
case "NestedImplicitPropertyDefinitions":
|
|
12557
12831
|
case "NestedBlockStatement":
|
|
12558
12832
|
case "NestedInterfaceProperty":
|
|
12559
12833
|
case "AssignmentExpressionTail":
|
|
@@ -12563,6 +12837,7 @@ makeCache = function() {
|
|
|
12563
12837
|
case "ElseClause":
|
|
12564
12838
|
case "CoffeeCommentEnabled":
|
|
12565
12839
|
case "SingleLineComment":
|
|
12840
|
+
case "Debugger":
|
|
12566
12841
|
break;
|
|
12567
12842
|
default:
|
|
12568
12843
|
cache = /* @__PURE__ */ new Map();
|