@danielx/civet 0.5.68 → 0.5.70
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/dist/browser.js +884 -325
- package/dist/civet +0 -0
- package/dist/main.js +884 -325
- package/dist/main.mjs +884 -325
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -440,7 +440,7 @@ ${input.slice(result.pos)}
|
|
|
440
440
|
ForbiddenImplicitCalls,
|
|
441
441
|
ArgumentsWithTrailingMemberExpressions,
|
|
442
442
|
TrailingMemberExpressions,
|
|
443
|
-
|
|
443
|
+
AllowedTrailingMemberExpressions,
|
|
444
444
|
CommaDelimiter,
|
|
445
445
|
ArgumentList,
|
|
446
446
|
NonPipelineArgumentList,
|
|
@@ -609,6 +609,7 @@ ${input.slice(result.pos)}
|
|
|
609
609
|
PropertyDefinitionList,
|
|
610
610
|
PropertyDefinition,
|
|
611
611
|
NamedProperty,
|
|
612
|
+
ImplicitNamedProperty,
|
|
612
613
|
SnugNamedProperty,
|
|
613
614
|
PropertyName,
|
|
614
615
|
ComputedPropertyName,
|
|
@@ -637,6 +638,9 @@ ${input.slice(result.pos)}
|
|
|
637
638
|
Statement,
|
|
638
639
|
EmptyStatement,
|
|
639
640
|
BlockStatement,
|
|
641
|
+
LabelledStatement,
|
|
642
|
+
Label,
|
|
643
|
+
LabelledItem,
|
|
640
644
|
IfStatement,
|
|
641
645
|
ElseClause,
|
|
642
646
|
IfClause,
|
|
@@ -682,13 +686,26 @@ ${input.slice(result.pos)}
|
|
|
682
686
|
FinallyClause,
|
|
683
687
|
CatchParameter,
|
|
684
688
|
Condition,
|
|
685
|
-
|
|
686
|
-
|
|
689
|
+
ExpressionWithIndentedApplicationForbidden,
|
|
690
|
+
ForbidIndentedApplication,
|
|
691
|
+
AllowIndentedApplication,
|
|
692
|
+
RestoreIndentedApplication,
|
|
687
693
|
IndentedApplicationAllowed,
|
|
688
|
-
|
|
694
|
+
ForbidTrailingMemberProperty,
|
|
695
|
+
AllowTrailingMemberProperty,
|
|
696
|
+
RestoreTrailingMemberProperty,
|
|
689
697
|
TrailingMemberPropertyAllowed,
|
|
698
|
+
ForbidMultiLineImplicitObjectLiteral,
|
|
699
|
+
AllowMultiLineImplicitObjectLiteral,
|
|
700
|
+
RestoreMultiLineImplicitObjectLiteral,
|
|
701
|
+
MultiLineImplicitObjectLiteralAllowed,
|
|
702
|
+
AllowAll,
|
|
703
|
+
RestoreAll,
|
|
690
704
|
ExpressionStatement,
|
|
691
705
|
KeywordStatement,
|
|
706
|
+
Break,
|
|
707
|
+
Continue,
|
|
708
|
+
Debugger,
|
|
692
709
|
DebuggerExpression,
|
|
693
710
|
ThrowExpression,
|
|
694
711
|
MaybeNestedExpression,
|
|
@@ -867,6 +884,7 @@ ${input.slice(result.pos)}
|
|
|
867
884
|
JSXElement,
|
|
868
885
|
JSXSelfClosingElement,
|
|
869
886
|
PushJSXOpeningElement,
|
|
887
|
+
PopJSXStack,
|
|
870
888
|
JSXOpeningElement,
|
|
871
889
|
JSXOptionalClosingElement,
|
|
872
890
|
JSXClosingElement,
|
|
@@ -966,7 +984,7 @@ ${input.slice(result.pos)}
|
|
|
966
984
|
DirectivePrologue,
|
|
967
985
|
EOS,
|
|
968
986
|
EOL,
|
|
969
|
-
|
|
987
|
+
DebugHere,
|
|
970
988
|
InsertSemicolon,
|
|
971
989
|
InsertOpenParen,
|
|
972
990
|
InsertCloseParen,
|
|
@@ -1094,98 +1112,99 @@ ${input.slice(result.pos)}
|
|
|
1094
1112
|
var $L82 = $L("&");
|
|
1095
1113
|
var $L83 = $L("|");
|
|
1096
1114
|
var $L84 = $L(";");
|
|
1097
|
-
var $L85 = $L("
|
|
1098
|
-
var $L86 = $L("
|
|
1099
|
-
var $L87 = $L("
|
|
1100
|
-
var $L88 = $L("
|
|
1101
|
-
var $L89 = $L("
|
|
1102
|
-
var $L90 = $L("
|
|
1103
|
-
var $L91 = $L("
|
|
1104
|
-
var $L92 = $L("
|
|
1105
|
-
var $L93 = $L("
|
|
1106
|
-
var $L94 = $L("
|
|
1107
|
-
var $L95 = $L("
|
|
1108
|
-
var $L96 = $L("
|
|
1109
|
-
var $L97 = $L("
|
|
1110
|
-
var $L98 = $L("
|
|
1111
|
-
var $L99 = $L("
|
|
1112
|
-
var $L100 = $L("
|
|
1113
|
-
var $L101 = $L("
|
|
1114
|
-
var $L102 = $L("
|
|
1115
|
-
var $L103 = $L("
|
|
1116
|
-
var $L104 = $L("
|
|
1117
|
-
var $L105 = $L("
|
|
1118
|
-
var $L106 = $L("
|
|
1119
|
-
var $L107 = $L("
|
|
1120
|
-
var $L108 = $L("
|
|
1121
|
-
var $L109 = $L("
|
|
1122
|
-
var $L110 = $L("
|
|
1123
|
-
var $L111 = $L("
|
|
1124
|
-
var $L112 = $L("
|
|
1125
|
-
var $L113 = $L("
|
|
1126
|
-
var $L114 = $L("
|
|
1127
|
-
var $L115 = $L(
|
|
1128
|
-
var $L116 = $L("
|
|
1129
|
-
var $L117 = $L("
|
|
1130
|
-
var $L118 = $L("
|
|
1131
|
-
var $L119 = $L("
|
|
1132
|
-
var $L120 = $L("
|
|
1133
|
-
var $L121 = $L("
|
|
1134
|
-
var $L122 = $L("
|
|
1135
|
-
var $L123 = $L("
|
|
1136
|
-
var $L124 = $L("
|
|
1137
|
-
var $L125 = $L("
|
|
1138
|
-
var $L126 = $L("
|
|
1139
|
-
var $L127 = $L("
|
|
1140
|
-
var $L128 = $L("
|
|
1141
|
-
var $L129 = $L("
|
|
1142
|
-
var $L130 = $L("
|
|
1143
|
-
var $L131 = $L("
|
|
1144
|
-
var $L132 = $L("
|
|
1145
|
-
var $L133 = $L("
|
|
1146
|
-
var $L134 = $L("
|
|
1147
|
-
var $L135 = $L("
|
|
1148
|
-
var $L136 = $L("
|
|
1149
|
-
var $L137 = $L("
|
|
1150
|
-
var $L138 = $L("
|
|
1151
|
-
var $L139 = $L("
|
|
1152
|
-
var $L140 = $L("
|
|
1153
|
-
var $L141 = $L("
|
|
1154
|
-
var $L142 = $L("
|
|
1155
|
-
var $L143 = $L("
|
|
1156
|
-
var $L144 = $L("
|
|
1157
|
-
var $L145 = $L("
|
|
1158
|
-
var $L146 = $L("
|
|
1159
|
-
var $L147 = $L("
|
|
1160
|
-
var $L148 = $L("
|
|
1161
|
-
var $L149 = $L("
|
|
1162
|
-
var $L150 = $L(
|
|
1163
|
-
var $L151 = $L("'
|
|
1164
|
-
var $L152 = $L("
|
|
1165
|
-
var $L153 = $L("
|
|
1166
|
-
var $L154 = $L("
|
|
1167
|
-
var $L155 = $L("
|
|
1168
|
-
var $L156 = $L("
|
|
1169
|
-
var $L157 = $L("
|
|
1170
|
-
var $L158 = $L("
|
|
1171
|
-
var $L159 = $L("
|
|
1172
|
-
var $L160 = $L("
|
|
1173
|
-
var $L161 = $L("
|
|
1174
|
-
var $L162 = $L("
|
|
1175
|
-
var $L163 = $L("
|
|
1176
|
-
var $L164 = $L("
|
|
1177
|
-
var $L165 = $L("
|
|
1178
|
-
var $L166 = $L("
|
|
1179
|
-
var $L167 = $L("
|
|
1180
|
-
var $L168 = $L("
|
|
1181
|
-
var $L169 = $L("
|
|
1182
|
-
var $L170 = $L("
|
|
1183
|
-
var $L171 = $L("
|
|
1184
|
-
var $L172 = $L("
|
|
1185
|
-
var $L173 = $L("
|
|
1186
|
-
var $L174 = $L("
|
|
1187
|
-
var $L175 = $L("
|
|
1188
|
-
var $L176 = $L("
|
|
1115
|
+
var $L85 = $L("$:");
|
|
1116
|
+
var $L86 = $L("own");
|
|
1117
|
+
var $L87 = $L("break");
|
|
1118
|
+
var $L88 = $L("continue");
|
|
1119
|
+
var $L89 = $L("debugger");
|
|
1120
|
+
var $L90 = $L("assert");
|
|
1121
|
+
var $L91 = $L(":=");
|
|
1122
|
+
var $L92 = $L(".=");
|
|
1123
|
+
var $L93 = $L("/*");
|
|
1124
|
+
var $L94 = $L("*/");
|
|
1125
|
+
var $L95 = $L("\\");
|
|
1126
|
+
var $L96 = $L("[");
|
|
1127
|
+
var $L97 = $L("`");
|
|
1128
|
+
var $L98 = $L("abstract");
|
|
1129
|
+
var $L99 = $L("as");
|
|
1130
|
+
var $L100 = $L("@");
|
|
1131
|
+
var $L101 = $L("@@");
|
|
1132
|
+
var $L102 = $L("async");
|
|
1133
|
+
var $L103 = $L("await");
|
|
1134
|
+
var $L104 = $L("by");
|
|
1135
|
+
var $L105 = $L("case");
|
|
1136
|
+
var $L106 = $L("catch");
|
|
1137
|
+
var $L107 = $L("class");
|
|
1138
|
+
var $L108 = $L("#{");
|
|
1139
|
+
var $L109 = $L("declare");
|
|
1140
|
+
var $L110 = $L("default");
|
|
1141
|
+
var $L111 = $L("delete");
|
|
1142
|
+
var $L112 = $L("do");
|
|
1143
|
+
var $L113 = $L("..");
|
|
1144
|
+
var $L114 = $L("...");
|
|
1145
|
+
var $L115 = $L("::");
|
|
1146
|
+
var $L116 = $L('"');
|
|
1147
|
+
var $L117 = $L("else");
|
|
1148
|
+
var $L118 = $L("export");
|
|
1149
|
+
var $L119 = $L("extends");
|
|
1150
|
+
var $L120 = $L("finally");
|
|
1151
|
+
var $L121 = $L("for");
|
|
1152
|
+
var $L122 = $L("from");
|
|
1153
|
+
var $L123 = $L("function");
|
|
1154
|
+
var $L124 = $L("get");
|
|
1155
|
+
var $L125 = $L("set");
|
|
1156
|
+
var $L126 = $L("if");
|
|
1157
|
+
var $L127 = $L("let");
|
|
1158
|
+
var $L128 = $L("const");
|
|
1159
|
+
var $L129 = $L("loop");
|
|
1160
|
+
var $L130 = $L("new");
|
|
1161
|
+
var $L131 = $L("<");
|
|
1162
|
+
var $L132 = $L("{");
|
|
1163
|
+
var $L133 = $L("operator");
|
|
1164
|
+
var $L134 = $L("public");
|
|
1165
|
+
var $L135 = $L("private");
|
|
1166
|
+
var $L136 = $L("protected");
|
|
1167
|
+
var $L137 = $L("||>");
|
|
1168
|
+
var $L138 = $L("|>=");
|
|
1169
|
+
var $L139 = $L("|>");
|
|
1170
|
+
var $L140 = $L("readonly");
|
|
1171
|
+
var $L141 = $L("return");
|
|
1172
|
+
var $L142 = $L("satisfies");
|
|
1173
|
+
var $L143 = $L("'");
|
|
1174
|
+
var $L144 = $L("static");
|
|
1175
|
+
var $L145 = $L("${");
|
|
1176
|
+
var $L146 = $L("switch");
|
|
1177
|
+
var $L147 = $L("target");
|
|
1178
|
+
var $L148 = $L("then");
|
|
1179
|
+
var $L149 = $L("this");
|
|
1180
|
+
var $L150 = $L("throw");
|
|
1181
|
+
var $L151 = $L('"""');
|
|
1182
|
+
var $L152 = $L("'''");
|
|
1183
|
+
var $L153 = $L("///");
|
|
1184
|
+
var $L154 = $L("```");
|
|
1185
|
+
var $L155 = $L("try");
|
|
1186
|
+
var $L156 = $L("typeof");
|
|
1187
|
+
var $L157 = $L("unless");
|
|
1188
|
+
var $L158 = $L("until");
|
|
1189
|
+
var $L159 = $L("var");
|
|
1190
|
+
var $L160 = $L("void");
|
|
1191
|
+
var $L161 = $L("when");
|
|
1192
|
+
var $L162 = $L("while");
|
|
1193
|
+
var $L163 = $L("yield");
|
|
1194
|
+
var $L164 = $L("/>");
|
|
1195
|
+
var $L165 = $L("</");
|
|
1196
|
+
var $L166 = $L("<>");
|
|
1197
|
+
var $L167 = $L("</>");
|
|
1198
|
+
var $L168 = $L("<!--");
|
|
1199
|
+
var $L169 = $L("-->");
|
|
1200
|
+
var $L170 = $L("type");
|
|
1201
|
+
var $L171 = $L("interface");
|
|
1202
|
+
var $L172 = $L("namespace");
|
|
1203
|
+
var $L173 = $L("asserts");
|
|
1204
|
+
var $L174 = $L("keyof");
|
|
1205
|
+
var $L175 = $L("infer");
|
|
1206
|
+
var $L176 = $L("[]");
|
|
1207
|
+
var $L177 = $L("civet");
|
|
1189
1208
|
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1190
1209
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1191
1210
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -1195,7 +1214,7 @@ ${input.slice(result.pos)}
|
|
|
1195
1214
|
var $R6 = $R(new RegExp("[!+-]", "suy"));
|
|
1196
1215
|
var $R7 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
1197
1216
|
var $R8 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
1198
|
-
var $R9 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1217
|
+
var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1199
1218
|
var $R10 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
1200
1219
|
var $R11 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
1201
1220
|
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
@@ -1240,16 +1259,17 @@ ${input.slice(result.pos)}
|
|
|
1240
1259
|
var $R51 = $R(new RegExp("[\\s>]", "suy"));
|
|
1241
1260
|
var $R52 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
1242
1261
|
var $R53 = $R(new RegExp("[<>]", "suy"));
|
|
1243
|
-
var $R54 = $R(new RegExp("
|
|
1244
|
-
var $R55 = $R(new RegExp("[
|
|
1245
|
-
var $R56 = $R(new RegExp("[
|
|
1246
|
-
var $R57 = $R(new RegExp("[+-]", "suy"));
|
|
1247
|
-
var $R58 = $R(new RegExp("
|
|
1248
|
-
var $R59 = $R(new RegExp("[\\
|
|
1249
|
-
var $R60 = $R(new RegExp("[\\
|
|
1250
|
-
var $R61 = $R(new RegExp("
|
|
1251
|
-
var $R62 = $R(new RegExp("\\
|
|
1252
|
-
var $R63 = $R(new RegExp("
|
|
1262
|
+
var $R54 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1263
|
+
var $R55 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
1264
|
+
var $R56 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
1265
|
+
var $R57 = $R(new RegExp("[+-]?", "suy"));
|
|
1266
|
+
var $R58 = $R(new RegExp("[+-]", "suy"));
|
|
1267
|
+
var $R59 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1268
|
+
var $R60 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1269
|
+
var $R61 = $R(new RegExp("[\\s]*", "suy"));
|
|
1270
|
+
var $R62 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1271
|
+
var $R63 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1272
|
+
var $R64 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1253
1273
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1254
1274
|
var statements = $4;
|
|
1255
1275
|
module2.processProgram(statements);
|
|
@@ -1463,9 +1483,8 @@ ${input.slice(result.pos)}
|
|
|
1463
1483
|
}
|
|
1464
1484
|
}
|
|
1465
1485
|
var Arguments$0 = ExplicitArguments;
|
|
1466
|
-
var Arguments$1 = $TS($S(
|
|
1486
|
+
var Arguments$1 = $TS($S(ForbidTrailingMemberProperty, $E(ImplicitArguments), RestoreTrailingMemberProperty), function($skip, $loc, $0, $1, $2, $3) {
|
|
1467
1487
|
var args = $2;
|
|
1468
|
-
module2.suppressTrailingMemberProperty.pop();
|
|
1469
1488
|
if (args)
|
|
1470
1489
|
return args;
|
|
1471
1490
|
return $skip;
|
|
@@ -1656,14 +1675,14 @@ ${input.slice(result.pos)}
|
|
|
1656
1675
|
return result;
|
|
1657
1676
|
}
|
|
1658
1677
|
}
|
|
1659
|
-
var
|
|
1678
|
+
var AllowedTrailingMemberExpressions$0 = $T($S(TrailingMemberPropertyAllowed, TrailingMemberExpressions), function(value) {
|
|
1660
1679
|
return value[1];
|
|
1661
1680
|
});
|
|
1662
|
-
var
|
|
1663
|
-
function
|
|
1681
|
+
var AllowedTrailingMemberExpressions$1 = $Q(MemberExpressionRest);
|
|
1682
|
+
function AllowedTrailingMemberExpressions(state) {
|
|
1664
1683
|
let eventData;
|
|
1665
1684
|
if (state.events) {
|
|
1666
|
-
const result = state.events.enter?.("
|
|
1685
|
+
const result = state.events.enter?.("AllowedTrailingMemberExpressions", state);
|
|
1667
1686
|
if (result) {
|
|
1668
1687
|
if (result.cache)
|
|
1669
1688
|
return result.cache;
|
|
@@ -1671,14 +1690,14 @@ ${input.slice(result.pos)}
|
|
|
1671
1690
|
}
|
|
1672
1691
|
}
|
|
1673
1692
|
if (state.tokenize) {
|
|
1674
|
-
const result = $TOKEN("
|
|
1693
|
+
const result = $TOKEN("AllowedTrailingMemberExpressions", state, AllowedTrailingMemberExpressions$0(state) || AllowedTrailingMemberExpressions$1(state));
|
|
1675
1694
|
if (state.events)
|
|
1676
|
-
state.events.exit?.("
|
|
1695
|
+
state.events.exit?.("AllowedTrailingMemberExpressions", state, result, eventData);
|
|
1677
1696
|
return result;
|
|
1678
1697
|
} else {
|
|
1679
|
-
const result =
|
|
1698
|
+
const result = AllowedTrailingMemberExpressions$0(state) || AllowedTrailingMemberExpressions$1(state);
|
|
1680
1699
|
if (state.events)
|
|
1681
|
-
state.events.exit?.("
|
|
1700
|
+
state.events.exit?.("AllowedTrailingMemberExpressions", state, result, eventData);
|
|
1682
1701
|
return result;
|
|
1683
1702
|
}
|
|
1684
1703
|
}
|
|
@@ -2063,11 +2082,21 @@ ${input.slice(result.pos)}
|
|
|
2063
2082
|
return result;
|
|
2064
2083
|
}
|
|
2065
2084
|
}
|
|
2066
|
-
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression)
|
|
2085
|
+
var UpdateExpression$0 = $TS($S(UpdateExpressionSymbol, UnaryExpression), function($skip, $loc, $0, $1, $2) {
|
|
2086
|
+
return {
|
|
2087
|
+
type: "UpdateExpression",
|
|
2088
|
+
assigned: $2,
|
|
2089
|
+
children: $0
|
|
2090
|
+
};
|
|
2091
|
+
});
|
|
2067
2092
|
var UpdateExpression$1 = $TS($S(LeftHandSideExpression, $E(UpdateExpressionSymbol)), function($skip, $loc, $0, $1, $2) {
|
|
2068
|
-
if (
|
|
2069
|
-
return $
|
|
2070
|
-
return
|
|
2093
|
+
if (!$2)
|
|
2094
|
+
return $1;
|
|
2095
|
+
return {
|
|
2096
|
+
type: "UpdateExpression",
|
|
2097
|
+
assigned: $1,
|
|
2098
|
+
children: $0
|
|
2099
|
+
};
|
|
2071
2100
|
});
|
|
2072
2101
|
function UpdateExpression(state) {
|
|
2073
2102
|
let eventData;
|
|
@@ -2227,7 +2256,7 @@ ${input.slice(result.pos)}
|
|
|
2227
2256
|
return result;
|
|
2228
2257
|
}
|
|
2229
2258
|
}
|
|
2230
|
-
var ActualAssignment$0 = $TS($S($P($S(__,
|
|
2259
|
+
var ActualAssignment$0 = $TS($S($P($S(__, UpdateExpression, WAssignmentOp)), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
2231
2260
|
$1 = $1.map((x) => [x[0], x[1], ...x[2]]);
|
|
2232
2261
|
$0 = [$1, $2];
|
|
2233
2262
|
return {
|
|
@@ -2235,6 +2264,7 @@ ${input.slice(result.pos)}
|
|
|
2235
2264
|
children: $0,
|
|
2236
2265
|
names: null,
|
|
2237
2266
|
lhs: $1,
|
|
2267
|
+
assigned: $1[0][1],
|
|
2238
2268
|
exp: $2
|
|
2239
2269
|
};
|
|
2240
2270
|
});
|
|
@@ -2644,15 +2674,18 @@ ${input.slice(result.pos)}
|
|
|
2644
2674
|
return result;
|
|
2645
2675
|
}
|
|
2646
2676
|
}
|
|
2647
|
-
var ParenthesizedExpression$0 = $TS($S(OpenParen, PostfixedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2648
|
-
var
|
|
2677
|
+
var ParenthesizedExpression$0 = $TS($S(OpenParen, AllowAll, $E($S(PostfixedExpression, __, CloseParen)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2678
|
+
var open = $1;
|
|
2679
|
+
if (!$3)
|
|
2680
|
+
return $skip;
|
|
2681
|
+
const [exp, ws, close] = $3;
|
|
2649
2682
|
switch (exp.type) {
|
|
2650
2683
|
case "IterationExpression":
|
|
2651
|
-
return
|
|
2684
|
+
return exp;
|
|
2652
2685
|
}
|
|
2653
2686
|
return {
|
|
2654
2687
|
type: "ParenthesizedExpression",
|
|
2655
|
-
children:
|
|
2688
|
+
children: [open, exp, ws, close],
|
|
2656
2689
|
expression: exp
|
|
2657
2690
|
};
|
|
2658
2691
|
});
|
|
@@ -2834,7 +2867,7 @@ ${input.slice(result.pos)}
|
|
|
2834
2867
|
return result;
|
|
2835
2868
|
}
|
|
2836
2869
|
}
|
|
2837
|
-
var ExtendsTarget$0 = $TS($S(
|
|
2870
|
+
var ExtendsTarget$0 = $TS($S(ExpressionWithIndentedApplicationForbidden, $E(TypeArguments)), function($skip, $loc, $0, $1, $2) {
|
|
2838
2871
|
var exp = $1;
|
|
2839
2872
|
var ta = $2;
|
|
2840
2873
|
exp = module2.makeLeftHandSideExpression(exp);
|
|
@@ -3274,7 +3307,7 @@ ${input.slice(result.pos)}
|
|
|
3274
3307
|
children: [$1, ...$2, ...rest.flat()]
|
|
3275
3308
|
});
|
|
3276
3309
|
});
|
|
3277
|
-
var CallExpression$2 = $TS($S(MemberExpression,
|
|
3310
|
+
var CallExpression$2 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3278
3311
|
var member = $1;
|
|
3279
3312
|
var trailing = $2;
|
|
3280
3313
|
var rest = $3;
|
|
@@ -6270,9 +6303,11 @@ ${input.slice(result.pos)}
|
|
|
6270
6303
|
var ArrayLiteral$0 = $T($S(ArrayBindingPattern, UpcomingAssignment), function(value) {
|
|
6271
6304
|
return value[0];
|
|
6272
6305
|
});
|
|
6273
|
-
var ArrayLiteral$1 = $TS($S(OpenBracket, ArrayLiteralContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6274
|
-
var
|
|
6275
|
-
|
|
6306
|
+
var ArrayLiteral$1 = $TS($S(OpenBracket, AllowAll, $E($S(ArrayLiteralContent, __, CloseBracket)), RestoreIndentedApplication, RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6307
|
+
var open = $1;
|
|
6308
|
+
if (!$3)
|
|
6309
|
+
return $skip;
|
|
6310
|
+
const [content, ws, close] = $3;
|
|
6276
6311
|
if (content.type === "RangeExpression") {
|
|
6277
6312
|
return {
|
|
6278
6313
|
...content,
|
|
@@ -6281,9 +6316,9 @@ ${input.slice(result.pos)}
|
|
|
6281
6316
|
}
|
|
6282
6317
|
let children;
|
|
6283
6318
|
if (Array.isArray(content)) {
|
|
6284
|
-
children = [
|
|
6319
|
+
children = [open, ...content, ...ws, close];
|
|
6285
6320
|
} else {
|
|
6286
|
-
children = [
|
|
6321
|
+
children = [open, content, ...ws, close];
|
|
6287
6322
|
}
|
|
6288
6323
|
const names = children.flatMap((c) => {
|
|
6289
6324
|
return c.names || [];
|
|
@@ -6688,10 +6723,11 @@ ${input.slice(result.pos)}
|
|
|
6688
6723
|
return result;
|
|
6689
6724
|
}
|
|
6690
6725
|
}
|
|
6691
|
-
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent),
|
|
6726
|
+
var BracedObjectLiteral$0 = $TS($S(OpenBrace, AllowAll, $E($S($E(BracedObjectLiteralContent), __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6692
6727
|
var open = $1;
|
|
6693
|
-
|
|
6694
|
-
|
|
6728
|
+
if (!$3)
|
|
6729
|
+
return $skip;
|
|
6730
|
+
const [content, ...close] = $3;
|
|
6695
6731
|
if (content) {
|
|
6696
6732
|
const children = [open, ...content, close];
|
|
6697
6733
|
return {
|
|
@@ -6811,7 +6847,7 @@ ${input.slice(result.pos)}
|
|
|
6811
6847
|
return result;
|
|
6812
6848
|
}
|
|
6813
6849
|
}
|
|
6814
|
-
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested,
|
|
6850
|
+
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, ImplicitNamedProperty, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
6815
6851
|
var ws = $1;
|
|
6816
6852
|
var prop = $2;
|
|
6817
6853
|
var delimiter = $3;
|
|
@@ -6900,7 +6936,7 @@ ${input.slice(result.pos)}
|
|
|
6900
6936
|
return result;
|
|
6901
6937
|
}
|
|
6902
6938
|
}
|
|
6903
|
-
var InlineObjectLiteral$0 = $TS($S(InsertInlineOpenBrace, SnugNamedProperty, ImplicitInlineObjectPropertyDelimiter, $Q($S($C(Samedent, $Q(_)),
|
|
6939
|
+
var InlineObjectLiteral$0 = $TS($S(InsertInlineOpenBrace, SnugNamedProperty, ImplicitInlineObjectPropertyDelimiter, $Q($S($C(Samedent, $Q(_)), ImplicitNamedProperty, ImplicitInlineObjectPropertyDelimiter)), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6904
6940
|
var open = $1;
|
|
6905
6941
|
var close = $5;
|
|
6906
6942
|
return {
|
|
@@ -7166,8 +7202,41 @@ ${input.slice(result.pos)}
|
|
|
7166
7202
|
return result;
|
|
7167
7203
|
}
|
|
7168
7204
|
}
|
|
7169
|
-
var
|
|
7170
|
-
var
|
|
7205
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, __, Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7206
|
+
var name = $1;
|
|
7207
|
+
var exp = $5;
|
|
7208
|
+
return {
|
|
7209
|
+
type: "Property",
|
|
7210
|
+
children: $0,
|
|
7211
|
+
name,
|
|
7212
|
+
names: exp.names || [],
|
|
7213
|
+
value: exp
|
|
7214
|
+
};
|
|
7215
|
+
});
|
|
7216
|
+
function ImplicitNamedProperty(state) {
|
|
7217
|
+
let eventData;
|
|
7218
|
+
if (state.events) {
|
|
7219
|
+
const result = state.events.enter?.("ImplicitNamedProperty", state);
|
|
7220
|
+
if (result) {
|
|
7221
|
+
if (result.cache)
|
|
7222
|
+
return result.cache;
|
|
7223
|
+
eventData = result.data;
|
|
7224
|
+
}
|
|
7225
|
+
}
|
|
7226
|
+
if (state.tokenize) {
|
|
7227
|
+
const result = $TOKEN("ImplicitNamedProperty", state, ImplicitNamedProperty$0(state));
|
|
7228
|
+
if (state.events)
|
|
7229
|
+
state.events.exit?.("ImplicitNamedProperty", state, result, eventData);
|
|
7230
|
+
return result;
|
|
7231
|
+
} else {
|
|
7232
|
+
const result = ImplicitNamedProperty$0(state);
|
|
7233
|
+
if (state.events)
|
|
7234
|
+
state.events.exit?.("ImplicitNamedProperty", state, result, eventData);
|
|
7235
|
+
return result;
|
|
7236
|
+
}
|
|
7237
|
+
}
|
|
7238
|
+
var SnugNamedProperty$0 = $TS($S(PropertyName, Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7239
|
+
var exp = $4;
|
|
7171
7240
|
return {
|
|
7172
7241
|
type: "Property",
|
|
7173
7242
|
children: $0,
|
|
@@ -7950,7 +8019,7 @@ ${input.slice(result.pos)}
|
|
|
7950
8019
|
return result;
|
|
7951
8020
|
}
|
|
7952
8021
|
}
|
|
7953
|
-
var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8022
|
+
var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7954
8023
|
return { $loc, token: $0 };
|
|
7955
8024
|
});
|
|
7956
8025
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -8118,13 +8187,14 @@ ${input.slice(result.pos)}
|
|
|
8118
8187
|
var Statement$4 = SwitchStatement;
|
|
8119
8188
|
var Statement$5 = TryStatement;
|
|
8120
8189
|
var Statement$6 = EmptyStatement;
|
|
8121
|
-
var Statement$7 =
|
|
8190
|
+
var Statement$7 = LabelledStatement;
|
|
8191
|
+
var Statement$8 = $TS($S(ExpressionStatement), function($skip, $loc, $0, $1) {
|
|
8122
8192
|
if ($1.type === "ObjectExpression" || $1.type === "FunctionExpression" && !$1.id) {
|
|
8123
8193
|
return module2.makeLeftHandSideExpression($1);
|
|
8124
8194
|
}
|
|
8125
8195
|
return $1;
|
|
8126
8196
|
});
|
|
8127
|
-
var Statement$
|
|
8197
|
+
var Statement$9 = BlockStatement;
|
|
8128
8198
|
function Statement(state) {
|
|
8129
8199
|
let eventData;
|
|
8130
8200
|
if (state.events) {
|
|
@@ -8136,12 +8206,12 @@ ${input.slice(result.pos)}
|
|
|
8136
8206
|
}
|
|
8137
8207
|
}
|
|
8138
8208
|
if (state.tokenize) {
|
|
8139
|
-
const result = $TOKEN("Statement", state, Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state));
|
|
8209
|
+
const result = $TOKEN("Statement", state, Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state) || Statement$9(state));
|
|
8140
8210
|
if (state.events)
|
|
8141
8211
|
state.events.exit?.("Statement", state, result, eventData);
|
|
8142
8212
|
return result;
|
|
8143
8213
|
} else {
|
|
8144
|
-
const result = Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
|
|
8214
|
+
const result = Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state) || Statement$9(state);
|
|
8145
8215
|
if (state.events)
|
|
8146
8216
|
state.events.exit?.("Statement", state, result, eventData);
|
|
8147
8217
|
return result;
|
|
@@ -8197,6 +8267,82 @@ ${input.slice(result.pos)}
|
|
|
8197
8267
|
return result;
|
|
8198
8268
|
}
|
|
8199
8269
|
}
|
|
8270
|
+
var LabelledStatement$0 = $S(Label, LabelledItem);
|
|
8271
|
+
function LabelledStatement(state) {
|
|
8272
|
+
let eventData;
|
|
8273
|
+
if (state.events) {
|
|
8274
|
+
const result = state.events.enter?.("LabelledStatement", state);
|
|
8275
|
+
if (result) {
|
|
8276
|
+
if (result.cache)
|
|
8277
|
+
return result.cache;
|
|
8278
|
+
eventData = result.data;
|
|
8279
|
+
}
|
|
8280
|
+
}
|
|
8281
|
+
if (state.tokenize) {
|
|
8282
|
+
const result = $TOKEN("LabelledStatement", state, LabelledStatement$0(state));
|
|
8283
|
+
if (state.events)
|
|
8284
|
+
state.events.exit?.("LabelledStatement", state, result, eventData);
|
|
8285
|
+
return result;
|
|
8286
|
+
} else {
|
|
8287
|
+
const result = LabelledStatement$0(state);
|
|
8288
|
+
if (state.events)
|
|
8289
|
+
state.events.exit?.("LabelledStatement", state, result, eventData);
|
|
8290
|
+
return result;
|
|
8291
|
+
}
|
|
8292
|
+
}
|
|
8293
|
+
var Label$0 = $TS($S(Colon, Identifier, Whitespace), function($skip, $loc, $0, $1, $2, $3) {
|
|
8294
|
+
var colon = $1;
|
|
8295
|
+
var id = $2;
|
|
8296
|
+
var w = $3;
|
|
8297
|
+
return [id, colon, w];
|
|
8298
|
+
});
|
|
8299
|
+
var Label$1 = $S($EXPECT($L85, fail, 'Label "$:"'), Whitespace);
|
|
8300
|
+
function Label(state) {
|
|
8301
|
+
let eventData;
|
|
8302
|
+
if (state.events) {
|
|
8303
|
+
const result = state.events.enter?.("Label", state);
|
|
8304
|
+
if (result) {
|
|
8305
|
+
if (result.cache)
|
|
8306
|
+
return result.cache;
|
|
8307
|
+
eventData = result.data;
|
|
8308
|
+
}
|
|
8309
|
+
}
|
|
8310
|
+
if (state.tokenize) {
|
|
8311
|
+
const result = $TOKEN("Label", state, Label$0(state) || Label$1(state));
|
|
8312
|
+
if (state.events)
|
|
8313
|
+
state.events.exit?.("Label", state, result, eventData);
|
|
8314
|
+
return result;
|
|
8315
|
+
} else {
|
|
8316
|
+
const result = Label$0(state) || Label$1(state);
|
|
8317
|
+
if (state.events)
|
|
8318
|
+
state.events.exit?.("Label", state, result, eventData);
|
|
8319
|
+
return result;
|
|
8320
|
+
}
|
|
8321
|
+
}
|
|
8322
|
+
var LabelledItem$0 = Statement;
|
|
8323
|
+
var LabelledItem$1 = FunctionDeclaration;
|
|
8324
|
+
function LabelledItem(state) {
|
|
8325
|
+
let eventData;
|
|
8326
|
+
if (state.events) {
|
|
8327
|
+
const result = state.events.enter?.("LabelledItem", state);
|
|
8328
|
+
if (result) {
|
|
8329
|
+
if (result.cache)
|
|
8330
|
+
return result.cache;
|
|
8331
|
+
eventData = result.data;
|
|
8332
|
+
}
|
|
8333
|
+
}
|
|
8334
|
+
if (state.tokenize) {
|
|
8335
|
+
const result = $TOKEN("LabelledItem", state, LabelledItem$0(state) || LabelledItem$1(state));
|
|
8336
|
+
if (state.events)
|
|
8337
|
+
state.events.exit?.("LabelledItem", state, result, eventData);
|
|
8338
|
+
return result;
|
|
8339
|
+
} else {
|
|
8340
|
+
const result = LabelledItem$0(state) || LabelledItem$1(state);
|
|
8341
|
+
if (state.events)
|
|
8342
|
+
state.events.exit?.("LabelledItem", state, result, eventData);
|
|
8343
|
+
return result;
|
|
8344
|
+
}
|
|
8345
|
+
}
|
|
8200
8346
|
var IfStatement$0 = $TS($S($C(IfClause, UnlessClause), Block, $E(ElseClause)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8201
8347
|
var clause = $1;
|
|
8202
8348
|
var block = $2;
|
|
@@ -8463,7 +8609,7 @@ ${input.slice(result.pos)}
|
|
|
8463
8609
|
children: [$1, exps, $3, $4, $5]
|
|
8464
8610
|
};
|
|
8465
8611
|
});
|
|
8466
|
-
var ElseExpressionBlock$1 = $T($S($N(EOS),
|
|
8612
|
+
var ElseExpressionBlock$1 = $T($S($N(EOS), ExpressionWithIndentedApplicationForbidden), function(value) {
|
|
8467
8613
|
return value[1];
|
|
8468
8614
|
});
|
|
8469
8615
|
function ElseExpressionBlock(state) {
|
|
@@ -9102,7 +9248,7 @@ ${input.slice(result.pos)}
|
|
|
9102
9248
|
return result;
|
|
9103
9249
|
}
|
|
9104
9250
|
}
|
|
9105
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9251
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L86, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9106
9252
|
var own = $1;
|
|
9107
9253
|
var binding = $2;
|
|
9108
9254
|
return {
|
|
@@ -9148,14 +9294,14 @@ ${input.slice(result.pos)}
|
|
|
9148
9294
|
children: $0
|
|
9149
9295
|
};
|
|
9150
9296
|
});
|
|
9151
|
-
var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of),
|
|
9297
|
+
var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationForbidden, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9152
9298
|
var declaration = $4;
|
|
9153
9299
|
return {
|
|
9154
9300
|
declaration,
|
|
9155
9301
|
children: $0
|
|
9156
9302
|
};
|
|
9157
9303
|
});
|
|
9158
|
-
var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of),
|
|
9304
|
+
var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
9159
9305
|
var declaration = $3;
|
|
9160
9306
|
return {
|
|
9161
9307
|
declaration,
|
|
@@ -9550,14 +9696,18 @@ ${input.slice(result.pos)}
|
|
|
9550
9696
|
return result;
|
|
9551
9697
|
}
|
|
9552
9698
|
}
|
|
9553
|
-
var CaseExpressionList$0 = $TS($S($S($Q(_),
|
|
9554
|
-
|
|
9699
|
+
var CaseExpressionList$0 = $TS($S(ForbidMultiLineImplicitObjectLiteral, $E($S($Q(_), ExpressionWithIndentedApplicationForbidden, ImpliedColon)), $Q($S(__, Comma, ExpressionWithIndentedApplicationForbidden, ImpliedColon)), RestoreMultiLineImplicitObjectLiteral), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
9700
|
+
var first = $2;
|
|
9701
|
+
var rest = $3;
|
|
9702
|
+
if (!first)
|
|
9703
|
+
return $skip;
|
|
9704
|
+
const result = rest.map(([ws, _comma, exp, col]) => {
|
|
9555
9705
|
exp = module2.insertTrimmingSpace(exp, "");
|
|
9556
9706
|
if (ws.length)
|
|
9557
9707
|
return [module2.insertTrimmingSpace("case ", ws), exp, col];
|
|
9558
9708
|
return ["case ", exp, col];
|
|
9559
9709
|
});
|
|
9560
|
-
result.unshift(
|
|
9710
|
+
result.unshift(first);
|
|
9561
9711
|
return result;
|
|
9562
9712
|
});
|
|
9563
9713
|
function CaseExpressionList(state) {
|
|
@@ -9773,7 +9923,7 @@ ${input.slice(result.pos)}
|
|
|
9773
9923
|
var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp, Dot, QuestionMark))), $N($S(_, OperatorAssignmentOp))), function(value) {
|
|
9774
9924
|
return value[0];
|
|
9775
9925
|
});
|
|
9776
|
-
var Condition$1 = $TS($S(InsertOpenParen,
|
|
9926
|
+
var Condition$1 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
|
|
9777
9927
|
var open = $1;
|
|
9778
9928
|
var expression = $2;
|
|
9779
9929
|
var close = $3;
|
|
@@ -9808,17 +9958,66 @@ ${input.slice(result.pos)}
|
|
|
9808
9958
|
return result;
|
|
9809
9959
|
}
|
|
9810
9960
|
}
|
|
9811
|
-
var
|
|
9961
|
+
var ExpressionWithIndentedApplicationForbidden$0 = $TS($S(ForbidIndentedApplication, $E(ExtendedExpression), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
|
|
9812
9962
|
var exp = $2;
|
|
9813
|
-
module2.suppressIndentedApplication = false;
|
|
9814
9963
|
if (exp)
|
|
9815
9964
|
return exp;
|
|
9816
9965
|
return $skip;
|
|
9817
9966
|
});
|
|
9818
|
-
function
|
|
9967
|
+
function ExpressionWithIndentedApplicationForbidden(state) {
|
|
9968
|
+
let eventData;
|
|
9969
|
+
if (state.events) {
|
|
9970
|
+
const result = state.events.enter?.("ExpressionWithIndentedApplicationForbidden", state);
|
|
9971
|
+
if (result) {
|
|
9972
|
+
if (result.cache)
|
|
9973
|
+
return result.cache;
|
|
9974
|
+
eventData = result.data;
|
|
9975
|
+
}
|
|
9976
|
+
}
|
|
9977
|
+
if (state.tokenize) {
|
|
9978
|
+
const result = $TOKEN("ExpressionWithIndentedApplicationForbidden", state, ExpressionWithIndentedApplicationForbidden$0(state));
|
|
9979
|
+
if (state.events)
|
|
9980
|
+
state.events.exit?.("ExpressionWithIndentedApplicationForbidden", state, result, eventData);
|
|
9981
|
+
return result;
|
|
9982
|
+
} else {
|
|
9983
|
+
const result = ExpressionWithIndentedApplicationForbidden$0(state);
|
|
9984
|
+
if (state.events)
|
|
9985
|
+
state.events.exit?.("ExpressionWithIndentedApplicationForbidden", state, result, eventData);
|
|
9986
|
+
return result;
|
|
9987
|
+
}
|
|
9988
|
+
}
|
|
9989
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L18, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9990
|
+
module2.forbidIndentedApplication.push(true);
|
|
9991
|
+
});
|
|
9992
|
+
function ForbidIndentedApplication(state) {
|
|
9993
|
+
let eventData;
|
|
9994
|
+
if (state.events) {
|
|
9995
|
+
const result = state.events.enter?.("ForbidIndentedApplication", state);
|
|
9996
|
+
if (result) {
|
|
9997
|
+
if (result.cache)
|
|
9998
|
+
return result.cache;
|
|
9999
|
+
eventData = result.data;
|
|
10000
|
+
}
|
|
10001
|
+
}
|
|
10002
|
+
if (state.tokenize) {
|
|
10003
|
+
const result = $TOKEN("ForbidIndentedApplication", state, ForbidIndentedApplication$0(state));
|
|
10004
|
+
if (state.events)
|
|
10005
|
+
state.events.exit?.("ForbidIndentedApplication", state, result, eventData);
|
|
10006
|
+
return result;
|
|
10007
|
+
} else {
|
|
10008
|
+
const result = ForbidIndentedApplication$0(state);
|
|
10009
|
+
if (state.events)
|
|
10010
|
+
state.events.exit?.("ForbidIndentedApplication", state, result, eventData);
|
|
10011
|
+
return result;
|
|
10012
|
+
}
|
|
10013
|
+
}
|
|
10014
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L18, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10015
|
+
module2.forbidIndentedApplication.push(false);
|
|
10016
|
+
});
|
|
10017
|
+
function AllowIndentedApplication(state) {
|
|
9819
10018
|
let eventData;
|
|
9820
10019
|
if (state.events) {
|
|
9821
|
-
const result = state.events.enter?.("
|
|
10020
|
+
const result = state.events.enter?.("AllowIndentedApplication", state);
|
|
9822
10021
|
if (result) {
|
|
9823
10022
|
if (result.cache)
|
|
9824
10023
|
return result.cache;
|
|
@@ -9826,24 +10025,24 @@ ${input.slice(result.pos)}
|
|
|
9826
10025
|
}
|
|
9827
10026
|
}
|
|
9828
10027
|
if (state.tokenize) {
|
|
9829
|
-
const result = $TOKEN("
|
|
10028
|
+
const result = $TOKEN("AllowIndentedApplication", state, AllowIndentedApplication$0(state));
|
|
9830
10029
|
if (state.events)
|
|
9831
|
-
state.events.exit?.("
|
|
10030
|
+
state.events.exit?.("AllowIndentedApplication", state, result, eventData);
|
|
9832
10031
|
return result;
|
|
9833
10032
|
} else {
|
|
9834
|
-
const result =
|
|
10033
|
+
const result = AllowIndentedApplication$0(state);
|
|
9835
10034
|
if (state.events)
|
|
9836
|
-
state.events.exit?.("
|
|
10035
|
+
state.events.exit?.("AllowIndentedApplication", state, result, eventData);
|
|
9837
10036
|
return result;
|
|
9838
10037
|
}
|
|
9839
10038
|
}
|
|
9840
|
-
var
|
|
9841
|
-
module2.
|
|
10039
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L18, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10040
|
+
module2.forbidIndentedApplication.pop();
|
|
9842
10041
|
});
|
|
9843
|
-
function
|
|
10042
|
+
function RestoreIndentedApplication(state) {
|
|
9844
10043
|
let eventData;
|
|
9845
10044
|
if (state.events) {
|
|
9846
|
-
const result = state.events.enter?.("
|
|
10045
|
+
const result = state.events.enter?.("RestoreIndentedApplication", state);
|
|
9847
10046
|
if (result) {
|
|
9848
10047
|
if (result.cache)
|
|
9849
10048
|
return result.cache;
|
|
@@ -9851,19 +10050,22 @@ ${input.slice(result.pos)}
|
|
|
9851
10050
|
}
|
|
9852
10051
|
}
|
|
9853
10052
|
if (state.tokenize) {
|
|
9854
|
-
const result = $TOKEN("
|
|
10053
|
+
const result = $TOKEN("RestoreIndentedApplication", state, RestoreIndentedApplication$0(state));
|
|
9855
10054
|
if (state.events)
|
|
9856
|
-
state.events.exit?.("
|
|
10055
|
+
state.events.exit?.("RestoreIndentedApplication", state, result, eventData);
|
|
9857
10056
|
return result;
|
|
9858
10057
|
} else {
|
|
9859
|
-
const result =
|
|
10058
|
+
const result = RestoreIndentedApplication$0(state);
|
|
9860
10059
|
if (state.events)
|
|
9861
|
-
state.events.exit?.("
|
|
10060
|
+
state.events.exit?.("RestoreIndentedApplication", state, result, eventData);
|
|
9862
10061
|
return result;
|
|
9863
10062
|
}
|
|
9864
10063
|
}
|
|
9865
10064
|
var IndentedApplicationAllowed$0 = $TV($EXPECT($L18, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9866
|
-
if (module2.
|
|
10065
|
+
if (module2.config.verbose) {
|
|
10066
|
+
console.log("forbidIndentedApplication:", module2.forbidIndentedApplication);
|
|
10067
|
+
}
|
|
10068
|
+
if (module2.indentedApplicationForbidden)
|
|
9867
10069
|
return $skip;
|
|
9868
10070
|
return;
|
|
9869
10071
|
});
|
|
@@ -9889,13 +10091,13 @@ ${input.slice(result.pos)}
|
|
|
9889
10091
|
return result;
|
|
9890
10092
|
}
|
|
9891
10093
|
}
|
|
9892
|
-
var
|
|
9893
|
-
module2.
|
|
10094
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10095
|
+
module2.forbidTrailingMemberProperty.push(true);
|
|
9894
10096
|
});
|
|
9895
|
-
function
|
|
10097
|
+
function ForbidTrailingMemberProperty(state) {
|
|
9896
10098
|
let eventData;
|
|
9897
10099
|
if (state.events) {
|
|
9898
|
-
const result = state.events.enter?.("
|
|
10100
|
+
const result = state.events.enter?.("ForbidTrailingMemberProperty", state);
|
|
9899
10101
|
if (result) {
|
|
9900
10102
|
if (result.cache)
|
|
9901
10103
|
return result.cache;
|
|
@@ -9903,19 +10105,72 @@ ${input.slice(result.pos)}
|
|
|
9903
10105
|
}
|
|
9904
10106
|
}
|
|
9905
10107
|
if (state.tokenize) {
|
|
9906
|
-
const result = $TOKEN("
|
|
10108
|
+
const result = $TOKEN("ForbidTrailingMemberProperty", state, ForbidTrailingMemberProperty$0(state));
|
|
9907
10109
|
if (state.events)
|
|
9908
|
-
state.events.exit?.("
|
|
10110
|
+
state.events.exit?.("ForbidTrailingMemberProperty", state, result, eventData);
|
|
9909
10111
|
return result;
|
|
9910
10112
|
} else {
|
|
9911
|
-
const result =
|
|
10113
|
+
const result = ForbidTrailingMemberProperty$0(state);
|
|
9912
10114
|
if (state.events)
|
|
9913
|
-
state.events.exit?.("
|
|
10115
|
+
state.events.exit?.("ForbidTrailingMemberProperty", state, result, eventData);
|
|
10116
|
+
return result;
|
|
10117
|
+
}
|
|
10118
|
+
}
|
|
10119
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10120
|
+
module2.forbidTrailingMemberProperty.push(false);
|
|
10121
|
+
});
|
|
10122
|
+
function AllowTrailingMemberProperty(state) {
|
|
10123
|
+
let eventData;
|
|
10124
|
+
if (state.events) {
|
|
10125
|
+
const result = state.events.enter?.("AllowTrailingMemberProperty", state);
|
|
10126
|
+
if (result) {
|
|
10127
|
+
if (result.cache)
|
|
10128
|
+
return result.cache;
|
|
10129
|
+
eventData = result.data;
|
|
10130
|
+
}
|
|
10131
|
+
}
|
|
10132
|
+
if (state.tokenize) {
|
|
10133
|
+
const result = $TOKEN("AllowTrailingMemberProperty", state, AllowTrailingMemberProperty$0(state));
|
|
10134
|
+
if (state.events)
|
|
10135
|
+
state.events.exit?.("AllowTrailingMemberProperty", state, result, eventData);
|
|
10136
|
+
return result;
|
|
10137
|
+
} else {
|
|
10138
|
+
const result = AllowTrailingMemberProperty$0(state);
|
|
10139
|
+
if (state.events)
|
|
10140
|
+
state.events.exit?.("AllowTrailingMemberProperty", state, result, eventData);
|
|
10141
|
+
return result;
|
|
10142
|
+
}
|
|
10143
|
+
}
|
|
10144
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10145
|
+
module2.forbidTrailingMemberProperty.pop();
|
|
10146
|
+
});
|
|
10147
|
+
function RestoreTrailingMemberProperty(state) {
|
|
10148
|
+
let eventData;
|
|
10149
|
+
if (state.events) {
|
|
10150
|
+
const result = state.events.enter?.("RestoreTrailingMemberProperty", state);
|
|
10151
|
+
if (result) {
|
|
10152
|
+
if (result.cache)
|
|
10153
|
+
return result.cache;
|
|
10154
|
+
eventData = result.data;
|
|
10155
|
+
}
|
|
10156
|
+
}
|
|
10157
|
+
if (state.tokenize) {
|
|
10158
|
+
const result = $TOKEN("RestoreTrailingMemberProperty", state, RestoreTrailingMemberProperty$0(state));
|
|
10159
|
+
if (state.events)
|
|
10160
|
+
state.events.exit?.("RestoreTrailingMemberProperty", state, result, eventData);
|
|
10161
|
+
return result;
|
|
10162
|
+
} else {
|
|
10163
|
+
const result = RestoreTrailingMemberProperty$0(state);
|
|
10164
|
+
if (state.events)
|
|
10165
|
+
state.events.exit?.("RestoreTrailingMemberProperty", state, result, eventData);
|
|
9914
10166
|
return result;
|
|
9915
10167
|
}
|
|
9916
10168
|
}
|
|
9917
10169
|
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L18, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9918
|
-
if (module2.
|
|
10170
|
+
if (module2.config.verbose) {
|
|
10171
|
+
console.log("forbidTrailingMemberProperty:", module2.forbidTrailingMemberProperty);
|
|
10172
|
+
}
|
|
10173
|
+
if (module2.trailingMemberPropertyForbidden)
|
|
9919
10174
|
return $skip;
|
|
9920
10175
|
});
|
|
9921
10176
|
function TrailingMemberPropertyAllowed(state) {
|
|
@@ -9940,6 +10195,156 @@ ${input.slice(result.pos)}
|
|
|
9940
10195
|
return result;
|
|
9941
10196
|
}
|
|
9942
10197
|
}
|
|
10198
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L18, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10199
|
+
module2.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10200
|
+
});
|
|
10201
|
+
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
10202
|
+
let eventData;
|
|
10203
|
+
if (state.events) {
|
|
10204
|
+
const result = state.events.enter?.("ForbidMultiLineImplicitObjectLiteral", state);
|
|
10205
|
+
if (result) {
|
|
10206
|
+
if (result.cache)
|
|
10207
|
+
return result.cache;
|
|
10208
|
+
eventData = result.data;
|
|
10209
|
+
}
|
|
10210
|
+
}
|
|
10211
|
+
if (state.tokenize) {
|
|
10212
|
+
const result = $TOKEN("ForbidMultiLineImplicitObjectLiteral", state, ForbidMultiLineImplicitObjectLiteral$0(state));
|
|
10213
|
+
if (state.events)
|
|
10214
|
+
state.events.exit?.("ForbidMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10215
|
+
return result;
|
|
10216
|
+
} else {
|
|
10217
|
+
const result = ForbidMultiLineImplicitObjectLiteral$0(state);
|
|
10218
|
+
if (state.events)
|
|
10219
|
+
state.events.exit?.("ForbidMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10220
|
+
return result;
|
|
10221
|
+
}
|
|
10222
|
+
}
|
|
10223
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L18, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10224
|
+
module2.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10225
|
+
});
|
|
10226
|
+
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
10227
|
+
let eventData;
|
|
10228
|
+
if (state.events) {
|
|
10229
|
+
const result = state.events.enter?.("AllowMultiLineImplicitObjectLiteral", state);
|
|
10230
|
+
if (result) {
|
|
10231
|
+
if (result.cache)
|
|
10232
|
+
return result.cache;
|
|
10233
|
+
eventData = result.data;
|
|
10234
|
+
}
|
|
10235
|
+
}
|
|
10236
|
+
if (state.tokenize) {
|
|
10237
|
+
const result = $TOKEN("AllowMultiLineImplicitObjectLiteral", state, AllowMultiLineImplicitObjectLiteral$0(state));
|
|
10238
|
+
if (state.events)
|
|
10239
|
+
state.events.exit?.("AllowMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10240
|
+
return result;
|
|
10241
|
+
} else {
|
|
10242
|
+
const result = AllowMultiLineImplicitObjectLiteral$0(state);
|
|
10243
|
+
if (state.events)
|
|
10244
|
+
state.events.exit?.("AllowMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10245
|
+
return result;
|
|
10246
|
+
}
|
|
10247
|
+
}
|
|
10248
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L18, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10249
|
+
module2.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10250
|
+
});
|
|
10251
|
+
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
10252
|
+
let eventData;
|
|
10253
|
+
if (state.events) {
|
|
10254
|
+
const result = state.events.enter?.("RestoreMultiLineImplicitObjectLiteral", state);
|
|
10255
|
+
if (result) {
|
|
10256
|
+
if (result.cache)
|
|
10257
|
+
return result.cache;
|
|
10258
|
+
eventData = result.data;
|
|
10259
|
+
}
|
|
10260
|
+
}
|
|
10261
|
+
if (state.tokenize) {
|
|
10262
|
+
const result = $TOKEN("RestoreMultiLineImplicitObjectLiteral", state, RestoreMultiLineImplicitObjectLiteral$0(state));
|
|
10263
|
+
if (state.events)
|
|
10264
|
+
state.events.exit?.("RestoreMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10265
|
+
return result;
|
|
10266
|
+
} else {
|
|
10267
|
+
const result = RestoreMultiLineImplicitObjectLiteral$0(state);
|
|
10268
|
+
if (state.events)
|
|
10269
|
+
state.events.exit?.("RestoreMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10270
|
+
return result;
|
|
10271
|
+
}
|
|
10272
|
+
}
|
|
10273
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L18, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10274
|
+
if (module2.config.verbose) {
|
|
10275
|
+
console.log("forbidMultiLineImplicitObjectLiteral:", module2.forbidMultiLineImplicitObjectLiteral);
|
|
10276
|
+
}
|
|
10277
|
+
if (module2.multiLineImplicitObjectLiteralForbidden)
|
|
10278
|
+
return $skip;
|
|
10279
|
+
});
|
|
10280
|
+
function MultiLineImplicitObjectLiteralAllowed(state) {
|
|
10281
|
+
let eventData;
|
|
10282
|
+
if (state.events) {
|
|
10283
|
+
const result = state.events.enter?.("MultiLineImplicitObjectLiteralAllowed", state);
|
|
10284
|
+
if (result) {
|
|
10285
|
+
if (result.cache)
|
|
10286
|
+
return result.cache;
|
|
10287
|
+
eventData = result.data;
|
|
10288
|
+
}
|
|
10289
|
+
}
|
|
10290
|
+
if (state.tokenize) {
|
|
10291
|
+
const result = $TOKEN("MultiLineImplicitObjectLiteralAllowed", state, MultiLineImplicitObjectLiteralAllowed$0(state));
|
|
10292
|
+
if (state.events)
|
|
10293
|
+
state.events.exit?.("MultiLineImplicitObjectLiteralAllowed", state, result, eventData);
|
|
10294
|
+
return result;
|
|
10295
|
+
} else {
|
|
10296
|
+
const result = MultiLineImplicitObjectLiteralAllowed$0(state);
|
|
10297
|
+
if (state.events)
|
|
10298
|
+
state.events.exit?.("MultiLineImplicitObjectLiteralAllowed", state, result, eventData);
|
|
10299
|
+
return result;
|
|
10300
|
+
}
|
|
10301
|
+
}
|
|
10302
|
+
var AllowAll$0 = $S(AllowTrailingMemberProperty, AllowIndentedApplication, AllowMultiLineImplicitObjectLiteral);
|
|
10303
|
+
function AllowAll(state) {
|
|
10304
|
+
let eventData;
|
|
10305
|
+
if (state.events) {
|
|
10306
|
+
const result = state.events.enter?.("AllowAll", state);
|
|
10307
|
+
if (result) {
|
|
10308
|
+
if (result.cache)
|
|
10309
|
+
return result.cache;
|
|
10310
|
+
eventData = result.data;
|
|
10311
|
+
}
|
|
10312
|
+
}
|
|
10313
|
+
if (state.tokenize) {
|
|
10314
|
+
const result = $TOKEN("AllowAll", state, AllowAll$0(state));
|
|
10315
|
+
if (state.events)
|
|
10316
|
+
state.events.exit?.("AllowAll", state, result, eventData);
|
|
10317
|
+
return result;
|
|
10318
|
+
} else {
|
|
10319
|
+
const result = AllowAll$0(state);
|
|
10320
|
+
if (state.events)
|
|
10321
|
+
state.events.exit?.("AllowAll", state, result, eventData);
|
|
10322
|
+
return result;
|
|
10323
|
+
}
|
|
10324
|
+
}
|
|
10325
|
+
var RestoreAll$0 = $S(RestoreTrailingMemberProperty, RestoreIndentedApplication, RestoreMultiLineImplicitObjectLiteral);
|
|
10326
|
+
function RestoreAll(state) {
|
|
10327
|
+
let eventData;
|
|
10328
|
+
if (state.events) {
|
|
10329
|
+
const result = state.events.enter?.("RestoreAll", state);
|
|
10330
|
+
if (result) {
|
|
10331
|
+
if (result.cache)
|
|
10332
|
+
return result.cache;
|
|
10333
|
+
eventData = result.data;
|
|
10334
|
+
}
|
|
10335
|
+
}
|
|
10336
|
+
if (state.tokenize) {
|
|
10337
|
+
const result = $TOKEN("RestoreAll", state, RestoreAll$0(state));
|
|
10338
|
+
if (state.events)
|
|
10339
|
+
state.events.exit?.("RestoreAll", state, result, eventData);
|
|
10340
|
+
return result;
|
|
10341
|
+
} else {
|
|
10342
|
+
const result = RestoreAll$0(state);
|
|
10343
|
+
if (state.events)
|
|
10344
|
+
state.events.exit?.("RestoreAll", state, result, eventData);
|
|
10345
|
+
return result;
|
|
10346
|
+
}
|
|
10347
|
+
}
|
|
9943
10348
|
var ExpressionStatement$0 = Expression;
|
|
9944
10349
|
function ExpressionStatement(state) {
|
|
9945
10350
|
let eventData;
|
|
@@ -9963,13 +10368,19 @@ ${input.slice(result.pos)}
|
|
|
9963
10368
|
return result;
|
|
9964
10369
|
}
|
|
9965
10370
|
}
|
|
9966
|
-
var KeywordStatement$0 = $
|
|
9967
|
-
return {
|
|
10371
|
+
var KeywordStatement$0 = $TS($S(Break, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10372
|
+
return {
|
|
10373
|
+
type: "BreakStatement",
|
|
10374
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10375
|
+
};
|
|
9968
10376
|
});
|
|
9969
|
-
var KeywordStatement$1 = $
|
|
9970
|
-
return {
|
|
10377
|
+
var KeywordStatement$1 = $TS($S(Continue, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10378
|
+
return {
|
|
10379
|
+
type: "ContinueStatement",
|
|
10380
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10381
|
+
};
|
|
9971
10382
|
});
|
|
9972
|
-
var KeywordStatement$2 = $T($S(
|
|
10383
|
+
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
9973
10384
|
return { "type": "DebuggerStatement", "children": value };
|
|
9974
10385
|
});
|
|
9975
10386
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -10000,7 +10411,82 @@ ${input.slice(result.pos)}
|
|
|
10000
10411
|
return result;
|
|
10001
10412
|
}
|
|
10002
10413
|
}
|
|
10003
|
-
var
|
|
10414
|
+
var Break$0 = $TS($S($EXPECT($L87, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10415
|
+
return { $loc, token: $1 };
|
|
10416
|
+
});
|
|
10417
|
+
function Break(state) {
|
|
10418
|
+
let eventData;
|
|
10419
|
+
if (state.events) {
|
|
10420
|
+
const result = state.events.enter?.("Break", state);
|
|
10421
|
+
if (result) {
|
|
10422
|
+
if (result.cache)
|
|
10423
|
+
return result.cache;
|
|
10424
|
+
eventData = result.data;
|
|
10425
|
+
}
|
|
10426
|
+
}
|
|
10427
|
+
if (state.tokenize) {
|
|
10428
|
+
const result = $TOKEN("Break", state, Break$0(state));
|
|
10429
|
+
if (state.events)
|
|
10430
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10431
|
+
return result;
|
|
10432
|
+
} else {
|
|
10433
|
+
const result = Break$0(state);
|
|
10434
|
+
if (state.events)
|
|
10435
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10436
|
+
return result;
|
|
10437
|
+
}
|
|
10438
|
+
}
|
|
10439
|
+
var Continue$0 = $TS($S($EXPECT($L88, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10440
|
+
return { $loc, token: $1 };
|
|
10441
|
+
});
|
|
10442
|
+
function Continue(state) {
|
|
10443
|
+
let eventData;
|
|
10444
|
+
if (state.events) {
|
|
10445
|
+
const result = state.events.enter?.("Continue", state);
|
|
10446
|
+
if (result) {
|
|
10447
|
+
if (result.cache)
|
|
10448
|
+
return result.cache;
|
|
10449
|
+
eventData = result.data;
|
|
10450
|
+
}
|
|
10451
|
+
}
|
|
10452
|
+
if (state.tokenize) {
|
|
10453
|
+
const result = $TOKEN("Continue", state, Continue$0(state));
|
|
10454
|
+
if (state.events)
|
|
10455
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10456
|
+
return result;
|
|
10457
|
+
} else {
|
|
10458
|
+
const result = Continue$0(state);
|
|
10459
|
+
if (state.events)
|
|
10460
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10461
|
+
return result;
|
|
10462
|
+
}
|
|
10463
|
+
}
|
|
10464
|
+
var Debugger$0 = $TS($S($EXPECT($L89, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10465
|
+
return { $loc, token: $1 };
|
|
10466
|
+
});
|
|
10467
|
+
function Debugger(state) {
|
|
10468
|
+
let eventData;
|
|
10469
|
+
if (state.events) {
|
|
10470
|
+
const result = state.events.enter?.("Debugger", state);
|
|
10471
|
+
if (result) {
|
|
10472
|
+
if (result.cache)
|
|
10473
|
+
return result.cache;
|
|
10474
|
+
eventData = result.data;
|
|
10475
|
+
}
|
|
10476
|
+
}
|
|
10477
|
+
if (state.tokenize) {
|
|
10478
|
+
const result = $TOKEN("Debugger", state, Debugger$0(state));
|
|
10479
|
+
if (state.events)
|
|
10480
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10481
|
+
return result;
|
|
10482
|
+
} else {
|
|
10483
|
+
const result = Debugger$0(state);
|
|
10484
|
+
if (state.events)
|
|
10485
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10486
|
+
return result;
|
|
10487
|
+
}
|
|
10488
|
+
}
|
|
10489
|
+
var DebuggerExpression$0 = $TS($S(Debugger), function($skip, $loc, $0, $1) {
|
|
10004
10490
|
return {
|
|
10005
10491
|
type: "DebuggerExpression",
|
|
10006
10492
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10277,7 +10763,7 @@ ${input.slice(result.pos)}
|
|
|
10277
10763
|
return result;
|
|
10278
10764
|
}
|
|
10279
10765
|
}
|
|
10280
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10766
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L90, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10281
10767
|
function ImportAssertion(state) {
|
|
10282
10768
|
let eventData;
|
|
10283
10769
|
if (state.events) {
|
|
@@ -10881,7 +11367,7 @@ ${input.slice(result.pos)}
|
|
|
10881
11367
|
return result;
|
|
10882
11368
|
}
|
|
10883
11369
|
}
|
|
10884
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11370
|
+
var ConstAssignment$0 = $TV($EXPECT($L91, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
10885
11371
|
return { $loc, token: "=" };
|
|
10886
11372
|
});
|
|
10887
11373
|
function ConstAssignment(state) {
|
|
@@ -10906,7 +11392,7 @@ ${input.slice(result.pos)}
|
|
|
10906
11392
|
return result;
|
|
10907
11393
|
}
|
|
10908
11394
|
}
|
|
10909
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11395
|
+
var LetAssignment$0 = $TV($EXPECT($L92, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10910
11396
|
return { $loc, token: "=" };
|
|
10911
11397
|
});
|
|
10912
11398
|
function LetAssignment(state) {
|
|
@@ -12171,7 +12657,7 @@ ${input.slice(result.pos)}
|
|
|
12171
12657
|
return result;
|
|
12172
12658
|
}
|
|
12173
12659
|
}
|
|
12174
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12660
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L93, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L94, fail, 'JSMultiLineComment "*/"')), $EXPECT($R42, fail, "JSMultiLineComment /./"))), $EXPECT($L94, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12175
12661
|
return { $loc, token: $1 };
|
|
12176
12662
|
});
|
|
12177
12663
|
function JSMultiLineComment(state) {
|
|
@@ -12270,7 +12756,7 @@ ${input.slice(result.pos)}
|
|
|
12270
12756
|
return result;
|
|
12271
12757
|
}
|
|
12272
12758
|
}
|
|
12273
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12759
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L93, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L94, fail, 'InlineComment "*/"')), $EXPECT($R46, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L94, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12274
12760
|
return { $loc, token: $1 };
|
|
12275
12761
|
});
|
|
12276
12762
|
function InlineComment(state) {
|
|
@@ -12369,7 +12855,7 @@ ${input.slice(result.pos)}
|
|
|
12369
12855
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12370
12856
|
return { $loc, token: $0 };
|
|
12371
12857
|
});
|
|
12372
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12858
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L95, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12373
12859
|
return "";
|
|
12374
12860
|
});
|
|
12375
12861
|
function NonNewlineWhitespace(state) {
|
|
@@ -12521,7 +13007,7 @@ ${input.slice(result.pos)}
|
|
|
12521
13007
|
}
|
|
12522
13008
|
}
|
|
12523
13009
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12524
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13010
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L96, fail, 'StatementDelimiter "["'), $EXPECT($L97, fail, 'StatementDelimiter "`"'), $EXPECT($L57, fail, 'StatementDelimiter "+"'), $EXPECT($L16, fail, 'StatementDelimiter "-"'), $EXPECT($L53, fail, 'StatementDelimiter "*"'), $EXPECT($L54, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
12525
13011
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12526
13012
|
function StatementDelimiter(state) {
|
|
12527
13013
|
let eventData;
|
|
@@ -12621,7 +13107,7 @@ ${input.slice(result.pos)}
|
|
|
12621
13107
|
return result;
|
|
12622
13108
|
}
|
|
12623
13109
|
}
|
|
12624
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13110
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L98, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
12625
13111
|
return { $loc, token: $1, ts: true };
|
|
12626
13112
|
});
|
|
12627
13113
|
function Abstract(state) {
|
|
@@ -12671,7 +13157,7 @@ ${input.slice(result.pos)}
|
|
|
12671
13157
|
return result;
|
|
12672
13158
|
}
|
|
12673
13159
|
}
|
|
12674
|
-
var As$0 = $TS($S($EXPECT($
|
|
13160
|
+
var As$0 = $TS($S($EXPECT($L99, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12675
13161
|
return { $loc, token: $1 };
|
|
12676
13162
|
});
|
|
12677
13163
|
function As(state) {
|
|
@@ -12696,7 +13182,7 @@ ${input.slice(result.pos)}
|
|
|
12696
13182
|
return result;
|
|
12697
13183
|
}
|
|
12698
13184
|
}
|
|
12699
|
-
var At$0 = $TV($EXPECT($
|
|
13185
|
+
var At$0 = $TV($EXPECT($L100, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
12700
13186
|
return { $loc, token: $1 };
|
|
12701
13187
|
});
|
|
12702
13188
|
function At(state) {
|
|
@@ -12721,7 +13207,7 @@ ${input.slice(result.pos)}
|
|
|
12721
13207
|
return result;
|
|
12722
13208
|
}
|
|
12723
13209
|
}
|
|
12724
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13210
|
+
var AtAt$0 = $TV($EXPECT($L101, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
12725
13211
|
return { $loc, token: "@" };
|
|
12726
13212
|
});
|
|
12727
13213
|
function AtAt(state) {
|
|
@@ -12746,7 +13232,7 @@ ${input.slice(result.pos)}
|
|
|
12746
13232
|
return result;
|
|
12747
13233
|
}
|
|
12748
13234
|
}
|
|
12749
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13235
|
+
var Async$0 = $TS($S($EXPECT($L102, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12750
13236
|
return { $loc, token: $1, type: "Async" };
|
|
12751
13237
|
});
|
|
12752
13238
|
function Async(state) {
|
|
@@ -12771,7 +13257,7 @@ ${input.slice(result.pos)}
|
|
|
12771
13257
|
return result;
|
|
12772
13258
|
}
|
|
12773
13259
|
}
|
|
12774
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13260
|
+
var Await$0 = $TS($S($EXPECT($L103, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12775
13261
|
return { $loc, token: $1 };
|
|
12776
13262
|
});
|
|
12777
13263
|
function Await(state) {
|
|
@@ -12796,7 +13282,7 @@ ${input.slice(result.pos)}
|
|
|
12796
13282
|
return result;
|
|
12797
13283
|
}
|
|
12798
13284
|
}
|
|
12799
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13285
|
+
var Backtick$0 = $TV($EXPECT($L97, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
12800
13286
|
return { $loc, token: $1 };
|
|
12801
13287
|
});
|
|
12802
13288
|
function Backtick(state) {
|
|
@@ -12821,7 +13307,7 @@ ${input.slice(result.pos)}
|
|
|
12821
13307
|
return result;
|
|
12822
13308
|
}
|
|
12823
13309
|
}
|
|
12824
|
-
var By$0 = $TS($S($EXPECT($
|
|
13310
|
+
var By$0 = $TS($S($EXPECT($L104, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12825
13311
|
return { $loc, token: $1 };
|
|
12826
13312
|
});
|
|
12827
13313
|
function By(state) {
|
|
@@ -12846,7 +13332,7 @@ ${input.slice(result.pos)}
|
|
|
12846
13332
|
return result;
|
|
12847
13333
|
}
|
|
12848
13334
|
}
|
|
12849
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13335
|
+
var Case$0 = $TS($S($EXPECT($L105, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12850
13336
|
return { $loc, token: $1 };
|
|
12851
13337
|
});
|
|
12852
13338
|
function Case(state) {
|
|
@@ -12871,7 +13357,7 @@ ${input.slice(result.pos)}
|
|
|
12871
13357
|
return result;
|
|
12872
13358
|
}
|
|
12873
13359
|
}
|
|
12874
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13360
|
+
var Catch$0 = $TS($S($EXPECT($L106, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12875
13361
|
return { $loc, token: $1 };
|
|
12876
13362
|
});
|
|
12877
13363
|
function Catch(state) {
|
|
@@ -12896,7 +13382,7 @@ ${input.slice(result.pos)}
|
|
|
12896
13382
|
return result;
|
|
12897
13383
|
}
|
|
12898
13384
|
}
|
|
12899
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13385
|
+
var Class$0 = $TS($S($EXPECT($L107, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12900
13386
|
return { $loc, token: $1 };
|
|
12901
13387
|
});
|
|
12902
13388
|
function Class(state) {
|
|
@@ -12996,7 +13482,7 @@ ${input.slice(result.pos)}
|
|
|
12996
13482
|
return result;
|
|
12997
13483
|
}
|
|
12998
13484
|
}
|
|
12999
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13485
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L108, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
13000
13486
|
return { $loc, token: "${" };
|
|
13001
13487
|
});
|
|
13002
13488
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13071,7 +13557,7 @@ ${input.slice(result.pos)}
|
|
|
13071
13557
|
return result;
|
|
13072
13558
|
}
|
|
13073
13559
|
}
|
|
13074
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13560
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L100, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13075
13561
|
return { $loc, token: "constructor" };
|
|
13076
13562
|
});
|
|
13077
13563
|
function ConstructorShorthand(state) {
|
|
@@ -13096,7 +13582,7 @@ ${input.slice(result.pos)}
|
|
|
13096
13582
|
return result;
|
|
13097
13583
|
}
|
|
13098
13584
|
}
|
|
13099
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13585
|
+
var Declare$0 = $TS($S($EXPECT($L109, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13100
13586
|
return { $loc, token: $1 };
|
|
13101
13587
|
});
|
|
13102
13588
|
function Declare(state) {
|
|
@@ -13121,7 +13607,7 @@ ${input.slice(result.pos)}
|
|
|
13121
13607
|
return result;
|
|
13122
13608
|
}
|
|
13123
13609
|
}
|
|
13124
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13610
|
+
var Default$0 = $TS($S($EXPECT($L110, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13125
13611
|
return { $loc, token: $1 };
|
|
13126
13612
|
});
|
|
13127
13613
|
function Default(state) {
|
|
@@ -13146,7 +13632,7 @@ ${input.slice(result.pos)}
|
|
|
13146
13632
|
return result;
|
|
13147
13633
|
}
|
|
13148
13634
|
}
|
|
13149
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13635
|
+
var Delete$0 = $TS($S($EXPECT($L111, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13150
13636
|
return { $loc, token: $1 };
|
|
13151
13637
|
});
|
|
13152
13638
|
function Delete(state) {
|
|
@@ -13171,7 +13657,7 @@ ${input.slice(result.pos)}
|
|
|
13171
13657
|
return result;
|
|
13172
13658
|
}
|
|
13173
13659
|
}
|
|
13174
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13660
|
+
var Do$0 = $TS($S($EXPECT($L112, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13175
13661
|
return { $loc, token: $1 };
|
|
13176
13662
|
});
|
|
13177
13663
|
function Do(state) {
|
|
@@ -13221,7 +13707,7 @@ ${input.slice(result.pos)}
|
|
|
13221
13707
|
return result;
|
|
13222
13708
|
}
|
|
13223
13709
|
}
|
|
13224
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13710
|
+
var DotDot$0 = $TV($EXPECT($L113, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13225
13711
|
return { $loc, token: $1 };
|
|
13226
13712
|
});
|
|
13227
13713
|
function DotDot(state) {
|
|
@@ -13246,7 +13732,7 @@ ${input.slice(result.pos)}
|
|
|
13246
13732
|
return result;
|
|
13247
13733
|
}
|
|
13248
13734
|
}
|
|
13249
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13735
|
+
var DotDotDot$0 = $TV($EXPECT($L114, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13250
13736
|
return { $loc, token: $1 };
|
|
13251
13737
|
});
|
|
13252
13738
|
function DotDotDot(state) {
|
|
@@ -13271,7 +13757,7 @@ ${input.slice(result.pos)}
|
|
|
13271
13757
|
return result;
|
|
13272
13758
|
}
|
|
13273
13759
|
}
|
|
13274
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13760
|
+
var DoubleColon$0 = $TV($EXPECT($L115, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13275
13761
|
return { $loc, token: $1 };
|
|
13276
13762
|
});
|
|
13277
13763
|
function DoubleColon(state) {
|
|
@@ -13296,7 +13782,7 @@ ${input.slice(result.pos)}
|
|
|
13296
13782
|
return result;
|
|
13297
13783
|
}
|
|
13298
13784
|
}
|
|
13299
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13785
|
+
var DoubleQuote$0 = $TV($EXPECT($L116, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13300
13786
|
return { $loc, token: $1 };
|
|
13301
13787
|
});
|
|
13302
13788
|
function DoubleQuote(state) {
|
|
@@ -13321,7 +13807,7 @@ ${input.slice(result.pos)}
|
|
|
13321
13807
|
return result;
|
|
13322
13808
|
}
|
|
13323
13809
|
}
|
|
13324
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13810
|
+
var Else$0 = $TS($S($EXPECT($L117, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13325
13811
|
return { $loc, token: $1 };
|
|
13326
13812
|
});
|
|
13327
13813
|
function Else(state) {
|
|
@@ -13371,7 +13857,7 @@ ${input.slice(result.pos)}
|
|
|
13371
13857
|
return result;
|
|
13372
13858
|
}
|
|
13373
13859
|
}
|
|
13374
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13860
|
+
var Export$0 = $TS($S($EXPECT($L118, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13375
13861
|
return { $loc, token: $1 };
|
|
13376
13862
|
});
|
|
13377
13863
|
function Export(state) {
|
|
@@ -13396,7 +13882,7 @@ ${input.slice(result.pos)}
|
|
|
13396
13882
|
return result;
|
|
13397
13883
|
}
|
|
13398
13884
|
}
|
|
13399
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13885
|
+
var Extends$0 = $TS($S($EXPECT($L119, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13400
13886
|
return { $loc, token: $1 };
|
|
13401
13887
|
});
|
|
13402
13888
|
function Extends(state) {
|
|
@@ -13421,7 +13907,7 @@ ${input.slice(result.pos)}
|
|
|
13421
13907
|
return result;
|
|
13422
13908
|
}
|
|
13423
13909
|
}
|
|
13424
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13910
|
+
var Finally$0 = $TS($S($EXPECT($L120, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13425
13911
|
return { $loc, token: $1 };
|
|
13426
13912
|
});
|
|
13427
13913
|
function Finally(state) {
|
|
@@ -13446,7 +13932,7 @@ ${input.slice(result.pos)}
|
|
|
13446
13932
|
return result;
|
|
13447
13933
|
}
|
|
13448
13934
|
}
|
|
13449
|
-
var For$0 = $TS($S($EXPECT($
|
|
13935
|
+
var For$0 = $TS($S($EXPECT($L121, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13450
13936
|
return { $loc, token: $1 };
|
|
13451
13937
|
});
|
|
13452
13938
|
function For(state) {
|
|
@@ -13471,7 +13957,7 @@ ${input.slice(result.pos)}
|
|
|
13471
13957
|
return result;
|
|
13472
13958
|
}
|
|
13473
13959
|
}
|
|
13474
|
-
var From$0 = $TS($S($EXPECT($
|
|
13960
|
+
var From$0 = $TS($S($EXPECT($L122, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13475
13961
|
return { $loc, token: $1 };
|
|
13476
13962
|
});
|
|
13477
13963
|
function From(state) {
|
|
@@ -13496,7 +13982,7 @@ ${input.slice(result.pos)}
|
|
|
13496
13982
|
return result;
|
|
13497
13983
|
}
|
|
13498
13984
|
}
|
|
13499
|
-
var Function$0 = $TS($S($EXPECT($
|
|
13985
|
+
var Function$0 = $TS($S($EXPECT($L123, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13500
13986
|
return { $loc, token: $1 };
|
|
13501
13987
|
});
|
|
13502
13988
|
function Function(state) {
|
|
@@ -13521,7 +14007,7 @@ ${input.slice(result.pos)}
|
|
|
13521
14007
|
return result;
|
|
13522
14008
|
}
|
|
13523
14009
|
}
|
|
13524
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14010
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L124, fail, 'GetOrSet "get"'), $EXPECT($L125, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13525
14011
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13526
14012
|
});
|
|
13527
14013
|
function GetOrSet(state) {
|
|
@@ -13546,7 +14032,7 @@ ${input.slice(result.pos)}
|
|
|
13546
14032
|
return result;
|
|
13547
14033
|
}
|
|
13548
14034
|
}
|
|
13549
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14035
|
+
var If$0 = $TV($TEXT($S($EXPECT($L126, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13550
14036
|
return { $loc, token: $1 };
|
|
13551
14037
|
});
|
|
13552
14038
|
function If(state) {
|
|
@@ -13621,7 +14107,7 @@ ${input.slice(result.pos)}
|
|
|
13621
14107
|
return result;
|
|
13622
14108
|
}
|
|
13623
14109
|
}
|
|
13624
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14110
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L127, fail, 'LetOrConst "let"'), $EXPECT($L128, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13625
14111
|
return { $loc, token: $1 };
|
|
13626
14112
|
});
|
|
13627
14113
|
function LetOrConst(state) {
|
|
@@ -13646,7 +14132,7 @@ ${input.slice(result.pos)}
|
|
|
13646
14132
|
return result;
|
|
13647
14133
|
}
|
|
13648
14134
|
}
|
|
13649
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14135
|
+
var Loop$0 = $TS($S($EXPECT($L129, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13650
14136
|
return { $loc, token: "while(true)" };
|
|
13651
14137
|
});
|
|
13652
14138
|
function Loop(state) {
|
|
@@ -13671,7 +14157,7 @@ ${input.slice(result.pos)}
|
|
|
13671
14157
|
return result;
|
|
13672
14158
|
}
|
|
13673
14159
|
}
|
|
13674
|
-
var New$0 = $TS($S($EXPECT($
|
|
14160
|
+
var New$0 = $TS($S($EXPECT($L130, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13675
14161
|
return { $loc, token: $1 };
|
|
13676
14162
|
});
|
|
13677
14163
|
function New(state) {
|
|
@@ -13746,7 +14232,7 @@ ${input.slice(result.pos)}
|
|
|
13746
14232
|
return result;
|
|
13747
14233
|
}
|
|
13748
14234
|
}
|
|
13749
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14235
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L131, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
13750
14236
|
return { $loc, token: $1 };
|
|
13751
14237
|
});
|
|
13752
14238
|
function OpenAngleBracket(state) {
|
|
@@ -13771,7 +14257,7 @@ ${input.slice(result.pos)}
|
|
|
13771
14257
|
return result;
|
|
13772
14258
|
}
|
|
13773
14259
|
}
|
|
13774
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14260
|
+
var OpenBrace$0 = $TV($EXPECT($L132, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
13775
14261
|
return { $loc, token: $1 };
|
|
13776
14262
|
});
|
|
13777
14263
|
function OpenBrace(state) {
|
|
@@ -13796,7 +14282,7 @@ ${input.slice(result.pos)}
|
|
|
13796
14282
|
return result;
|
|
13797
14283
|
}
|
|
13798
14284
|
}
|
|
13799
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14285
|
+
var OpenBracket$0 = $TV($EXPECT($L96, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
13800
14286
|
return { $loc, token: $1 };
|
|
13801
14287
|
});
|
|
13802
14288
|
function OpenBracket(state) {
|
|
@@ -13846,7 +14332,7 @@ ${input.slice(result.pos)}
|
|
|
13846
14332
|
return result;
|
|
13847
14333
|
}
|
|
13848
14334
|
}
|
|
13849
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14335
|
+
var Operator$0 = $TS($S($EXPECT($L133, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13850
14336
|
return { $loc, token: $1 };
|
|
13851
14337
|
});
|
|
13852
14338
|
function Operator(state) {
|
|
@@ -13871,7 +14357,7 @@ ${input.slice(result.pos)}
|
|
|
13871
14357
|
return result;
|
|
13872
14358
|
}
|
|
13873
14359
|
}
|
|
13874
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14360
|
+
var Public$0 = $TS($S($EXPECT($L134, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13875
14361
|
return { $loc, token: $1 };
|
|
13876
14362
|
});
|
|
13877
14363
|
function Public(state) {
|
|
@@ -13896,7 +14382,7 @@ ${input.slice(result.pos)}
|
|
|
13896
14382
|
return result;
|
|
13897
14383
|
}
|
|
13898
14384
|
}
|
|
13899
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14385
|
+
var Private$0 = $TS($S($EXPECT($L135, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13900
14386
|
return { $loc, token: $1 };
|
|
13901
14387
|
});
|
|
13902
14388
|
function Private(state) {
|
|
@@ -13921,7 +14407,7 @@ ${input.slice(result.pos)}
|
|
|
13921
14407
|
return result;
|
|
13922
14408
|
}
|
|
13923
14409
|
}
|
|
13924
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14410
|
+
var Protected$0 = $TS($S($EXPECT($L136, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13925
14411
|
return { $loc, token: $1 };
|
|
13926
14412
|
});
|
|
13927
14413
|
function Protected(state) {
|
|
@@ -13946,13 +14432,13 @@ ${input.slice(result.pos)}
|
|
|
13946
14432
|
return result;
|
|
13947
14433
|
}
|
|
13948
14434
|
}
|
|
13949
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14435
|
+
var Pipe$0 = $TV($EXPECT($L137, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
13950
14436
|
return { $loc, token: $1 };
|
|
13951
14437
|
});
|
|
13952
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14438
|
+
var Pipe$1 = $TV($EXPECT($L138, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
13953
14439
|
return { $loc, token: $1 };
|
|
13954
14440
|
});
|
|
13955
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14441
|
+
var Pipe$2 = $TV($EXPECT($L139, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
13956
14442
|
return { $loc, token: $1 };
|
|
13957
14443
|
});
|
|
13958
14444
|
function Pipe(state) {
|
|
@@ -14002,7 +14488,7 @@ ${input.slice(result.pos)}
|
|
|
14002
14488
|
return result;
|
|
14003
14489
|
}
|
|
14004
14490
|
}
|
|
14005
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14491
|
+
var Readonly$0 = $TS($S($EXPECT($L140, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14006
14492
|
return { $loc, token: $1, ts: true };
|
|
14007
14493
|
});
|
|
14008
14494
|
function Readonly(state) {
|
|
@@ -14027,7 +14513,7 @@ ${input.slice(result.pos)}
|
|
|
14027
14513
|
return result;
|
|
14028
14514
|
}
|
|
14029
14515
|
}
|
|
14030
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14516
|
+
var Return$0 = $TS($S($EXPECT($L141, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14031
14517
|
return { $loc, token: $1 };
|
|
14032
14518
|
});
|
|
14033
14519
|
function Return(state) {
|
|
@@ -14052,7 +14538,7 @@ ${input.slice(result.pos)}
|
|
|
14052
14538
|
return result;
|
|
14053
14539
|
}
|
|
14054
14540
|
}
|
|
14055
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14541
|
+
var Satisfies$0 = $TS($S($EXPECT($L142, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14056
14542
|
return { $loc, token: $1 };
|
|
14057
14543
|
});
|
|
14058
14544
|
function Satisfies(state) {
|
|
@@ -14102,7 +14588,7 @@ ${input.slice(result.pos)}
|
|
|
14102
14588
|
return result;
|
|
14103
14589
|
}
|
|
14104
14590
|
}
|
|
14105
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14591
|
+
var SingleQuote$0 = $TV($EXPECT($L143, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14106
14592
|
return { $loc, token: $1 };
|
|
14107
14593
|
});
|
|
14108
14594
|
function SingleQuote(state) {
|
|
@@ -14152,10 +14638,10 @@ ${input.slice(result.pos)}
|
|
|
14152
14638
|
return result;
|
|
14153
14639
|
}
|
|
14154
14640
|
}
|
|
14155
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14641
|
+
var Static$0 = $TS($S($EXPECT($L144, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14156
14642
|
return { $loc, token: $1 };
|
|
14157
14643
|
});
|
|
14158
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14644
|
+
var Static$1 = $TS($S($EXPECT($L100, fail, 'Static "@"'), $N($C($EXPECT($L2, fail, 'Static "("'), $EXPECT($L100, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
14159
14645
|
return { $loc, token: "static " };
|
|
14160
14646
|
});
|
|
14161
14647
|
function Static(state) {
|
|
@@ -14180,7 +14666,7 @@ ${input.slice(result.pos)}
|
|
|
14180
14666
|
return result;
|
|
14181
14667
|
}
|
|
14182
14668
|
}
|
|
14183
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14669
|
+
var SubstitutionStart$0 = $TV($EXPECT($L145, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14184
14670
|
return { $loc, token: $1 };
|
|
14185
14671
|
});
|
|
14186
14672
|
function SubstitutionStart(state) {
|
|
@@ -14205,7 +14691,7 @@ ${input.slice(result.pos)}
|
|
|
14205
14691
|
return result;
|
|
14206
14692
|
}
|
|
14207
14693
|
}
|
|
14208
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14694
|
+
var Switch$0 = $TS($S($EXPECT($L146, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14209
14695
|
return { $loc, token: $1 };
|
|
14210
14696
|
});
|
|
14211
14697
|
function Switch(state) {
|
|
@@ -14230,7 +14716,7 @@ ${input.slice(result.pos)}
|
|
|
14230
14716
|
return result;
|
|
14231
14717
|
}
|
|
14232
14718
|
}
|
|
14233
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14719
|
+
var Target$0 = $TS($S($EXPECT($L147, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14234
14720
|
return { $loc, token: $1 };
|
|
14235
14721
|
});
|
|
14236
14722
|
function Target(state) {
|
|
@@ -14255,7 +14741,7 @@ ${input.slice(result.pos)}
|
|
|
14255
14741
|
return result;
|
|
14256
14742
|
}
|
|
14257
14743
|
}
|
|
14258
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14744
|
+
var Then$0 = $TS($S(__, $EXPECT($L148, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14259
14745
|
return { $loc, token: "" };
|
|
14260
14746
|
});
|
|
14261
14747
|
function Then(state) {
|
|
@@ -14280,7 +14766,7 @@ ${input.slice(result.pos)}
|
|
|
14280
14766
|
return result;
|
|
14281
14767
|
}
|
|
14282
14768
|
}
|
|
14283
|
-
var This$0 = $TS($S($EXPECT($
|
|
14769
|
+
var This$0 = $TS($S($EXPECT($L149, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14284
14770
|
return { $loc, token: $1 };
|
|
14285
14771
|
});
|
|
14286
14772
|
function This(state) {
|
|
@@ -14305,7 +14791,7 @@ ${input.slice(result.pos)}
|
|
|
14305
14791
|
return result;
|
|
14306
14792
|
}
|
|
14307
14793
|
}
|
|
14308
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14794
|
+
var Throw$0 = $TS($S($EXPECT($L150, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14309
14795
|
return { $loc, token: $1 };
|
|
14310
14796
|
});
|
|
14311
14797
|
function Throw(state) {
|
|
@@ -14330,7 +14816,7 @@ ${input.slice(result.pos)}
|
|
|
14330
14816
|
return result;
|
|
14331
14817
|
}
|
|
14332
14818
|
}
|
|
14333
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14819
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L151, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14334
14820
|
return { $loc, token: "`" };
|
|
14335
14821
|
});
|
|
14336
14822
|
function TripleDoubleQuote(state) {
|
|
@@ -14355,7 +14841,7 @@ ${input.slice(result.pos)}
|
|
|
14355
14841
|
return result;
|
|
14356
14842
|
}
|
|
14357
14843
|
}
|
|
14358
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14844
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L152, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14359
14845
|
return { $loc, token: "`" };
|
|
14360
14846
|
});
|
|
14361
14847
|
function TripleSingleQuote(state) {
|
|
@@ -14380,7 +14866,7 @@ ${input.slice(result.pos)}
|
|
|
14380
14866
|
return result;
|
|
14381
14867
|
}
|
|
14382
14868
|
}
|
|
14383
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14869
|
+
var TripleSlash$0 = $TV($EXPECT($L153, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14384
14870
|
return { $loc, token: "/" };
|
|
14385
14871
|
});
|
|
14386
14872
|
function TripleSlash(state) {
|
|
@@ -14405,7 +14891,7 @@ ${input.slice(result.pos)}
|
|
|
14405
14891
|
return result;
|
|
14406
14892
|
}
|
|
14407
14893
|
}
|
|
14408
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14894
|
+
var TripleTick$0 = $TV($EXPECT($L154, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14409
14895
|
return { $loc, token: "`" };
|
|
14410
14896
|
});
|
|
14411
14897
|
function TripleTick(state) {
|
|
@@ -14430,7 +14916,7 @@ ${input.slice(result.pos)}
|
|
|
14430
14916
|
return result;
|
|
14431
14917
|
}
|
|
14432
14918
|
}
|
|
14433
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14919
|
+
var Try$0 = $TS($S($EXPECT($L155, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14434
14920
|
return { $loc, token: $1 };
|
|
14435
14921
|
});
|
|
14436
14922
|
function Try(state) {
|
|
@@ -14455,7 +14941,7 @@ ${input.slice(result.pos)}
|
|
|
14455
14941
|
return result;
|
|
14456
14942
|
}
|
|
14457
14943
|
}
|
|
14458
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
14944
|
+
var Typeof$0 = $TS($S($EXPECT($L156, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14459
14945
|
return { $loc, token: $1 };
|
|
14460
14946
|
});
|
|
14461
14947
|
function Typeof(state) {
|
|
@@ -14480,7 +14966,7 @@ ${input.slice(result.pos)}
|
|
|
14480
14966
|
return result;
|
|
14481
14967
|
}
|
|
14482
14968
|
}
|
|
14483
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
14969
|
+
var Unless$0 = $TS($S($EXPECT($L157, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14484
14970
|
return { $loc, token: $1 };
|
|
14485
14971
|
});
|
|
14486
14972
|
function Unless(state) {
|
|
@@ -14505,7 +14991,7 @@ ${input.slice(result.pos)}
|
|
|
14505
14991
|
return result;
|
|
14506
14992
|
}
|
|
14507
14993
|
}
|
|
14508
|
-
var Until$0 = $TS($S($EXPECT($
|
|
14994
|
+
var Until$0 = $TS($S($EXPECT($L158, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14509
14995
|
return { $loc, token: $1 };
|
|
14510
14996
|
});
|
|
14511
14997
|
function Until(state) {
|
|
@@ -14530,7 +15016,7 @@ ${input.slice(result.pos)}
|
|
|
14530
15016
|
return result;
|
|
14531
15017
|
}
|
|
14532
15018
|
}
|
|
14533
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15019
|
+
var Var$0 = $TS($S($EXPECT($L159, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14534
15020
|
return { $loc, token: $1 };
|
|
14535
15021
|
});
|
|
14536
15022
|
function Var(state) {
|
|
@@ -14555,7 +15041,7 @@ ${input.slice(result.pos)}
|
|
|
14555
15041
|
return result;
|
|
14556
15042
|
}
|
|
14557
15043
|
}
|
|
14558
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15044
|
+
var Void$0 = $TS($S($EXPECT($L160, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14559
15045
|
return { $loc, token: $1 };
|
|
14560
15046
|
});
|
|
14561
15047
|
function Void(state) {
|
|
@@ -14580,7 +15066,7 @@ ${input.slice(result.pos)}
|
|
|
14580
15066
|
return result;
|
|
14581
15067
|
}
|
|
14582
15068
|
}
|
|
14583
|
-
var When$0 = $TS($S($EXPECT($
|
|
15069
|
+
var When$0 = $TS($S($EXPECT($L161, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14584
15070
|
return { $loc, token: "case" };
|
|
14585
15071
|
});
|
|
14586
15072
|
function When(state) {
|
|
@@ -14605,7 +15091,7 @@ ${input.slice(result.pos)}
|
|
|
14605
15091
|
return result;
|
|
14606
15092
|
}
|
|
14607
15093
|
}
|
|
14608
|
-
var While$0 = $TS($S($EXPECT($
|
|
15094
|
+
var While$0 = $TS($S($EXPECT($L162, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14609
15095
|
return { $loc, token: $1 };
|
|
14610
15096
|
});
|
|
14611
15097
|
function While(state) {
|
|
@@ -14630,7 +15116,7 @@ ${input.slice(result.pos)}
|
|
|
14630
15116
|
return result;
|
|
14631
15117
|
}
|
|
14632
15118
|
}
|
|
14633
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15119
|
+
var Yield$0 = $TS($S($EXPECT($L163, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14634
15120
|
return { $loc, token: $1 };
|
|
14635
15121
|
});
|
|
14636
15122
|
function Yield(state) {
|
|
@@ -14723,11 +15209,10 @@ ${input.slice(result.pos)}
|
|
|
14723
15209
|
}
|
|
14724
15210
|
}
|
|
14725
15211
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
14726
|
-
var JSXElement$1 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningElement, $E(JSXMixedChildren), JSXOptionalClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
15212
|
+
var JSXElement$1 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningElement, $E(JSXMixedChildren), JSXOptionalClosingElement, PopJSXStack), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14727
15213
|
var open = $2;
|
|
14728
15214
|
var children = $3;
|
|
14729
15215
|
var close = $4;
|
|
14730
|
-
module2.JSXTagStack.pop();
|
|
14731
15216
|
if (!children)
|
|
14732
15217
|
return $skip;
|
|
14733
15218
|
$0 = $0.slice(1);
|
|
@@ -14776,7 +15261,7 @@ ${input.slice(result.pos)}
|
|
|
14776
15261
|
return result;
|
|
14777
15262
|
}
|
|
14778
15263
|
}
|
|
14779
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15264
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L131, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L164, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
14780
15265
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
14781
15266
|
});
|
|
14782
15267
|
function JSXSelfClosingElement(state) {
|
|
@@ -14827,7 +15312,32 @@ ${input.slice(result.pos)}
|
|
|
14827
15312
|
return result;
|
|
14828
15313
|
}
|
|
14829
15314
|
}
|
|
14830
|
-
var
|
|
15315
|
+
var PopJSXStack$0 = $TV($EXPECT($L18, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15316
|
+
module2.JSXTagStack.pop();
|
|
15317
|
+
});
|
|
15318
|
+
function PopJSXStack(state) {
|
|
15319
|
+
let eventData;
|
|
15320
|
+
if (state.events) {
|
|
15321
|
+
const result = state.events.enter?.("PopJSXStack", state);
|
|
15322
|
+
if (result) {
|
|
15323
|
+
if (result.cache)
|
|
15324
|
+
return result.cache;
|
|
15325
|
+
eventData = result.data;
|
|
15326
|
+
}
|
|
15327
|
+
}
|
|
15328
|
+
if (state.tokenize) {
|
|
15329
|
+
const result = $TOKEN("PopJSXStack", state, PopJSXStack$0(state));
|
|
15330
|
+
if (state.events)
|
|
15331
|
+
state.events.exit?.("PopJSXStack", state, result, eventData);
|
|
15332
|
+
return result;
|
|
15333
|
+
} else {
|
|
15334
|
+
const result = PopJSXStack$0(state);
|
|
15335
|
+
if (state.events)
|
|
15336
|
+
state.events.exit?.("PopJSXStack", state, result, eventData);
|
|
15337
|
+
return result;
|
|
15338
|
+
}
|
|
15339
|
+
}
|
|
15340
|
+
var JSXOpeningElement$0 = $S($EXPECT($L131, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L29, fail, 'JSXOpeningElement ">"'));
|
|
14831
15341
|
function JSXOpeningElement(state) {
|
|
14832
15342
|
let eventData;
|
|
14833
15343
|
if (state.events) {
|
|
@@ -14879,7 +15389,7 @@ ${input.slice(result.pos)}
|
|
|
14879
15389
|
return result;
|
|
14880
15390
|
}
|
|
14881
15391
|
}
|
|
14882
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15392
|
+
var JSXClosingElement$0 = $S($EXPECT($L165, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L29, fail, 'JSXClosingElement ">"'));
|
|
14883
15393
|
function JSXClosingElement(state) {
|
|
14884
15394
|
let eventData;
|
|
14885
15395
|
if (state.events) {
|
|
@@ -14902,11 +15412,10 @@ ${input.slice(result.pos)}
|
|
|
14902
15412
|
return result;
|
|
14903
15413
|
}
|
|
14904
15414
|
}
|
|
14905
|
-
var JSXFragment$0 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningFragment, $E(JSXMixedChildren), JSXOptionalClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
15415
|
+
var JSXFragment$0 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningFragment, $E(JSXMixedChildren), JSXOptionalClosingFragment, PopJSXStack), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14906
15416
|
var open = $2;
|
|
14907
15417
|
var children = $3;
|
|
14908
15418
|
var close = $4;
|
|
14909
|
-
module2.JSXTagStack.pop();
|
|
14910
15419
|
if (!children)
|
|
14911
15420
|
return $skip;
|
|
14912
15421
|
$0 = $0.slice(1);
|
|
@@ -14918,7 +15427,7 @@ ${input.slice(result.pos)}
|
|
|
14918
15427
|
];
|
|
14919
15428
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
14920
15429
|
});
|
|
14921
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15430
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L166, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14922
15431
|
var children = $3;
|
|
14923
15432
|
$0 = $0.slice(1);
|
|
14924
15433
|
return {
|
|
@@ -14949,7 +15458,7 @@ ${input.slice(result.pos)}
|
|
|
14949
15458
|
return result;
|
|
14950
15459
|
}
|
|
14951
15460
|
}
|
|
14952
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15461
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L166, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
14953
15462
|
module2.JSXTagStack.push("");
|
|
14954
15463
|
return $1;
|
|
14955
15464
|
});
|
|
@@ -15003,7 +15512,7 @@ ${input.slice(result.pos)}
|
|
|
15003
15512
|
return result;
|
|
15004
15513
|
}
|
|
15005
15514
|
}
|
|
15006
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15515
|
+
var JSXClosingFragment$0 = $EXPECT($L167, fail, 'JSXClosingFragment "</>"');
|
|
15007
15516
|
function JSXClosingFragment(state) {
|
|
15008
15517
|
let eventData;
|
|
15009
15518
|
if (state.events) {
|
|
@@ -15479,7 +15988,7 @@ ${input.slice(result.pos)}
|
|
|
15479
15988
|
return result;
|
|
15480
15989
|
}
|
|
15481
15990
|
}
|
|
15482
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
15991
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R54, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15483
15992
|
return { $loc, token: $0 };
|
|
15484
15993
|
});
|
|
15485
15994
|
function InlineJSXUnaryOp(state) {
|
|
@@ -15899,7 +16408,7 @@ ${input.slice(result.pos)}
|
|
|
15899
16408
|
return result;
|
|
15900
16409
|
}
|
|
15901
16410
|
}
|
|
15902
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16411
|
+
var JSXComment$0 = $TS($S($EXPECT($L168, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L169, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
15903
16412
|
return ["{/*", $2, "*/}"];
|
|
15904
16413
|
});
|
|
15905
16414
|
function JSXComment(state) {
|
|
@@ -15924,7 +16433,7 @@ ${input.slice(result.pos)}
|
|
|
15924
16433
|
return result;
|
|
15925
16434
|
}
|
|
15926
16435
|
}
|
|
15927
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
16436
|
+
var JSXCommentContent$0 = $TR($EXPECT($R55, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15928
16437
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
15929
16438
|
});
|
|
15930
16439
|
function JSXCommentContent(state) {
|
|
@@ -15949,7 +16458,7 @@ ${input.slice(result.pos)}
|
|
|
15949
16458
|
return result;
|
|
15950
16459
|
}
|
|
15951
16460
|
}
|
|
15952
|
-
var JSXText$0 = $TR($EXPECT($
|
|
16461
|
+
var JSXText$0 = $TR($EXPECT($R56, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15953
16462
|
return {
|
|
15954
16463
|
type: "JSXText",
|
|
15955
16464
|
token: $0,
|
|
@@ -16197,7 +16706,7 @@ ${input.slice(result.pos)}
|
|
|
16197
16706
|
return result;
|
|
16198
16707
|
}
|
|
16199
16708
|
}
|
|
16200
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16709
|
+
var TypeKeyword$0 = $S($EXPECT($L170, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16201
16710
|
function TypeKeyword(state) {
|
|
16202
16711
|
let eventData;
|
|
16203
16712
|
if (state.events) {
|
|
@@ -16220,7 +16729,7 @@ ${input.slice(result.pos)}
|
|
|
16220
16729
|
return result;
|
|
16221
16730
|
}
|
|
16222
16731
|
}
|
|
16223
|
-
var Interface$0 = $S($EXPECT($
|
|
16732
|
+
var Interface$0 = $S($EXPECT($L171, fail, 'Interface "interface"'), NonIdContinue);
|
|
16224
16733
|
function Interface(state) {
|
|
16225
16734
|
let eventData;
|
|
16226
16735
|
if (state.events) {
|
|
@@ -16243,7 +16752,7 @@ ${input.slice(result.pos)}
|
|
|
16243
16752
|
return result;
|
|
16244
16753
|
}
|
|
16245
16754
|
}
|
|
16246
|
-
var Namespace$0 = $S($EXPECT($
|
|
16755
|
+
var Namespace$0 = $S($EXPECT($L172, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16247
16756
|
function Namespace(state) {
|
|
16248
16757
|
let eventData;
|
|
16249
16758
|
if (state.events) {
|
|
@@ -16491,7 +17000,7 @@ ${input.slice(result.pos)}
|
|
|
16491
17000
|
return result;
|
|
16492
17001
|
}
|
|
16493
17002
|
}
|
|
16494
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
17003
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L140, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R58, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
16495
17004
|
function TypeIndexSignature(state) {
|
|
16496
17005
|
let eventData;
|
|
16497
17006
|
if (state.events) {
|
|
@@ -16563,7 +17072,7 @@ ${input.slice(result.pos)}
|
|
|
16563
17072
|
return result;
|
|
16564
17073
|
}
|
|
16565
17074
|
}
|
|
16566
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
17075
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L173, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
16567
17076
|
const children = [...$1, $2];
|
|
16568
17077
|
if ($3)
|
|
16569
17078
|
children.push($3);
|
|
@@ -16722,10 +17231,10 @@ ${input.slice(result.pos)}
|
|
|
16722
17231
|
return result;
|
|
16723
17232
|
}
|
|
16724
17233
|
}
|
|
16725
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
16726
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
16727
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
16728
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17234
|
+
var TypeUnaryOp$0 = $S($EXPECT($L174, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17235
|
+
var TypeUnaryOp$1 = $S($EXPECT($L156, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17236
|
+
var TypeUnaryOp$2 = $S($EXPECT($L175, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17237
|
+
var TypeUnaryOp$3 = $S($EXPECT($L140, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
16729
17238
|
function TypeUnaryOp(state) {
|
|
16730
17239
|
let eventData;
|
|
16731
17240
|
if (state.events) {
|
|
@@ -16778,7 +17287,7 @@ ${input.slice(result.pos)}
|
|
|
16778
17287
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
16779
17288
|
var TypePrimary$5 = $S($E(_), TypeLiteral);
|
|
16780
17289
|
var TypePrimary$6 = $S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
16781
|
-
var TypePrimary$7 = $S(__, OpenParen, Type, __, CloseParen);
|
|
17290
|
+
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
16782
17291
|
function TypePrimary(state) {
|
|
16783
17292
|
let eventData;
|
|
16784
17293
|
if (state.events) {
|
|
@@ -16923,7 +17432,7 @@ ${input.slice(result.pos)}
|
|
|
16923
17432
|
return result;
|
|
16924
17433
|
}
|
|
16925
17434
|
}
|
|
16926
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17435
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L119, fail, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
16927
17436
|
if ($2)
|
|
16928
17437
|
return $0;
|
|
16929
17438
|
return $1;
|
|
@@ -16952,10 +17461,10 @@ ${input.slice(result.pos)}
|
|
|
16952
17461
|
}
|
|
16953
17462
|
var TypeLiteral$0 = TemplateLiteral;
|
|
16954
17463
|
var TypeLiteral$1 = Literal;
|
|
16955
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17464
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L160, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16956
17465
|
return { $loc, token: "void" };
|
|
16957
17466
|
});
|
|
16958
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17467
|
+
var TypeLiteral$3 = $TV($EXPECT($L176, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
16959
17468
|
return { $loc, token: "[]" };
|
|
16960
17469
|
});
|
|
16961
17470
|
function TypeLiteral(state) {
|
|
@@ -17139,7 +17648,7 @@ ${input.slice(result.pos)}
|
|
|
17139
17648
|
return result;
|
|
17140
17649
|
}
|
|
17141
17650
|
}
|
|
17142
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17651
|
+
var TypeArguments$0 = $TS($S($EXPECT($L131, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L29, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17143
17652
|
return { ts: true, children: $0 };
|
|
17144
17653
|
});
|
|
17145
17654
|
function TypeArguments(state) {
|
|
@@ -17210,7 +17719,7 @@ ${input.slice(result.pos)}
|
|
|
17210
17719
|
return result;
|
|
17211
17720
|
}
|
|
17212
17721
|
}
|
|
17213
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17722
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L131, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L29, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17214
17723
|
var parameters = $3;
|
|
17215
17724
|
return {
|
|
17216
17725
|
type: "TypeParameters",
|
|
@@ -17264,7 +17773,7 @@ ${input.slice(result.pos)}
|
|
|
17264
17773
|
return result;
|
|
17265
17774
|
}
|
|
17266
17775
|
}
|
|
17267
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17776
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L119, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17268
17777
|
function TypeConstraint(state) {
|
|
17269
17778
|
let eventData;
|
|
17270
17779
|
if (state.events) {
|
|
@@ -17362,7 +17871,7 @@ ${input.slice(result.pos)}
|
|
|
17362
17871
|
return result;
|
|
17363
17872
|
}
|
|
17364
17873
|
}
|
|
17365
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
17874
|
+
var Shebang$0 = $S($R$0($EXPECT($R59, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
17366
17875
|
function Shebang(state) {
|
|
17367
17876
|
let eventData;
|
|
17368
17877
|
if (state.events) {
|
|
@@ -17385,11 +17894,11 @@ ${input.slice(result.pos)}
|
|
|
17385
17894
|
return result;
|
|
17386
17895
|
}
|
|
17387
17896
|
}
|
|
17388
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
17897
|
+
var CivetPrologue$0 = $T($S($EXPECT($R60, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17389
17898
|
var content = value[2];
|
|
17390
17899
|
return content;
|
|
17391
17900
|
});
|
|
17392
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
17901
|
+
var CivetPrologue$1 = $T($S($EXPECT($R60, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17393
17902
|
var content = value[2];
|
|
17394
17903
|
return content;
|
|
17395
17904
|
});
|
|
@@ -17415,7 +17924,7 @@ ${input.slice(result.pos)}
|
|
|
17415
17924
|
return result;
|
|
17416
17925
|
}
|
|
17417
17926
|
}
|
|
17418
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
17927
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L177, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R61, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17419
17928
|
var options = $3;
|
|
17420
17929
|
return {
|
|
17421
17930
|
type: "CivetPrologue",
|
|
@@ -17445,7 +17954,7 @@ ${input.slice(result.pos)}
|
|
|
17445
17954
|
return result;
|
|
17446
17955
|
}
|
|
17447
17956
|
}
|
|
17448
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
17957
|
+
var CivetOption$0 = $TR($EXPECT($R62, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17449
17958
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
17450
17959
|
if (l)
|
|
17451
17960
|
return l.toUpperCase();
|
|
@@ -17481,7 +17990,7 @@ ${input.slice(result.pos)}
|
|
|
17481
17990
|
return result;
|
|
17482
17991
|
}
|
|
17483
17992
|
}
|
|
17484
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
17993
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R60, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
17485
17994
|
function UnknownPrologue(state) {
|
|
17486
17995
|
let eventData;
|
|
17487
17996
|
if (state.events) {
|
|
@@ -17551,7 +18060,7 @@ ${input.slice(result.pos)}
|
|
|
17551
18060
|
return result;
|
|
17552
18061
|
}
|
|
17553
18062
|
}
|
|
17554
|
-
var EOL$0 = $TR($EXPECT($
|
|
18063
|
+
var EOL$0 = $TR($EXPECT($R63, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17555
18064
|
return { $loc, token: $0 };
|
|
17556
18065
|
});
|
|
17557
18066
|
function EOL(state) {
|
|
@@ -17576,13 +18085,13 @@ ${input.slice(result.pos)}
|
|
|
17576
18085
|
return result;
|
|
17577
18086
|
}
|
|
17578
18087
|
}
|
|
17579
|
-
var
|
|
18088
|
+
var DebugHere$0 = $TV($EXPECT($L18, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
17580
18089
|
debugger;
|
|
17581
18090
|
});
|
|
17582
|
-
function
|
|
18091
|
+
function DebugHere(state) {
|
|
17583
18092
|
let eventData;
|
|
17584
18093
|
if (state.events) {
|
|
17585
|
-
const result = state.events.enter?.("
|
|
18094
|
+
const result = state.events.enter?.("DebugHere", state);
|
|
17586
18095
|
if (result) {
|
|
17587
18096
|
if (result.cache)
|
|
17588
18097
|
return result.cache;
|
|
@@ -17590,14 +18099,14 @@ ${input.slice(result.pos)}
|
|
|
17590
18099
|
}
|
|
17591
18100
|
}
|
|
17592
18101
|
if (state.tokenize) {
|
|
17593
|
-
const result = $TOKEN("
|
|
18102
|
+
const result = $TOKEN("DebugHere", state, DebugHere$0(state));
|
|
17594
18103
|
if (state.events)
|
|
17595
|
-
state.events.exit?.("
|
|
18104
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
17596
18105
|
return result;
|
|
17597
18106
|
} else {
|
|
17598
|
-
const result =
|
|
18107
|
+
const result = DebugHere$0(state);
|
|
17599
18108
|
if (state.events)
|
|
17600
|
-
state.events.exit?.("
|
|
18109
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
17601
18110
|
return result;
|
|
17602
18111
|
}
|
|
17603
18112
|
}
|
|
@@ -18434,7 +18943,9 @@ ${input.slice(result.pos)}
|
|
|
18434
18943
|
level: 0,
|
|
18435
18944
|
token: ""
|
|
18436
18945
|
}];
|
|
18437
|
-
module2.
|
|
18946
|
+
module2.forbidIndentedApplication = [false];
|
|
18947
|
+
module2.forbidTrailingMemberProperty = [false];
|
|
18948
|
+
module2.forbidMultiLineImplicitObjectLiteral = [false];
|
|
18438
18949
|
module2.JSXTagStack = [];
|
|
18439
18950
|
module2.operators = /* @__PURE__ */ new Set();
|
|
18440
18951
|
if (!module2._init) {
|
|
@@ -18446,9 +18957,21 @@ ${input.slice(result.pos)}
|
|
|
18446
18957
|
return l[l.length - 1];
|
|
18447
18958
|
}
|
|
18448
18959
|
},
|
|
18449
|
-
|
|
18960
|
+
indentedApplicationForbidden: {
|
|
18450
18961
|
get() {
|
|
18451
|
-
const {
|
|
18962
|
+
const { forbidIndentedApplication: s } = module2;
|
|
18963
|
+
return s[s.length - 1];
|
|
18964
|
+
}
|
|
18965
|
+
},
|
|
18966
|
+
trailingMemberPropertyForbidden: {
|
|
18967
|
+
get() {
|
|
18968
|
+
const { forbidTrailingMemberProperty: s } = module2;
|
|
18969
|
+
return s[s.length - 1];
|
|
18970
|
+
}
|
|
18971
|
+
},
|
|
18972
|
+
multiLineImplicitObjectLiteralForbidden: {
|
|
18973
|
+
get() {
|
|
18974
|
+
const { forbidMultiLineImplicitObjectLiteral: s } = module2;
|
|
18452
18975
|
return s[s.length - 1];
|
|
18453
18976
|
}
|
|
18454
18977
|
},
|
|
@@ -19440,7 +19963,12 @@ ${input.slice(result.pos)}
|
|
|
19440
19963
|
names
|
|
19441
19964
|
};
|
|
19442
19965
|
}
|
|
19443
|
-
|
|
19966
|
+
return {
|
|
19967
|
+
children: [{
|
|
19968
|
+
type: "Error",
|
|
19969
|
+
message: "Multiple rest properties in object pattern"
|
|
19970
|
+
}, props2]
|
|
19971
|
+
};
|
|
19444
19972
|
};
|
|
19445
19973
|
function gatherNodes(node, predicate) {
|
|
19446
19974
|
if (node == null)
|
|
@@ -19580,7 +20108,7 @@ ${input.slice(result.pos)}
|
|
|
19580
20108
|
}
|
|
19581
20109
|
function processAssignments(statements) {
|
|
19582
20110
|
gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
|
|
19583
|
-
let { lhs: $12, exp: $22 } = exp,
|
|
20111
|
+
let { lhs: $12, exp: $22 } = exp, tail = [], i = 0, len = $12.length;
|
|
19584
20112
|
if ($12.some((left) => left[left.length - 1].special)) {
|
|
19585
20113
|
if ($12.length !== 1) {
|
|
19586
20114
|
throw new Error("Only one assignment with id= is allowed");
|
|
@@ -19590,17 +20118,6 @@ ${input.slice(result.pos)}
|
|
|
19590
20118
|
op[op.length - 1] = "=";
|
|
19591
20119
|
$22 = [call, "(", lhs, ", ", $22, ")"];
|
|
19592
20120
|
}
|
|
19593
|
-
$12.forEach((lhsPart, i2) => {
|
|
19594
|
-
let expr = lhsPart[1];
|
|
19595
|
-
while (expr.type === "ParenthesizedExpression") {
|
|
19596
|
-
expr = expr.expression;
|
|
19597
|
-
}
|
|
19598
|
-
if (expr.type === "AssignmentExpression") {
|
|
19599
|
-
pre.push([lhsPart[1], ", "]);
|
|
19600
|
-
const newLhs = expr.lhs[0][1];
|
|
19601
|
-
lhsPart[1] = newLhs;
|
|
19602
|
-
}
|
|
19603
|
-
});
|
|
19604
20121
|
let wrapped = false;
|
|
19605
20122
|
while (i < len) {
|
|
19606
20123
|
const lastAssignment = $12[i++];
|
|
@@ -19651,9 +20168,49 @@ ${input.slice(result.pos)}
|
|
|
19651
20168
|
i--;
|
|
19652
20169
|
}
|
|
19653
20170
|
const names = $12.flatMap(([, l]) => l.names || []);
|
|
19654
|
-
exp.children = [
|
|
20171
|
+
exp.children = [$12, $22, ...tail];
|
|
19655
20172
|
exp.names = names;
|
|
19656
20173
|
});
|
|
20174
|
+
gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
|
|
20175
|
+
function extractAssignment(lhs) {
|
|
20176
|
+
let expr = lhs;
|
|
20177
|
+
while (expr.type === "ParenthesizedExpression") {
|
|
20178
|
+
expr = expr.expression;
|
|
20179
|
+
}
|
|
20180
|
+
if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
|
|
20181
|
+
if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
|
|
20182
|
+
post.push([", ", lhs]);
|
|
20183
|
+
} else {
|
|
20184
|
+
pre.push([lhs, ", "]);
|
|
20185
|
+
}
|
|
20186
|
+
return expr.assigned;
|
|
20187
|
+
}
|
|
20188
|
+
}
|
|
20189
|
+
const pre = [], post = [];
|
|
20190
|
+
switch (exp.type) {
|
|
20191
|
+
case "AssignmentExpression":
|
|
20192
|
+
if (!exp.lhs)
|
|
20193
|
+
return;
|
|
20194
|
+
exp.lhs.forEach((lhsPart, i) => {
|
|
20195
|
+
let newLhs2 = extractAssignment(lhsPart[1]);
|
|
20196
|
+
if (newLhs2) {
|
|
20197
|
+
lhsPart[1] = newLhs2;
|
|
20198
|
+
}
|
|
20199
|
+
});
|
|
20200
|
+
break;
|
|
20201
|
+
case "UpdateExpression":
|
|
20202
|
+
let newLhs = extractAssignment(exp.assigned);
|
|
20203
|
+
if (newLhs) {
|
|
20204
|
+
const i = exp.children.indexOf(exp.assigned);
|
|
20205
|
+
exp.assigned = exp.children[i] = newLhs;
|
|
20206
|
+
}
|
|
20207
|
+
break;
|
|
20208
|
+
}
|
|
20209
|
+
if (pre.length)
|
|
20210
|
+
exp.children.unshift(...pre);
|
|
20211
|
+
if (post.length)
|
|
20212
|
+
exp.children.push(...post);
|
|
20213
|
+
});
|
|
19657
20214
|
}
|
|
19658
20215
|
function checkSpliceRef(statements) {
|
|
19659
20216
|
const spliceRef = module2.getRef("splice");
|
|
@@ -20300,7 +20857,7 @@ ${input.slice(result.pos)}
|
|
|
20300
20857
|
return result;
|
|
20301
20858
|
}
|
|
20302
20859
|
}
|
|
20303
|
-
var Indent$0 = $TR($EXPECT($
|
|
20860
|
+
var Indent$0 = $TR($EXPECT($R64, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
20304
20861
|
let level;
|
|
20305
20862
|
if (module2.config.tab) {
|
|
20306
20863
|
const tabs = $0.match(/\t/g);
|
|
@@ -20957,7 +21514,7 @@ var parse;
|
|
|
20957
21514
|
var uncacheable;
|
|
20958
21515
|
({ parse } = import_parser.default);
|
|
20959
21516
|
({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
|
|
20960
|
-
uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "
|
|
21517
|
+
uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "AllowAll", "AllowIndentedApplication", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "ForbidIndentedApplication", "ForbidTrailingMemberProperty", "FunctionDeclaration", "FunctionExpression", "HoistableDeclaration", "ImplicitArguments", "ImplicitInlineObjectPropertyDelimiter", "ImplicitNestedBlock", "IndentedApplicationAllowed", "IndentedFurther", "IndentedJSXChildExpression", "InlineObjectLiteral", "InsertIndent", "JSXChild", "JSXChildren", "JSXElement", "JSXFragment", "JSXImplicitFragment", "JSXMixedChildren", "JSXNested", "JSXNestedChildren", "JSXOptionalClosingElement", "JSXOptionalClosingFragment", "JSXTag", "LeftHandSideExpression", "MemberExpression", "MemberExpressionRest", "Nested", "NestedBindingElement", "NestedBindingElements", "NestedBlockExpression", "NestedBlockExpression", "NestedBlockStatement", "NestedBlockStatements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "ObjectLiteral", "PopIndent", "PopJSXStack", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RestoreAll", "RestoreIndentedApplication", "RestoreTrailingMemberProperty", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuffixedExpression", "SuffixedStatement", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
|
|
20961
21518
|
var compile = function(src, options) {
|
|
20962
21519
|
var ast, code, events, filename, ref, result, sm, srcMapJSON;
|
|
20963
21520
|
if (!options) {
|
|
@@ -20994,7 +21551,9 @@ ${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode2(JSON.stri
|
|
|
20994
21551
|
}
|
|
20995
21552
|
result = generate_default(ast, options);
|
|
20996
21553
|
if ((ref = options.errors) != null ? ref.length : void 0) {
|
|
20997
|
-
throw new Error(`Parse errors: ${options.errors.
|
|
21554
|
+
throw new Error(`Parse errors: ${options.errors.map(function(e) {
|
|
21555
|
+
return e.message;
|
|
21556
|
+
}).join("\n")} `);
|
|
20998
21557
|
}
|
|
20999
21558
|
return result;
|
|
21000
21559
|
};
|