@danielx/civet 0.5.68 → 0.5.70
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +884 -325
- package/dist/civet +0 -0
- package/dist/main.js +884 -325
- package/dist/main.mjs +884 -325
- package/package.json +1 -1
package/dist/main.mjs
CHANGED
|
@@ -438,7 +438,7 @@ ${input.slice(result.pos)}
|
|
|
438
438
|
ForbiddenImplicitCalls,
|
|
439
439
|
ArgumentsWithTrailingMemberExpressions,
|
|
440
440
|
TrailingMemberExpressions,
|
|
441
|
-
|
|
441
|
+
AllowedTrailingMemberExpressions,
|
|
442
442
|
CommaDelimiter,
|
|
443
443
|
ArgumentList,
|
|
444
444
|
NonPipelineArgumentList,
|
|
@@ -607,6 +607,7 @@ ${input.slice(result.pos)}
|
|
|
607
607
|
PropertyDefinitionList,
|
|
608
608
|
PropertyDefinition,
|
|
609
609
|
NamedProperty,
|
|
610
|
+
ImplicitNamedProperty,
|
|
610
611
|
SnugNamedProperty,
|
|
611
612
|
PropertyName,
|
|
612
613
|
ComputedPropertyName,
|
|
@@ -635,6 +636,9 @@ ${input.slice(result.pos)}
|
|
|
635
636
|
Statement,
|
|
636
637
|
EmptyStatement,
|
|
637
638
|
BlockStatement,
|
|
639
|
+
LabelledStatement,
|
|
640
|
+
Label,
|
|
641
|
+
LabelledItem,
|
|
638
642
|
IfStatement,
|
|
639
643
|
ElseClause,
|
|
640
644
|
IfClause,
|
|
@@ -680,13 +684,26 @@ ${input.slice(result.pos)}
|
|
|
680
684
|
FinallyClause,
|
|
681
685
|
CatchParameter,
|
|
682
686
|
Condition,
|
|
683
|
-
|
|
684
|
-
|
|
687
|
+
ExpressionWithIndentedApplicationForbidden,
|
|
688
|
+
ForbidIndentedApplication,
|
|
689
|
+
AllowIndentedApplication,
|
|
690
|
+
RestoreIndentedApplication,
|
|
685
691
|
IndentedApplicationAllowed,
|
|
686
|
-
|
|
692
|
+
ForbidTrailingMemberProperty,
|
|
693
|
+
AllowTrailingMemberProperty,
|
|
694
|
+
RestoreTrailingMemberProperty,
|
|
687
695
|
TrailingMemberPropertyAllowed,
|
|
696
|
+
ForbidMultiLineImplicitObjectLiteral,
|
|
697
|
+
AllowMultiLineImplicitObjectLiteral,
|
|
698
|
+
RestoreMultiLineImplicitObjectLiteral,
|
|
699
|
+
MultiLineImplicitObjectLiteralAllowed,
|
|
700
|
+
AllowAll,
|
|
701
|
+
RestoreAll,
|
|
688
702
|
ExpressionStatement,
|
|
689
703
|
KeywordStatement,
|
|
704
|
+
Break,
|
|
705
|
+
Continue,
|
|
706
|
+
Debugger,
|
|
690
707
|
DebuggerExpression,
|
|
691
708
|
ThrowExpression,
|
|
692
709
|
MaybeNestedExpression,
|
|
@@ -865,6 +882,7 @@ ${input.slice(result.pos)}
|
|
|
865
882
|
JSXElement,
|
|
866
883
|
JSXSelfClosingElement,
|
|
867
884
|
PushJSXOpeningElement,
|
|
885
|
+
PopJSXStack,
|
|
868
886
|
JSXOpeningElement,
|
|
869
887
|
JSXOptionalClosingElement,
|
|
870
888
|
JSXClosingElement,
|
|
@@ -964,7 +982,7 @@ ${input.slice(result.pos)}
|
|
|
964
982
|
DirectivePrologue,
|
|
965
983
|
EOS,
|
|
966
984
|
EOL,
|
|
967
|
-
|
|
985
|
+
DebugHere,
|
|
968
986
|
InsertSemicolon,
|
|
969
987
|
InsertOpenParen,
|
|
970
988
|
InsertCloseParen,
|
|
@@ -1092,98 +1110,99 @@ ${input.slice(result.pos)}
|
|
|
1092
1110
|
var $L82 = $L("&");
|
|
1093
1111
|
var $L83 = $L("|");
|
|
1094
1112
|
var $L84 = $L(";");
|
|
1095
|
-
var $L85 = $L("
|
|
1096
|
-
var $L86 = $L("
|
|
1097
|
-
var $L87 = $L("
|
|
1098
|
-
var $L88 = $L("
|
|
1099
|
-
var $L89 = $L("
|
|
1100
|
-
var $L90 = $L("
|
|
1101
|
-
var $L91 = $L("
|
|
1102
|
-
var $L92 = $L("
|
|
1103
|
-
var $L93 = $L("
|
|
1104
|
-
var $L94 = $L("
|
|
1105
|
-
var $L95 = $L("
|
|
1106
|
-
var $L96 = $L("
|
|
1107
|
-
var $L97 = $L("
|
|
1108
|
-
var $L98 = $L("
|
|
1109
|
-
var $L99 = $L("
|
|
1110
|
-
var $L100 = $L("
|
|
1111
|
-
var $L101 = $L("
|
|
1112
|
-
var $L102 = $L("
|
|
1113
|
-
var $L103 = $L("
|
|
1114
|
-
var $L104 = $L("
|
|
1115
|
-
var $L105 = $L("
|
|
1116
|
-
var $L106 = $L("
|
|
1117
|
-
var $L107 = $L("
|
|
1118
|
-
var $L108 = $L("
|
|
1119
|
-
var $L109 = $L("
|
|
1120
|
-
var $L110 = $L("
|
|
1121
|
-
var $L111 = $L("
|
|
1122
|
-
var $L112 = $L("
|
|
1123
|
-
var $L113 = $L("
|
|
1124
|
-
var $L114 = $L("
|
|
1125
|
-
var $L115 = $L(
|
|
1126
|
-
var $L116 = $L("
|
|
1127
|
-
var $L117 = $L("
|
|
1128
|
-
var $L118 = $L("
|
|
1129
|
-
var $L119 = $L("
|
|
1130
|
-
var $L120 = $L("
|
|
1131
|
-
var $L121 = $L("
|
|
1132
|
-
var $L122 = $L("
|
|
1133
|
-
var $L123 = $L("
|
|
1134
|
-
var $L124 = $L("
|
|
1135
|
-
var $L125 = $L("
|
|
1136
|
-
var $L126 = $L("
|
|
1137
|
-
var $L127 = $L("
|
|
1138
|
-
var $L128 = $L("
|
|
1139
|
-
var $L129 = $L("
|
|
1140
|
-
var $L130 = $L("
|
|
1141
|
-
var $L131 = $L("
|
|
1142
|
-
var $L132 = $L("
|
|
1143
|
-
var $L133 = $L("
|
|
1144
|
-
var $L134 = $L("
|
|
1145
|
-
var $L135 = $L("
|
|
1146
|
-
var $L136 = $L("
|
|
1147
|
-
var $L137 = $L("
|
|
1148
|
-
var $L138 = $L("
|
|
1149
|
-
var $L139 = $L("
|
|
1150
|
-
var $L140 = $L("
|
|
1151
|
-
var $L141 = $L("
|
|
1152
|
-
var $L142 = $L("
|
|
1153
|
-
var $L143 = $L("
|
|
1154
|
-
var $L144 = $L("
|
|
1155
|
-
var $L145 = $L("
|
|
1156
|
-
var $L146 = $L("
|
|
1157
|
-
var $L147 = $L("
|
|
1158
|
-
var $L148 = $L("
|
|
1159
|
-
var $L149 = $L("
|
|
1160
|
-
var $L150 = $L(
|
|
1161
|
-
var $L151 = $L("'
|
|
1162
|
-
var $L152 = $L("
|
|
1163
|
-
var $L153 = $L("
|
|
1164
|
-
var $L154 = $L("
|
|
1165
|
-
var $L155 = $L("
|
|
1166
|
-
var $L156 = $L("
|
|
1167
|
-
var $L157 = $L("
|
|
1168
|
-
var $L158 = $L("
|
|
1169
|
-
var $L159 = $L("
|
|
1170
|
-
var $L160 = $L("
|
|
1171
|
-
var $L161 = $L("
|
|
1172
|
-
var $L162 = $L("
|
|
1173
|
-
var $L163 = $L("
|
|
1174
|
-
var $L164 = $L("
|
|
1175
|
-
var $L165 = $L("
|
|
1176
|
-
var $L166 = $L("
|
|
1177
|
-
var $L167 = $L("
|
|
1178
|
-
var $L168 = $L("
|
|
1179
|
-
var $L169 = $L("
|
|
1180
|
-
var $L170 = $L("
|
|
1181
|
-
var $L171 = $L("
|
|
1182
|
-
var $L172 = $L("
|
|
1183
|
-
var $L173 = $L("
|
|
1184
|
-
var $L174 = $L("
|
|
1185
|
-
var $L175 = $L("
|
|
1186
|
-
var $L176 = $L("
|
|
1113
|
+
var $L85 = $L("$:");
|
|
1114
|
+
var $L86 = $L("own");
|
|
1115
|
+
var $L87 = $L("break");
|
|
1116
|
+
var $L88 = $L("continue");
|
|
1117
|
+
var $L89 = $L("debugger");
|
|
1118
|
+
var $L90 = $L("assert");
|
|
1119
|
+
var $L91 = $L(":=");
|
|
1120
|
+
var $L92 = $L(".=");
|
|
1121
|
+
var $L93 = $L("/*");
|
|
1122
|
+
var $L94 = $L("*/");
|
|
1123
|
+
var $L95 = $L("\\");
|
|
1124
|
+
var $L96 = $L("[");
|
|
1125
|
+
var $L97 = $L("`");
|
|
1126
|
+
var $L98 = $L("abstract");
|
|
1127
|
+
var $L99 = $L("as");
|
|
1128
|
+
var $L100 = $L("@");
|
|
1129
|
+
var $L101 = $L("@@");
|
|
1130
|
+
var $L102 = $L("async");
|
|
1131
|
+
var $L103 = $L("await");
|
|
1132
|
+
var $L104 = $L("by");
|
|
1133
|
+
var $L105 = $L("case");
|
|
1134
|
+
var $L106 = $L("catch");
|
|
1135
|
+
var $L107 = $L("class");
|
|
1136
|
+
var $L108 = $L("#{");
|
|
1137
|
+
var $L109 = $L("declare");
|
|
1138
|
+
var $L110 = $L("default");
|
|
1139
|
+
var $L111 = $L("delete");
|
|
1140
|
+
var $L112 = $L("do");
|
|
1141
|
+
var $L113 = $L("..");
|
|
1142
|
+
var $L114 = $L("...");
|
|
1143
|
+
var $L115 = $L("::");
|
|
1144
|
+
var $L116 = $L('"');
|
|
1145
|
+
var $L117 = $L("else");
|
|
1146
|
+
var $L118 = $L("export");
|
|
1147
|
+
var $L119 = $L("extends");
|
|
1148
|
+
var $L120 = $L("finally");
|
|
1149
|
+
var $L121 = $L("for");
|
|
1150
|
+
var $L122 = $L("from");
|
|
1151
|
+
var $L123 = $L("function");
|
|
1152
|
+
var $L124 = $L("get");
|
|
1153
|
+
var $L125 = $L("set");
|
|
1154
|
+
var $L126 = $L("if");
|
|
1155
|
+
var $L127 = $L("let");
|
|
1156
|
+
var $L128 = $L("const");
|
|
1157
|
+
var $L129 = $L("loop");
|
|
1158
|
+
var $L130 = $L("new");
|
|
1159
|
+
var $L131 = $L("<");
|
|
1160
|
+
var $L132 = $L("{");
|
|
1161
|
+
var $L133 = $L("operator");
|
|
1162
|
+
var $L134 = $L("public");
|
|
1163
|
+
var $L135 = $L("private");
|
|
1164
|
+
var $L136 = $L("protected");
|
|
1165
|
+
var $L137 = $L("||>");
|
|
1166
|
+
var $L138 = $L("|>=");
|
|
1167
|
+
var $L139 = $L("|>");
|
|
1168
|
+
var $L140 = $L("readonly");
|
|
1169
|
+
var $L141 = $L("return");
|
|
1170
|
+
var $L142 = $L("satisfies");
|
|
1171
|
+
var $L143 = $L("'");
|
|
1172
|
+
var $L144 = $L("static");
|
|
1173
|
+
var $L145 = $L("${");
|
|
1174
|
+
var $L146 = $L("switch");
|
|
1175
|
+
var $L147 = $L("target");
|
|
1176
|
+
var $L148 = $L("then");
|
|
1177
|
+
var $L149 = $L("this");
|
|
1178
|
+
var $L150 = $L("throw");
|
|
1179
|
+
var $L151 = $L('"""');
|
|
1180
|
+
var $L152 = $L("'''");
|
|
1181
|
+
var $L153 = $L("///");
|
|
1182
|
+
var $L154 = $L("```");
|
|
1183
|
+
var $L155 = $L("try");
|
|
1184
|
+
var $L156 = $L("typeof");
|
|
1185
|
+
var $L157 = $L("unless");
|
|
1186
|
+
var $L158 = $L("until");
|
|
1187
|
+
var $L159 = $L("var");
|
|
1188
|
+
var $L160 = $L("void");
|
|
1189
|
+
var $L161 = $L("when");
|
|
1190
|
+
var $L162 = $L("while");
|
|
1191
|
+
var $L163 = $L("yield");
|
|
1192
|
+
var $L164 = $L("/>");
|
|
1193
|
+
var $L165 = $L("</");
|
|
1194
|
+
var $L166 = $L("<>");
|
|
1195
|
+
var $L167 = $L("</>");
|
|
1196
|
+
var $L168 = $L("<!--");
|
|
1197
|
+
var $L169 = $L("-->");
|
|
1198
|
+
var $L170 = $L("type");
|
|
1199
|
+
var $L171 = $L("interface");
|
|
1200
|
+
var $L172 = $L("namespace");
|
|
1201
|
+
var $L173 = $L("asserts");
|
|
1202
|
+
var $L174 = $L("keyof");
|
|
1203
|
+
var $L175 = $L("infer");
|
|
1204
|
+
var $L176 = $L("[]");
|
|
1205
|
+
var $L177 = $L("civet");
|
|
1187
1206
|
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1188
1207
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1189
1208
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -1193,7 +1212,7 @@ ${input.slice(result.pos)}
|
|
|
1193
1212
|
var $R6 = $R(new RegExp("[!+-]", "suy"));
|
|
1194
1213
|
var $R7 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
1195
1214
|
var $R8 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
1196
|
-
var $R9 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1215
|
+
var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1197
1216
|
var $R10 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
1198
1217
|
var $R11 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
1199
1218
|
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
@@ -1238,16 +1257,17 @@ ${input.slice(result.pos)}
|
|
|
1238
1257
|
var $R51 = $R(new RegExp("[\\s>]", "suy"));
|
|
1239
1258
|
var $R52 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
1240
1259
|
var $R53 = $R(new RegExp("[<>]", "suy"));
|
|
1241
|
-
var $R54 = $R(new RegExp("
|
|
1242
|
-
var $R55 = $R(new RegExp("[
|
|
1243
|
-
var $R56 = $R(new RegExp("[
|
|
1244
|
-
var $R57 = $R(new RegExp("[+-]", "suy"));
|
|
1245
|
-
var $R58 = $R(new RegExp("
|
|
1246
|
-
var $R59 = $R(new RegExp("[\\
|
|
1247
|
-
var $R60 = $R(new RegExp("[\\
|
|
1248
|
-
var $R61 = $R(new RegExp("
|
|
1249
|
-
var $R62 = $R(new RegExp("\\
|
|
1250
|
-
var $R63 = $R(new RegExp("
|
|
1260
|
+
var $R54 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1261
|
+
var $R55 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
1262
|
+
var $R56 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
1263
|
+
var $R57 = $R(new RegExp("[+-]?", "suy"));
|
|
1264
|
+
var $R58 = $R(new RegExp("[+-]", "suy"));
|
|
1265
|
+
var $R59 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1266
|
+
var $R60 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1267
|
+
var $R61 = $R(new RegExp("[\\s]*", "suy"));
|
|
1268
|
+
var $R62 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1269
|
+
var $R63 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1270
|
+
var $R64 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1251
1271
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1252
1272
|
var statements = $4;
|
|
1253
1273
|
module.processProgram(statements);
|
|
@@ -1461,9 +1481,8 @@ ${input.slice(result.pos)}
|
|
|
1461
1481
|
}
|
|
1462
1482
|
}
|
|
1463
1483
|
var Arguments$0 = ExplicitArguments;
|
|
1464
|
-
var Arguments$1 = $TS($S(
|
|
1484
|
+
var Arguments$1 = $TS($S(ForbidTrailingMemberProperty, $E(ImplicitArguments), RestoreTrailingMemberProperty), function($skip, $loc, $0, $1, $2, $3) {
|
|
1465
1485
|
var args = $2;
|
|
1466
|
-
module.suppressTrailingMemberProperty.pop();
|
|
1467
1486
|
if (args)
|
|
1468
1487
|
return args;
|
|
1469
1488
|
return $skip;
|
|
@@ -1654,14 +1673,14 @@ ${input.slice(result.pos)}
|
|
|
1654
1673
|
return result;
|
|
1655
1674
|
}
|
|
1656
1675
|
}
|
|
1657
|
-
var
|
|
1676
|
+
var AllowedTrailingMemberExpressions$0 = $T($S(TrailingMemberPropertyAllowed, TrailingMemberExpressions), function(value) {
|
|
1658
1677
|
return value[1];
|
|
1659
1678
|
});
|
|
1660
|
-
var
|
|
1661
|
-
function
|
|
1679
|
+
var AllowedTrailingMemberExpressions$1 = $Q(MemberExpressionRest);
|
|
1680
|
+
function AllowedTrailingMemberExpressions(state) {
|
|
1662
1681
|
let eventData;
|
|
1663
1682
|
if (state.events) {
|
|
1664
|
-
const result = state.events.enter?.("
|
|
1683
|
+
const result = state.events.enter?.("AllowedTrailingMemberExpressions", state);
|
|
1665
1684
|
if (result) {
|
|
1666
1685
|
if (result.cache)
|
|
1667
1686
|
return result.cache;
|
|
@@ -1669,14 +1688,14 @@ ${input.slice(result.pos)}
|
|
|
1669
1688
|
}
|
|
1670
1689
|
}
|
|
1671
1690
|
if (state.tokenize) {
|
|
1672
|
-
const result = $TOKEN("
|
|
1691
|
+
const result = $TOKEN("AllowedTrailingMemberExpressions", state, AllowedTrailingMemberExpressions$0(state) || AllowedTrailingMemberExpressions$1(state));
|
|
1673
1692
|
if (state.events)
|
|
1674
|
-
state.events.exit?.("
|
|
1693
|
+
state.events.exit?.("AllowedTrailingMemberExpressions", state, result, eventData);
|
|
1675
1694
|
return result;
|
|
1676
1695
|
} else {
|
|
1677
|
-
const result =
|
|
1696
|
+
const result = AllowedTrailingMemberExpressions$0(state) || AllowedTrailingMemberExpressions$1(state);
|
|
1678
1697
|
if (state.events)
|
|
1679
|
-
state.events.exit?.("
|
|
1698
|
+
state.events.exit?.("AllowedTrailingMemberExpressions", state, result, eventData);
|
|
1680
1699
|
return result;
|
|
1681
1700
|
}
|
|
1682
1701
|
}
|
|
@@ -2061,11 +2080,21 @@ ${input.slice(result.pos)}
|
|
|
2061
2080
|
return result;
|
|
2062
2081
|
}
|
|
2063
2082
|
}
|
|
2064
|
-
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression)
|
|
2083
|
+
var UpdateExpression$0 = $TS($S(UpdateExpressionSymbol, UnaryExpression), function($skip, $loc, $0, $1, $2) {
|
|
2084
|
+
return {
|
|
2085
|
+
type: "UpdateExpression",
|
|
2086
|
+
assigned: $2,
|
|
2087
|
+
children: $0
|
|
2088
|
+
};
|
|
2089
|
+
});
|
|
2065
2090
|
var UpdateExpression$1 = $TS($S(LeftHandSideExpression, $E(UpdateExpressionSymbol)), function($skip, $loc, $0, $1, $2) {
|
|
2066
|
-
if (
|
|
2067
|
-
return $
|
|
2068
|
-
return
|
|
2091
|
+
if (!$2)
|
|
2092
|
+
return $1;
|
|
2093
|
+
return {
|
|
2094
|
+
type: "UpdateExpression",
|
|
2095
|
+
assigned: $1,
|
|
2096
|
+
children: $0
|
|
2097
|
+
};
|
|
2069
2098
|
});
|
|
2070
2099
|
function UpdateExpression(state) {
|
|
2071
2100
|
let eventData;
|
|
@@ -2225,7 +2254,7 @@ ${input.slice(result.pos)}
|
|
|
2225
2254
|
return result;
|
|
2226
2255
|
}
|
|
2227
2256
|
}
|
|
2228
|
-
var ActualAssignment$0 = $TS($S($P($S(__,
|
|
2257
|
+
var ActualAssignment$0 = $TS($S($P($S(__, UpdateExpression, WAssignmentOp)), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
2229
2258
|
$1 = $1.map((x) => [x[0], x[1], ...x[2]]);
|
|
2230
2259
|
$0 = [$1, $2];
|
|
2231
2260
|
return {
|
|
@@ -2233,6 +2262,7 @@ ${input.slice(result.pos)}
|
|
|
2233
2262
|
children: $0,
|
|
2234
2263
|
names: null,
|
|
2235
2264
|
lhs: $1,
|
|
2265
|
+
assigned: $1[0][1],
|
|
2236
2266
|
exp: $2
|
|
2237
2267
|
};
|
|
2238
2268
|
});
|
|
@@ -2642,15 +2672,18 @@ ${input.slice(result.pos)}
|
|
|
2642
2672
|
return result;
|
|
2643
2673
|
}
|
|
2644
2674
|
}
|
|
2645
|
-
var ParenthesizedExpression$0 = $TS($S(OpenParen, PostfixedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2646
|
-
var
|
|
2675
|
+
var ParenthesizedExpression$0 = $TS($S(OpenParen, AllowAll, $E($S(PostfixedExpression, __, CloseParen)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2676
|
+
var open = $1;
|
|
2677
|
+
if (!$3)
|
|
2678
|
+
return $skip;
|
|
2679
|
+
const [exp, ws, close] = $3;
|
|
2647
2680
|
switch (exp.type) {
|
|
2648
2681
|
case "IterationExpression":
|
|
2649
|
-
return
|
|
2682
|
+
return exp;
|
|
2650
2683
|
}
|
|
2651
2684
|
return {
|
|
2652
2685
|
type: "ParenthesizedExpression",
|
|
2653
|
-
children:
|
|
2686
|
+
children: [open, exp, ws, close],
|
|
2654
2687
|
expression: exp
|
|
2655
2688
|
};
|
|
2656
2689
|
});
|
|
@@ -2832,7 +2865,7 @@ ${input.slice(result.pos)}
|
|
|
2832
2865
|
return result;
|
|
2833
2866
|
}
|
|
2834
2867
|
}
|
|
2835
|
-
var ExtendsTarget$0 = $TS($S(
|
|
2868
|
+
var ExtendsTarget$0 = $TS($S(ExpressionWithIndentedApplicationForbidden, $E(TypeArguments)), function($skip, $loc, $0, $1, $2) {
|
|
2836
2869
|
var exp = $1;
|
|
2837
2870
|
var ta = $2;
|
|
2838
2871
|
exp = module.makeLeftHandSideExpression(exp);
|
|
@@ -3272,7 +3305,7 @@ ${input.slice(result.pos)}
|
|
|
3272
3305
|
children: [$1, ...$2, ...rest.flat()]
|
|
3273
3306
|
});
|
|
3274
3307
|
});
|
|
3275
|
-
var CallExpression$2 = $TS($S(MemberExpression,
|
|
3308
|
+
var CallExpression$2 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3276
3309
|
var member = $1;
|
|
3277
3310
|
var trailing = $2;
|
|
3278
3311
|
var rest = $3;
|
|
@@ -6268,9 +6301,11 @@ ${input.slice(result.pos)}
|
|
|
6268
6301
|
var ArrayLiteral$0 = $T($S(ArrayBindingPattern, UpcomingAssignment), function(value) {
|
|
6269
6302
|
return value[0];
|
|
6270
6303
|
});
|
|
6271
|
-
var ArrayLiteral$1 = $TS($S(OpenBracket, ArrayLiteralContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6272
|
-
var
|
|
6273
|
-
|
|
6304
|
+
var ArrayLiteral$1 = $TS($S(OpenBracket, AllowAll, $E($S(ArrayLiteralContent, __, CloseBracket)), RestoreIndentedApplication, RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6305
|
+
var open = $1;
|
|
6306
|
+
if (!$3)
|
|
6307
|
+
return $skip;
|
|
6308
|
+
const [content, ws, close] = $3;
|
|
6274
6309
|
if (content.type === "RangeExpression") {
|
|
6275
6310
|
return {
|
|
6276
6311
|
...content,
|
|
@@ -6279,9 +6314,9 @@ ${input.slice(result.pos)}
|
|
|
6279
6314
|
}
|
|
6280
6315
|
let children;
|
|
6281
6316
|
if (Array.isArray(content)) {
|
|
6282
|
-
children = [
|
|
6317
|
+
children = [open, ...content, ...ws, close];
|
|
6283
6318
|
} else {
|
|
6284
|
-
children = [
|
|
6319
|
+
children = [open, content, ...ws, close];
|
|
6285
6320
|
}
|
|
6286
6321
|
const names = children.flatMap((c) => {
|
|
6287
6322
|
return c.names || [];
|
|
@@ -6686,10 +6721,11 @@ ${input.slice(result.pos)}
|
|
|
6686
6721
|
return result;
|
|
6687
6722
|
}
|
|
6688
6723
|
}
|
|
6689
|
-
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent),
|
|
6724
|
+
var BracedObjectLiteral$0 = $TS($S(OpenBrace, AllowAll, $E($S($E(BracedObjectLiteralContent), __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6690
6725
|
var open = $1;
|
|
6691
|
-
|
|
6692
|
-
|
|
6726
|
+
if (!$3)
|
|
6727
|
+
return $skip;
|
|
6728
|
+
const [content, ...close] = $3;
|
|
6693
6729
|
if (content) {
|
|
6694
6730
|
const children = [open, ...content, close];
|
|
6695
6731
|
return {
|
|
@@ -6809,7 +6845,7 @@ ${input.slice(result.pos)}
|
|
|
6809
6845
|
return result;
|
|
6810
6846
|
}
|
|
6811
6847
|
}
|
|
6812
|
-
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested,
|
|
6848
|
+
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, ImplicitNamedProperty, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
6813
6849
|
var ws = $1;
|
|
6814
6850
|
var prop = $2;
|
|
6815
6851
|
var delimiter = $3;
|
|
@@ -6898,7 +6934,7 @@ ${input.slice(result.pos)}
|
|
|
6898
6934
|
return result;
|
|
6899
6935
|
}
|
|
6900
6936
|
}
|
|
6901
|
-
var InlineObjectLiteral$0 = $TS($S(InsertInlineOpenBrace, SnugNamedProperty, ImplicitInlineObjectPropertyDelimiter, $Q($S($C(Samedent, $Q(_)),
|
|
6937
|
+
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) {
|
|
6902
6938
|
var open = $1;
|
|
6903
6939
|
var close = $5;
|
|
6904
6940
|
return {
|
|
@@ -7164,8 +7200,41 @@ ${input.slice(result.pos)}
|
|
|
7164
7200
|
return result;
|
|
7165
7201
|
}
|
|
7166
7202
|
}
|
|
7167
|
-
var
|
|
7168
|
-
var
|
|
7203
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, __, Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7204
|
+
var name = $1;
|
|
7205
|
+
var exp = $5;
|
|
7206
|
+
return {
|
|
7207
|
+
type: "Property",
|
|
7208
|
+
children: $0,
|
|
7209
|
+
name,
|
|
7210
|
+
names: exp.names || [],
|
|
7211
|
+
value: exp
|
|
7212
|
+
};
|
|
7213
|
+
});
|
|
7214
|
+
function ImplicitNamedProperty(state) {
|
|
7215
|
+
let eventData;
|
|
7216
|
+
if (state.events) {
|
|
7217
|
+
const result = state.events.enter?.("ImplicitNamedProperty", state);
|
|
7218
|
+
if (result) {
|
|
7219
|
+
if (result.cache)
|
|
7220
|
+
return result.cache;
|
|
7221
|
+
eventData = result.data;
|
|
7222
|
+
}
|
|
7223
|
+
}
|
|
7224
|
+
if (state.tokenize) {
|
|
7225
|
+
const result = $TOKEN("ImplicitNamedProperty", state, ImplicitNamedProperty$0(state));
|
|
7226
|
+
if (state.events)
|
|
7227
|
+
state.events.exit?.("ImplicitNamedProperty", state, result, eventData);
|
|
7228
|
+
return result;
|
|
7229
|
+
} else {
|
|
7230
|
+
const result = ImplicitNamedProperty$0(state);
|
|
7231
|
+
if (state.events)
|
|
7232
|
+
state.events.exit?.("ImplicitNamedProperty", state, result, eventData);
|
|
7233
|
+
return result;
|
|
7234
|
+
}
|
|
7235
|
+
}
|
|
7236
|
+
var SnugNamedProperty$0 = $TS($S(PropertyName, Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7237
|
+
var exp = $4;
|
|
7169
7238
|
return {
|
|
7170
7239
|
type: "Property",
|
|
7171
7240
|
children: $0,
|
|
@@ -7948,7 +8017,7 @@ ${input.slice(result.pos)}
|
|
|
7948
8017
|
return result;
|
|
7949
8018
|
}
|
|
7950
8019
|
}
|
|
7951
|
-
var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8020
|
+
var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7952
8021
|
return { $loc, token: $0 };
|
|
7953
8022
|
});
|
|
7954
8023
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -8116,13 +8185,14 @@ ${input.slice(result.pos)}
|
|
|
8116
8185
|
var Statement$4 = SwitchStatement;
|
|
8117
8186
|
var Statement$5 = TryStatement;
|
|
8118
8187
|
var Statement$6 = EmptyStatement;
|
|
8119
|
-
var Statement$7 =
|
|
8188
|
+
var Statement$7 = LabelledStatement;
|
|
8189
|
+
var Statement$8 = $TS($S(ExpressionStatement), function($skip, $loc, $0, $1) {
|
|
8120
8190
|
if ($1.type === "ObjectExpression" || $1.type === "FunctionExpression" && !$1.id) {
|
|
8121
8191
|
return module.makeLeftHandSideExpression($1);
|
|
8122
8192
|
}
|
|
8123
8193
|
return $1;
|
|
8124
8194
|
});
|
|
8125
|
-
var Statement$
|
|
8195
|
+
var Statement$9 = BlockStatement;
|
|
8126
8196
|
function Statement(state) {
|
|
8127
8197
|
let eventData;
|
|
8128
8198
|
if (state.events) {
|
|
@@ -8134,12 +8204,12 @@ ${input.slice(result.pos)}
|
|
|
8134
8204
|
}
|
|
8135
8205
|
}
|
|
8136
8206
|
if (state.tokenize) {
|
|
8137
|
-
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));
|
|
8207
|
+
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));
|
|
8138
8208
|
if (state.events)
|
|
8139
8209
|
state.events.exit?.("Statement", state, result, eventData);
|
|
8140
8210
|
return result;
|
|
8141
8211
|
} else {
|
|
8142
|
-
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);
|
|
8212
|
+
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);
|
|
8143
8213
|
if (state.events)
|
|
8144
8214
|
state.events.exit?.("Statement", state, result, eventData);
|
|
8145
8215
|
return result;
|
|
@@ -8195,6 +8265,82 @@ ${input.slice(result.pos)}
|
|
|
8195
8265
|
return result;
|
|
8196
8266
|
}
|
|
8197
8267
|
}
|
|
8268
|
+
var LabelledStatement$0 = $S(Label, LabelledItem);
|
|
8269
|
+
function LabelledStatement(state) {
|
|
8270
|
+
let eventData;
|
|
8271
|
+
if (state.events) {
|
|
8272
|
+
const result = state.events.enter?.("LabelledStatement", state);
|
|
8273
|
+
if (result) {
|
|
8274
|
+
if (result.cache)
|
|
8275
|
+
return result.cache;
|
|
8276
|
+
eventData = result.data;
|
|
8277
|
+
}
|
|
8278
|
+
}
|
|
8279
|
+
if (state.tokenize) {
|
|
8280
|
+
const result = $TOKEN("LabelledStatement", state, LabelledStatement$0(state));
|
|
8281
|
+
if (state.events)
|
|
8282
|
+
state.events.exit?.("LabelledStatement", state, result, eventData);
|
|
8283
|
+
return result;
|
|
8284
|
+
} else {
|
|
8285
|
+
const result = LabelledStatement$0(state);
|
|
8286
|
+
if (state.events)
|
|
8287
|
+
state.events.exit?.("LabelledStatement", state, result, eventData);
|
|
8288
|
+
return result;
|
|
8289
|
+
}
|
|
8290
|
+
}
|
|
8291
|
+
var Label$0 = $TS($S(Colon, Identifier, Whitespace), function($skip, $loc, $0, $1, $2, $3) {
|
|
8292
|
+
var colon = $1;
|
|
8293
|
+
var id = $2;
|
|
8294
|
+
var w = $3;
|
|
8295
|
+
return [id, colon, w];
|
|
8296
|
+
});
|
|
8297
|
+
var Label$1 = $S($EXPECT($L85, fail, 'Label "$:"'), Whitespace);
|
|
8298
|
+
function Label(state) {
|
|
8299
|
+
let eventData;
|
|
8300
|
+
if (state.events) {
|
|
8301
|
+
const result = state.events.enter?.("Label", state);
|
|
8302
|
+
if (result) {
|
|
8303
|
+
if (result.cache)
|
|
8304
|
+
return result.cache;
|
|
8305
|
+
eventData = result.data;
|
|
8306
|
+
}
|
|
8307
|
+
}
|
|
8308
|
+
if (state.tokenize) {
|
|
8309
|
+
const result = $TOKEN("Label", state, Label$0(state) || Label$1(state));
|
|
8310
|
+
if (state.events)
|
|
8311
|
+
state.events.exit?.("Label", state, result, eventData);
|
|
8312
|
+
return result;
|
|
8313
|
+
} else {
|
|
8314
|
+
const result = Label$0(state) || Label$1(state);
|
|
8315
|
+
if (state.events)
|
|
8316
|
+
state.events.exit?.("Label", state, result, eventData);
|
|
8317
|
+
return result;
|
|
8318
|
+
}
|
|
8319
|
+
}
|
|
8320
|
+
var LabelledItem$0 = Statement;
|
|
8321
|
+
var LabelledItem$1 = FunctionDeclaration;
|
|
8322
|
+
function LabelledItem(state) {
|
|
8323
|
+
let eventData;
|
|
8324
|
+
if (state.events) {
|
|
8325
|
+
const result = state.events.enter?.("LabelledItem", state);
|
|
8326
|
+
if (result) {
|
|
8327
|
+
if (result.cache)
|
|
8328
|
+
return result.cache;
|
|
8329
|
+
eventData = result.data;
|
|
8330
|
+
}
|
|
8331
|
+
}
|
|
8332
|
+
if (state.tokenize) {
|
|
8333
|
+
const result = $TOKEN("LabelledItem", state, LabelledItem$0(state) || LabelledItem$1(state));
|
|
8334
|
+
if (state.events)
|
|
8335
|
+
state.events.exit?.("LabelledItem", state, result, eventData);
|
|
8336
|
+
return result;
|
|
8337
|
+
} else {
|
|
8338
|
+
const result = LabelledItem$0(state) || LabelledItem$1(state);
|
|
8339
|
+
if (state.events)
|
|
8340
|
+
state.events.exit?.("LabelledItem", state, result, eventData);
|
|
8341
|
+
return result;
|
|
8342
|
+
}
|
|
8343
|
+
}
|
|
8198
8344
|
var IfStatement$0 = $TS($S($C(IfClause, UnlessClause), Block, $E(ElseClause)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8199
8345
|
var clause = $1;
|
|
8200
8346
|
var block = $2;
|
|
@@ -8461,7 +8607,7 @@ ${input.slice(result.pos)}
|
|
|
8461
8607
|
children: [$1, exps, $3, $4, $5]
|
|
8462
8608
|
};
|
|
8463
8609
|
});
|
|
8464
|
-
var ElseExpressionBlock$1 = $T($S($N(EOS),
|
|
8610
|
+
var ElseExpressionBlock$1 = $T($S($N(EOS), ExpressionWithIndentedApplicationForbidden), function(value) {
|
|
8465
8611
|
return value[1];
|
|
8466
8612
|
});
|
|
8467
8613
|
function ElseExpressionBlock(state) {
|
|
@@ -9100,7 +9246,7 @@ ${input.slice(result.pos)}
|
|
|
9100
9246
|
return result;
|
|
9101
9247
|
}
|
|
9102
9248
|
}
|
|
9103
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9249
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L86, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9104
9250
|
var own = $1;
|
|
9105
9251
|
var binding = $2;
|
|
9106
9252
|
return {
|
|
@@ -9146,14 +9292,14 @@ ${input.slice(result.pos)}
|
|
|
9146
9292
|
children: $0
|
|
9147
9293
|
};
|
|
9148
9294
|
});
|
|
9149
|
-
var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of),
|
|
9295
|
+
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) {
|
|
9150
9296
|
var declaration = $4;
|
|
9151
9297
|
return {
|
|
9152
9298
|
declaration,
|
|
9153
9299
|
children: $0
|
|
9154
9300
|
};
|
|
9155
9301
|
});
|
|
9156
|
-
var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of),
|
|
9302
|
+
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) {
|
|
9157
9303
|
var declaration = $3;
|
|
9158
9304
|
return {
|
|
9159
9305
|
declaration,
|
|
@@ -9548,14 +9694,18 @@ ${input.slice(result.pos)}
|
|
|
9548
9694
|
return result;
|
|
9549
9695
|
}
|
|
9550
9696
|
}
|
|
9551
|
-
var CaseExpressionList$0 = $TS($S($S($Q(_),
|
|
9552
|
-
|
|
9697
|
+
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) {
|
|
9698
|
+
var first = $2;
|
|
9699
|
+
var rest = $3;
|
|
9700
|
+
if (!first)
|
|
9701
|
+
return $skip;
|
|
9702
|
+
const result = rest.map(([ws, _comma, exp, col]) => {
|
|
9553
9703
|
exp = module.insertTrimmingSpace(exp, "");
|
|
9554
9704
|
if (ws.length)
|
|
9555
9705
|
return [module.insertTrimmingSpace("case ", ws), exp, col];
|
|
9556
9706
|
return ["case ", exp, col];
|
|
9557
9707
|
});
|
|
9558
|
-
result.unshift(
|
|
9708
|
+
result.unshift(first);
|
|
9559
9709
|
return result;
|
|
9560
9710
|
});
|
|
9561
9711
|
function CaseExpressionList(state) {
|
|
@@ -9771,7 +9921,7 @@ ${input.slice(result.pos)}
|
|
|
9771
9921
|
var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp, Dot, QuestionMark))), $N($S(_, OperatorAssignmentOp))), function(value) {
|
|
9772
9922
|
return value[0];
|
|
9773
9923
|
});
|
|
9774
|
-
var Condition$1 = $TS($S(InsertOpenParen,
|
|
9924
|
+
var Condition$1 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
|
|
9775
9925
|
var open = $1;
|
|
9776
9926
|
var expression = $2;
|
|
9777
9927
|
var close = $3;
|
|
@@ -9806,17 +9956,66 @@ ${input.slice(result.pos)}
|
|
|
9806
9956
|
return result;
|
|
9807
9957
|
}
|
|
9808
9958
|
}
|
|
9809
|
-
var
|
|
9959
|
+
var ExpressionWithIndentedApplicationForbidden$0 = $TS($S(ForbidIndentedApplication, $E(ExtendedExpression), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
|
|
9810
9960
|
var exp = $2;
|
|
9811
|
-
module.suppressIndentedApplication = false;
|
|
9812
9961
|
if (exp)
|
|
9813
9962
|
return exp;
|
|
9814
9963
|
return $skip;
|
|
9815
9964
|
});
|
|
9816
|
-
function
|
|
9965
|
+
function ExpressionWithIndentedApplicationForbidden(state) {
|
|
9966
|
+
let eventData;
|
|
9967
|
+
if (state.events) {
|
|
9968
|
+
const result = state.events.enter?.("ExpressionWithIndentedApplicationForbidden", state);
|
|
9969
|
+
if (result) {
|
|
9970
|
+
if (result.cache)
|
|
9971
|
+
return result.cache;
|
|
9972
|
+
eventData = result.data;
|
|
9973
|
+
}
|
|
9974
|
+
}
|
|
9975
|
+
if (state.tokenize) {
|
|
9976
|
+
const result = $TOKEN("ExpressionWithIndentedApplicationForbidden", state, ExpressionWithIndentedApplicationForbidden$0(state));
|
|
9977
|
+
if (state.events)
|
|
9978
|
+
state.events.exit?.("ExpressionWithIndentedApplicationForbidden", state, result, eventData);
|
|
9979
|
+
return result;
|
|
9980
|
+
} else {
|
|
9981
|
+
const result = ExpressionWithIndentedApplicationForbidden$0(state);
|
|
9982
|
+
if (state.events)
|
|
9983
|
+
state.events.exit?.("ExpressionWithIndentedApplicationForbidden", state, result, eventData);
|
|
9984
|
+
return result;
|
|
9985
|
+
}
|
|
9986
|
+
}
|
|
9987
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L18, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9988
|
+
module.forbidIndentedApplication.push(true);
|
|
9989
|
+
});
|
|
9990
|
+
function ForbidIndentedApplication(state) {
|
|
9991
|
+
let eventData;
|
|
9992
|
+
if (state.events) {
|
|
9993
|
+
const result = state.events.enter?.("ForbidIndentedApplication", state);
|
|
9994
|
+
if (result) {
|
|
9995
|
+
if (result.cache)
|
|
9996
|
+
return result.cache;
|
|
9997
|
+
eventData = result.data;
|
|
9998
|
+
}
|
|
9999
|
+
}
|
|
10000
|
+
if (state.tokenize) {
|
|
10001
|
+
const result = $TOKEN("ForbidIndentedApplication", state, ForbidIndentedApplication$0(state));
|
|
10002
|
+
if (state.events)
|
|
10003
|
+
state.events.exit?.("ForbidIndentedApplication", state, result, eventData);
|
|
10004
|
+
return result;
|
|
10005
|
+
} else {
|
|
10006
|
+
const result = ForbidIndentedApplication$0(state);
|
|
10007
|
+
if (state.events)
|
|
10008
|
+
state.events.exit?.("ForbidIndentedApplication", state, result, eventData);
|
|
10009
|
+
return result;
|
|
10010
|
+
}
|
|
10011
|
+
}
|
|
10012
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L18, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10013
|
+
module.forbidIndentedApplication.push(false);
|
|
10014
|
+
});
|
|
10015
|
+
function AllowIndentedApplication(state) {
|
|
9817
10016
|
let eventData;
|
|
9818
10017
|
if (state.events) {
|
|
9819
|
-
const result = state.events.enter?.("
|
|
10018
|
+
const result = state.events.enter?.("AllowIndentedApplication", state);
|
|
9820
10019
|
if (result) {
|
|
9821
10020
|
if (result.cache)
|
|
9822
10021
|
return result.cache;
|
|
@@ -9824,24 +10023,24 @@ ${input.slice(result.pos)}
|
|
|
9824
10023
|
}
|
|
9825
10024
|
}
|
|
9826
10025
|
if (state.tokenize) {
|
|
9827
|
-
const result = $TOKEN("
|
|
10026
|
+
const result = $TOKEN("AllowIndentedApplication", state, AllowIndentedApplication$0(state));
|
|
9828
10027
|
if (state.events)
|
|
9829
|
-
state.events.exit?.("
|
|
10028
|
+
state.events.exit?.("AllowIndentedApplication", state, result, eventData);
|
|
9830
10029
|
return result;
|
|
9831
10030
|
} else {
|
|
9832
|
-
const result =
|
|
10031
|
+
const result = AllowIndentedApplication$0(state);
|
|
9833
10032
|
if (state.events)
|
|
9834
|
-
state.events.exit?.("
|
|
10033
|
+
state.events.exit?.("AllowIndentedApplication", state, result, eventData);
|
|
9835
10034
|
return result;
|
|
9836
10035
|
}
|
|
9837
10036
|
}
|
|
9838
|
-
var
|
|
9839
|
-
module.
|
|
10037
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L18, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10038
|
+
module.forbidIndentedApplication.pop();
|
|
9840
10039
|
});
|
|
9841
|
-
function
|
|
10040
|
+
function RestoreIndentedApplication(state) {
|
|
9842
10041
|
let eventData;
|
|
9843
10042
|
if (state.events) {
|
|
9844
|
-
const result = state.events.enter?.("
|
|
10043
|
+
const result = state.events.enter?.("RestoreIndentedApplication", state);
|
|
9845
10044
|
if (result) {
|
|
9846
10045
|
if (result.cache)
|
|
9847
10046
|
return result.cache;
|
|
@@ -9849,19 +10048,22 @@ ${input.slice(result.pos)}
|
|
|
9849
10048
|
}
|
|
9850
10049
|
}
|
|
9851
10050
|
if (state.tokenize) {
|
|
9852
|
-
const result = $TOKEN("
|
|
10051
|
+
const result = $TOKEN("RestoreIndentedApplication", state, RestoreIndentedApplication$0(state));
|
|
9853
10052
|
if (state.events)
|
|
9854
|
-
state.events.exit?.("
|
|
10053
|
+
state.events.exit?.("RestoreIndentedApplication", state, result, eventData);
|
|
9855
10054
|
return result;
|
|
9856
10055
|
} else {
|
|
9857
|
-
const result =
|
|
10056
|
+
const result = RestoreIndentedApplication$0(state);
|
|
9858
10057
|
if (state.events)
|
|
9859
|
-
state.events.exit?.("
|
|
10058
|
+
state.events.exit?.("RestoreIndentedApplication", state, result, eventData);
|
|
9860
10059
|
return result;
|
|
9861
10060
|
}
|
|
9862
10061
|
}
|
|
9863
10062
|
var IndentedApplicationAllowed$0 = $TV($EXPECT($L18, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9864
|
-
if (module.
|
|
10063
|
+
if (module.config.verbose) {
|
|
10064
|
+
console.log("forbidIndentedApplication:", module.forbidIndentedApplication);
|
|
10065
|
+
}
|
|
10066
|
+
if (module.indentedApplicationForbidden)
|
|
9865
10067
|
return $skip;
|
|
9866
10068
|
return;
|
|
9867
10069
|
});
|
|
@@ -9887,13 +10089,13 @@ ${input.slice(result.pos)}
|
|
|
9887
10089
|
return result;
|
|
9888
10090
|
}
|
|
9889
10091
|
}
|
|
9890
|
-
var
|
|
9891
|
-
module.
|
|
10092
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10093
|
+
module.forbidTrailingMemberProperty.push(true);
|
|
9892
10094
|
});
|
|
9893
|
-
function
|
|
10095
|
+
function ForbidTrailingMemberProperty(state) {
|
|
9894
10096
|
let eventData;
|
|
9895
10097
|
if (state.events) {
|
|
9896
|
-
const result = state.events.enter?.("
|
|
10098
|
+
const result = state.events.enter?.("ForbidTrailingMemberProperty", state);
|
|
9897
10099
|
if (result) {
|
|
9898
10100
|
if (result.cache)
|
|
9899
10101
|
return result.cache;
|
|
@@ -9901,19 +10103,72 @@ ${input.slice(result.pos)}
|
|
|
9901
10103
|
}
|
|
9902
10104
|
}
|
|
9903
10105
|
if (state.tokenize) {
|
|
9904
|
-
const result = $TOKEN("
|
|
10106
|
+
const result = $TOKEN("ForbidTrailingMemberProperty", state, ForbidTrailingMemberProperty$0(state));
|
|
9905
10107
|
if (state.events)
|
|
9906
|
-
state.events.exit?.("
|
|
10108
|
+
state.events.exit?.("ForbidTrailingMemberProperty", state, result, eventData);
|
|
9907
10109
|
return result;
|
|
9908
10110
|
} else {
|
|
9909
|
-
const result =
|
|
10111
|
+
const result = ForbidTrailingMemberProperty$0(state);
|
|
9910
10112
|
if (state.events)
|
|
9911
|
-
state.events.exit?.("
|
|
10113
|
+
state.events.exit?.("ForbidTrailingMemberProperty", state, result, eventData);
|
|
10114
|
+
return result;
|
|
10115
|
+
}
|
|
10116
|
+
}
|
|
10117
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10118
|
+
module.forbidTrailingMemberProperty.push(false);
|
|
10119
|
+
});
|
|
10120
|
+
function AllowTrailingMemberProperty(state) {
|
|
10121
|
+
let eventData;
|
|
10122
|
+
if (state.events) {
|
|
10123
|
+
const result = state.events.enter?.("AllowTrailingMemberProperty", state);
|
|
10124
|
+
if (result) {
|
|
10125
|
+
if (result.cache)
|
|
10126
|
+
return result.cache;
|
|
10127
|
+
eventData = result.data;
|
|
10128
|
+
}
|
|
10129
|
+
}
|
|
10130
|
+
if (state.tokenize) {
|
|
10131
|
+
const result = $TOKEN("AllowTrailingMemberProperty", state, AllowTrailingMemberProperty$0(state));
|
|
10132
|
+
if (state.events)
|
|
10133
|
+
state.events.exit?.("AllowTrailingMemberProperty", state, result, eventData);
|
|
10134
|
+
return result;
|
|
10135
|
+
} else {
|
|
10136
|
+
const result = AllowTrailingMemberProperty$0(state);
|
|
10137
|
+
if (state.events)
|
|
10138
|
+
state.events.exit?.("AllowTrailingMemberProperty", state, result, eventData);
|
|
10139
|
+
return result;
|
|
10140
|
+
}
|
|
10141
|
+
}
|
|
10142
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10143
|
+
module.forbidTrailingMemberProperty.pop();
|
|
10144
|
+
});
|
|
10145
|
+
function RestoreTrailingMemberProperty(state) {
|
|
10146
|
+
let eventData;
|
|
10147
|
+
if (state.events) {
|
|
10148
|
+
const result = state.events.enter?.("RestoreTrailingMemberProperty", state);
|
|
10149
|
+
if (result) {
|
|
10150
|
+
if (result.cache)
|
|
10151
|
+
return result.cache;
|
|
10152
|
+
eventData = result.data;
|
|
10153
|
+
}
|
|
10154
|
+
}
|
|
10155
|
+
if (state.tokenize) {
|
|
10156
|
+
const result = $TOKEN("RestoreTrailingMemberProperty", state, RestoreTrailingMemberProperty$0(state));
|
|
10157
|
+
if (state.events)
|
|
10158
|
+
state.events.exit?.("RestoreTrailingMemberProperty", state, result, eventData);
|
|
10159
|
+
return result;
|
|
10160
|
+
} else {
|
|
10161
|
+
const result = RestoreTrailingMemberProperty$0(state);
|
|
10162
|
+
if (state.events)
|
|
10163
|
+
state.events.exit?.("RestoreTrailingMemberProperty", state, result, eventData);
|
|
9912
10164
|
return result;
|
|
9913
10165
|
}
|
|
9914
10166
|
}
|
|
9915
10167
|
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L18, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9916
|
-
if (module.
|
|
10168
|
+
if (module.config.verbose) {
|
|
10169
|
+
console.log("forbidTrailingMemberProperty:", module.forbidTrailingMemberProperty);
|
|
10170
|
+
}
|
|
10171
|
+
if (module.trailingMemberPropertyForbidden)
|
|
9917
10172
|
return $skip;
|
|
9918
10173
|
});
|
|
9919
10174
|
function TrailingMemberPropertyAllowed(state) {
|
|
@@ -9938,6 +10193,156 @@ ${input.slice(result.pos)}
|
|
|
9938
10193
|
return result;
|
|
9939
10194
|
}
|
|
9940
10195
|
}
|
|
10196
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L18, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10197
|
+
module.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10198
|
+
});
|
|
10199
|
+
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
10200
|
+
let eventData;
|
|
10201
|
+
if (state.events) {
|
|
10202
|
+
const result = state.events.enter?.("ForbidMultiLineImplicitObjectLiteral", state);
|
|
10203
|
+
if (result) {
|
|
10204
|
+
if (result.cache)
|
|
10205
|
+
return result.cache;
|
|
10206
|
+
eventData = result.data;
|
|
10207
|
+
}
|
|
10208
|
+
}
|
|
10209
|
+
if (state.tokenize) {
|
|
10210
|
+
const result = $TOKEN("ForbidMultiLineImplicitObjectLiteral", state, ForbidMultiLineImplicitObjectLiteral$0(state));
|
|
10211
|
+
if (state.events)
|
|
10212
|
+
state.events.exit?.("ForbidMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10213
|
+
return result;
|
|
10214
|
+
} else {
|
|
10215
|
+
const result = ForbidMultiLineImplicitObjectLiteral$0(state);
|
|
10216
|
+
if (state.events)
|
|
10217
|
+
state.events.exit?.("ForbidMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10218
|
+
return result;
|
|
10219
|
+
}
|
|
10220
|
+
}
|
|
10221
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L18, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10222
|
+
module.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10223
|
+
});
|
|
10224
|
+
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
10225
|
+
let eventData;
|
|
10226
|
+
if (state.events) {
|
|
10227
|
+
const result = state.events.enter?.("AllowMultiLineImplicitObjectLiteral", state);
|
|
10228
|
+
if (result) {
|
|
10229
|
+
if (result.cache)
|
|
10230
|
+
return result.cache;
|
|
10231
|
+
eventData = result.data;
|
|
10232
|
+
}
|
|
10233
|
+
}
|
|
10234
|
+
if (state.tokenize) {
|
|
10235
|
+
const result = $TOKEN("AllowMultiLineImplicitObjectLiteral", state, AllowMultiLineImplicitObjectLiteral$0(state));
|
|
10236
|
+
if (state.events)
|
|
10237
|
+
state.events.exit?.("AllowMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10238
|
+
return result;
|
|
10239
|
+
} else {
|
|
10240
|
+
const result = AllowMultiLineImplicitObjectLiteral$0(state);
|
|
10241
|
+
if (state.events)
|
|
10242
|
+
state.events.exit?.("AllowMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10243
|
+
return result;
|
|
10244
|
+
}
|
|
10245
|
+
}
|
|
10246
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L18, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10247
|
+
module.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10248
|
+
});
|
|
10249
|
+
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
10250
|
+
let eventData;
|
|
10251
|
+
if (state.events) {
|
|
10252
|
+
const result = state.events.enter?.("RestoreMultiLineImplicitObjectLiteral", state);
|
|
10253
|
+
if (result) {
|
|
10254
|
+
if (result.cache)
|
|
10255
|
+
return result.cache;
|
|
10256
|
+
eventData = result.data;
|
|
10257
|
+
}
|
|
10258
|
+
}
|
|
10259
|
+
if (state.tokenize) {
|
|
10260
|
+
const result = $TOKEN("RestoreMultiLineImplicitObjectLiteral", state, RestoreMultiLineImplicitObjectLiteral$0(state));
|
|
10261
|
+
if (state.events)
|
|
10262
|
+
state.events.exit?.("RestoreMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10263
|
+
return result;
|
|
10264
|
+
} else {
|
|
10265
|
+
const result = RestoreMultiLineImplicitObjectLiteral$0(state);
|
|
10266
|
+
if (state.events)
|
|
10267
|
+
state.events.exit?.("RestoreMultiLineImplicitObjectLiteral", state, result, eventData);
|
|
10268
|
+
return result;
|
|
10269
|
+
}
|
|
10270
|
+
}
|
|
10271
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L18, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10272
|
+
if (module.config.verbose) {
|
|
10273
|
+
console.log("forbidMultiLineImplicitObjectLiteral:", module.forbidMultiLineImplicitObjectLiteral);
|
|
10274
|
+
}
|
|
10275
|
+
if (module.multiLineImplicitObjectLiteralForbidden)
|
|
10276
|
+
return $skip;
|
|
10277
|
+
});
|
|
10278
|
+
function MultiLineImplicitObjectLiteralAllowed(state) {
|
|
10279
|
+
let eventData;
|
|
10280
|
+
if (state.events) {
|
|
10281
|
+
const result = state.events.enter?.("MultiLineImplicitObjectLiteralAllowed", state);
|
|
10282
|
+
if (result) {
|
|
10283
|
+
if (result.cache)
|
|
10284
|
+
return result.cache;
|
|
10285
|
+
eventData = result.data;
|
|
10286
|
+
}
|
|
10287
|
+
}
|
|
10288
|
+
if (state.tokenize) {
|
|
10289
|
+
const result = $TOKEN("MultiLineImplicitObjectLiteralAllowed", state, MultiLineImplicitObjectLiteralAllowed$0(state));
|
|
10290
|
+
if (state.events)
|
|
10291
|
+
state.events.exit?.("MultiLineImplicitObjectLiteralAllowed", state, result, eventData);
|
|
10292
|
+
return result;
|
|
10293
|
+
} else {
|
|
10294
|
+
const result = MultiLineImplicitObjectLiteralAllowed$0(state);
|
|
10295
|
+
if (state.events)
|
|
10296
|
+
state.events.exit?.("MultiLineImplicitObjectLiteralAllowed", state, result, eventData);
|
|
10297
|
+
return result;
|
|
10298
|
+
}
|
|
10299
|
+
}
|
|
10300
|
+
var AllowAll$0 = $S(AllowTrailingMemberProperty, AllowIndentedApplication, AllowMultiLineImplicitObjectLiteral);
|
|
10301
|
+
function AllowAll(state) {
|
|
10302
|
+
let eventData;
|
|
10303
|
+
if (state.events) {
|
|
10304
|
+
const result = state.events.enter?.("AllowAll", state);
|
|
10305
|
+
if (result) {
|
|
10306
|
+
if (result.cache)
|
|
10307
|
+
return result.cache;
|
|
10308
|
+
eventData = result.data;
|
|
10309
|
+
}
|
|
10310
|
+
}
|
|
10311
|
+
if (state.tokenize) {
|
|
10312
|
+
const result = $TOKEN("AllowAll", state, AllowAll$0(state));
|
|
10313
|
+
if (state.events)
|
|
10314
|
+
state.events.exit?.("AllowAll", state, result, eventData);
|
|
10315
|
+
return result;
|
|
10316
|
+
} else {
|
|
10317
|
+
const result = AllowAll$0(state);
|
|
10318
|
+
if (state.events)
|
|
10319
|
+
state.events.exit?.("AllowAll", state, result, eventData);
|
|
10320
|
+
return result;
|
|
10321
|
+
}
|
|
10322
|
+
}
|
|
10323
|
+
var RestoreAll$0 = $S(RestoreTrailingMemberProperty, RestoreIndentedApplication, RestoreMultiLineImplicitObjectLiteral);
|
|
10324
|
+
function RestoreAll(state) {
|
|
10325
|
+
let eventData;
|
|
10326
|
+
if (state.events) {
|
|
10327
|
+
const result = state.events.enter?.("RestoreAll", state);
|
|
10328
|
+
if (result) {
|
|
10329
|
+
if (result.cache)
|
|
10330
|
+
return result.cache;
|
|
10331
|
+
eventData = result.data;
|
|
10332
|
+
}
|
|
10333
|
+
}
|
|
10334
|
+
if (state.tokenize) {
|
|
10335
|
+
const result = $TOKEN("RestoreAll", state, RestoreAll$0(state));
|
|
10336
|
+
if (state.events)
|
|
10337
|
+
state.events.exit?.("RestoreAll", state, result, eventData);
|
|
10338
|
+
return result;
|
|
10339
|
+
} else {
|
|
10340
|
+
const result = RestoreAll$0(state);
|
|
10341
|
+
if (state.events)
|
|
10342
|
+
state.events.exit?.("RestoreAll", state, result, eventData);
|
|
10343
|
+
return result;
|
|
10344
|
+
}
|
|
10345
|
+
}
|
|
9941
10346
|
var ExpressionStatement$0 = Expression;
|
|
9942
10347
|
function ExpressionStatement(state) {
|
|
9943
10348
|
let eventData;
|
|
@@ -9961,13 +10366,19 @@ ${input.slice(result.pos)}
|
|
|
9961
10366
|
return result;
|
|
9962
10367
|
}
|
|
9963
10368
|
}
|
|
9964
|
-
var KeywordStatement$0 = $
|
|
9965
|
-
return {
|
|
10369
|
+
var KeywordStatement$0 = $TS($S(Break, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10370
|
+
return {
|
|
10371
|
+
type: "BreakStatement",
|
|
10372
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10373
|
+
};
|
|
9966
10374
|
});
|
|
9967
|
-
var KeywordStatement$1 = $
|
|
9968
|
-
return {
|
|
10375
|
+
var KeywordStatement$1 = $TS($S(Continue, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10376
|
+
return {
|
|
10377
|
+
type: "ContinueStatement",
|
|
10378
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10379
|
+
};
|
|
9969
10380
|
});
|
|
9970
|
-
var KeywordStatement$2 = $T($S(
|
|
10381
|
+
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
9971
10382
|
return { "type": "DebuggerStatement", "children": value };
|
|
9972
10383
|
});
|
|
9973
10384
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -9998,7 +10409,82 @@ ${input.slice(result.pos)}
|
|
|
9998
10409
|
return result;
|
|
9999
10410
|
}
|
|
10000
10411
|
}
|
|
10001
|
-
var
|
|
10412
|
+
var Break$0 = $TS($S($EXPECT($L87, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10413
|
+
return { $loc, token: $1 };
|
|
10414
|
+
});
|
|
10415
|
+
function Break(state) {
|
|
10416
|
+
let eventData;
|
|
10417
|
+
if (state.events) {
|
|
10418
|
+
const result = state.events.enter?.("Break", state);
|
|
10419
|
+
if (result) {
|
|
10420
|
+
if (result.cache)
|
|
10421
|
+
return result.cache;
|
|
10422
|
+
eventData = result.data;
|
|
10423
|
+
}
|
|
10424
|
+
}
|
|
10425
|
+
if (state.tokenize) {
|
|
10426
|
+
const result = $TOKEN("Break", state, Break$0(state));
|
|
10427
|
+
if (state.events)
|
|
10428
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10429
|
+
return result;
|
|
10430
|
+
} else {
|
|
10431
|
+
const result = Break$0(state);
|
|
10432
|
+
if (state.events)
|
|
10433
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10434
|
+
return result;
|
|
10435
|
+
}
|
|
10436
|
+
}
|
|
10437
|
+
var Continue$0 = $TS($S($EXPECT($L88, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10438
|
+
return { $loc, token: $1 };
|
|
10439
|
+
});
|
|
10440
|
+
function Continue(state) {
|
|
10441
|
+
let eventData;
|
|
10442
|
+
if (state.events) {
|
|
10443
|
+
const result = state.events.enter?.("Continue", state);
|
|
10444
|
+
if (result) {
|
|
10445
|
+
if (result.cache)
|
|
10446
|
+
return result.cache;
|
|
10447
|
+
eventData = result.data;
|
|
10448
|
+
}
|
|
10449
|
+
}
|
|
10450
|
+
if (state.tokenize) {
|
|
10451
|
+
const result = $TOKEN("Continue", state, Continue$0(state));
|
|
10452
|
+
if (state.events)
|
|
10453
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10454
|
+
return result;
|
|
10455
|
+
} else {
|
|
10456
|
+
const result = Continue$0(state);
|
|
10457
|
+
if (state.events)
|
|
10458
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10459
|
+
return result;
|
|
10460
|
+
}
|
|
10461
|
+
}
|
|
10462
|
+
var Debugger$0 = $TS($S($EXPECT($L89, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10463
|
+
return { $loc, token: $1 };
|
|
10464
|
+
});
|
|
10465
|
+
function Debugger(state) {
|
|
10466
|
+
let eventData;
|
|
10467
|
+
if (state.events) {
|
|
10468
|
+
const result = state.events.enter?.("Debugger", state);
|
|
10469
|
+
if (result) {
|
|
10470
|
+
if (result.cache)
|
|
10471
|
+
return result.cache;
|
|
10472
|
+
eventData = result.data;
|
|
10473
|
+
}
|
|
10474
|
+
}
|
|
10475
|
+
if (state.tokenize) {
|
|
10476
|
+
const result = $TOKEN("Debugger", state, Debugger$0(state));
|
|
10477
|
+
if (state.events)
|
|
10478
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10479
|
+
return result;
|
|
10480
|
+
} else {
|
|
10481
|
+
const result = Debugger$0(state);
|
|
10482
|
+
if (state.events)
|
|
10483
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10484
|
+
return result;
|
|
10485
|
+
}
|
|
10486
|
+
}
|
|
10487
|
+
var DebuggerExpression$0 = $TS($S(Debugger), function($skip, $loc, $0, $1) {
|
|
10002
10488
|
return {
|
|
10003
10489
|
type: "DebuggerExpression",
|
|
10004
10490
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10275,7 +10761,7 @@ ${input.slice(result.pos)}
|
|
|
10275
10761
|
return result;
|
|
10276
10762
|
}
|
|
10277
10763
|
}
|
|
10278
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10764
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L90, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10279
10765
|
function ImportAssertion(state) {
|
|
10280
10766
|
let eventData;
|
|
10281
10767
|
if (state.events) {
|
|
@@ -10879,7 +11365,7 @@ ${input.slice(result.pos)}
|
|
|
10879
11365
|
return result;
|
|
10880
11366
|
}
|
|
10881
11367
|
}
|
|
10882
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11368
|
+
var ConstAssignment$0 = $TV($EXPECT($L91, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
10883
11369
|
return { $loc, token: "=" };
|
|
10884
11370
|
});
|
|
10885
11371
|
function ConstAssignment(state) {
|
|
@@ -10904,7 +11390,7 @@ ${input.slice(result.pos)}
|
|
|
10904
11390
|
return result;
|
|
10905
11391
|
}
|
|
10906
11392
|
}
|
|
10907
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11393
|
+
var LetAssignment$0 = $TV($EXPECT($L92, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10908
11394
|
return { $loc, token: "=" };
|
|
10909
11395
|
});
|
|
10910
11396
|
function LetAssignment(state) {
|
|
@@ -12169,7 +12655,7 @@ ${input.slice(result.pos)}
|
|
|
12169
12655
|
return result;
|
|
12170
12656
|
}
|
|
12171
12657
|
}
|
|
12172
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12658
|
+
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) {
|
|
12173
12659
|
return { $loc, token: $1 };
|
|
12174
12660
|
});
|
|
12175
12661
|
function JSMultiLineComment(state) {
|
|
@@ -12268,7 +12754,7 @@ ${input.slice(result.pos)}
|
|
|
12268
12754
|
return result;
|
|
12269
12755
|
}
|
|
12270
12756
|
}
|
|
12271
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12757
|
+
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) {
|
|
12272
12758
|
return { $loc, token: $1 };
|
|
12273
12759
|
});
|
|
12274
12760
|
function InlineComment(state) {
|
|
@@ -12367,7 +12853,7 @@ ${input.slice(result.pos)}
|
|
|
12367
12853
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12368
12854
|
return { $loc, token: $0 };
|
|
12369
12855
|
});
|
|
12370
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12856
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L95, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12371
12857
|
return "";
|
|
12372
12858
|
});
|
|
12373
12859
|
function NonNewlineWhitespace(state) {
|
|
@@ -12519,7 +13005,7 @@ ${input.slice(result.pos)}
|
|
|
12519
13005
|
}
|
|
12520
13006
|
}
|
|
12521
13007
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12522
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13008
|
+
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);
|
|
12523
13009
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12524
13010
|
function StatementDelimiter(state) {
|
|
12525
13011
|
let eventData;
|
|
@@ -12619,7 +13105,7 @@ ${input.slice(result.pos)}
|
|
|
12619
13105
|
return result;
|
|
12620
13106
|
}
|
|
12621
13107
|
}
|
|
12622
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13108
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L98, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
12623
13109
|
return { $loc, token: $1, ts: true };
|
|
12624
13110
|
});
|
|
12625
13111
|
function Abstract(state) {
|
|
@@ -12669,7 +13155,7 @@ ${input.slice(result.pos)}
|
|
|
12669
13155
|
return result;
|
|
12670
13156
|
}
|
|
12671
13157
|
}
|
|
12672
|
-
var As$0 = $TS($S($EXPECT($
|
|
13158
|
+
var As$0 = $TS($S($EXPECT($L99, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12673
13159
|
return { $loc, token: $1 };
|
|
12674
13160
|
});
|
|
12675
13161
|
function As(state) {
|
|
@@ -12694,7 +13180,7 @@ ${input.slice(result.pos)}
|
|
|
12694
13180
|
return result;
|
|
12695
13181
|
}
|
|
12696
13182
|
}
|
|
12697
|
-
var At$0 = $TV($EXPECT($
|
|
13183
|
+
var At$0 = $TV($EXPECT($L100, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
12698
13184
|
return { $loc, token: $1 };
|
|
12699
13185
|
});
|
|
12700
13186
|
function At(state) {
|
|
@@ -12719,7 +13205,7 @@ ${input.slice(result.pos)}
|
|
|
12719
13205
|
return result;
|
|
12720
13206
|
}
|
|
12721
13207
|
}
|
|
12722
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13208
|
+
var AtAt$0 = $TV($EXPECT($L101, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
12723
13209
|
return { $loc, token: "@" };
|
|
12724
13210
|
});
|
|
12725
13211
|
function AtAt(state) {
|
|
@@ -12744,7 +13230,7 @@ ${input.slice(result.pos)}
|
|
|
12744
13230
|
return result;
|
|
12745
13231
|
}
|
|
12746
13232
|
}
|
|
12747
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13233
|
+
var Async$0 = $TS($S($EXPECT($L102, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12748
13234
|
return { $loc, token: $1, type: "Async" };
|
|
12749
13235
|
});
|
|
12750
13236
|
function Async(state) {
|
|
@@ -12769,7 +13255,7 @@ ${input.slice(result.pos)}
|
|
|
12769
13255
|
return result;
|
|
12770
13256
|
}
|
|
12771
13257
|
}
|
|
12772
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13258
|
+
var Await$0 = $TS($S($EXPECT($L103, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12773
13259
|
return { $loc, token: $1 };
|
|
12774
13260
|
});
|
|
12775
13261
|
function Await(state) {
|
|
@@ -12794,7 +13280,7 @@ ${input.slice(result.pos)}
|
|
|
12794
13280
|
return result;
|
|
12795
13281
|
}
|
|
12796
13282
|
}
|
|
12797
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13283
|
+
var Backtick$0 = $TV($EXPECT($L97, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
12798
13284
|
return { $loc, token: $1 };
|
|
12799
13285
|
});
|
|
12800
13286
|
function Backtick(state) {
|
|
@@ -12819,7 +13305,7 @@ ${input.slice(result.pos)}
|
|
|
12819
13305
|
return result;
|
|
12820
13306
|
}
|
|
12821
13307
|
}
|
|
12822
|
-
var By$0 = $TS($S($EXPECT($
|
|
13308
|
+
var By$0 = $TS($S($EXPECT($L104, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12823
13309
|
return { $loc, token: $1 };
|
|
12824
13310
|
});
|
|
12825
13311
|
function By(state) {
|
|
@@ -12844,7 +13330,7 @@ ${input.slice(result.pos)}
|
|
|
12844
13330
|
return result;
|
|
12845
13331
|
}
|
|
12846
13332
|
}
|
|
12847
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13333
|
+
var Case$0 = $TS($S($EXPECT($L105, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12848
13334
|
return { $loc, token: $1 };
|
|
12849
13335
|
});
|
|
12850
13336
|
function Case(state) {
|
|
@@ -12869,7 +13355,7 @@ ${input.slice(result.pos)}
|
|
|
12869
13355
|
return result;
|
|
12870
13356
|
}
|
|
12871
13357
|
}
|
|
12872
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13358
|
+
var Catch$0 = $TS($S($EXPECT($L106, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12873
13359
|
return { $loc, token: $1 };
|
|
12874
13360
|
});
|
|
12875
13361
|
function Catch(state) {
|
|
@@ -12894,7 +13380,7 @@ ${input.slice(result.pos)}
|
|
|
12894
13380
|
return result;
|
|
12895
13381
|
}
|
|
12896
13382
|
}
|
|
12897
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13383
|
+
var Class$0 = $TS($S($EXPECT($L107, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12898
13384
|
return { $loc, token: $1 };
|
|
12899
13385
|
});
|
|
12900
13386
|
function Class(state) {
|
|
@@ -12994,7 +13480,7 @@ ${input.slice(result.pos)}
|
|
|
12994
13480
|
return result;
|
|
12995
13481
|
}
|
|
12996
13482
|
}
|
|
12997
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13483
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L108, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
12998
13484
|
return { $loc, token: "${" };
|
|
12999
13485
|
});
|
|
13000
13486
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13069,7 +13555,7 @@ ${input.slice(result.pos)}
|
|
|
13069
13555
|
return result;
|
|
13070
13556
|
}
|
|
13071
13557
|
}
|
|
13072
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13558
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L100, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13073
13559
|
return { $loc, token: "constructor" };
|
|
13074
13560
|
});
|
|
13075
13561
|
function ConstructorShorthand(state) {
|
|
@@ -13094,7 +13580,7 @@ ${input.slice(result.pos)}
|
|
|
13094
13580
|
return result;
|
|
13095
13581
|
}
|
|
13096
13582
|
}
|
|
13097
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13583
|
+
var Declare$0 = $TS($S($EXPECT($L109, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13098
13584
|
return { $loc, token: $1 };
|
|
13099
13585
|
});
|
|
13100
13586
|
function Declare(state) {
|
|
@@ -13119,7 +13605,7 @@ ${input.slice(result.pos)}
|
|
|
13119
13605
|
return result;
|
|
13120
13606
|
}
|
|
13121
13607
|
}
|
|
13122
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13608
|
+
var Default$0 = $TS($S($EXPECT($L110, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13123
13609
|
return { $loc, token: $1 };
|
|
13124
13610
|
});
|
|
13125
13611
|
function Default(state) {
|
|
@@ -13144,7 +13630,7 @@ ${input.slice(result.pos)}
|
|
|
13144
13630
|
return result;
|
|
13145
13631
|
}
|
|
13146
13632
|
}
|
|
13147
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13633
|
+
var Delete$0 = $TS($S($EXPECT($L111, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13148
13634
|
return { $loc, token: $1 };
|
|
13149
13635
|
});
|
|
13150
13636
|
function Delete(state) {
|
|
@@ -13169,7 +13655,7 @@ ${input.slice(result.pos)}
|
|
|
13169
13655
|
return result;
|
|
13170
13656
|
}
|
|
13171
13657
|
}
|
|
13172
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13658
|
+
var Do$0 = $TS($S($EXPECT($L112, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13173
13659
|
return { $loc, token: $1 };
|
|
13174
13660
|
});
|
|
13175
13661
|
function Do(state) {
|
|
@@ -13219,7 +13705,7 @@ ${input.slice(result.pos)}
|
|
|
13219
13705
|
return result;
|
|
13220
13706
|
}
|
|
13221
13707
|
}
|
|
13222
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13708
|
+
var DotDot$0 = $TV($EXPECT($L113, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13223
13709
|
return { $loc, token: $1 };
|
|
13224
13710
|
});
|
|
13225
13711
|
function DotDot(state) {
|
|
@@ -13244,7 +13730,7 @@ ${input.slice(result.pos)}
|
|
|
13244
13730
|
return result;
|
|
13245
13731
|
}
|
|
13246
13732
|
}
|
|
13247
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13733
|
+
var DotDotDot$0 = $TV($EXPECT($L114, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13248
13734
|
return { $loc, token: $1 };
|
|
13249
13735
|
});
|
|
13250
13736
|
function DotDotDot(state) {
|
|
@@ -13269,7 +13755,7 @@ ${input.slice(result.pos)}
|
|
|
13269
13755
|
return result;
|
|
13270
13756
|
}
|
|
13271
13757
|
}
|
|
13272
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13758
|
+
var DoubleColon$0 = $TV($EXPECT($L115, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13273
13759
|
return { $loc, token: $1 };
|
|
13274
13760
|
});
|
|
13275
13761
|
function DoubleColon(state) {
|
|
@@ -13294,7 +13780,7 @@ ${input.slice(result.pos)}
|
|
|
13294
13780
|
return result;
|
|
13295
13781
|
}
|
|
13296
13782
|
}
|
|
13297
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13783
|
+
var DoubleQuote$0 = $TV($EXPECT($L116, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13298
13784
|
return { $loc, token: $1 };
|
|
13299
13785
|
});
|
|
13300
13786
|
function DoubleQuote(state) {
|
|
@@ -13319,7 +13805,7 @@ ${input.slice(result.pos)}
|
|
|
13319
13805
|
return result;
|
|
13320
13806
|
}
|
|
13321
13807
|
}
|
|
13322
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13808
|
+
var Else$0 = $TS($S($EXPECT($L117, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13323
13809
|
return { $loc, token: $1 };
|
|
13324
13810
|
});
|
|
13325
13811
|
function Else(state) {
|
|
@@ -13369,7 +13855,7 @@ ${input.slice(result.pos)}
|
|
|
13369
13855
|
return result;
|
|
13370
13856
|
}
|
|
13371
13857
|
}
|
|
13372
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13858
|
+
var Export$0 = $TS($S($EXPECT($L118, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13373
13859
|
return { $loc, token: $1 };
|
|
13374
13860
|
});
|
|
13375
13861
|
function Export(state) {
|
|
@@ -13394,7 +13880,7 @@ ${input.slice(result.pos)}
|
|
|
13394
13880
|
return result;
|
|
13395
13881
|
}
|
|
13396
13882
|
}
|
|
13397
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13883
|
+
var Extends$0 = $TS($S($EXPECT($L119, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13398
13884
|
return { $loc, token: $1 };
|
|
13399
13885
|
});
|
|
13400
13886
|
function Extends(state) {
|
|
@@ -13419,7 +13905,7 @@ ${input.slice(result.pos)}
|
|
|
13419
13905
|
return result;
|
|
13420
13906
|
}
|
|
13421
13907
|
}
|
|
13422
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13908
|
+
var Finally$0 = $TS($S($EXPECT($L120, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13423
13909
|
return { $loc, token: $1 };
|
|
13424
13910
|
});
|
|
13425
13911
|
function Finally(state) {
|
|
@@ -13444,7 +13930,7 @@ ${input.slice(result.pos)}
|
|
|
13444
13930
|
return result;
|
|
13445
13931
|
}
|
|
13446
13932
|
}
|
|
13447
|
-
var For$0 = $TS($S($EXPECT($
|
|
13933
|
+
var For$0 = $TS($S($EXPECT($L121, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13448
13934
|
return { $loc, token: $1 };
|
|
13449
13935
|
});
|
|
13450
13936
|
function For(state) {
|
|
@@ -13469,7 +13955,7 @@ ${input.slice(result.pos)}
|
|
|
13469
13955
|
return result;
|
|
13470
13956
|
}
|
|
13471
13957
|
}
|
|
13472
|
-
var From$0 = $TS($S($EXPECT($
|
|
13958
|
+
var From$0 = $TS($S($EXPECT($L122, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13473
13959
|
return { $loc, token: $1 };
|
|
13474
13960
|
});
|
|
13475
13961
|
function From(state) {
|
|
@@ -13494,7 +13980,7 @@ ${input.slice(result.pos)}
|
|
|
13494
13980
|
return result;
|
|
13495
13981
|
}
|
|
13496
13982
|
}
|
|
13497
|
-
var Function$0 = $TS($S($EXPECT($
|
|
13983
|
+
var Function$0 = $TS($S($EXPECT($L123, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13498
13984
|
return { $loc, token: $1 };
|
|
13499
13985
|
});
|
|
13500
13986
|
function Function(state) {
|
|
@@ -13519,7 +14005,7 @@ ${input.slice(result.pos)}
|
|
|
13519
14005
|
return result;
|
|
13520
14006
|
}
|
|
13521
14007
|
}
|
|
13522
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14008
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L124, fail, 'GetOrSet "get"'), $EXPECT($L125, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13523
14009
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13524
14010
|
});
|
|
13525
14011
|
function GetOrSet(state) {
|
|
@@ -13544,7 +14030,7 @@ ${input.slice(result.pos)}
|
|
|
13544
14030
|
return result;
|
|
13545
14031
|
}
|
|
13546
14032
|
}
|
|
13547
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14033
|
+
var If$0 = $TV($TEXT($S($EXPECT($L126, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13548
14034
|
return { $loc, token: $1 };
|
|
13549
14035
|
});
|
|
13550
14036
|
function If(state) {
|
|
@@ -13619,7 +14105,7 @@ ${input.slice(result.pos)}
|
|
|
13619
14105
|
return result;
|
|
13620
14106
|
}
|
|
13621
14107
|
}
|
|
13622
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14108
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L127, fail, 'LetOrConst "let"'), $EXPECT($L128, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13623
14109
|
return { $loc, token: $1 };
|
|
13624
14110
|
});
|
|
13625
14111
|
function LetOrConst(state) {
|
|
@@ -13644,7 +14130,7 @@ ${input.slice(result.pos)}
|
|
|
13644
14130
|
return result;
|
|
13645
14131
|
}
|
|
13646
14132
|
}
|
|
13647
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14133
|
+
var Loop$0 = $TS($S($EXPECT($L129, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13648
14134
|
return { $loc, token: "while(true)" };
|
|
13649
14135
|
});
|
|
13650
14136
|
function Loop(state) {
|
|
@@ -13669,7 +14155,7 @@ ${input.slice(result.pos)}
|
|
|
13669
14155
|
return result;
|
|
13670
14156
|
}
|
|
13671
14157
|
}
|
|
13672
|
-
var New$0 = $TS($S($EXPECT($
|
|
14158
|
+
var New$0 = $TS($S($EXPECT($L130, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13673
14159
|
return { $loc, token: $1 };
|
|
13674
14160
|
});
|
|
13675
14161
|
function New(state) {
|
|
@@ -13744,7 +14230,7 @@ ${input.slice(result.pos)}
|
|
|
13744
14230
|
return result;
|
|
13745
14231
|
}
|
|
13746
14232
|
}
|
|
13747
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14233
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L131, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
13748
14234
|
return { $loc, token: $1 };
|
|
13749
14235
|
});
|
|
13750
14236
|
function OpenAngleBracket(state) {
|
|
@@ -13769,7 +14255,7 @@ ${input.slice(result.pos)}
|
|
|
13769
14255
|
return result;
|
|
13770
14256
|
}
|
|
13771
14257
|
}
|
|
13772
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14258
|
+
var OpenBrace$0 = $TV($EXPECT($L132, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
13773
14259
|
return { $loc, token: $1 };
|
|
13774
14260
|
});
|
|
13775
14261
|
function OpenBrace(state) {
|
|
@@ -13794,7 +14280,7 @@ ${input.slice(result.pos)}
|
|
|
13794
14280
|
return result;
|
|
13795
14281
|
}
|
|
13796
14282
|
}
|
|
13797
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14283
|
+
var OpenBracket$0 = $TV($EXPECT($L96, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
13798
14284
|
return { $loc, token: $1 };
|
|
13799
14285
|
});
|
|
13800
14286
|
function OpenBracket(state) {
|
|
@@ -13844,7 +14330,7 @@ ${input.slice(result.pos)}
|
|
|
13844
14330
|
return result;
|
|
13845
14331
|
}
|
|
13846
14332
|
}
|
|
13847
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14333
|
+
var Operator$0 = $TS($S($EXPECT($L133, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13848
14334
|
return { $loc, token: $1 };
|
|
13849
14335
|
});
|
|
13850
14336
|
function Operator(state) {
|
|
@@ -13869,7 +14355,7 @@ ${input.slice(result.pos)}
|
|
|
13869
14355
|
return result;
|
|
13870
14356
|
}
|
|
13871
14357
|
}
|
|
13872
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14358
|
+
var Public$0 = $TS($S($EXPECT($L134, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13873
14359
|
return { $loc, token: $1 };
|
|
13874
14360
|
});
|
|
13875
14361
|
function Public(state) {
|
|
@@ -13894,7 +14380,7 @@ ${input.slice(result.pos)}
|
|
|
13894
14380
|
return result;
|
|
13895
14381
|
}
|
|
13896
14382
|
}
|
|
13897
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14383
|
+
var Private$0 = $TS($S($EXPECT($L135, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13898
14384
|
return { $loc, token: $1 };
|
|
13899
14385
|
});
|
|
13900
14386
|
function Private(state) {
|
|
@@ -13919,7 +14405,7 @@ ${input.slice(result.pos)}
|
|
|
13919
14405
|
return result;
|
|
13920
14406
|
}
|
|
13921
14407
|
}
|
|
13922
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14408
|
+
var Protected$0 = $TS($S($EXPECT($L136, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13923
14409
|
return { $loc, token: $1 };
|
|
13924
14410
|
});
|
|
13925
14411
|
function Protected(state) {
|
|
@@ -13944,13 +14430,13 @@ ${input.slice(result.pos)}
|
|
|
13944
14430
|
return result;
|
|
13945
14431
|
}
|
|
13946
14432
|
}
|
|
13947
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14433
|
+
var Pipe$0 = $TV($EXPECT($L137, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
13948
14434
|
return { $loc, token: $1 };
|
|
13949
14435
|
});
|
|
13950
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14436
|
+
var Pipe$1 = $TV($EXPECT($L138, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
13951
14437
|
return { $loc, token: $1 };
|
|
13952
14438
|
});
|
|
13953
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14439
|
+
var Pipe$2 = $TV($EXPECT($L139, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
13954
14440
|
return { $loc, token: $1 };
|
|
13955
14441
|
});
|
|
13956
14442
|
function Pipe(state) {
|
|
@@ -14000,7 +14486,7 @@ ${input.slice(result.pos)}
|
|
|
14000
14486
|
return result;
|
|
14001
14487
|
}
|
|
14002
14488
|
}
|
|
14003
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14489
|
+
var Readonly$0 = $TS($S($EXPECT($L140, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14004
14490
|
return { $loc, token: $1, ts: true };
|
|
14005
14491
|
});
|
|
14006
14492
|
function Readonly(state) {
|
|
@@ -14025,7 +14511,7 @@ ${input.slice(result.pos)}
|
|
|
14025
14511
|
return result;
|
|
14026
14512
|
}
|
|
14027
14513
|
}
|
|
14028
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14514
|
+
var Return$0 = $TS($S($EXPECT($L141, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14029
14515
|
return { $loc, token: $1 };
|
|
14030
14516
|
});
|
|
14031
14517
|
function Return(state) {
|
|
@@ -14050,7 +14536,7 @@ ${input.slice(result.pos)}
|
|
|
14050
14536
|
return result;
|
|
14051
14537
|
}
|
|
14052
14538
|
}
|
|
14053
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14539
|
+
var Satisfies$0 = $TS($S($EXPECT($L142, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14054
14540
|
return { $loc, token: $1 };
|
|
14055
14541
|
});
|
|
14056
14542
|
function Satisfies(state) {
|
|
@@ -14100,7 +14586,7 @@ ${input.slice(result.pos)}
|
|
|
14100
14586
|
return result;
|
|
14101
14587
|
}
|
|
14102
14588
|
}
|
|
14103
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14589
|
+
var SingleQuote$0 = $TV($EXPECT($L143, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14104
14590
|
return { $loc, token: $1 };
|
|
14105
14591
|
});
|
|
14106
14592
|
function SingleQuote(state) {
|
|
@@ -14150,10 +14636,10 @@ ${input.slice(result.pos)}
|
|
|
14150
14636
|
return result;
|
|
14151
14637
|
}
|
|
14152
14638
|
}
|
|
14153
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14639
|
+
var Static$0 = $TS($S($EXPECT($L144, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14154
14640
|
return { $loc, token: $1 };
|
|
14155
14641
|
});
|
|
14156
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14642
|
+
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) {
|
|
14157
14643
|
return { $loc, token: "static " };
|
|
14158
14644
|
});
|
|
14159
14645
|
function Static(state) {
|
|
@@ -14178,7 +14664,7 @@ ${input.slice(result.pos)}
|
|
|
14178
14664
|
return result;
|
|
14179
14665
|
}
|
|
14180
14666
|
}
|
|
14181
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14667
|
+
var SubstitutionStart$0 = $TV($EXPECT($L145, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14182
14668
|
return { $loc, token: $1 };
|
|
14183
14669
|
});
|
|
14184
14670
|
function SubstitutionStart(state) {
|
|
@@ -14203,7 +14689,7 @@ ${input.slice(result.pos)}
|
|
|
14203
14689
|
return result;
|
|
14204
14690
|
}
|
|
14205
14691
|
}
|
|
14206
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14692
|
+
var Switch$0 = $TS($S($EXPECT($L146, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14207
14693
|
return { $loc, token: $1 };
|
|
14208
14694
|
});
|
|
14209
14695
|
function Switch(state) {
|
|
@@ -14228,7 +14714,7 @@ ${input.slice(result.pos)}
|
|
|
14228
14714
|
return result;
|
|
14229
14715
|
}
|
|
14230
14716
|
}
|
|
14231
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14717
|
+
var Target$0 = $TS($S($EXPECT($L147, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14232
14718
|
return { $loc, token: $1 };
|
|
14233
14719
|
});
|
|
14234
14720
|
function Target(state) {
|
|
@@ -14253,7 +14739,7 @@ ${input.slice(result.pos)}
|
|
|
14253
14739
|
return result;
|
|
14254
14740
|
}
|
|
14255
14741
|
}
|
|
14256
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14742
|
+
var Then$0 = $TS($S(__, $EXPECT($L148, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14257
14743
|
return { $loc, token: "" };
|
|
14258
14744
|
});
|
|
14259
14745
|
function Then(state) {
|
|
@@ -14278,7 +14764,7 @@ ${input.slice(result.pos)}
|
|
|
14278
14764
|
return result;
|
|
14279
14765
|
}
|
|
14280
14766
|
}
|
|
14281
|
-
var This$0 = $TS($S($EXPECT($
|
|
14767
|
+
var This$0 = $TS($S($EXPECT($L149, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14282
14768
|
return { $loc, token: $1 };
|
|
14283
14769
|
});
|
|
14284
14770
|
function This(state) {
|
|
@@ -14303,7 +14789,7 @@ ${input.slice(result.pos)}
|
|
|
14303
14789
|
return result;
|
|
14304
14790
|
}
|
|
14305
14791
|
}
|
|
14306
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14792
|
+
var Throw$0 = $TS($S($EXPECT($L150, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14307
14793
|
return { $loc, token: $1 };
|
|
14308
14794
|
});
|
|
14309
14795
|
function Throw(state) {
|
|
@@ -14328,7 +14814,7 @@ ${input.slice(result.pos)}
|
|
|
14328
14814
|
return result;
|
|
14329
14815
|
}
|
|
14330
14816
|
}
|
|
14331
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14817
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L151, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14332
14818
|
return { $loc, token: "`" };
|
|
14333
14819
|
});
|
|
14334
14820
|
function TripleDoubleQuote(state) {
|
|
@@ -14353,7 +14839,7 @@ ${input.slice(result.pos)}
|
|
|
14353
14839
|
return result;
|
|
14354
14840
|
}
|
|
14355
14841
|
}
|
|
14356
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14842
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L152, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14357
14843
|
return { $loc, token: "`" };
|
|
14358
14844
|
});
|
|
14359
14845
|
function TripleSingleQuote(state) {
|
|
@@ -14378,7 +14864,7 @@ ${input.slice(result.pos)}
|
|
|
14378
14864
|
return result;
|
|
14379
14865
|
}
|
|
14380
14866
|
}
|
|
14381
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14867
|
+
var TripleSlash$0 = $TV($EXPECT($L153, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14382
14868
|
return { $loc, token: "/" };
|
|
14383
14869
|
});
|
|
14384
14870
|
function TripleSlash(state) {
|
|
@@ -14403,7 +14889,7 @@ ${input.slice(result.pos)}
|
|
|
14403
14889
|
return result;
|
|
14404
14890
|
}
|
|
14405
14891
|
}
|
|
14406
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14892
|
+
var TripleTick$0 = $TV($EXPECT($L154, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14407
14893
|
return { $loc, token: "`" };
|
|
14408
14894
|
});
|
|
14409
14895
|
function TripleTick(state) {
|
|
@@ -14428,7 +14914,7 @@ ${input.slice(result.pos)}
|
|
|
14428
14914
|
return result;
|
|
14429
14915
|
}
|
|
14430
14916
|
}
|
|
14431
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14917
|
+
var Try$0 = $TS($S($EXPECT($L155, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14432
14918
|
return { $loc, token: $1 };
|
|
14433
14919
|
});
|
|
14434
14920
|
function Try(state) {
|
|
@@ -14453,7 +14939,7 @@ ${input.slice(result.pos)}
|
|
|
14453
14939
|
return result;
|
|
14454
14940
|
}
|
|
14455
14941
|
}
|
|
14456
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
14942
|
+
var Typeof$0 = $TS($S($EXPECT($L156, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14457
14943
|
return { $loc, token: $1 };
|
|
14458
14944
|
});
|
|
14459
14945
|
function Typeof(state) {
|
|
@@ -14478,7 +14964,7 @@ ${input.slice(result.pos)}
|
|
|
14478
14964
|
return result;
|
|
14479
14965
|
}
|
|
14480
14966
|
}
|
|
14481
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
14967
|
+
var Unless$0 = $TS($S($EXPECT($L157, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14482
14968
|
return { $loc, token: $1 };
|
|
14483
14969
|
});
|
|
14484
14970
|
function Unless(state) {
|
|
@@ -14503,7 +14989,7 @@ ${input.slice(result.pos)}
|
|
|
14503
14989
|
return result;
|
|
14504
14990
|
}
|
|
14505
14991
|
}
|
|
14506
|
-
var Until$0 = $TS($S($EXPECT($
|
|
14992
|
+
var Until$0 = $TS($S($EXPECT($L158, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14507
14993
|
return { $loc, token: $1 };
|
|
14508
14994
|
});
|
|
14509
14995
|
function Until(state) {
|
|
@@ -14528,7 +15014,7 @@ ${input.slice(result.pos)}
|
|
|
14528
15014
|
return result;
|
|
14529
15015
|
}
|
|
14530
15016
|
}
|
|
14531
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15017
|
+
var Var$0 = $TS($S($EXPECT($L159, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14532
15018
|
return { $loc, token: $1 };
|
|
14533
15019
|
});
|
|
14534
15020
|
function Var(state) {
|
|
@@ -14553,7 +15039,7 @@ ${input.slice(result.pos)}
|
|
|
14553
15039
|
return result;
|
|
14554
15040
|
}
|
|
14555
15041
|
}
|
|
14556
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15042
|
+
var Void$0 = $TS($S($EXPECT($L160, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14557
15043
|
return { $loc, token: $1 };
|
|
14558
15044
|
});
|
|
14559
15045
|
function Void(state) {
|
|
@@ -14578,7 +15064,7 @@ ${input.slice(result.pos)}
|
|
|
14578
15064
|
return result;
|
|
14579
15065
|
}
|
|
14580
15066
|
}
|
|
14581
|
-
var When$0 = $TS($S($EXPECT($
|
|
15067
|
+
var When$0 = $TS($S($EXPECT($L161, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14582
15068
|
return { $loc, token: "case" };
|
|
14583
15069
|
});
|
|
14584
15070
|
function When(state) {
|
|
@@ -14603,7 +15089,7 @@ ${input.slice(result.pos)}
|
|
|
14603
15089
|
return result;
|
|
14604
15090
|
}
|
|
14605
15091
|
}
|
|
14606
|
-
var While$0 = $TS($S($EXPECT($
|
|
15092
|
+
var While$0 = $TS($S($EXPECT($L162, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14607
15093
|
return { $loc, token: $1 };
|
|
14608
15094
|
});
|
|
14609
15095
|
function While(state) {
|
|
@@ -14628,7 +15114,7 @@ ${input.slice(result.pos)}
|
|
|
14628
15114
|
return result;
|
|
14629
15115
|
}
|
|
14630
15116
|
}
|
|
14631
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15117
|
+
var Yield$0 = $TS($S($EXPECT($L163, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14632
15118
|
return { $loc, token: $1 };
|
|
14633
15119
|
});
|
|
14634
15120
|
function Yield(state) {
|
|
@@ -14721,11 +15207,10 @@ ${input.slice(result.pos)}
|
|
|
14721
15207
|
}
|
|
14722
15208
|
}
|
|
14723
15209
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
14724
|
-
var JSXElement$1 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningElement, $E(JSXMixedChildren), JSXOptionalClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
15210
|
+
var JSXElement$1 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningElement, $E(JSXMixedChildren), JSXOptionalClosingElement, PopJSXStack), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14725
15211
|
var open = $2;
|
|
14726
15212
|
var children = $3;
|
|
14727
15213
|
var close = $4;
|
|
14728
|
-
module.JSXTagStack.pop();
|
|
14729
15214
|
if (!children)
|
|
14730
15215
|
return $skip;
|
|
14731
15216
|
$0 = $0.slice(1);
|
|
@@ -14774,7 +15259,7 @@ ${input.slice(result.pos)}
|
|
|
14774
15259
|
return result;
|
|
14775
15260
|
}
|
|
14776
15261
|
}
|
|
14777
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15262
|
+
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) {
|
|
14778
15263
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
14779
15264
|
});
|
|
14780
15265
|
function JSXSelfClosingElement(state) {
|
|
@@ -14825,7 +15310,32 @@ ${input.slice(result.pos)}
|
|
|
14825
15310
|
return result;
|
|
14826
15311
|
}
|
|
14827
15312
|
}
|
|
14828
|
-
var
|
|
15313
|
+
var PopJSXStack$0 = $TV($EXPECT($L18, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15314
|
+
module.JSXTagStack.pop();
|
|
15315
|
+
});
|
|
15316
|
+
function PopJSXStack(state) {
|
|
15317
|
+
let eventData;
|
|
15318
|
+
if (state.events) {
|
|
15319
|
+
const result = state.events.enter?.("PopJSXStack", state);
|
|
15320
|
+
if (result) {
|
|
15321
|
+
if (result.cache)
|
|
15322
|
+
return result.cache;
|
|
15323
|
+
eventData = result.data;
|
|
15324
|
+
}
|
|
15325
|
+
}
|
|
15326
|
+
if (state.tokenize) {
|
|
15327
|
+
const result = $TOKEN("PopJSXStack", state, PopJSXStack$0(state));
|
|
15328
|
+
if (state.events)
|
|
15329
|
+
state.events.exit?.("PopJSXStack", state, result, eventData);
|
|
15330
|
+
return result;
|
|
15331
|
+
} else {
|
|
15332
|
+
const result = PopJSXStack$0(state);
|
|
15333
|
+
if (state.events)
|
|
15334
|
+
state.events.exit?.("PopJSXStack", state, result, eventData);
|
|
15335
|
+
return result;
|
|
15336
|
+
}
|
|
15337
|
+
}
|
|
15338
|
+
var JSXOpeningElement$0 = $S($EXPECT($L131, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L29, fail, 'JSXOpeningElement ">"'));
|
|
14829
15339
|
function JSXOpeningElement(state) {
|
|
14830
15340
|
let eventData;
|
|
14831
15341
|
if (state.events) {
|
|
@@ -14877,7 +15387,7 @@ ${input.slice(result.pos)}
|
|
|
14877
15387
|
return result;
|
|
14878
15388
|
}
|
|
14879
15389
|
}
|
|
14880
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15390
|
+
var JSXClosingElement$0 = $S($EXPECT($L165, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L29, fail, 'JSXClosingElement ">"'));
|
|
14881
15391
|
function JSXClosingElement(state) {
|
|
14882
15392
|
let eventData;
|
|
14883
15393
|
if (state.events) {
|
|
@@ -14900,11 +15410,10 @@ ${input.slice(result.pos)}
|
|
|
14900
15410
|
return result;
|
|
14901
15411
|
}
|
|
14902
15412
|
}
|
|
14903
|
-
var JSXFragment$0 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningFragment, $E(JSXMixedChildren), JSXOptionalClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
15413
|
+
var JSXFragment$0 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningFragment, $E(JSXMixedChildren), JSXOptionalClosingFragment, PopJSXStack), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14904
15414
|
var open = $2;
|
|
14905
15415
|
var children = $3;
|
|
14906
15416
|
var close = $4;
|
|
14907
|
-
module.JSXTagStack.pop();
|
|
14908
15417
|
if (!children)
|
|
14909
15418
|
return $skip;
|
|
14910
15419
|
$0 = $0.slice(1);
|
|
@@ -14916,7 +15425,7 @@ ${input.slice(result.pos)}
|
|
|
14916
15425
|
];
|
|
14917
15426
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
14918
15427
|
});
|
|
14919
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15428
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L166, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14920
15429
|
var children = $3;
|
|
14921
15430
|
$0 = $0.slice(1);
|
|
14922
15431
|
return {
|
|
@@ -14947,7 +15456,7 @@ ${input.slice(result.pos)}
|
|
|
14947
15456
|
return result;
|
|
14948
15457
|
}
|
|
14949
15458
|
}
|
|
14950
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15459
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L166, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
14951
15460
|
module.JSXTagStack.push("");
|
|
14952
15461
|
return $1;
|
|
14953
15462
|
});
|
|
@@ -15001,7 +15510,7 @@ ${input.slice(result.pos)}
|
|
|
15001
15510
|
return result;
|
|
15002
15511
|
}
|
|
15003
15512
|
}
|
|
15004
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15513
|
+
var JSXClosingFragment$0 = $EXPECT($L167, fail, 'JSXClosingFragment "</>"');
|
|
15005
15514
|
function JSXClosingFragment(state) {
|
|
15006
15515
|
let eventData;
|
|
15007
15516
|
if (state.events) {
|
|
@@ -15477,7 +15986,7 @@ ${input.slice(result.pos)}
|
|
|
15477
15986
|
return result;
|
|
15478
15987
|
}
|
|
15479
15988
|
}
|
|
15480
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
15989
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R54, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15481
15990
|
return { $loc, token: $0 };
|
|
15482
15991
|
});
|
|
15483
15992
|
function InlineJSXUnaryOp(state) {
|
|
@@ -15897,7 +16406,7 @@ ${input.slice(result.pos)}
|
|
|
15897
16406
|
return result;
|
|
15898
16407
|
}
|
|
15899
16408
|
}
|
|
15900
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16409
|
+
var JSXComment$0 = $TS($S($EXPECT($L168, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L169, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
15901
16410
|
return ["{/*", $2, "*/}"];
|
|
15902
16411
|
});
|
|
15903
16412
|
function JSXComment(state) {
|
|
@@ -15922,7 +16431,7 @@ ${input.slice(result.pos)}
|
|
|
15922
16431
|
return result;
|
|
15923
16432
|
}
|
|
15924
16433
|
}
|
|
15925
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
16434
|
+
var JSXCommentContent$0 = $TR($EXPECT($R55, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15926
16435
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
15927
16436
|
});
|
|
15928
16437
|
function JSXCommentContent(state) {
|
|
@@ -15947,7 +16456,7 @@ ${input.slice(result.pos)}
|
|
|
15947
16456
|
return result;
|
|
15948
16457
|
}
|
|
15949
16458
|
}
|
|
15950
|
-
var JSXText$0 = $TR($EXPECT($
|
|
16459
|
+
var JSXText$0 = $TR($EXPECT($R56, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15951
16460
|
return {
|
|
15952
16461
|
type: "JSXText",
|
|
15953
16462
|
token: $0,
|
|
@@ -16195,7 +16704,7 @@ ${input.slice(result.pos)}
|
|
|
16195
16704
|
return result;
|
|
16196
16705
|
}
|
|
16197
16706
|
}
|
|
16198
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16707
|
+
var TypeKeyword$0 = $S($EXPECT($L170, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16199
16708
|
function TypeKeyword(state) {
|
|
16200
16709
|
let eventData;
|
|
16201
16710
|
if (state.events) {
|
|
@@ -16218,7 +16727,7 @@ ${input.slice(result.pos)}
|
|
|
16218
16727
|
return result;
|
|
16219
16728
|
}
|
|
16220
16729
|
}
|
|
16221
|
-
var Interface$0 = $S($EXPECT($
|
|
16730
|
+
var Interface$0 = $S($EXPECT($L171, fail, 'Interface "interface"'), NonIdContinue);
|
|
16222
16731
|
function Interface(state) {
|
|
16223
16732
|
let eventData;
|
|
16224
16733
|
if (state.events) {
|
|
@@ -16241,7 +16750,7 @@ ${input.slice(result.pos)}
|
|
|
16241
16750
|
return result;
|
|
16242
16751
|
}
|
|
16243
16752
|
}
|
|
16244
|
-
var Namespace$0 = $S($EXPECT($
|
|
16753
|
+
var Namespace$0 = $S($EXPECT($L172, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16245
16754
|
function Namespace(state) {
|
|
16246
16755
|
let eventData;
|
|
16247
16756
|
if (state.events) {
|
|
@@ -16489,7 +16998,7 @@ ${input.slice(result.pos)}
|
|
|
16489
16998
|
return result;
|
|
16490
16999
|
}
|
|
16491
17000
|
}
|
|
16492
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
17001
|
+
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)));
|
|
16493
17002
|
function TypeIndexSignature(state) {
|
|
16494
17003
|
let eventData;
|
|
16495
17004
|
if (state.events) {
|
|
@@ -16561,7 +17070,7 @@ ${input.slice(result.pos)}
|
|
|
16561
17070
|
return result;
|
|
16562
17071
|
}
|
|
16563
17072
|
}
|
|
16564
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
17073
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L173, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
16565
17074
|
const children = [...$1, $2];
|
|
16566
17075
|
if ($3)
|
|
16567
17076
|
children.push($3);
|
|
@@ -16720,10 +17229,10 @@ ${input.slice(result.pos)}
|
|
|
16720
17229
|
return result;
|
|
16721
17230
|
}
|
|
16722
17231
|
}
|
|
16723
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
16724
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
16725
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
16726
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17232
|
+
var TypeUnaryOp$0 = $S($EXPECT($L174, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17233
|
+
var TypeUnaryOp$1 = $S($EXPECT($L156, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17234
|
+
var TypeUnaryOp$2 = $S($EXPECT($L175, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17235
|
+
var TypeUnaryOp$3 = $S($EXPECT($L140, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
16727
17236
|
function TypeUnaryOp(state) {
|
|
16728
17237
|
let eventData;
|
|
16729
17238
|
if (state.events) {
|
|
@@ -16776,7 +17285,7 @@ ${input.slice(result.pos)}
|
|
|
16776
17285
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
16777
17286
|
var TypePrimary$5 = $S($E(_), TypeLiteral);
|
|
16778
17287
|
var TypePrimary$6 = $S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
16779
|
-
var TypePrimary$7 = $S(__, OpenParen, Type, __, CloseParen);
|
|
17288
|
+
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
16780
17289
|
function TypePrimary(state) {
|
|
16781
17290
|
let eventData;
|
|
16782
17291
|
if (state.events) {
|
|
@@ -16921,7 +17430,7 @@ ${input.slice(result.pos)}
|
|
|
16921
17430
|
return result;
|
|
16922
17431
|
}
|
|
16923
17432
|
}
|
|
16924
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17433
|
+
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) {
|
|
16925
17434
|
if ($2)
|
|
16926
17435
|
return $0;
|
|
16927
17436
|
return $1;
|
|
@@ -16950,10 +17459,10 @@ ${input.slice(result.pos)}
|
|
|
16950
17459
|
}
|
|
16951
17460
|
var TypeLiteral$0 = TemplateLiteral;
|
|
16952
17461
|
var TypeLiteral$1 = Literal;
|
|
16953
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17462
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L160, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16954
17463
|
return { $loc, token: "void" };
|
|
16955
17464
|
});
|
|
16956
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17465
|
+
var TypeLiteral$3 = $TV($EXPECT($L176, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
16957
17466
|
return { $loc, token: "[]" };
|
|
16958
17467
|
});
|
|
16959
17468
|
function TypeLiteral(state) {
|
|
@@ -17137,7 +17646,7 @@ ${input.slice(result.pos)}
|
|
|
17137
17646
|
return result;
|
|
17138
17647
|
}
|
|
17139
17648
|
}
|
|
17140
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17649
|
+
var TypeArguments$0 = $TS($S($EXPECT($L131, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L29, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17141
17650
|
return { ts: true, children: $0 };
|
|
17142
17651
|
});
|
|
17143
17652
|
function TypeArguments(state) {
|
|
@@ -17208,7 +17717,7 @@ ${input.slice(result.pos)}
|
|
|
17208
17717
|
return result;
|
|
17209
17718
|
}
|
|
17210
17719
|
}
|
|
17211
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17720
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L131, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L29, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17212
17721
|
var parameters = $3;
|
|
17213
17722
|
return {
|
|
17214
17723
|
type: "TypeParameters",
|
|
@@ -17262,7 +17771,7 @@ ${input.slice(result.pos)}
|
|
|
17262
17771
|
return result;
|
|
17263
17772
|
}
|
|
17264
17773
|
}
|
|
17265
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17774
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L119, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17266
17775
|
function TypeConstraint(state) {
|
|
17267
17776
|
let eventData;
|
|
17268
17777
|
if (state.events) {
|
|
@@ -17360,7 +17869,7 @@ ${input.slice(result.pos)}
|
|
|
17360
17869
|
return result;
|
|
17361
17870
|
}
|
|
17362
17871
|
}
|
|
17363
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
17872
|
+
var Shebang$0 = $S($R$0($EXPECT($R59, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
17364
17873
|
function Shebang(state) {
|
|
17365
17874
|
let eventData;
|
|
17366
17875
|
if (state.events) {
|
|
@@ -17383,11 +17892,11 @@ ${input.slice(result.pos)}
|
|
|
17383
17892
|
return result;
|
|
17384
17893
|
}
|
|
17385
17894
|
}
|
|
17386
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
17895
|
+
var CivetPrologue$0 = $T($S($EXPECT($R60, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17387
17896
|
var content = value[2];
|
|
17388
17897
|
return content;
|
|
17389
17898
|
});
|
|
17390
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
17899
|
+
var CivetPrologue$1 = $T($S($EXPECT($R60, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17391
17900
|
var content = value[2];
|
|
17392
17901
|
return content;
|
|
17393
17902
|
});
|
|
@@ -17413,7 +17922,7 @@ ${input.slice(result.pos)}
|
|
|
17413
17922
|
return result;
|
|
17414
17923
|
}
|
|
17415
17924
|
}
|
|
17416
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
17925
|
+
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) {
|
|
17417
17926
|
var options = $3;
|
|
17418
17927
|
return {
|
|
17419
17928
|
type: "CivetPrologue",
|
|
@@ -17443,7 +17952,7 @@ ${input.slice(result.pos)}
|
|
|
17443
17952
|
return result;
|
|
17444
17953
|
}
|
|
17445
17954
|
}
|
|
17446
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
17955
|
+
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) {
|
|
17447
17956
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
17448
17957
|
if (l)
|
|
17449
17958
|
return l.toUpperCase();
|
|
@@ -17479,7 +17988,7 @@ ${input.slice(result.pos)}
|
|
|
17479
17988
|
return result;
|
|
17480
17989
|
}
|
|
17481
17990
|
}
|
|
17482
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
17991
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R60, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
17483
17992
|
function UnknownPrologue(state) {
|
|
17484
17993
|
let eventData;
|
|
17485
17994
|
if (state.events) {
|
|
@@ -17549,7 +18058,7 @@ ${input.slice(result.pos)}
|
|
|
17549
18058
|
return result;
|
|
17550
18059
|
}
|
|
17551
18060
|
}
|
|
17552
|
-
var EOL$0 = $TR($EXPECT($
|
|
18061
|
+
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) {
|
|
17553
18062
|
return { $loc, token: $0 };
|
|
17554
18063
|
});
|
|
17555
18064
|
function EOL(state) {
|
|
@@ -17574,13 +18083,13 @@ ${input.slice(result.pos)}
|
|
|
17574
18083
|
return result;
|
|
17575
18084
|
}
|
|
17576
18085
|
}
|
|
17577
|
-
var
|
|
18086
|
+
var DebugHere$0 = $TV($EXPECT($L18, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
17578
18087
|
debugger;
|
|
17579
18088
|
});
|
|
17580
|
-
function
|
|
18089
|
+
function DebugHere(state) {
|
|
17581
18090
|
let eventData;
|
|
17582
18091
|
if (state.events) {
|
|
17583
|
-
const result = state.events.enter?.("
|
|
18092
|
+
const result = state.events.enter?.("DebugHere", state);
|
|
17584
18093
|
if (result) {
|
|
17585
18094
|
if (result.cache)
|
|
17586
18095
|
return result.cache;
|
|
@@ -17588,14 +18097,14 @@ ${input.slice(result.pos)}
|
|
|
17588
18097
|
}
|
|
17589
18098
|
}
|
|
17590
18099
|
if (state.tokenize) {
|
|
17591
|
-
const result = $TOKEN("
|
|
18100
|
+
const result = $TOKEN("DebugHere", state, DebugHere$0(state));
|
|
17592
18101
|
if (state.events)
|
|
17593
|
-
state.events.exit?.("
|
|
18102
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
17594
18103
|
return result;
|
|
17595
18104
|
} else {
|
|
17596
|
-
const result =
|
|
18105
|
+
const result = DebugHere$0(state);
|
|
17597
18106
|
if (state.events)
|
|
17598
|
-
state.events.exit?.("
|
|
18107
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
17599
18108
|
return result;
|
|
17600
18109
|
}
|
|
17601
18110
|
}
|
|
@@ -18432,7 +18941,9 @@ ${input.slice(result.pos)}
|
|
|
18432
18941
|
level: 0,
|
|
18433
18942
|
token: ""
|
|
18434
18943
|
}];
|
|
18435
|
-
module.
|
|
18944
|
+
module.forbidIndentedApplication = [false];
|
|
18945
|
+
module.forbidTrailingMemberProperty = [false];
|
|
18946
|
+
module.forbidMultiLineImplicitObjectLiteral = [false];
|
|
18436
18947
|
module.JSXTagStack = [];
|
|
18437
18948
|
module.operators = /* @__PURE__ */ new Set();
|
|
18438
18949
|
if (!module._init) {
|
|
@@ -18444,9 +18955,21 @@ ${input.slice(result.pos)}
|
|
|
18444
18955
|
return l[l.length - 1];
|
|
18445
18956
|
}
|
|
18446
18957
|
},
|
|
18447
|
-
|
|
18958
|
+
indentedApplicationForbidden: {
|
|
18448
18959
|
get() {
|
|
18449
|
-
const {
|
|
18960
|
+
const { forbidIndentedApplication: s } = module;
|
|
18961
|
+
return s[s.length - 1];
|
|
18962
|
+
}
|
|
18963
|
+
},
|
|
18964
|
+
trailingMemberPropertyForbidden: {
|
|
18965
|
+
get() {
|
|
18966
|
+
const { forbidTrailingMemberProperty: s } = module;
|
|
18967
|
+
return s[s.length - 1];
|
|
18968
|
+
}
|
|
18969
|
+
},
|
|
18970
|
+
multiLineImplicitObjectLiteralForbidden: {
|
|
18971
|
+
get() {
|
|
18972
|
+
const { forbidMultiLineImplicitObjectLiteral: s } = module;
|
|
18450
18973
|
return s[s.length - 1];
|
|
18451
18974
|
}
|
|
18452
18975
|
},
|
|
@@ -19438,7 +19961,12 @@ ${input.slice(result.pos)}
|
|
|
19438
19961
|
names
|
|
19439
19962
|
};
|
|
19440
19963
|
}
|
|
19441
|
-
|
|
19964
|
+
return {
|
|
19965
|
+
children: [{
|
|
19966
|
+
type: "Error",
|
|
19967
|
+
message: "Multiple rest properties in object pattern"
|
|
19968
|
+
}, props2]
|
|
19969
|
+
};
|
|
19442
19970
|
};
|
|
19443
19971
|
function gatherNodes(node, predicate) {
|
|
19444
19972
|
if (node == null)
|
|
@@ -19578,7 +20106,7 @@ ${input.slice(result.pos)}
|
|
|
19578
20106
|
}
|
|
19579
20107
|
function processAssignments(statements) {
|
|
19580
20108
|
gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
|
|
19581
|
-
let { lhs: $12, exp: $22 } = exp,
|
|
20109
|
+
let { lhs: $12, exp: $22 } = exp, tail = [], i = 0, len = $12.length;
|
|
19582
20110
|
if ($12.some((left) => left[left.length - 1].special)) {
|
|
19583
20111
|
if ($12.length !== 1) {
|
|
19584
20112
|
throw new Error("Only one assignment with id= is allowed");
|
|
@@ -19588,17 +20116,6 @@ ${input.slice(result.pos)}
|
|
|
19588
20116
|
op[op.length - 1] = "=";
|
|
19589
20117
|
$22 = [call, "(", lhs, ", ", $22, ")"];
|
|
19590
20118
|
}
|
|
19591
|
-
$12.forEach((lhsPart, i2) => {
|
|
19592
|
-
let expr = lhsPart[1];
|
|
19593
|
-
while (expr.type === "ParenthesizedExpression") {
|
|
19594
|
-
expr = expr.expression;
|
|
19595
|
-
}
|
|
19596
|
-
if (expr.type === "AssignmentExpression") {
|
|
19597
|
-
pre.push([lhsPart[1], ", "]);
|
|
19598
|
-
const newLhs = expr.lhs[0][1];
|
|
19599
|
-
lhsPart[1] = newLhs;
|
|
19600
|
-
}
|
|
19601
|
-
});
|
|
19602
20119
|
let wrapped = false;
|
|
19603
20120
|
while (i < len) {
|
|
19604
20121
|
const lastAssignment = $12[i++];
|
|
@@ -19649,9 +20166,49 @@ ${input.slice(result.pos)}
|
|
|
19649
20166
|
i--;
|
|
19650
20167
|
}
|
|
19651
20168
|
const names = $12.flatMap(([, l]) => l.names || []);
|
|
19652
|
-
exp.children = [
|
|
20169
|
+
exp.children = [$12, $22, ...tail];
|
|
19653
20170
|
exp.names = names;
|
|
19654
20171
|
});
|
|
20172
|
+
gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
|
|
20173
|
+
function extractAssignment(lhs) {
|
|
20174
|
+
let expr = lhs;
|
|
20175
|
+
while (expr.type === "ParenthesizedExpression") {
|
|
20176
|
+
expr = expr.expression;
|
|
20177
|
+
}
|
|
20178
|
+
if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
|
|
20179
|
+
if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
|
|
20180
|
+
post.push([", ", lhs]);
|
|
20181
|
+
} else {
|
|
20182
|
+
pre.push([lhs, ", "]);
|
|
20183
|
+
}
|
|
20184
|
+
return expr.assigned;
|
|
20185
|
+
}
|
|
20186
|
+
}
|
|
20187
|
+
const pre = [], post = [];
|
|
20188
|
+
switch (exp.type) {
|
|
20189
|
+
case "AssignmentExpression":
|
|
20190
|
+
if (!exp.lhs)
|
|
20191
|
+
return;
|
|
20192
|
+
exp.lhs.forEach((lhsPart, i) => {
|
|
20193
|
+
let newLhs2 = extractAssignment(lhsPart[1]);
|
|
20194
|
+
if (newLhs2) {
|
|
20195
|
+
lhsPart[1] = newLhs2;
|
|
20196
|
+
}
|
|
20197
|
+
});
|
|
20198
|
+
break;
|
|
20199
|
+
case "UpdateExpression":
|
|
20200
|
+
let newLhs = extractAssignment(exp.assigned);
|
|
20201
|
+
if (newLhs) {
|
|
20202
|
+
const i = exp.children.indexOf(exp.assigned);
|
|
20203
|
+
exp.assigned = exp.children[i] = newLhs;
|
|
20204
|
+
}
|
|
20205
|
+
break;
|
|
20206
|
+
}
|
|
20207
|
+
if (pre.length)
|
|
20208
|
+
exp.children.unshift(...pre);
|
|
20209
|
+
if (post.length)
|
|
20210
|
+
exp.children.push(...post);
|
|
20211
|
+
});
|
|
19655
20212
|
}
|
|
19656
20213
|
function checkSpliceRef(statements) {
|
|
19657
20214
|
const spliceRef = module.getRef("splice");
|
|
@@ -20298,7 +20855,7 @@ ${input.slice(result.pos)}
|
|
|
20298
20855
|
return result;
|
|
20299
20856
|
}
|
|
20300
20857
|
}
|
|
20301
|
-
var Indent$0 = $TR($EXPECT($
|
|
20858
|
+
var Indent$0 = $TR($EXPECT($R64, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
20302
20859
|
let level;
|
|
20303
20860
|
if (module.config.tab) {
|
|
20304
20861
|
const tabs = $0.match(/\t/g);
|
|
@@ -20945,7 +21502,7 @@ var parse;
|
|
|
20945
21502
|
var uncacheable;
|
|
20946
21503
|
({ parse } = import_parser.default);
|
|
20947
21504
|
({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
|
|
20948
|
-
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", "
|
|
21505
|
+
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"]);
|
|
20949
21506
|
var compile = function(src, options) {
|
|
20950
21507
|
var ast, code, events, filename, ref, result, sm, srcMapJSON;
|
|
20951
21508
|
if (!options) {
|
|
@@ -20982,7 +21539,9 @@ ${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode2(JSON.stri
|
|
|
20982
21539
|
}
|
|
20983
21540
|
result = generate_default(ast, options);
|
|
20984
21541
|
if ((ref = options.errors) != null ? ref.length : void 0) {
|
|
20985
|
-
throw new Error(`Parse errors: ${options.errors.
|
|
21542
|
+
throw new Error(`Parse errors: ${options.errors.map(function(e) {
|
|
21543
|
+
return e.message;
|
|
21544
|
+
}).join("\n")} `);
|
|
20986
21545
|
}
|
|
20987
21546
|
return result;
|
|
20988
21547
|
};
|