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