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