@danielx/civet 0.5.70 → 0.5.71
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 +678 -488
- package/dist/civet +8 -1
- package/dist/main.js +678 -488
- package/dist/main.mjs +678 -488
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -500,6 +500,8 @@ ${input.slice(result.pos)}
|
|
|
500
500
|
AtThis,
|
|
501
501
|
LeftHandSideExpression,
|
|
502
502
|
CallExpression,
|
|
503
|
+
ReturnValue,
|
|
504
|
+
AfterReturnShorthand,
|
|
503
505
|
CallExpressionRest,
|
|
504
506
|
OptionalShorthand,
|
|
505
507
|
OptionalDot,
|
|
@@ -1042,170 +1044,171 @@ ${input.slice(result.pos)}
|
|
|
1042
1044
|
var $L11 = $L("#");
|
|
1043
1045
|
var $L12 = $L("super");
|
|
1044
1046
|
var $L13 = $L("import");
|
|
1045
|
-
var $L14 = $L("
|
|
1046
|
-
var $L15 = $L("
|
|
1047
|
-
var $L16 = $L("
|
|
1048
|
-
var $L17 = $L("
|
|
1049
|
-
var $L18 = $L("");
|
|
1050
|
-
var $L19 = $L("
|
|
1051
|
-
var $L20 = $L("
|
|
1052
|
-
var $L21 = $L("
|
|
1053
|
-
var $L22 = $L("
|
|
1054
|
-
var $L23 = $L("
|
|
1055
|
-
var $L24 = $L("
|
|
1056
|
-
var $L25 = $L("
|
|
1057
|
-
var $L26 = $L("
|
|
1058
|
-
var $L27 = $L("
|
|
1059
|
-
var $L28 = $L("
|
|
1060
|
-
var $L29 = $L("
|
|
1061
|
-
var $L30 = $L("
|
|
1062
|
-
var $L31 = $L("
|
|
1063
|
-
var $L32 = $L("
|
|
1064
|
-
var $L33 = $L("
|
|
1065
|
-
var $L34 = $L("
|
|
1066
|
-
var $L35 = $L("
|
|
1067
|
-
var $L36 = $L("
|
|
1068
|
-
var $L37 = $L("
|
|
1069
|
-
var $L38 = $L("
|
|
1070
|
-
var $L39 = $L("
|
|
1071
|
-
var $L40 = $L("
|
|
1072
|
-
var $L41 = $L("
|
|
1073
|
-
var $L42 = $L("
|
|
1074
|
-
var $L43 = $L("
|
|
1075
|
-
var $L44 = $L("
|
|
1076
|
-
var $L45 = $L("
|
|
1077
|
-
var $L46 = $L("
|
|
1078
|
-
var $L47 = $L("
|
|
1079
|
-
var $L48 = $L("
|
|
1080
|
-
var $L49 = $L("
|
|
1081
|
-
var $L50 = $L("
|
|
1082
|
-
var $L51 = $L("
|
|
1083
|
-
var $L52 = $L("
|
|
1084
|
-
var $L53 = $L("
|
|
1085
|
-
var $L54 = $L("
|
|
1086
|
-
var $L55 = $L("
|
|
1087
|
-
var $L56 = $L("
|
|
1088
|
-
var $L57 = $L("
|
|
1089
|
-
var $L58 = $L("
|
|
1090
|
-
var $L59 = $L("
|
|
1091
|
-
var $L60 = $L("
|
|
1092
|
-
var $L61 = $L("
|
|
1093
|
-
var $L62 = $L("
|
|
1094
|
-
var $L63 = $L("
|
|
1095
|
-
var $L64 = $L("
|
|
1096
|
-
var $L65 = $L("
|
|
1097
|
-
var $L66 = $L("
|
|
1098
|
-
var $L67 = $L("
|
|
1099
|
-
var $L68 = $L("
|
|
1100
|
-
var $L69 = $L("
|
|
1101
|
-
var $L70 = $L("
|
|
1102
|
-
var $L71 = $L("
|
|
1103
|
-
var $L72 = $L("
|
|
1104
|
-
var $L73 = $L("
|
|
1105
|
-
var $L74 = $L("
|
|
1106
|
-
var $L75 = $L("
|
|
1107
|
-
var $L76 = $L("
|
|
1108
|
-
var $L77 = $L("
|
|
1109
|
-
var $L78 = $L("
|
|
1110
|
-
var $L79 = $L("
|
|
1111
|
-
var $L80 = $L("
|
|
1112
|
-
var $L81 = $L("
|
|
1113
|
-
var $L82 = $L("
|
|
1114
|
-
var $L83 = $L("
|
|
1115
|
-
var $L84 = $L("
|
|
1116
|
-
var $L85 = $L("
|
|
1117
|
-
var $L86 = $L("
|
|
1118
|
-
var $L87 = $L("
|
|
1119
|
-
var $L88 = $L("
|
|
1120
|
-
var $L89 = $L("
|
|
1121
|
-
var $L90 = $L("
|
|
1122
|
-
var $L91 = $L("
|
|
1123
|
-
var $L92 = $L("
|
|
1124
|
-
var $L93 = $L("
|
|
1125
|
-
var $L94 = $L("
|
|
1126
|
-
var $L95 = $L("
|
|
1127
|
-
var $L96 = $L("
|
|
1128
|
-
var $L97 = $L("
|
|
1129
|
-
var $L98 = $L("
|
|
1130
|
-
var $L99 = $L("
|
|
1131
|
-
var $L100 = $L("
|
|
1132
|
-
var $L101 = $L("
|
|
1133
|
-
var $L102 = $L("
|
|
1134
|
-
var $L103 = $L("
|
|
1135
|
-
var $L104 = $L("
|
|
1136
|
-
var $L105 = $L("
|
|
1137
|
-
var $L106 = $L("
|
|
1138
|
-
var $L107 = $L("
|
|
1139
|
-
var $L108 = $L("
|
|
1140
|
-
var $L109 = $L("
|
|
1141
|
-
var $L110 = $L("
|
|
1142
|
-
var $L111 = $L("
|
|
1143
|
-
var $L112 = $L("
|
|
1144
|
-
var $L113 = $L("
|
|
1145
|
-
var $L114 = $L("
|
|
1146
|
-
var $L115 = $L("
|
|
1147
|
-
var $L116 = $L(
|
|
1148
|
-
var $L117 = $L("
|
|
1149
|
-
var $L118 = $L("
|
|
1150
|
-
var $L119 = $L("
|
|
1151
|
-
var $L120 = $L("
|
|
1152
|
-
var $L121 = $L("
|
|
1153
|
-
var $L122 = $L("
|
|
1154
|
-
var $L123 = $L("
|
|
1155
|
-
var $L124 = $L("
|
|
1156
|
-
var $L125 = $L("
|
|
1157
|
-
var $L126 = $L("
|
|
1158
|
-
var $L127 = $L("
|
|
1159
|
-
var $L128 = $L("
|
|
1160
|
-
var $L129 = $L("
|
|
1161
|
-
var $L130 = $L("
|
|
1162
|
-
var $L131 = $L("
|
|
1163
|
-
var $L132 = $L("
|
|
1164
|
-
var $L133 = $L("
|
|
1165
|
-
var $L134 = $L("
|
|
1166
|
-
var $L135 = $L("
|
|
1167
|
-
var $L136 = $L("
|
|
1168
|
-
var $L137 = $L("
|
|
1169
|
-
var $L138 = $L("
|
|
1170
|
-
var $L139 = $L("
|
|
1171
|
-
var $L140 = $L("
|
|
1172
|
-
var $L141 = $L("
|
|
1173
|
-
var $L142 = $L("
|
|
1174
|
-
var $L143 = $L("
|
|
1175
|
-
var $L144 = $L("
|
|
1176
|
-
var $L145 = $L("
|
|
1177
|
-
var $L146 = $L("
|
|
1178
|
-
var $L147 = $L("
|
|
1179
|
-
var $L148 = $L("
|
|
1180
|
-
var $L149 = $L("
|
|
1181
|
-
var $L150 = $L("
|
|
1182
|
-
var $L151 = $L(
|
|
1183
|
-
var $L152 = $L("'
|
|
1184
|
-
var $L153 = $L("
|
|
1185
|
-
var $L154 = $L("
|
|
1186
|
-
var $L155 = $L("
|
|
1187
|
-
var $L156 = $L("
|
|
1188
|
-
var $L157 = $L("
|
|
1189
|
-
var $L158 = $L("
|
|
1190
|
-
var $L159 = $L("
|
|
1191
|
-
var $L160 = $L("
|
|
1192
|
-
var $L161 = $L("
|
|
1193
|
-
var $L162 = $L("
|
|
1194
|
-
var $L163 = $L("
|
|
1195
|
-
var $L164 = $L("
|
|
1196
|
-
var $L165 = $L("
|
|
1197
|
-
var $L166 = $L("
|
|
1198
|
-
var $L167 = $L("
|
|
1199
|
-
var $L168 = $L("
|
|
1200
|
-
var $L169 = $L("
|
|
1201
|
-
var $L170 = $L("
|
|
1202
|
-
var $L171 = $L("
|
|
1203
|
-
var $L172 = $L("
|
|
1204
|
-
var $L173 = $L("
|
|
1205
|
-
var $L174 = $L("
|
|
1206
|
-
var $L175 = $L("
|
|
1207
|
-
var $L176 = $L("
|
|
1208
|
-
var $L177 = $L("
|
|
1047
|
+
var $L14 = $L("return.value");
|
|
1048
|
+
var $L15 = $L("!");
|
|
1049
|
+
var $L16 = $L("^");
|
|
1050
|
+
var $L17 = $L("-");
|
|
1051
|
+
var $L18 = $L("import.meta");
|
|
1052
|
+
var $L19 = $L("");
|
|
1053
|
+
var $L20 = $L(",");
|
|
1054
|
+
var $L21 = $L("->");
|
|
1055
|
+
var $L22 = $L("}");
|
|
1056
|
+
var $L23 = $L("null");
|
|
1057
|
+
var $L24 = $L("true");
|
|
1058
|
+
var $L25 = $L("false");
|
|
1059
|
+
var $L26 = $L("yes");
|
|
1060
|
+
var $L27 = $L("on");
|
|
1061
|
+
var $L28 = $L("no");
|
|
1062
|
+
var $L29 = $L("off");
|
|
1063
|
+
var $L30 = $L(">");
|
|
1064
|
+
var $L31 = $L("]");
|
|
1065
|
+
var $L32 = $L(":");
|
|
1066
|
+
var $L33 = $L(")");
|
|
1067
|
+
var $L34 = $L("**=");
|
|
1068
|
+
var $L35 = $L("*=");
|
|
1069
|
+
var $L36 = $L("/=");
|
|
1070
|
+
var $L37 = $L("%=");
|
|
1071
|
+
var $L38 = $L("+=");
|
|
1072
|
+
var $L39 = $L("-=");
|
|
1073
|
+
var $L40 = $L("<<=");
|
|
1074
|
+
var $L41 = $L(">>>=");
|
|
1075
|
+
var $L42 = $L(">>=");
|
|
1076
|
+
var $L43 = $L("&&=");
|
|
1077
|
+
var $L44 = $L("&=");
|
|
1078
|
+
var $L45 = $L("^=");
|
|
1079
|
+
var $L46 = $L("||=");
|
|
1080
|
+
var $L47 = $L("|=");
|
|
1081
|
+
var $L48 = $L("??=");
|
|
1082
|
+
var $L49 = $L("?=");
|
|
1083
|
+
var $L50 = $L("and=");
|
|
1084
|
+
var $L51 = $L("or=");
|
|
1085
|
+
var $L52 = $L("not");
|
|
1086
|
+
var $L53 = $L("**");
|
|
1087
|
+
var $L54 = $L("*");
|
|
1088
|
+
var $L55 = $L("/");
|
|
1089
|
+
var $L56 = $L("%%");
|
|
1090
|
+
var $L57 = $L("%");
|
|
1091
|
+
var $L58 = $L("+");
|
|
1092
|
+
var $L59 = $L("<=");
|
|
1093
|
+
var $L60 = $L(">=");
|
|
1094
|
+
var $L61 = $L("<?");
|
|
1095
|
+
var $L62 = $L("!<?");
|
|
1096
|
+
var $L63 = $L("<<");
|
|
1097
|
+
var $L64 = $L(">>>");
|
|
1098
|
+
var $L65 = $L(">>");
|
|
1099
|
+
var $L66 = $L("!==");
|
|
1100
|
+
var $L67 = $L("!=");
|
|
1101
|
+
var $L68 = $L("isnt");
|
|
1102
|
+
var $L69 = $L("===");
|
|
1103
|
+
var $L70 = $L("==");
|
|
1104
|
+
var $L71 = $L("and");
|
|
1105
|
+
var $L72 = $L("&&");
|
|
1106
|
+
var $L73 = $L("of");
|
|
1107
|
+
var $L74 = $L("or");
|
|
1108
|
+
var $L75 = $L("||");
|
|
1109
|
+
var $L76 = $L("^^");
|
|
1110
|
+
var $L77 = $L("xor");
|
|
1111
|
+
var $L78 = $L("xnor");
|
|
1112
|
+
var $L79 = $L("??");
|
|
1113
|
+
var $L80 = $L("instanceof");
|
|
1114
|
+
var $L81 = $L("in");
|
|
1115
|
+
var $L82 = $L("is");
|
|
1116
|
+
var $L83 = $L("&");
|
|
1117
|
+
var $L84 = $L("|");
|
|
1118
|
+
var $L85 = $L(";");
|
|
1119
|
+
var $L86 = $L("$:");
|
|
1120
|
+
var $L87 = $L("own");
|
|
1121
|
+
var $L88 = $L("break");
|
|
1122
|
+
var $L89 = $L("continue");
|
|
1123
|
+
var $L90 = $L("debugger");
|
|
1124
|
+
var $L91 = $L("assert");
|
|
1125
|
+
var $L92 = $L(":=");
|
|
1126
|
+
var $L93 = $L(".=");
|
|
1127
|
+
var $L94 = $L("/*");
|
|
1128
|
+
var $L95 = $L("*/");
|
|
1129
|
+
var $L96 = $L("\\");
|
|
1130
|
+
var $L97 = $L("[");
|
|
1131
|
+
var $L98 = $L("`");
|
|
1132
|
+
var $L99 = $L("abstract");
|
|
1133
|
+
var $L100 = $L("as");
|
|
1134
|
+
var $L101 = $L("@");
|
|
1135
|
+
var $L102 = $L("@@");
|
|
1136
|
+
var $L103 = $L("async");
|
|
1137
|
+
var $L104 = $L("await");
|
|
1138
|
+
var $L105 = $L("by");
|
|
1139
|
+
var $L106 = $L("case");
|
|
1140
|
+
var $L107 = $L("catch");
|
|
1141
|
+
var $L108 = $L("class");
|
|
1142
|
+
var $L109 = $L("#{");
|
|
1143
|
+
var $L110 = $L("declare");
|
|
1144
|
+
var $L111 = $L("default");
|
|
1145
|
+
var $L112 = $L("delete");
|
|
1146
|
+
var $L113 = $L("do");
|
|
1147
|
+
var $L114 = $L("..");
|
|
1148
|
+
var $L115 = $L("...");
|
|
1149
|
+
var $L116 = $L("::");
|
|
1150
|
+
var $L117 = $L('"');
|
|
1151
|
+
var $L118 = $L("else");
|
|
1152
|
+
var $L119 = $L("export");
|
|
1153
|
+
var $L120 = $L("extends");
|
|
1154
|
+
var $L121 = $L("finally");
|
|
1155
|
+
var $L122 = $L("for");
|
|
1156
|
+
var $L123 = $L("from");
|
|
1157
|
+
var $L124 = $L("function");
|
|
1158
|
+
var $L125 = $L("get");
|
|
1159
|
+
var $L126 = $L("set");
|
|
1160
|
+
var $L127 = $L("if");
|
|
1161
|
+
var $L128 = $L("let");
|
|
1162
|
+
var $L129 = $L("const");
|
|
1163
|
+
var $L130 = $L("loop");
|
|
1164
|
+
var $L131 = $L("new");
|
|
1165
|
+
var $L132 = $L("<");
|
|
1166
|
+
var $L133 = $L("{");
|
|
1167
|
+
var $L134 = $L("operator");
|
|
1168
|
+
var $L135 = $L("public");
|
|
1169
|
+
var $L136 = $L("private");
|
|
1170
|
+
var $L137 = $L("protected");
|
|
1171
|
+
var $L138 = $L("||>");
|
|
1172
|
+
var $L139 = $L("|>=");
|
|
1173
|
+
var $L140 = $L("|>");
|
|
1174
|
+
var $L141 = $L("readonly");
|
|
1175
|
+
var $L142 = $L("return");
|
|
1176
|
+
var $L143 = $L("satisfies");
|
|
1177
|
+
var $L144 = $L("'");
|
|
1178
|
+
var $L145 = $L("static");
|
|
1179
|
+
var $L146 = $L("${");
|
|
1180
|
+
var $L147 = $L("switch");
|
|
1181
|
+
var $L148 = $L("target");
|
|
1182
|
+
var $L149 = $L("then");
|
|
1183
|
+
var $L150 = $L("this");
|
|
1184
|
+
var $L151 = $L("throw");
|
|
1185
|
+
var $L152 = $L('"""');
|
|
1186
|
+
var $L153 = $L("'''");
|
|
1187
|
+
var $L154 = $L("///");
|
|
1188
|
+
var $L155 = $L("```");
|
|
1189
|
+
var $L156 = $L("try");
|
|
1190
|
+
var $L157 = $L("typeof");
|
|
1191
|
+
var $L158 = $L("unless");
|
|
1192
|
+
var $L159 = $L("until");
|
|
1193
|
+
var $L160 = $L("var");
|
|
1194
|
+
var $L161 = $L("void");
|
|
1195
|
+
var $L162 = $L("when");
|
|
1196
|
+
var $L163 = $L("while");
|
|
1197
|
+
var $L164 = $L("yield");
|
|
1198
|
+
var $L165 = $L("/>");
|
|
1199
|
+
var $L166 = $L("</");
|
|
1200
|
+
var $L167 = $L("<>");
|
|
1201
|
+
var $L168 = $L("</>");
|
|
1202
|
+
var $L169 = $L("<!--");
|
|
1203
|
+
var $L170 = $L("-->");
|
|
1204
|
+
var $L171 = $L("type");
|
|
1205
|
+
var $L172 = $L("interface");
|
|
1206
|
+
var $L173 = $L("namespace");
|
|
1207
|
+
var $L174 = $L("asserts");
|
|
1208
|
+
var $L175 = $L("keyof");
|
|
1209
|
+
var $L176 = $L("infer");
|
|
1210
|
+
var $L177 = $L("[]");
|
|
1211
|
+
var $L178 = $L("civet");
|
|
1209
1212
|
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1210
1213
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1211
1214
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -2375,7 +2378,7 @@ ${input.slice(result.pos)}
|
|
|
2375
2378
|
return {
|
|
2376
2379
|
type: "ArrowFunction",
|
|
2377
2380
|
parameters,
|
|
2378
|
-
returnType: suffix
|
|
2381
|
+
returnType: suffix,
|
|
2379
2382
|
ts: false,
|
|
2380
2383
|
block: expOrBlock,
|
|
2381
2384
|
children: $0
|
|
@@ -3163,7 +3166,7 @@ ${input.slice(result.pos)}
|
|
|
3163
3166
|
return result;
|
|
3164
3167
|
}
|
|
3165
3168
|
}
|
|
3166
|
-
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName,
|
|
3169
|
+
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, $E(_), Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3167
3170
|
var id = $2;
|
|
3168
3171
|
var exp = $6;
|
|
3169
3172
|
switch (exp.type) {
|
|
@@ -3308,7 +3311,8 @@ ${input.slice(result.pos)}
|
|
|
3308
3311
|
children: [$1, ...$2, ...rest.flat()]
|
|
3309
3312
|
});
|
|
3310
3313
|
});
|
|
3311
|
-
var CallExpression$2 =
|
|
3314
|
+
var CallExpression$2 = ReturnValue;
|
|
3315
|
+
var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3312
3316
|
var member = $1;
|
|
3313
3317
|
var trailing = $2;
|
|
3314
3318
|
var rest = $3;
|
|
@@ -3332,17 +3336,69 @@ ${input.slice(result.pos)}
|
|
|
3332
3336
|
}
|
|
3333
3337
|
}
|
|
3334
3338
|
if (state.tokenize) {
|
|
3335
|
-
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
3339
|
+
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state));
|
|
3336
3340
|
if (state.events)
|
|
3337
3341
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3338
3342
|
return result;
|
|
3339
3343
|
} else {
|
|
3340
|
-
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
|
|
3344
|
+
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state);
|
|
3341
3345
|
if (state.events)
|
|
3342
3346
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3343
3347
|
return result;
|
|
3344
3348
|
}
|
|
3345
3349
|
}
|
|
3350
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L14, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
3351
|
+
return { type: "ReturnValue", children: [$1[0]] };
|
|
3352
|
+
});
|
|
3353
|
+
function ReturnValue(state) {
|
|
3354
|
+
let eventData;
|
|
3355
|
+
if (state.events) {
|
|
3356
|
+
const result = state.events.enter?.("ReturnValue", state);
|
|
3357
|
+
if (result) {
|
|
3358
|
+
if (result.cache)
|
|
3359
|
+
return result.cache;
|
|
3360
|
+
eventData = result.data;
|
|
3361
|
+
}
|
|
3362
|
+
}
|
|
3363
|
+
if (state.tokenize) {
|
|
3364
|
+
const result = $TOKEN("ReturnValue", state, ReturnValue$0(state));
|
|
3365
|
+
if (state.events)
|
|
3366
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3367
|
+
return result;
|
|
3368
|
+
} else {
|
|
3369
|
+
const result = ReturnValue$0(state);
|
|
3370
|
+
if (state.events)
|
|
3371
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3372
|
+
return result;
|
|
3373
|
+
}
|
|
3374
|
+
}
|
|
3375
|
+
var AfterReturnShorthand$0 = WAssignmentOp;
|
|
3376
|
+
var AfterReturnShorthand$1 = UpdateExpressionSymbol;
|
|
3377
|
+
var AfterReturnShorthand$2 = TypeSuffix;
|
|
3378
|
+
var AfterReturnShorthand$3 = $S(__, LetAssignment);
|
|
3379
|
+
var AfterReturnShorthand$4 = $S(__, ConstAssignment);
|
|
3380
|
+
function AfterReturnShorthand(state) {
|
|
3381
|
+
let eventData;
|
|
3382
|
+
if (state.events) {
|
|
3383
|
+
const result = state.events.enter?.("AfterReturnShorthand", state);
|
|
3384
|
+
if (result) {
|
|
3385
|
+
if (result.cache)
|
|
3386
|
+
return result.cache;
|
|
3387
|
+
eventData = result.data;
|
|
3388
|
+
}
|
|
3389
|
+
}
|
|
3390
|
+
if (state.tokenize) {
|
|
3391
|
+
const result = $TOKEN("AfterReturnShorthand", state, AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state));
|
|
3392
|
+
if (state.events)
|
|
3393
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3394
|
+
return result;
|
|
3395
|
+
} else {
|
|
3396
|
+
const result = AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state);
|
|
3397
|
+
if (state.events)
|
|
3398
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3399
|
+
return result;
|
|
3400
|
+
}
|
|
3401
|
+
}
|
|
3346
3402
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
3347
3403
|
var CallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
|
|
3348
3404
|
if ($1.type === "StringLiteral") {
|
|
@@ -3429,7 +3485,7 @@ ${input.slice(result.pos)}
|
|
|
3429
3485
|
return result;
|
|
3430
3486
|
}
|
|
3431
3487
|
}
|
|
3432
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
3488
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L15, fail, 'NonNullAssertion "!"'), $N($EXPECT($L16, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3433
3489
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3434
3490
|
});
|
|
3435
3491
|
function NonNullAssertion(state) {
|
|
@@ -3567,7 +3623,7 @@ ${input.slice(result.pos)}
|
|
|
3567
3623
|
]
|
|
3568
3624
|
};
|
|
3569
3625
|
});
|
|
3570
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3626
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L17, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3571
3627
|
var dot = $1;
|
|
3572
3628
|
var neg = $2;
|
|
3573
3629
|
var num = $3;
|
|
@@ -3764,7 +3820,7 @@ ${input.slice(result.pos)}
|
|
|
3764
3820
|
}
|
|
3765
3821
|
}
|
|
3766
3822
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3767
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3823
|
+
var MetaProperty$1 = $TS($S($EXPECT($L18, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3768
3824
|
return { $loc, token: $1 };
|
|
3769
3825
|
});
|
|
3770
3826
|
function MetaProperty(state) {
|
|
@@ -3790,7 +3846,7 @@ ${input.slice(result.pos)}
|
|
|
3790
3846
|
}
|
|
3791
3847
|
}
|
|
3792
3848
|
var Parameters$0 = NonEmptyParameters;
|
|
3793
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3849
|
+
var Parameters$1 = $TV($EXPECT($L19, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3794
3850
|
return {
|
|
3795
3851
|
type: "Parameters",
|
|
3796
3852
|
children: [{ $loc, token: "()" }],
|
|
@@ -4013,6 +4069,9 @@ ${input.slice(result.pos)}
|
|
|
4013
4069
|
};
|
|
4014
4070
|
});
|
|
4015
4071
|
var NWBindingIdentifier$1 = Identifier;
|
|
4072
|
+
var NWBindingIdentifier$2 = $TS($S(ReturnValue), function($skip, $loc, $0, $1) {
|
|
4073
|
+
return { children: [$1], names: [] };
|
|
4074
|
+
});
|
|
4016
4075
|
function NWBindingIdentifier(state) {
|
|
4017
4076
|
let eventData;
|
|
4018
4077
|
if (state.events) {
|
|
@@ -4024,12 +4083,12 @@ ${input.slice(result.pos)}
|
|
|
4024
4083
|
}
|
|
4025
4084
|
}
|
|
4026
4085
|
if (state.tokenize) {
|
|
4027
|
-
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state));
|
|
4086
|
+
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state));
|
|
4028
4087
|
if (state.events)
|
|
4029
4088
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4030
4089
|
return result;
|
|
4031
4090
|
} else {
|
|
4032
|
-
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state);
|
|
4091
|
+
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state);
|
|
4033
4092
|
if (state.events)
|
|
4034
4093
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4035
4094
|
return result;
|
|
@@ -4410,7 +4469,7 @@ ${input.slice(result.pos)}
|
|
|
4410
4469
|
}
|
|
4411
4470
|
}
|
|
4412
4471
|
var BindingProperty$0 = BindingRestProperty;
|
|
4413
|
-
var BindingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4472
|
+
var BindingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4414
4473
|
var name = $2;
|
|
4415
4474
|
var b = $5;
|
|
4416
4475
|
var init = $6;
|
|
@@ -4571,7 +4630,7 @@ ${input.slice(result.pos)}
|
|
|
4571
4630
|
children: $0
|
|
4572
4631
|
};
|
|
4573
4632
|
});
|
|
4574
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4633
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4575
4634
|
return {
|
|
4576
4635
|
children: [{
|
|
4577
4636
|
type: "ElisionElement",
|
|
@@ -4644,7 +4703,7 @@ ${input.slice(result.pos)}
|
|
|
4644
4703
|
return result;
|
|
4645
4704
|
}
|
|
4646
4705
|
}
|
|
4647
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4706
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L19, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4648
4707
|
const ref = {
|
|
4649
4708
|
type: "Ref",
|
|
4650
4709
|
base: "ref",
|
|
@@ -4862,7 +4921,7 @@ ${input.slice(result.pos)}
|
|
|
4862
4921
|
}
|
|
4863
4922
|
}
|
|
4864
4923
|
var MatchingProperty$0 = MatchingRestProperty;
|
|
4865
|
-
var MatchingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4924
|
+
var MatchingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4866
4925
|
var name = $2;
|
|
4867
4926
|
var match = $6;
|
|
4868
4927
|
return {
|
|
@@ -5088,7 +5147,7 @@ ${input.slice(result.pos)}
|
|
|
5088
5147
|
}
|
|
5089
5148
|
}
|
|
5090
5149
|
var MatchingElement$0 = MatchingRestElement;
|
|
5091
|
-
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier,
|
|
5150
|
+
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5092
5151
|
var ws = $1;
|
|
5093
5152
|
var name = $2;
|
|
5094
5153
|
var match = $6;
|
|
@@ -5120,7 +5179,7 @@ ${input.slice(result.pos)}
|
|
|
5120
5179
|
children: [ws, binding]
|
|
5121
5180
|
};
|
|
5122
5181
|
});
|
|
5123
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5182
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5124
5183
|
return {
|
|
5125
5184
|
children: [{
|
|
5126
5185
|
type: "ElisionElement",
|
|
@@ -5213,7 +5272,7 @@ ${input.slice(result.pos)}
|
|
|
5213
5272
|
type: "FunctionSignature",
|
|
5214
5273
|
id: wid?.[1],
|
|
5215
5274
|
parameters,
|
|
5216
|
-
returnType: suffix
|
|
5275
|
+
returnType: suffix,
|
|
5217
5276
|
ts: false,
|
|
5218
5277
|
block: null,
|
|
5219
5278
|
children: !parameters.implicit ? $0 : [async, func, star, wid, parameters, w, suffix]
|
|
@@ -5372,7 +5431,7 @@ ${input.slice(result.pos)}
|
|
|
5372
5431
|
type: "FunctionSignature",
|
|
5373
5432
|
id,
|
|
5374
5433
|
parameters,
|
|
5375
|
-
returnType: suffix
|
|
5434
|
+
returnType: suffix,
|
|
5376
5435
|
ts: false,
|
|
5377
5436
|
block: null,
|
|
5378
5437
|
children: [func, w1, id, w2, parameters, suffix]
|
|
@@ -5481,7 +5540,7 @@ ${input.slice(result.pos)}
|
|
|
5481
5540
|
type: "FunctionExpression",
|
|
5482
5541
|
id: void 0,
|
|
5483
5542
|
parameters,
|
|
5484
|
-
returnType: suffix
|
|
5543
|
+
returnType: suffix,
|
|
5485
5544
|
ts: false,
|
|
5486
5545
|
block,
|
|
5487
5546
|
children: [
|
|
@@ -5514,7 +5573,7 @@ ${input.slice(result.pos)}
|
|
|
5514
5573
|
return result;
|
|
5515
5574
|
}
|
|
5516
5575
|
}
|
|
5517
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5576
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5518
5577
|
return { $loc, token: $1 };
|
|
5519
5578
|
});
|
|
5520
5579
|
function Arrow(state) {
|
|
@@ -5578,12 +5637,16 @@ ${input.slice(result.pos)}
|
|
|
5578
5637
|
return result;
|
|
5579
5638
|
}
|
|
5580
5639
|
}
|
|
5581
|
-
var ImplicitNestedBlock$0 = $TS($S(InsertOpenBrace, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5582
|
-
var
|
|
5583
|
-
|
|
5584
|
-
|
|
5640
|
+
var ImplicitNestedBlock$0 = $TS($S($Y(EOS), InsertOpenBrace, AllowAll, $E($S(NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5641
|
+
var open = $2;
|
|
5642
|
+
if (!$4)
|
|
5643
|
+
return $skip;
|
|
5644
|
+
const [block, ...tail] = $4;
|
|
5645
|
+
return {
|
|
5646
|
+
...block,
|
|
5647
|
+
children: [open, ...block.children, ...tail],
|
|
5585
5648
|
bare: false
|
|
5586
|
-
}
|
|
5649
|
+
};
|
|
5587
5650
|
});
|
|
5588
5651
|
function ImplicitNestedBlock(state) {
|
|
5589
5652
|
let eventData;
|
|
@@ -5748,7 +5811,7 @@ ${input.slice(result.pos)}
|
|
|
5748
5811
|
return result;
|
|
5749
5812
|
}
|
|
5750
5813
|
}
|
|
5751
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5814
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L19, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5752
5815
|
const expressions = [];
|
|
5753
5816
|
return {
|
|
5754
5817
|
type: "BlockStatement",
|
|
@@ -5851,12 +5914,16 @@ ${input.slice(result.pos)}
|
|
|
5851
5914
|
return result;
|
|
5852
5915
|
}
|
|
5853
5916
|
}
|
|
5854
|
-
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5855
|
-
var
|
|
5917
|
+
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5918
|
+
var ws1 = $1;
|
|
5919
|
+
var open = $2;
|
|
5920
|
+
if (!$4)
|
|
5921
|
+
return $skip;
|
|
5922
|
+
const [block, ws2, close] = $4;
|
|
5856
5923
|
return {
|
|
5857
5924
|
type: "BlockStatement",
|
|
5858
5925
|
expressions: block.expressions,
|
|
5859
|
-
children: [
|
|
5926
|
+
children: [ws1, open, ...block.children, ws2, close],
|
|
5860
5927
|
bare: false
|
|
5861
5928
|
};
|
|
5862
5929
|
return block;
|
|
@@ -5971,7 +6038,7 @@ ${input.slice(result.pos)}
|
|
|
5971
6038
|
children: [$1, expressions]
|
|
5972
6039
|
};
|
|
5973
6040
|
});
|
|
5974
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6041
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5975
6042
|
const expressions = [];
|
|
5976
6043
|
return {
|
|
5977
6044
|
type: "BlockStatement",
|
|
@@ -6116,7 +6183,7 @@ ${input.slice(result.pos)}
|
|
|
6116
6183
|
return result;
|
|
6117
6184
|
}
|
|
6118
6185
|
}
|
|
6119
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6186
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6120
6187
|
return { $loc, token: $1 };
|
|
6121
6188
|
});
|
|
6122
6189
|
function NullLiteral(state) {
|
|
@@ -6144,7 +6211,7 @@ ${input.slice(result.pos)}
|
|
|
6144
6211
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6145
6212
|
return value[1];
|
|
6146
6213
|
});
|
|
6147
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6214
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6148
6215
|
return { $loc, token: $1 };
|
|
6149
6216
|
});
|
|
6150
6217
|
function BooleanLiteral(state) {
|
|
@@ -6169,10 +6236,10 @@ ${input.slice(result.pos)}
|
|
|
6169
6236
|
return result;
|
|
6170
6237
|
}
|
|
6171
6238
|
}
|
|
6172
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6239
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6173
6240
|
return { $loc, token: "true" };
|
|
6174
6241
|
});
|
|
6175
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6242
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6176
6243
|
return { $loc, token: "false" };
|
|
6177
6244
|
});
|
|
6178
6245
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6278,7 +6345,7 @@ ${input.slice(result.pos)}
|
|
|
6278
6345
|
return result;
|
|
6279
6346
|
}
|
|
6280
6347
|
}
|
|
6281
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6348
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6282
6349
|
function UpcomingAssignment(state) {
|
|
6283
6350
|
let eventData;
|
|
6284
6351
|
if (state.events) {
|
|
@@ -6544,7 +6611,7 @@ ${input.slice(result.pos)}
|
|
|
6544
6611
|
}
|
|
6545
6612
|
}
|
|
6546
6613
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6547
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6614
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6548
6615
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6549
6616
|
return value[1];
|
|
6550
6617
|
});
|
|
@@ -6971,7 +7038,7 @@ ${input.slice(result.pos)}
|
|
|
6971
7038
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6972
7039
|
return value[1];
|
|
6973
7040
|
});
|
|
6974
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
7041
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L32, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L33, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L31, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L22, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
|
|
6975
7042
|
return "";
|
|
6976
7043
|
});
|
|
6977
7044
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -7000,7 +7067,7 @@ ${input.slice(result.pos)}
|
|
|
7000
7067
|
}
|
|
7001
7068
|
}
|
|
7002
7069
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
7003
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7070
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
7004
7071
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7005
7072
|
return value[1];
|
|
7006
7073
|
});
|
|
@@ -7170,7 +7237,7 @@ ${input.slice(result.pos)}
|
|
|
7170
7237
|
return result;
|
|
7171
7238
|
}
|
|
7172
7239
|
}
|
|
7173
|
-
var NamedProperty$0 = $TS($S(PropertyName,
|
|
7240
|
+
var NamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7174
7241
|
var name = $1;
|
|
7175
7242
|
var exp = $4;
|
|
7176
7243
|
return {
|
|
@@ -7203,7 +7270,7 @@ ${input.slice(result.pos)}
|
|
|
7203
7270
|
return result;
|
|
7204
7271
|
}
|
|
7205
7272
|
}
|
|
7206
|
-
var ImplicitNamedProperty$0 = $TS($S(PropertyName,
|
|
7273
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7207
7274
|
var name = $1;
|
|
7208
7275
|
var exp = $5;
|
|
7209
7276
|
return {
|
|
@@ -7310,7 +7377,7 @@ ${input.slice(result.pos)}
|
|
|
7310
7377
|
expression
|
|
7311
7378
|
};
|
|
7312
7379
|
});
|
|
7313
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7380
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L17, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7314
7381
|
return {
|
|
7315
7382
|
type: "ComputedPropertyName",
|
|
7316
7383
|
children: $0
|
|
@@ -7478,7 +7545,7 @@ ${input.slice(result.pos)}
|
|
|
7478
7545
|
children: $0,
|
|
7479
7546
|
name,
|
|
7480
7547
|
modifier: $1?.[0]?.token,
|
|
7481
|
-
returnType:
|
|
7548
|
+
returnType: suffix,
|
|
7482
7549
|
parameters
|
|
7483
7550
|
};
|
|
7484
7551
|
});
|
|
@@ -7659,22 +7726,22 @@ ${input.slice(result.pos)}
|
|
|
7659
7726
|
return result;
|
|
7660
7727
|
}
|
|
7661
7728
|
}
|
|
7662
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7663
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7664
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7665
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7666
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7667
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7668
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7669
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7670
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7671
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7672
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7673
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7674
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7675
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7676
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7677
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7729
|
+
var AssignmentOpSymbol$0 = $EXPECT($L34, fail, 'AssignmentOpSymbol "**="');
|
|
7730
|
+
var AssignmentOpSymbol$1 = $EXPECT($L35, fail, 'AssignmentOpSymbol "*="');
|
|
7731
|
+
var AssignmentOpSymbol$2 = $EXPECT($L36, fail, 'AssignmentOpSymbol "/="');
|
|
7732
|
+
var AssignmentOpSymbol$3 = $EXPECT($L37, fail, 'AssignmentOpSymbol "%="');
|
|
7733
|
+
var AssignmentOpSymbol$4 = $EXPECT($L38, fail, 'AssignmentOpSymbol "+="');
|
|
7734
|
+
var AssignmentOpSymbol$5 = $EXPECT($L39, fail, 'AssignmentOpSymbol "-="');
|
|
7735
|
+
var AssignmentOpSymbol$6 = $EXPECT($L40, fail, 'AssignmentOpSymbol "<<="');
|
|
7736
|
+
var AssignmentOpSymbol$7 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>>="');
|
|
7737
|
+
var AssignmentOpSymbol$8 = $EXPECT($L42, fail, 'AssignmentOpSymbol ">>="');
|
|
7738
|
+
var AssignmentOpSymbol$9 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&&="');
|
|
7739
|
+
var AssignmentOpSymbol$10 = $EXPECT($L44, fail, 'AssignmentOpSymbol "&="');
|
|
7740
|
+
var AssignmentOpSymbol$11 = $EXPECT($L45, fail, 'AssignmentOpSymbol "^="');
|
|
7741
|
+
var AssignmentOpSymbol$12 = $EXPECT($L46, fail, 'AssignmentOpSymbol "||="');
|
|
7742
|
+
var AssignmentOpSymbol$13 = $EXPECT($L47, fail, 'AssignmentOpSymbol "|="');
|
|
7743
|
+
var AssignmentOpSymbol$14 = $EXPECT($L48, fail, 'AssignmentOpSymbol "??="');
|
|
7744
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L49, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7678
7745
|
return "??=";
|
|
7679
7746
|
});
|
|
7680
7747
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7705,10 +7772,10 @@ ${input.slice(result.pos)}
|
|
|
7705
7772
|
return result;
|
|
7706
7773
|
}
|
|
7707
7774
|
}
|
|
7708
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7775
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7709
7776
|
return "&&=";
|
|
7710
7777
|
});
|
|
7711
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7778
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L51, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7712
7779
|
return "||=";
|
|
7713
7780
|
});
|
|
7714
7781
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7747,7 +7814,7 @@ ${input.slice(result.pos)}
|
|
|
7747
7814
|
special: true
|
|
7748
7815
|
};
|
|
7749
7816
|
});
|
|
7750
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7817
|
+
var BinaryOp$2 = $TS($S($EXPECT($L52, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7751
7818
|
var id = $4;
|
|
7752
7819
|
if (!module.operators.has(id.name))
|
|
7753
7820
|
return $skip;
|
|
@@ -7779,21 +7846,21 @@ ${input.slice(result.pos)}
|
|
|
7779
7846
|
return result;
|
|
7780
7847
|
}
|
|
7781
7848
|
}
|
|
7782
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7783
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7784
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7785
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7849
|
+
var BinaryOpSymbol$0 = $EXPECT($L53, fail, 'BinaryOpSymbol "**"');
|
|
7850
|
+
var BinaryOpSymbol$1 = $EXPECT($L54, fail, 'BinaryOpSymbol "*"');
|
|
7851
|
+
var BinaryOpSymbol$2 = $EXPECT($L55, fail, 'BinaryOpSymbol "/"');
|
|
7852
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7786
7853
|
return {
|
|
7787
7854
|
call: module.getRef("modulo"),
|
|
7788
7855
|
special: true
|
|
7789
7856
|
};
|
|
7790
7857
|
});
|
|
7791
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7792
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7793
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7794
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7795
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7796
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7858
|
+
var BinaryOpSymbol$4 = $EXPECT($L57, fail, 'BinaryOpSymbol "%"');
|
|
7859
|
+
var BinaryOpSymbol$5 = $EXPECT($L58, fail, 'BinaryOpSymbol "+"');
|
|
7860
|
+
var BinaryOpSymbol$6 = $EXPECT($L17, fail, 'BinaryOpSymbol "-"');
|
|
7861
|
+
var BinaryOpSymbol$7 = $EXPECT($L59, fail, 'BinaryOpSymbol "<="');
|
|
7862
|
+
var BinaryOpSymbol$8 = $EXPECT($L60, fail, 'BinaryOpSymbol ">="');
|
|
7863
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7797
7864
|
return {
|
|
7798
7865
|
$loc,
|
|
7799
7866
|
token: "instanceof",
|
|
@@ -7801,7 +7868,7 @@ ${input.slice(result.pos)}
|
|
|
7801
7868
|
special: true
|
|
7802
7869
|
};
|
|
7803
7870
|
});
|
|
7804
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7871
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L62, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7805
7872
|
return {
|
|
7806
7873
|
$loc,
|
|
7807
7874
|
token: "instanceof",
|
|
@@ -7810,58 +7877,58 @@ ${input.slice(result.pos)}
|
|
|
7810
7877
|
negated: true
|
|
7811
7878
|
};
|
|
7812
7879
|
});
|
|
7813
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7880
|
+
var BinaryOpSymbol$11 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
7814
7881
|
var BinaryOpSymbol$12 = $TR($EXPECT($R7, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7815
7882
|
return "<";
|
|
7816
7883
|
});
|
|
7817
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7818
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7819
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7820
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7821
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7884
|
+
var BinaryOpSymbol$13 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
7885
|
+
var BinaryOpSymbol$14 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
7886
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7887
|
+
var BinaryOpSymbol$16 = $EXPECT($L66, fail, 'BinaryOpSymbol "!=="');
|
|
7888
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L67, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7822
7889
|
if (module.config.coffeeEq)
|
|
7823
7890
|
return "!==";
|
|
7824
7891
|
return $1;
|
|
7825
7892
|
});
|
|
7826
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7893
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7827
7894
|
if (module.config.coffeeIsnt)
|
|
7828
7895
|
return "!==";
|
|
7829
7896
|
return $skip;
|
|
7830
7897
|
});
|
|
7831
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7832
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7898
|
+
var BinaryOpSymbol$19 = $EXPECT($L69, fail, 'BinaryOpSymbol "==="');
|
|
7899
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7833
7900
|
if (module.config.coffeeEq)
|
|
7834
7901
|
return "===";
|
|
7835
7902
|
return $1;
|
|
7836
7903
|
});
|
|
7837
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7904
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7838
7905
|
return "&&";
|
|
7839
7906
|
});
|
|
7840
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7841
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7907
|
+
var BinaryOpSymbol$22 = $EXPECT($L72, fail, 'BinaryOpSymbol "&&"');
|
|
7908
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7842
7909
|
return "in";
|
|
7843
7910
|
});
|
|
7844
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7911
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7845
7912
|
return "||";
|
|
7846
7913
|
});
|
|
7847
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7848
|
-
var BinaryOpSymbol$26 = $TV($C($EXPECT($
|
|
7914
|
+
var BinaryOpSymbol$25 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
7915
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L76, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7849
7916
|
return {
|
|
7850
7917
|
call: module.getRef("xor"),
|
|
7851
7918
|
special: true
|
|
7852
7919
|
};
|
|
7853
7920
|
});
|
|
7854
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
7921
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L78, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7855
7922
|
return {
|
|
7856
7923
|
call: module.getRef("xnor"),
|
|
7857
7924
|
special: true
|
|
7858
7925
|
};
|
|
7859
7926
|
});
|
|
7860
|
-
var BinaryOpSymbol$28 = $EXPECT($
|
|
7927
|
+
var BinaryOpSymbol$28 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
|
|
7861
7928
|
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7862
7929
|
return "??";
|
|
7863
7930
|
});
|
|
7864
|
-
var BinaryOpSymbol$30 = $TS($S($EXPECT($
|
|
7931
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7865
7932
|
return {
|
|
7866
7933
|
$loc,
|
|
7867
7934
|
token: $1,
|
|
@@ -7869,7 +7936,7 @@ ${input.slice(result.pos)}
|
|
|
7869
7936
|
special: true
|
|
7870
7937
|
};
|
|
7871
7938
|
});
|
|
7872
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
7939
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7873
7940
|
return {
|
|
7874
7941
|
$loc,
|
|
7875
7942
|
token: "instanceof",
|
|
@@ -7878,7 +7945,7 @@ ${input.slice(result.pos)}
|
|
|
7878
7945
|
negated: true
|
|
7879
7946
|
};
|
|
7880
7947
|
});
|
|
7881
|
-
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($
|
|
7948
|
+
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7882
7949
|
return {
|
|
7883
7950
|
$loc,
|
|
7884
7951
|
token: "in",
|
|
@@ -7886,7 +7953,7 @@ ${input.slice(result.pos)}
|
|
|
7886
7953
|
negated: true
|
|
7887
7954
|
};
|
|
7888
7955
|
});
|
|
7889
|
-
var BinaryOpSymbol$33 = $TS($S($EXPECT($
|
|
7956
|
+
var BinaryOpSymbol$33 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7890
7957
|
return {
|
|
7891
7958
|
method: "includes",
|
|
7892
7959
|
relational: true,
|
|
@@ -7894,7 +7961,7 @@ ${input.slice(result.pos)}
|
|
|
7894
7961
|
special: true
|
|
7895
7962
|
};
|
|
7896
7963
|
});
|
|
7897
|
-
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7964
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7898
7965
|
return {
|
|
7899
7966
|
call: [module.getRef("indexOf"), ".call"],
|
|
7900
7967
|
relational: true,
|
|
@@ -7903,7 +7970,7 @@ ${input.slice(result.pos)}
|
|
|
7903
7970
|
special: true
|
|
7904
7971
|
};
|
|
7905
7972
|
});
|
|
7906
|
-
var BinaryOpSymbol$35 = $TS($S($EXPECT($
|
|
7973
|
+
var BinaryOpSymbol$35 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
7907
7974
|
return {
|
|
7908
7975
|
method: "includes",
|
|
7909
7976
|
relational: true,
|
|
@@ -7912,7 +7979,7 @@ ${input.slice(result.pos)}
|
|
|
7912
7979
|
negated: true
|
|
7913
7980
|
};
|
|
7914
7981
|
});
|
|
7915
|
-
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7982
|
+
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7916
7983
|
return {
|
|
7917
7984
|
call: [module.getRef("indexOf"), ".call"],
|
|
7918
7985
|
relational: true,
|
|
@@ -7921,7 +7988,7 @@ ${input.slice(result.pos)}
|
|
|
7921
7988
|
special: true
|
|
7922
7989
|
};
|
|
7923
7990
|
});
|
|
7924
|
-
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($
|
|
7991
|
+
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7925
7992
|
if (module.config.objectIs) {
|
|
7926
7993
|
return {
|
|
7927
7994
|
call: module.getRef("is"),
|
|
@@ -7933,7 +8000,7 @@ ${input.slice(result.pos)}
|
|
|
7933
8000
|
}
|
|
7934
8001
|
return "!==";
|
|
7935
8002
|
});
|
|
7936
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8003
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7937
8004
|
if (module.config.objectIs) {
|
|
7938
8005
|
return {
|
|
7939
8006
|
call: module.getRef("is"),
|
|
@@ -7944,12 +8011,12 @@ ${input.slice(result.pos)}
|
|
|
7944
8011
|
}
|
|
7945
8012
|
return "===";
|
|
7946
8013
|
});
|
|
7947
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
8014
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7948
8015
|
return $1;
|
|
7949
8016
|
});
|
|
7950
|
-
var BinaryOpSymbol$40 = $EXPECT($
|
|
7951
|
-
var BinaryOpSymbol$41 = $EXPECT($
|
|
7952
|
-
var BinaryOpSymbol$42 = $EXPECT($
|
|
8017
|
+
var BinaryOpSymbol$40 = $EXPECT($L83, fail, 'BinaryOpSymbol "&"');
|
|
8018
|
+
var BinaryOpSymbol$41 = $EXPECT($L16, fail, 'BinaryOpSymbol "^"');
|
|
8019
|
+
var BinaryOpSymbol$42 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
|
|
7953
8020
|
function BinaryOpSymbol(state) {
|
|
7954
8021
|
let eventData;
|
|
7955
8022
|
if (state.events) {
|
|
@@ -7972,8 +8039,8 @@ ${input.slice(result.pos)}
|
|
|
7972
8039
|
return result;
|
|
7973
8040
|
}
|
|
7974
8041
|
}
|
|
7975
|
-
var Xor$0 = $EXPECT($
|
|
7976
|
-
var Xor$1 = $S($EXPECT($
|
|
8042
|
+
var Xor$0 = $EXPECT($L76, fail, 'Xor "^^"');
|
|
8043
|
+
var Xor$1 = $S($EXPECT($L77, fail, 'Xor "xor"'), NonIdContinue);
|
|
7977
8044
|
function Xor(state) {
|
|
7978
8045
|
let eventData;
|
|
7979
8046
|
if (state.events) {
|
|
@@ -7997,7 +8064,7 @@ ${input.slice(result.pos)}
|
|
|
7997
8064
|
}
|
|
7998
8065
|
}
|
|
7999
8066
|
var Xnor$0 = $R$0($EXPECT($R8, fail, "Xnor /!\\^\\^?/"));
|
|
8000
|
-
var Xnor$1 = $EXPECT($
|
|
8067
|
+
var Xnor$1 = $EXPECT($L78, fail, 'Xnor "xnor"');
|
|
8001
8068
|
function Xnor(state) {
|
|
8002
8069
|
let eventData;
|
|
8003
8070
|
if (state.events) {
|
|
@@ -8218,7 +8285,7 @@ ${input.slice(result.pos)}
|
|
|
8218
8285
|
return result;
|
|
8219
8286
|
}
|
|
8220
8287
|
}
|
|
8221
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8288
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8222
8289
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8223
8290
|
});
|
|
8224
8291
|
function EmptyStatement(state) {
|
|
@@ -8297,7 +8364,7 @@ ${input.slice(result.pos)}
|
|
|
8297
8364
|
var w = $3;
|
|
8298
8365
|
return [id, colon, w];
|
|
8299
8366
|
});
|
|
8300
|
-
var Label$1 = $S($EXPECT($
|
|
8367
|
+
var Label$1 = $S($EXPECT($L86, fail, 'Label "$:"'), Whitespace);
|
|
8301
8368
|
function Label(state) {
|
|
8302
8369
|
let eventData;
|
|
8303
8370
|
if (state.events) {
|
|
@@ -9249,7 +9316,7 @@ ${input.slice(result.pos)}
|
|
|
9249
9316
|
return result;
|
|
9250
9317
|
}
|
|
9251
9318
|
}
|
|
9252
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9319
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L87, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9253
9320
|
var own = $1;
|
|
9254
9321
|
var binding = $2;
|
|
9255
9322
|
return {
|
|
@@ -9733,8 +9800,8 @@ ${input.slice(result.pos)}
|
|
|
9733
9800
|
return result;
|
|
9734
9801
|
}
|
|
9735
9802
|
}
|
|
9736
|
-
var ImpliedColon$0 = $S(
|
|
9737
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9803
|
+
var ImpliedColon$0 = $S($E(_), Colon);
|
|
9804
|
+
var ImpliedColon$1 = $TV($EXPECT($L19, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9738
9805
|
return { $loc, token: ":" };
|
|
9739
9806
|
});
|
|
9740
9807
|
function ImpliedColon(state) {
|
|
@@ -9987,7 +10054,7 @@ ${input.slice(result.pos)}
|
|
|
9987
10054
|
return result;
|
|
9988
10055
|
}
|
|
9989
10056
|
}
|
|
9990
|
-
var ForbidIndentedApplication$0 = $TV($EXPECT($
|
|
10057
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L19, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9991
10058
|
module.forbidIndentedApplication.push(true);
|
|
9992
10059
|
});
|
|
9993
10060
|
function ForbidIndentedApplication(state) {
|
|
@@ -10012,7 +10079,7 @@ ${input.slice(result.pos)}
|
|
|
10012
10079
|
return result;
|
|
10013
10080
|
}
|
|
10014
10081
|
}
|
|
10015
|
-
var AllowIndentedApplication$0 = $TV($EXPECT($
|
|
10082
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L19, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10016
10083
|
module.forbidIndentedApplication.push(false);
|
|
10017
10084
|
});
|
|
10018
10085
|
function AllowIndentedApplication(state) {
|
|
@@ -10037,7 +10104,7 @@ ${input.slice(result.pos)}
|
|
|
10037
10104
|
return result;
|
|
10038
10105
|
}
|
|
10039
10106
|
}
|
|
10040
|
-
var RestoreIndentedApplication$0 = $TV($EXPECT($
|
|
10107
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L19, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10041
10108
|
module.forbidIndentedApplication.pop();
|
|
10042
10109
|
});
|
|
10043
10110
|
function RestoreIndentedApplication(state) {
|
|
@@ -10062,7 +10129,7 @@ ${input.slice(result.pos)}
|
|
|
10062
10129
|
return result;
|
|
10063
10130
|
}
|
|
10064
10131
|
}
|
|
10065
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
10132
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L19, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10066
10133
|
if (module.config.verbose) {
|
|
10067
10134
|
console.log("forbidIndentedApplication:", module.forbidIndentedApplication);
|
|
10068
10135
|
}
|
|
@@ -10092,7 +10159,7 @@ ${input.slice(result.pos)}
|
|
|
10092
10159
|
return result;
|
|
10093
10160
|
}
|
|
10094
10161
|
}
|
|
10095
|
-
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10162
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10096
10163
|
module.forbidTrailingMemberProperty.push(true);
|
|
10097
10164
|
});
|
|
10098
10165
|
function ForbidTrailingMemberProperty(state) {
|
|
@@ -10117,7 +10184,7 @@ ${input.slice(result.pos)}
|
|
|
10117
10184
|
return result;
|
|
10118
10185
|
}
|
|
10119
10186
|
}
|
|
10120
|
-
var AllowTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10187
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10121
10188
|
module.forbidTrailingMemberProperty.push(false);
|
|
10122
10189
|
});
|
|
10123
10190
|
function AllowTrailingMemberProperty(state) {
|
|
@@ -10142,7 +10209,7 @@ ${input.slice(result.pos)}
|
|
|
10142
10209
|
return result;
|
|
10143
10210
|
}
|
|
10144
10211
|
}
|
|
10145
|
-
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10212
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10146
10213
|
module.forbidTrailingMemberProperty.pop();
|
|
10147
10214
|
});
|
|
10148
10215
|
function RestoreTrailingMemberProperty(state) {
|
|
@@ -10167,7 +10234,7 @@ ${input.slice(result.pos)}
|
|
|
10167
10234
|
return result;
|
|
10168
10235
|
}
|
|
10169
10236
|
}
|
|
10170
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
10237
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L19, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10171
10238
|
if (module.config.verbose) {
|
|
10172
10239
|
console.log("forbidTrailingMemberProperty:", module.forbidTrailingMemberProperty);
|
|
10173
10240
|
}
|
|
@@ -10196,7 +10263,7 @@ ${input.slice(result.pos)}
|
|
|
10196
10263
|
return result;
|
|
10197
10264
|
}
|
|
10198
10265
|
}
|
|
10199
|
-
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10266
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10200
10267
|
module.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10201
10268
|
});
|
|
10202
10269
|
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10221,7 +10288,7 @@ ${input.slice(result.pos)}
|
|
|
10221
10288
|
return result;
|
|
10222
10289
|
}
|
|
10223
10290
|
}
|
|
10224
|
-
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10291
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10225
10292
|
module.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10226
10293
|
});
|
|
10227
10294
|
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10246,7 +10313,7 @@ ${input.slice(result.pos)}
|
|
|
10246
10313
|
return result;
|
|
10247
10314
|
}
|
|
10248
10315
|
}
|
|
10249
|
-
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10316
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10250
10317
|
module.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10251
10318
|
});
|
|
10252
10319
|
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10271,7 +10338,7 @@ ${input.slice(result.pos)}
|
|
|
10271
10338
|
return result;
|
|
10272
10339
|
}
|
|
10273
10340
|
}
|
|
10274
|
-
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($
|
|
10341
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L19, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10275
10342
|
if (module.config.verbose) {
|
|
10276
10343
|
console.log("forbidMultiLineImplicitObjectLiteral:", module.forbidMultiLineImplicitObjectLiteral);
|
|
10277
10344
|
}
|
|
@@ -10384,8 +10451,9 @@ ${input.slice(result.pos)}
|
|
|
10384
10451
|
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
10385
10452
|
return { "type": "DebuggerStatement", "children": value };
|
|
10386
10453
|
});
|
|
10387
|
-
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
10388
|
-
|
|
10454
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L4, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10455
|
+
var expression = value[2];
|
|
10456
|
+
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10389
10457
|
});
|
|
10390
10458
|
var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
|
|
10391
10459
|
return { "type": "ThrowStatement", "children": value };
|
|
@@ -10412,7 +10480,7 @@ ${input.slice(result.pos)}
|
|
|
10412
10480
|
return result;
|
|
10413
10481
|
}
|
|
10414
10482
|
}
|
|
10415
|
-
var Break$0 = $TS($S($EXPECT($
|
|
10483
|
+
var Break$0 = $TS($S($EXPECT($L88, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10416
10484
|
return { $loc, token: $1 };
|
|
10417
10485
|
});
|
|
10418
10486
|
function Break(state) {
|
|
@@ -10437,7 +10505,7 @@ ${input.slice(result.pos)}
|
|
|
10437
10505
|
return result;
|
|
10438
10506
|
}
|
|
10439
10507
|
}
|
|
10440
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
10508
|
+
var Continue$0 = $TS($S($EXPECT($L89, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10441
10509
|
return { $loc, token: $1 };
|
|
10442
10510
|
});
|
|
10443
10511
|
function Continue(state) {
|
|
@@ -10462,7 +10530,7 @@ ${input.slice(result.pos)}
|
|
|
10462
10530
|
return result;
|
|
10463
10531
|
}
|
|
10464
10532
|
}
|
|
10465
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
10533
|
+
var Debugger$0 = $TS($S($EXPECT($L90, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10466
10534
|
return { $loc, token: $1 };
|
|
10467
10535
|
});
|
|
10468
10536
|
function Debugger(state) {
|
|
@@ -10615,7 +10683,7 @@ ${input.slice(result.pos)}
|
|
|
10615
10683
|
return result;
|
|
10616
10684
|
}
|
|
10617
10685
|
}
|
|
10618
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10686
|
+
var ImpliedImport$0 = $TV($EXPECT($L19, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10619
10687
|
return { $loc, token: "import " };
|
|
10620
10688
|
});
|
|
10621
10689
|
function ImpliedImport(state) {
|
|
@@ -10764,7 +10832,7 @@ ${input.slice(result.pos)}
|
|
|
10764
10832
|
return result;
|
|
10765
10833
|
}
|
|
10766
10834
|
}
|
|
10767
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10835
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L91, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10768
10836
|
function ImportAssertion(state) {
|
|
10769
10837
|
let eventData;
|
|
10770
10838
|
if (state.events) {
|
|
@@ -11368,7 +11436,7 @@ ${input.slice(result.pos)}
|
|
|
11368
11436
|
return result;
|
|
11369
11437
|
}
|
|
11370
11438
|
}
|
|
11371
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11439
|
+
var ConstAssignment$0 = $TV($EXPECT($L92, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
11372
11440
|
return { $loc, token: "=" };
|
|
11373
11441
|
});
|
|
11374
11442
|
function ConstAssignment(state) {
|
|
@@ -11393,7 +11461,7 @@ ${input.slice(result.pos)}
|
|
|
11393
11461
|
return result;
|
|
11394
11462
|
}
|
|
11395
11463
|
}
|
|
11396
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11464
|
+
var LetAssignment$0 = $TV($EXPECT($L93, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
11397
11465
|
return { $loc, token: "=" };
|
|
11398
11466
|
});
|
|
11399
11467
|
function LetAssignment(state) {
|
|
@@ -12091,7 +12159,7 @@ ${input.slice(result.pos)}
|
|
|
12091
12159
|
}
|
|
12092
12160
|
}
|
|
12093
12161
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
12094
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
12162
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
12095
12163
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
12096
12164
|
});
|
|
12097
12165
|
function RegularExpressionLiteral(state) {
|
|
@@ -12658,7 +12726,7 @@ ${input.slice(result.pos)}
|
|
|
12658
12726
|
return result;
|
|
12659
12727
|
}
|
|
12660
12728
|
}
|
|
12661
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12729
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L94, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L95, fail, 'JSMultiLineComment "*/"')), $EXPECT($R42, fail, "JSMultiLineComment /./"))), $EXPECT($L95, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12662
12730
|
return { $loc, token: $1 };
|
|
12663
12731
|
});
|
|
12664
12732
|
function JSMultiLineComment(state) {
|
|
@@ -12757,7 +12825,7 @@ ${input.slice(result.pos)}
|
|
|
12757
12825
|
return result;
|
|
12758
12826
|
}
|
|
12759
12827
|
}
|
|
12760
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12828
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L94, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L95, fail, 'InlineComment "*/"')), $EXPECT($R46, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L95, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12761
12829
|
return { $loc, token: $1 };
|
|
12762
12830
|
});
|
|
12763
12831
|
function InlineComment(state) {
|
|
@@ -12856,7 +12924,7 @@ ${input.slice(result.pos)}
|
|
|
12856
12924
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12857
12925
|
return { $loc, token: $0 };
|
|
12858
12926
|
});
|
|
12859
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12927
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L96, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12860
12928
|
return "";
|
|
12861
12929
|
});
|
|
12862
12930
|
function NonNewlineWhitespace(state) {
|
|
@@ -13008,7 +13076,7 @@ ${input.slice(result.pos)}
|
|
|
13008
13076
|
}
|
|
13009
13077
|
}
|
|
13010
13078
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
13011
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13079
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L97, fail, 'StatementDelimiter "["'), $EXPECT($L98, fail, 'StatementDelimiter "`"'), $EXPECT($L58, fail, 'StatementDelimiter "+"'), $EXPECT($L17, fail, 'StatementDelimiter "-"'), $EXPECT($L54, fail, 'StatementDelimiter "*"'), $EXPECT($L55, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
13012
13080
|
var StatementDelimiter$2 = $Y(EOS);
|
|
13013
13081
|
function StatementDelimiter(state) {
|
|
13014
13082
|
let eventData;
|
|
@@ -13083,7 +13151,7 @@ ${input.slice(result.pos)}
|
|
|
13083
13151
|
return result;
|
|
13084
13152
|
}
|
|
13085
13153
|
}
|
|
13086
|
-
var Loc$0 = $TV($EXPECT($
|
|
13154
|
+
var Loc$0 = $TV($EXPECT($L19, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
13087
13155
|
return { $loc, token: "" };
|
|
13088
13156
|
});
|
|
13089
13157
|
function Loc(state) {
|
|
@@ -13108,7 +13176,7 @@ ${input.slice(result.pos)}
|
|
|
13108
13176
|
return result;
|
|
13109
13177
|
}
|
|
13110
13178
|
}
|
|
13111
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13179
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
13112
13180
|
return { $loc, token: $1, ts: true };
|
|
13113
13181
|
});
|
|
13114
13182
|
function Abstract(state) {
|
|
@@ -13133,7 +13201,7 @@ ${input.slice(result.pos)}
|
|
|
13133
13201
|
return result;
|
|
13134
13202
|
}
|
|
13135
13203
|
}
|
|
13136
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
13204
|
+
var Ampersand$0 = $TV($EXPECT($L83, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
13137
13205
|
return { $loc, token: $1 };
|
|
13138
13206
|
});
|
|
13139
13207
|
function Ampersand(state) {
|
|
@@ -13158,7 +13226,7 @@ ${input.slice(result.pos)}
|
|
|
13158
13226
|
return result;
|
|
13159
13227
|
}
|
|
13160
13228
|
}
|
|
13161
|
-
var As$0 = $TS($S($EXPECT($
|
|
13229
|
+
var As$0 = $TS($S($EXPECT($L100, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13162
13230
|
return { $loc, token: $1 };
|
|
13163
13231
|
});
|
|
13164
13232
|
function As(state) {
|
|
@@ -13183,7 +13251,7 @@ ${input.slice(result.pos)}
|
|
|
13183
13251
|
return result;
|
|
13184
13252
|
}
|
|
13185
13253
|
}
|
|
13186
|
-
var At$0 = $TV($EXPECT($
|
|
13254
|
+
var At$0 = $TV($EXPECT($L101, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
13187
13255
|
return { $loc, token: $1 };
|
|
13188
13256
|
});
|
|
13189
13257
|
function At(state) {
|
|
@@ -13208,7 +13276,7 @@ ${input.slice(result.pos)}
|
|
|
13208
13276
|
return result;
|
|
13209
13277
|
}
|
|
13210
13278
|
}
|
|
13211
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13279
|
+
var AtAt$0 = $TV($EXPECT($L102, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
13212
13280
|
return { $loc, token: "@" };
|
|
13213
13281
|
});
|
|
13214
13282
|
function AtAt(state) {
|
|
@@ -13233,7 +13301,7 @@ ${input.slice(result.pos)}
|
|
|
13233
13301
|
return result;
|
|
13234
13302
|
}
|
|
13235
13303
|
}
|
|
13236
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13304
|
+
var Async$0 = $TS($S($EXPECT($L103, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13237
13305
|
return { $loc, token: $1, type: "Async" };
|
|
13238
13306
|
});
|
|
13239
13307
|
function Async(state) {
|
|
@@ -13258,7 +13326,7 @@ ${input.slice(result.pos)}
|
|
|
13258
13326
|
return result;
|
|
13259
13327
|
}
|
|
13260
13328
|
}
|
|
13261
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13329
|
+
var Await$0 = $TS($S($EXPECT($L104, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13262
13330
|
return { $loc, token: $1 };
|
|
13263
13331
|
});
|
|
13264
13332
|
function Await(state) {
|
|
@@ -13283,7 +13351,7 @@ ${input.slice(result.pos)}
|
|
|
13283
13351
|
return result;
|
|
13284
13352
|
}
|
|
13285
13353
|
}
|
|
13286
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13354
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
13287
13355
|
return { $loc, token: $1 };
|
|
13288
13356
|
});
|
|
13289
13357
|
function Backtick(state) {
|
|
@@ -13308,7 +13376,7 @@ ${input.slice(result.pos)}
|
|
|
13308
13376
|
return result;
|
|
13309
13377
|
}
|
|
13310
13378
|
}
|
|
13311
|
-
var By$0 = $TS($S($EXPECT($
|
|
13379
|
+
var By$0 = $TS($S($EXPECT($L105, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13312
13380
|
return { $loc, token: $1 };
|
|
13313
13381
|
});
|
|
13314
13382
|
function By(state) {
|
|
@@ -13333,7 +13401,7 @@ ${input.slice(result.pos)}
|
|
|
13333
13401
|
return result;
|
|
13334
13402
|
}
|
|
13335
13403
|
}
|
|
13336
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13404
|
+
var Case$0 = $TS($S($EXPECT($L106, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13337
13405
|
return { $loc, token: $1 };
|
|
13338
13406
|
});
|
|
13339
13407
|
function Case(state) {
|
|
@@ -13358,7 +13426,7 @@ ${input.slice(result.pos)}
|
|
|
13358
13426
|
return result;
|
|
13359
13427
|
}
|
|
13360
13428
|
}
|
|
13361
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13429
|
+
var Catch$0 = $TS($S($EXPECT($L107, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13362
13430
|
return { $loc, token: $1 };
|
|
13363
13431
|
});
|
|
13364
13432
|
function Catch(state) {
|
|
@@ -13383,7 +13451,7 @@ ${input.slice(result.pos)}
|
|
|
13383
13451
|
return result;
|
|
13384
13452
|
}
|
|
13385
13453
|
}
|
|
13386
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13454
|
+
var Class$0 = $TS($S($EXPECT($L108, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13387
13455
|
return { $loc, token: $1 };
|
|
13388
13456
|
});
|
|
13389
13457
|
function Class(state) {
|
|
@@ -13408,7 +13476,7 @@ ${input.slice(result.pos)}
|
|
|
13408
13476
|
return result;
|
|
13409
13477
|
}
|
|
13410
13478
|
}
|
|
13411
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
13479
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
13412
13480
|
return { $loc, token: $1 };
|
|
13413
13481
|
});
|
|
13414
13482
|
function CloseBrace(state) {
|
|
@@ -13433,7 +13501,7 @@ ${input.slice(result.pos)}
|
|
|
13433
13501
|
return result;
|
|
13434
13502
|
}
|
|
13435
13503
|
}
|
|
13436
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
13504
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
13437
13505
|
return { $loc, token: $1 };
|
|
13438
13506
|
});
|
|
13439
13507
|
function CloseBracket(state) {
|
|
@@ -13458,7 +13526,7 @@ ${input.slice(result.pos)}
|
|
|
13458
13526
|
return result;
|
|
13459
13527
|
}
|
|
13460
13528
|
}
|
|
13461
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
13529
|
+
var CloseParen$0 = $TV($EXPECT($L33, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
13462
13530
|
return { $loc, token: $1 };
|
|
13463
13531
|
});
|
|
13464
13532
|
function CloseParen(state) {
|
|
@@ -13483,7 +13551,7 @@ ${input.slice(result.pos)}
|
|
|
13483
13551
|
return result;
|
|
13484
13552
|
}
|
|
13485
13553
|
}
|
|
13486
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13554
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L109, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
13487
13555
|
return { $loc, token: "${" };
|
|
13488
13556
|
});
|
|
13489
13557
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13508,7 +13576,7 @@ ${input.slice(result.pos)}
|
|
|
13508
13576
|
return result;
|
|
13509
13577
|
}
|
|
13510
13578
|
}
|
|
13511
|
-
var Colon$0 = $TV($EXPECT($
|
|
13579
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
13512
13580
|
return { $loc, token: $1 };
|
|
13513
13581
|
});
|
|
13514
13582
|
function Colon(state) {
|
|
@@ -13533,7 +13601,7 @@ ${input.slice(result.pos)}
|
|
|
13533
13601
|
return result;
|
|
13534
13602
|
}
|
|
13535
13603
|
}
|
|
13536
|
-
var Comma$0 = $TV($EXPECT($
|
|
13604
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
13537
13605
|
return { $loc, token: $1 };
|
|
13538
13606
|
});
|
|
13539
13607
|
function Comma(state) {
|
|
@@ -13558,7 +13626,7 @@ ${input.slice(result.pos)}
|
|
|
13558
13626
|
return result;
|
|
13559
13627
|
}
|
|
13560
13628
|
}
|
|
13561
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13629
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L101, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13562
13630
|
return { $loc, token: "constructor" };
|
|
13563
13631
|
});
|
|
13564
13632
|
function ConstructorShorthand(state) {
|
|
@@ -13583,7 +13651,7 @@ ${input.slice(result.pos)}
|
|
|
13583
13651
|
return result;
|
|
13584
13652
|
}
|
|
13585
13653
|
}
|
|
13586
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13654
|
+
var Declare$0 = $TS($S($EXPECT($L110, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13587
13655
|
return { $loc, token: $1 };
|
|
13588
13656
|
});
|
|
13589
13657
|
function Declare(state) {
|
|
@@ -13608,7 +13676,7 @@ ${input.slice(result.pos)}
|
|
|
13608
13676
|
return result;
|
|
13609
13677
|
}
|
|
13610
13678
|
}
|
|
13611
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13679
|
+
var Default$0 = $TS($S($EXPECT($L111, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13612
13680
|
return { $loc, token: $1 };
|
|
13613
13681
|
});
|
|
13614
13682
|
function Default(state) {
|
|
@@ -13633,7 +13701,7 @@ ${input.slice(result.pos)}
|
|
|
13633
13701
|
return result;
|
|
13634
13702
|
}
|
|
13635
13703
|
}
|
|
13636
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13704
|
+
var Delete$0 = $TS($S($EXPECT($L112, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13637
13705
|
return { $loc, token: $1 };
|
|
13638
13706
|
});
|
|
13639
13707
|
function Delete(state) {
|
|
@@ -13658,7 +13726,7 @@ ${input.slice(result.pos)}
|
|
|
13658
13726
|
return result;
|
|
13659
13727
|
}
|
|
13660
13728
|
}
|
|
13661
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13729
|
+
var Do$0 = $TS($S($EXPECT($L113, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13662
13730
|
return { $loc, token: $1 };
|
|
13663
13731
|
});
|
|
13664
13732
|
function Do(state) {
|
|
@@ -13708,7 +13776,7 @@ ${input.slice(result.pos)}
|
|
|
13708
13776
|
return result;
|
|
13709
13777
|
}
|
|
13710
13778
|
}
|
|
13711
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13779
|
+
var DotDot$0 = $TV($EXPECT($L114, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13712
13780
|
return { $loc, token: $1 };
|
|
13713
13781
|
});
|
|
13714
13782
|
function DotDot(state) {
|
|
@@ -13733,7 +13801,7 @@ ${input.slice(result.pos)}
|
|
|
13733
13801
|
return result;
|
|
13734
13802
|
}
|
|
13735
13803
|
}
|
|
13736
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13804
|
+
var DotDotDot$0 = $TV($EXPECT($L115, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13737
13805
|
return { $loc, token: $1 };
|
|
13738
13806
|
});
|
|
13739
13807
|
function DotDotDot(state) {
|
|
@@ -13758,7 +13826,7 @@ ${input.slice(result.pos)}
|
|
|
13758
13826
|
return result;
|
|
13759
13827
|
}
|
|
13760
13828
|
}
|
|
13761
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13829
|
+
var DoubleColon$0 = $TV($EXPECT($L116, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13762
13830
|
return { $loc, token: $1 };
|
|
13763
13831
|
});
|
|
13764
13832
|
function DoubleColon(state) {
|
|
@@ -13783,7 +13851,7 @@ ${input.slice(result.pos)}
|
|
|
13783
13851
|
return result;
|
|
13784
13852
|
}
|
|
13785
13853
|
}
|
|
13786
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13854
|
+
var DoubleQuote$0 = $TV($EXPECT($L117, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13787
13855
|
return { $loc, token: $1 };
|
|
13788
13856
|
});
|
|
13789
13857
|
function DoubleQuote(state) {
|
|
@@ -13808,7 +13876,7 @@ ${input.slice(result.pos)}
|
|
|
13808
13876
|
return result;
|
|
13809
13877
|
}
|
|
13810
13878
|
}
|
|
13811
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13879
|
+
var Else$0 = $TS($S($EXPECT($L118, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13812
13880
|
return { $loc, token: $1 };
|
|
13813
13881
|
});
|
|
13814
13882
|
function Else(state) {
|
|
@@ -13858,7 +13926,7 @@ ${input.slice(result.pos)}
|
|
|
13858
13926
|
return result;
|
|
13859
13927
|
}
|
|
13860
13928
|
}
|
|
13861
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13929
|
+
var Export$0 = $TS($S($EXPECT($L119, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13862
13930
|
return { $loc, token: $1 };
|
|
13863
13931
|
});
|
|
13864
13932
|
function Export(state) {
|
|
@@ -13883,7 +13951,7 @@ ${input.slice(result.pos)}
|
|
|
13883
13951
|
return result;
|
|
13884
13952
|
}
|
|
13885
13953
|
}
|
|
13886
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13954
|
+
var Extends$0 = $TS($S($EXPECT($L120, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13887
13955
|
return { $loc, token: $1 };
|
|
13888
13956
|
});
|
|
13889
13957
|
function Extends(state) {
|
|
@@ -13908,7 +13976,7 @@ ${input.slice(result.pos)}
|
|
|
13908
13976
|
return result;
|
|
13909
13977
|
}
|
|
13910
13978
|
}
|
|
13911
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13979
|
+
var Finally$0 = $TS($S($EXPECT($L121, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13912
13980
|
return { $loc, token: $1 };
|
|
13913
13981
|
});
|
|
13914
13982
|
function Finally(state) {
|
|
@@ -13933,7 +14001,7 @@ ${input.slice(result.pos)}
|
|
|
13933
14001
|
return result;
|
|
13934
14002
|
}
|
|
13935
14003
|
}
|
|
13936
|
-
var For$0 = $TS($S($EXPECT($
|
|
14004
|
+
var For$0 = $TS($S($EXPECT($L122, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13937
14005
|
return { $loc, token: $1 };
|
|
13938
14006
|
});
|
|
13939
14007
|
function For(state) {
|
|
@@ -13958,7 +14026,7 @@ ${input.slice(result.pos)}
|
|
|
13958
14026
|
return result;
|
|
13959
14027
|
}
|
|
13960
14028
|
}
|
|
13961
|
-
var From$0 = $TS($S($EXPECT($
|
|
14029
|
+
var From$0 = $TS($S($EXPECT($L123, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13962
14030
|
return { $loc, token: $1 };
|
|
13963
14031
|
});
|
|
13964
14032
|
function From(state) {
|
|
@@ -13983,7 +14051,7 @@ ${input.slice(result.pos)}
|
|
|
13983
14051
|
return result;
|
|
13984
14052
|
}
|
|
13985
14053
|
}
|
|
13986
|
-
var Function$0 = $TS($S($EXPECT($
|
|
14054
|
+
var Function$0 = $TS($S($EXPECT($L124, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13987
14055
|
return { $loc, token: $1 };
|
|
13988
14056
|
});
|
|
13989
14057
|
function Function(state) {
|
|
@@ -14008,7 +14076,7 @@ ${input.slice(result.pos)}
|
|
|
14008
14076
|
return result;
|
|
14009
14077
|
}
|
|
14010
14078
|
}
|
|
14011
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14079
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L125, fail, 'GetOrSet "get"'), $EXPECT($L126, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14012
14080
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
14013
14081
|
});
|
|
14014
14082
|
function GetOrSet(state) {
|
|
@@ -14033,7 +14101,7 @@ ${input.slice(result.pos)}
|
|
|
14033
14101
|
return result;
|
|
14034
14102
|
}
|
|
14035
14103
|
}
|
|
14036
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14104
|
+
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
14037
14105
|
return { $loc, token: $1 };
|
|
14038
14106
|
});
|
|
14039
14107
|
function If(state) {
|
|
@@ -14083,7 +14151,7 @@ ${input.slice(result.pos)}
|
|
|
14083
14151
|
return result;
|
|
14084
14152
|
}
|
|
14085
14153
|
}
|
|
14086
|
-
var In$0 = $TS($S($EXPECT($
|
|
14154
|
+
var In$0 = $TS($S($EXPECT($L81, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14087
14155
|
return { $loc, token: $1 };
|
|
14088
14156
|
});
|
|
14089
14157
|
function In(state) {
|
|
@@ -14108,7 +14176,7 @@ ${input.slice(result.pos)}
|
|
|
14108
14176
|
return result;
|
|
14109
14177
|
}
|
|
14110
14178
|
}
|
|
14111
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14179
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L128, fail, 'LetOrConst "let"'), $EXPECT($L129, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14112
14180
|
return { $loc, token: $1 };
|
|
14113
14181
|
});
|
|
14114
14182
|
function LetOrConst(state) {
|
|
@@ -14133,7 +14201,7 @@ ${input.slice(result.pos)}
|
|
|
14133
14201
|
return result;
|
|
14134
14202
|
}
|
|
14135
14203
|
}
|
|
14136
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14204
|
+
var Loop$0 = $TS($S($EXPECT($L130, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14137
14205
|
return { $loc, token: "while(true)" };
|
|
14138
14206
|
});
|
|
14139
14207
|
function Loop(state) {
|
|
@@ -14158,7 +14226,7 @@ ${input.slice(result.pos)}
|
|
|
14158
14226
|
return result;
|
|
14159
14227
|
}
|
|
14160
14228
|
}
|
|
14161
|
-
var New$0 = $TS($S($EXPECT($
|
|
14229
|
+
var New$0 = $TS($S($EXPECT($L131, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14162
14230
|
return { $loc, token: $1 };
|
|
14163
14231
|
});
|
|
14164
14232
|
function New(state) {
|
|
@@ -14183,7 +14251,7 @@ ${input.slice(result.pos)}
|
|
|
14183
14251
|
return result;
|
|
14184
14252
|
}
|
|
14185
14253
|
}
|
|
14186
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
14254
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L52, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L8, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14187
14255
|
return { $loc, token: "!" };
|
|
14188
14256
|
});
|
|
14189
14257
|
function Not(state) {
|
|
@@ -14208,7 +14276,7 @@ ${input.slice(result.pos)}
|
|
|
14208
14276
|
return result;
|
|
14209
14277
|
}
|
|
14210
14278
|
}
|
|
14211
|
-
var Of$0 = $TS($S($EXPECT($
|
|
14279
|
+
var Of$0 = $TS($S($EXPECT($L73, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14212
14280
|
return { $loc, token: $1 };
|
|
14213
14281
|
});
|
|
14214
14282
|
function Of(state) {
|
|
@@ -14233,7 +14301,7 @@ ${input.slice(result.pos)}
|
|
|
14233
14301
|
return result;
|
|
14234
14302
|
}
|
|
14235
14303
|
}
|
|
14236
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14304
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L132, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
14237
14305
|
return { $loc, token: $1 };
|
|
14238
14306
|
});
|
|
14239
14307
|
function OpenAngleBracket(state) {
|
|
@@ -14258,7 +14326,7 @@ ${input.slice(result.pos)}
|
|
|
14258
14326
|
return result;
|
|
14259
14327
|
}
|
|
14260
14328
|
}
|
|
14261
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14329
|
+
var OpenBrace$0 = $TV($EXPECT($L133, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
14262
14330
|
return { $loc, token: $1 };
|
|
14263
14331
|
});
|
|
14264
14332
|
function OpenBrace(state) {
|
|
@@ -14283,7 +14351,7 @@ ${input.slice(result.pos)}
|
|
|
14283
14351
|
return result;
|
|
14284
14352
|
}
|
|
14285
14353
|
}
|
|
14286
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14354
|
+
var OpenBracket$0 = $TV($EXPECT($L97, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
14287
14355
|
return { $loc, token: $1 };
|
|
14288
14356
|
});
|
|
14289
14357
|
function OpenBracket(state) {
|
|
@@ -14333,7 +14401,7 @@ ${input.slice(result.pos)}
|
|
|
14333
14401
|
return result;
|
|
14334
14402
|
}
|
|
14335
14403
|
}
|
|
14336
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14404
|
+
var Operator$0 = $TS($S($EXPECT($L134, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14337
14405
|
return { $loc, token: $1 };
|
|
14338
14406
|
});
|
|
14339
14407
|
function Operator(state) {
|
|
@@ -14358,7 +14426,7 @@ ${input.slice(result.pos)}
|
|
|
14358
14426
|
return result;
|
|
14359
14427
|
}
|
|
14360
14428
|
}
|
|
14361
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14429
|
+
var Public$0 = $TS($S($EXPECT($L135, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14362
14430
|
return { $loc, token: $1 };
|
|
14363
14431
|
});
|
|
14364
14432
|
function Public(state) {
|
|
@@ -14383,7 +14451,7 @@ ${input.slice(result.pos)}
|
|
|
14383
14451
|
return result;
|
|
14384
14452
|
}
|
|
14385
14453
|
}
|
|
14386
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14454
|
+
var Private$0 = $TS($S($EXPECT($L136, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14387
14455
|
return { $loc, token: $1 };
|
|
14388
14456
|
});
|
|
14389
14457
|
function Private(state) {
|
|
@@ -14408,7 +14476,7 @@ ${input.slice(result.pos)}
|
|
|
14408
14476
|
return result;
|
|
14409
14477
|
}
|
|
14410
14478
|
}
|
|
14411
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14479
|
+
var Protected$0 = $TS($S($EXPECT($L137, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14412
14480
|
return { $loc, token: $1 };
|
|
14413
14481
|
});
|
|
14414
14482
|
function Protected(state) {
|
|
@@ -14433,13 +14501,13 @@ ${input.slice(result.pos)}
|
|
|
14433
14501
|
return result;
|
|
14434
14502
|
}
|
|
14435
14503
|
}
|
|
14436
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14504
|
+
var Pipe$0 = $TV($EXPECT($L138, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
14437
14505
|
return { $loc, token: $1 };
|
|
14438
14506
|
});
|
|
14439
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14507
|
+
var Pipe$1 = $TV($EXPECT($L139, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
14440
14508
|
return { $loc, token: $1 };
|
|
14441
14509
|
});
|
|
14442
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14510
|
+
var Pipe$2 = $TV($EXPECT($L140, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
14443
14511
|
return { $loc, token: $1 };
|
|
14444
14512
|
});
|
|
14445
14513
|
function Pipe(state) {
|
|
@@ -14489,7 +14557,7 @@ ${input.slice(result.pos)}
|
|
|
14489
14557
|
return result;
|
|
14490
14558
|
}
|
|
14491
14559
|
}
|
|
14492
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14560
|
+
var Readonly$0 = $TS($S($EXPECT($L141, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14493
14561
|
return { $loc, token: $1, ts: true };
|
|
14494
14562
|
});
|
|
14495
14563
|
function Readonly(state) {
|
|
@@ -14514,7 +14582,7 @@ ${input.slice(result.pos)}
|
|
|
14514
14582
|
return result;
|
|
14515
14583
|
}
|
|
14516
14584
|
}
|
|
14517
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14585
|
+
var Return$0 = $TS($S($EXPECT($L142, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14518
14586
|
return { $loc, token: $1 };
|
|
14519
14587
|
});
|
|
14520
14588
|
function Return(state) {
|
|
@@ -14539,7 +14607,7 @@ ${input.slice(result.pos)}
|
|
|
14539
14607
|
return result;
|
|
14540
14608
|
}
|
|
14541
14609
|
}
|
|
14542
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14610
|
+
var Satisfies$0 = $TS($S($EXPECT($L143, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14543
14611
|
return { $loc, token: $1 };
|
|
14544
14612
|
});
|
|
14545
14613
|
function Satisfies(state) {
|
|
@@ -14564,7 +14632,7 @@ ${input.slice(result.pos)}
|
|
|
14564
14632
|
return result;
|
|
14565
14633
|
}
|
|
14566
14634
|
}
|
|
14567
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14635
|
+
var Semicolon$0 = $TV($EXPECT($L85, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
14568
14636
|
return { $loc, token: $1 };
|
|
14569
14637
|
});
|
|
14570
14638
|
function Semicolon(state) {
|
|
@@ -14589,7 +14657,7 @@ ${input.slice(result.pos)}
|
|
|
14589
14657
|
return result;
|
|
14590
14658
|
}
|
|
14591
14659
|
}
|
|
14592
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14660
|
+
var SingleQuote$0 = $TV($EXPECT($L144, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14593
14661
|
return { $loc, token: $1 };
|
|
14594
14662
|
});
|
|
14595
14663
|
function SingleQuote(state) {
|
|
@@ -14614,7 +14682,7 @@ ${input.slice(result.pos)}
|
|
|
14614
14682
|
return result;
|
|
14615
14683
|
}
|
|
14616
14684
|
}
|
|
14617
|
-
var Star$0 = $TV($EXPECT($
|
|
14685
|
+
var Star$0 = $TV($EXPECT($L54, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14618
14686
|
return { $loc, token: $1 };
|
|
14619
14687
|
});
|
|
14620
14688
|
function Star(state) {
|
|
@@ -14639,10 +14707,10 @@ ${input.slice(result.pos)}
|
|
|
14639
14707
|
return result;
|
|
14640
14708
|
}
|
|
14641
14709
|
}
|
|
14642
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14710
|
+
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14643
14711
|
return { $loc, token: $1 };
|
|
14644
14712
|
});
|
|
14645
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14713
|
+
var Static$1 = $TS($S($EXPECT($L101, fail, 'Static "@"'), $N($C($EXPECT($L2, fail, 'Static "("'), $EXPECT($L101, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
14646
14714
|
return { $loc, token: "static " };
|
|
14647
14715
|
});
|
|
14648
14716
|
function Static(state) {
|
|
@@ -14667,7 +14735,7 @@ ${input.slice(result.pos)}
|
|
|
14667
14735
|
return result;
|
|
14668
14736
|
}
|
|
14669
14737
|
}
|
|
14670
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14738
|
+
var SubstitutionStart$0 = $TV($EXPECT($L146, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14671
14739
|
return { $loc, token: $1 };
|
|
14672
14740
|
});
|
|
14673
14741
|
function SubstitutionStart(state) {
|
|
@@ -14692,7 +14760,7 @@ ${input.slice(result.pos)}
|
|
|
14692
14760
|
return result;
|
|
14693
14761
|
}
|
|
14694
14762
|
}
|
|
14695
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14763
|
+
var Switch$0 = $TS($S($EXPECT($L147, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14696
14764
|
return { $loc, token: $1 };
|
|
14697
14765
|
});
|
|
14698
14766
|
function Switch(state) {
|
|
@@ -14717,7 +14785,7 @@ ${input.slice(result.pos)}
|
|
|
14717
14785
|
return result;
|
|
14718
14786
|
}
|
|
14719
14787
|
}
|
|
14720
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14788
|
+
var Target$0 = $TS($S($EXPECT($L148, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14721
14789
|
return { $loc, token: $1 };
|
|
14722
14790
|
});
|
|
14723
14791
|
function Target(state) {
|
|
@@ -14742,7 +14810,7 @@ ${input.slice(result.pos)}
|
|
|
14742
14810
|
return result;
|
|
14743
14811
|
}
|
|
14744
14812
|
}
|
|
14745
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14813
|
+
var Then$0 = $TS($S(__, $EXPECT($L149, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14746
14814
|
return { $loc, token: "" };
|
|
14747
14815
|
});
|
|
14748
14816
|
function Then(state) {
|
|
@@ -14767,7 +14835,7 @@ ${input.slice(result.pos)}
|
|
|
14767
14835
|
return result;
|
|
14768
14836
|
}
|
|
14769
14837
|
}
|
|
14770
|
-
var This$0 = $TS($S($EXPECT($
|
|
14838
|
+
var This$0 = $TS($S($EXPECT($L150, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14771
14839
|
return { $loc, token: $1 };
|
|
14772
14840
|
});
|
|
14773
14841
|
function This(state) {
|
|
@@ -14792,7 +14860,7 @@ ${input.slice(result.pos)}
|
|
|
14792
14860
|
return result;
|
|
14793
14861
|
}
|
|
14794
14862
|
}
|
|
14795
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14863
|
+
var Throw$0 = $TS($S($EXPECT($L151, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14796
14864
|
return { $loc, token: $1 };
|
|
14797
14865
|
});
|
|
14798
14866
|
function Throw(state) {
|
|
@@ -14817,7 +14885,7 @@ ${input.slice(result.pos)}
|
|
|
14817
14885
|
return result;
|
|
14818
14886
|
}
|
|
14819
14887
|
}
|
|
14820
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14888
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L152, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14821
14889
|
return { $loc, token: "`" };
|
|
14822
14890
|
});
|
|
14823
14891
|
function TripleDoubleQuote(state) {
|
|
@@ -14842,7 +14910,7 @@ ${input.slice(result.pos)}
|
|
|
14842
14910
|
return result;
|
|
14843
14911
|
}
|
|
14844
14912
|
}
|
|
14845
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14913
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L153, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14846
14914
|
return { $loc, token: "`" };
|
|
14847
14915
|
});
|
|
14848
14916
|
function TripleSingleQuote(state) {
|
|
@@ -14867,7 +14935,7 @@ ${input.slice(result.pos)}
|
|
|
14867
14935
|
return result;
|
|
14868
14936
|
}
|
|
14869
14937
|
}
|
|
14870
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14938
|
+
var TripleSlash$0 = $TV($EXPECT($L154, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14871
14939
|
return { $loc, token: "/" };
|
|
14872
14940
|
});
|
|
14873
14941
|
function TripleSlash(state) {
|
|
@@ -14892,7 +14960,7 @@ ${input.slice(result.pos)}
|
|
|
14892
14960
|
return result;
|
|
14893
14961
|
}
|
|
14894
14962
|
}
|
|
14895
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14963
|
+
var TripleTick$0 = $TV($EXPECT($L155, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14896
14964
|
return { $loc, token: "`" };
|
|
14897
14965
|
});
|
|
14898
14966
|
function TripleTick(state) {
|
|
@@ -14917,7 +14985,7 @@ ${input.slice(result.pos)}
|
|
|
14917
14985
|
return result;
|
|
14918
14986
|
}
|
|
14919
14987
|
}
|
|
14920
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14988
|
+
var Try$0 = $TS($S($EXPECT($L156, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14921
14989
|
return { $loc, token: $1 };
|
|
14922
14990
|
});
|
|
14923
14991
|
function Try(state) {
|
|
@@ -14942,7 +15010,7 @@ ${input.slice(result.pos)}
|
|
|
14942
15010
|
return result;
|
|
14943
15011
|
}
|
|
14944
15012
|
}
|
|
14945
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
15013
|
+
var Typeof$0 = $TS($S($EXPECT($L157, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14946
15014
|
return { $loc, token: $1 };
|
|
14947
15015
|
});
|
|
14948
15016
|
function Typeof(state) {
|
|
@@ -14967,7 +15035,7 @@ ${input.slice(result.pos)}
|
|
|
14967
15035
|
return result;
|
|
14968
15036
|
}
|
|
14969
15037
|
}
|
|
14970
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
15038
|
+
var Unless$0 = $TS($S($EXPECT($L158, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14971
15039
|
return { $loc, token: $1 };
|
|
14972
15040
|
});
|
|
14973
15041
|
function Unless(state) {
|
|
@@ -14992,7 +15060,7 @@ ${input.slice(result.pos)}
|
|
|
14992
15060
|
return result;
|
|
14993
15061
|
}
|
|
14994
15062
|
}
|
|
14995
|
-
var Until$0 = $TS($S($EXPECT($
|
|
15063
|
+
var Until$0 = $TS($S($EXPECT($L159, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14996
15064
|
return { $loc, token: $1 };
|
|
14997
15065
|
});
|
|
14998
15066
|
function Until(state) {
|
|
@@ -15017,7 +15085,7 @@ ${input.slice(result.pos)}
|
|
|
15017
15085
|
return result;
|
|
15018
15086
|
}
|
|
15019
15087
|
}
|
|
15020
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15088
|
+
var Var$0 = $TS($S($EXPECT($L160, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15021
15089
|
return { $loc, token: $1 };
|
|
15022
15090
|
});
|
|
15023
15091
|
function Var(state) {
|
|
@@ -15042,7 +15110,7 @@ ${input.slice(result.pos)}
|
|
|
15042
15110
|
return result;
|
|
15043
15111
|
}
|
|
15044
15112
|
}
|
|
15045
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15113
|
+
var Void$0 = $TS($S($EXPECT($L161, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15046
15114
|
return { $loc, token: $1 };
|
|
15047
15115
|
});
|
|
15048
15116
|
function Void(state) {
|
|
@@ -15067,7 +15135,7 @@ ${input.slice(result.pos)}
|
|
|
15067
15135
|
return result;
|
|
15068
15136
|
}
|
|
15069
15137
|
}
|
|
15070
|
-
var When$0 = $TS($S($EXPECT($
|
|
15138
|
+
var When$0 = $TS($S($EXPECT($L162, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15071
15139
|
return { $loc, token: "case" };
|
|
15072
15140
|
});
|
|
15073
15141
|
function When(state) {
|
|
@@ -15092,7 +15160,7 @@ ${input.slice(result.pos)}
|
|
|
15092
15160
|
return result;
|
|
15093
15161
|
}
|
|
15094
15162
|
}
|
|
15095
|
-
var While$0 = $TS($S($EXPECT($
|
|
15163
|
+
var While$0 = $TS($S($EXPECT($L163, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15096
15164
|
return { $loc, token: $1 };
|
|
15097
15165
|
});
|
|
15098
15166
|
function While(state) {
|
|
@@ -15117,7 +15185,7 @@ ${input.slice(result.pos)}
|
|
|
15117
15185
|
return result;
|
|
15118
15186
|
}
|
|
15119
15187
|
}
|
|
15120
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15188
|
+
var Yield$0 = $TS($S($EXPECT($L164, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15121
15189
|
return { $loc, token: $1 };
|
|
15122
15190
|
});
|
|
15123
15191
|
function Yield(state) {
|
|
@@ -15262,7 +15330,7 @@ ${input.slice(result.pos)}
|
|
|
15262
15330
|
return result;
|
|
15263
15331
|
}
|
|
15264
15332
|
}
|
|
15265
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15333
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L132, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L165, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
15266
15334
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
15267
15335
|
});
|
|
15268
15336
|
function JSXSelfClosingElement(state) {
|
|
@@ -15313,7 +15381,7 @@ ${input.slice(result.pos)}
|
|
|
15313
15381
|
return result;
|
|
15314
15382
|
}
|
|
15315
15383
|
}
|
|
15316
|
-
var PopJSXStack$0 = $TV($EXPECT($
|
|
15384
|
+
var PopJSXStack$0 = $TV($EXPECT($L19, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15317
15385
|
module.JSXTagStack.pop();
|
|
15318
15386
|
});
|
|
15319
15387
|
function PopJSXStack(state) {
|
|
@@ -15338,7 +15406,7 @@ ${input.slice(result.pos)}
|
|
|
15338
15406
|
return result;
|
|
15339
15407
|
}
|
|
15340
15408
|
}
|
|
15341
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
15409
|
+
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
15342
15410
|
function JSXOpeningElement(state) {
|
|
15343
15411
|
let eventData;
|
|
15344
15412
|
if (state.events) {
|
|
@@ -15367,7 +15435,7 @@ ${input.slice(result.pos)}
|
|
|
15367
15435
|
return $skip;
|
|
15368
15436
|
return $0;
|
|
15369
15437
|
});
|
|
15370
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
15438
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L19, fail, 'JSXOptionalClosingElement ""');
|
|
15371
15439
|
function JSXOptionalClosingElement(state) {
|
|
15372
15440
|
let eventData;
|
|
15373
15441
|
if (state.events) {
|
|
@@ -15390,7 +15458,7 @@ ${input.slice(result.pos)}
|
|
|
15390
15458
|
return result;
|
|
15391
15459
|
}
|
|
15392
15460
|
}
|
|
15393
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15461
|
+
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
15394
15462
|
function JSXClosingElement(state) {
|
|
15395
15463
|
let eventData;
|
|
15396
15464
|
if (state.events) {
|
|
@@ -15428,7 +15496,7 @@ ${input.slice(result.pos)}
|
|
|
15428
15496
|
];
|
|
15429
15497
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
15430
15498
|
});
|
|
15431
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15499
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L167, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
15432
15500
|
var children = $3;
|
|
15433
15501
|
$0 = $0.slice(1);
|
|
15434
15502
|
return {
|
|
@@ -15459,7 +15527,7 @@ ${input.slice(result.pos)}
|
|
|
15459
15527
|
return result;
|
|
15460
15528
|
}
|
|
15461
15529
|
}
|
|
15462
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15530
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L167, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
15463
15531
|
module.JSXTagStack.push("");
|
|
15464
15532
|
return $1;
|
|
15465
15533
|
});
|
|
@@ -15490,7 +15558,7 @@ ${input.slice(result.pos)}
|
|
|
15490
15558
|
return $skip;
|
|
15491
15559
|
return $0;
|
|
15492
15560
|
});
|
|
15493
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
15561
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L19, fail, 'JSXOptionalClosingFragment ""');
|
|
15494
15562
|
function JSXOptionalClosingFragment(state) {
|
|
15495
15563
|
let eventData;
|
|
15496
15564
|
if (state.events) {
|
|
@@ -15513,7 +15581,7 @@ ${input.slice(result.pos)}
|
|
|
15513
15581
|
return result;
|
|
15514
15582
|
}
|
|
15515
15583
|
}
|
|
15516
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15584
|
+
var JSXClosingFragment$0 = $EXPECT($L168, fail, 'JSXClosingFragment "</>"');
|
|
15517
15585
|
function JSXClosingFragment(state) {
|
|
15518
15586
|
let eventData;
|
|
15519
15587
|
if (state.events) {
|
|
@@ -16280,7 +16348,7 @@ ${input.slice(result.pos)}
|
|
|
16280
16348
|
}
|
|
16281
16349
|
return $skip;
|
|
16282
16350
|
});
|
|
16283
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
16351
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
16284
16352
|
return { children: [], jsxChildren: [] };
|
|
16285
16353
|
});
|
|
16286
16354
|
function JSXNestedChildren(state) {
|
|
@@ -16409,7 +16477,7 @@ ${input.slice(result.pos)}
|
|
|
16409
16477
|
return result;
|
|
16410
16478
|
}
|
|
16411
16479
|
}
|
|
16412
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16480
|
+
var JSXComment$0 = $TS($S($EXPECT($L169, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L170, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16413
16481
|
return ["{/*", $2, "*/}"];
|
|
16414
16482
|
});
|
|
16415
16483
|
function JSXComment(state) {
|
|
@@ -16707,7 +16775,7 @@ ${input.slice(result.pos)}
|
|
|
16707
16775
|
return result;
|
|
16708
16776
|
}
|
|
16709
16777
|
}
|
|
16710
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16778
|
+
var TypeKeyword$0 = $S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16711
16779
|
function TypeKeyword(state) {
|
|
16712
16780
|
let eventData;
|
|
16713
16781
|
if (state.events) {
|
|
@@ -16730,7 +16798,7 @@ ${input.slice(result.pos)}
|
|
|
16730
16798
|
return result;
|
|
16731
16799
|
}
|
|
16732
16800
|
}
|
|
16733
|
-
var Interface$0 = $S($EXPECT($
|
|
16801
|
+
var Interface$0 = $S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue);
|
|
16734
16802
|
function Interface(state) {
|
|
16735
16803
|
let eventData;
|
|
16736
16804
|
if (state.events) {
|
|
@@ -16753,7 +16821,7 @@ ${input.slice(result.pos)}
|
|
|
16753
16821
|
return result;
|
|
16754
16822
|
}
|
|
16755
16823
|
}
|
|
16756
|
-
var Namespace$0 = $S($EXPECT($
|
|
16824
|
+
var Namespace$0 = $S($EXPECT($L173, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16757
16825
|
function Namespace(state) {
|
|
16758
16826
|
let eventData;
|
|
16759
16827
|
if (state.events) {
|
|
@@ -17001,7 +17069,7 @@ ${input.slice(result.pos)}
|
|
|
17001
17069
|
return result;
|
|
17002
17070
|
}
|
|
17003
17071
|
}
|
|
17004
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
17072
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L141, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R58, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
17005
17073
|
function TypeIndexSignature(state) {
|
|
17006
17074
|
let eventData;
|
|
17007
17075
|
if (state.events) {
|
|
@@ -17048,7 +17116,7 @@ ${input.slice(result.pos)}
|
|
|
17048
17116
|
return result;
|
|
17049
17117
|
}
|
|
17050
17118
|
}
|
|
17051
|
-
var TypeSuffix$0 = $T($S($E(QuestionMark),
|
|
17119
|
+
var TypeSuffix$0 = $T($S($E(QuestionMark), $E(_), Colon, Type), function(value) {
|
|
17052
17120
|
return { "type": "TypeSuffix", "ts": true, "children": value };
|
|
17053
17121
|
});
|
|
17054
17122
|
function TypeSuffix(state) {
|
|
@@ -17073,14 +17141,20 @@ ${input.slice(result.pos)}
|
|
|
17073
17141
|
return result;
|
|
17074
17142
|
}
|
|
17075
17143
|
}
|
|
17076
|
-
var ReturnTypeSuffix$0 = $TS($S(
|
|
17077
|
-
|
|
17078
|
-
|
|
17079
|
-
|
|
17080
|
-
|
|
17144
|
+
var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L174, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17145
|
+
var asserts = $3;
|
|
17146
|
+
var t = $4;
|
|
17147
|
+
if (asserts) {
|
|
17148
|
+
t = {
|
|
17149
|
+
type: "AssertsType",
|
|
17150
|
+
t,
|
|
17151
|
+
children: [asserts[0], asserts[1], t]
|
|
17152
|
+
};
|
|
17153
|
+
}
|
|
17081
17154
|
return {
|
|
17082
17155
|
type: "ReturnTypeAnnotation",
|
|
17083
|
-
children,
|
|
17156
|
+
children: [$1, $2, t],
|
|
17157
|
+
t,
|
|
17084
17158
|
ts: true
|
|
17085
17159
|
};
|
|
17086
17160
|
});
|
|
@@ -17106,10 +17180,17 @@ ${input.slice(result.pos)}
|
|
|
17106
17180
|
return result;
|
|
17107
17181
|
}
|
|
17108
17182
|
}
|
|
17109
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
17110
|
-
|
|
17111
|
-
|
|
17112
|
-
|
|
17183
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L82, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
17184
|
+
var lhs = $1;
|
|
17185
|
+
var rhs = $2;
|
|
17186
|
+
if (!rhs)
|
|
17187
|
+
return lhs;
|
|
17188
|
+
return {
|
|
17189
|
+
type: "TypePredicate",
|
|
17190
|
+
lhs,
|
|
17191
|
+
rhs: rhs[3],
|
|
17192
|
+
children: [lhs, ...rhs]
|
|
17193
|
+
};
|
|
17113
17194
|
});
|
|
17114
17195
|
function TypePredicate(state) {
|
|
17115
17196
|
let eventData;
|
|
@@ -17184,6 +17265,8 @@ ${input.slice(result.pos)}
|
|
|
17184
17265
|
}
|
|
17185
17266
|
}
|
|
17186
17267
|
var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
17268
|
+
if (!$1.length && !$3.length)
|
|
17269
|
+
return $2;
|
|
17187
17270
|
return [...$1, $2, ...$3];
|
|
17188
17271
|
});
|
|
17189
17272
|
function TypeUnary(state) {
|
|
@@ -17232,10 +17315,10 @@ ${input.slice(result.pos)}
|
|
|
17232
17315
|
return result;
|
|
17233
17316
|
}
|
|
17234
17317
|
}
|
|
17235
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
17236
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
17237
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
17238
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17318
|
+
var TypeUnaryOp$0 = $S($EXPECT($L175, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17319
|
+
var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17320
|
+
var TypeUnaryOp$2 = $S($EXPECT($L176, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17321
|
+
var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
17239
17322
|
function TypeUnaryOp(state) {
|
|
17240
17323
|
let eventData;
|
|
17241
17324
|
if (state.events) {
|
|
@@ -17286,8 +17369,23 @@ ${input.slice(result.pos)}
|
|
|
17286
17369
|
var TypePrimary$2 = $S($E(_), InlineInterfaceLiteral);
|
|
17287
17370
|
var TypePrimary$3 = $S($E(_), TypeTuple);
|
|
17288
17371
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
17289
|
-
var TypePrimary$5 = $S($E(_), TypeLiteral)
|
|
17290
|
-
|
|
17372
|
+
var TypePrimary$5 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
|
|
17373
|
+
var t = $2;
|
|
17374
|
+
return {
|
|
17375
|
+
type: "LiteralType",
|
|
17376
|
+
t,
|
|
17377
|
+
children: $0
|
|
17378
|
+
};
|
|
17379
|
+
});
|
|
17380
|
+
var TypePrimary$6 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17381
|
+
var args = $4;
|
|
17382
|
+
return {
|
|
17383
|
+
type: "IdentifierType",
|
|
17384
|
+
children: $0,
|
|
17385
|
+
raw: [$2.name, ...$3.map(([dot, id]) => dot.token + id.name)].join(""),
|
|
17386
|
+
args
|
|
17387
|
+
};
|
|
17388
|
+
});
|
|
17291
17389
|
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
17292
17390
|
function TypePrimary(state) {
|
|
17293
17391
|
let eventData;
|
|
@@ -17433,7 +17531,7 @@ ${input.slice(result.pos)}
|
|
|
17433
17531
|
return result;
|
|
17434
17532
|
}
|
|
17435
17533
|
}
|
|
17436
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17534
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L120, fail, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
17437
17535
|
if ($2)
|
|
17438
17536
|
return $0;
|
|
17439
17537
|
return $1;
|
|
@@ -17462,10 +17560,10 @@ ${input.slice(result.pos)}
|
|
|
17462
17560
|
}
|
|
17463
17561
|
var TypeLiteral$0 = TemplateLiteral;
|
|
17464
17562
|
var TypeLiteral$1 = Literal;
|
|
17465
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17466
|
-
return { $loc, token:
|
|
17563
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
17564
|
+
return { type: "VoidType", $loc, token: $1 };
|
|
17467
17565
|
});
|
|
17468
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17566
|
+
var TypeLiteral$3 = $TV($EXPECT($L177, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
17469
17567
|
return { $loc, token: "[]" };
|
|
17470
17568
|
});
|
|
17471
17569
|
function TypeLiteral(state) {
|
|
@@ -17540,7 +17638,7 @@ ${input.slice(result.pos)}
|
|
|
17540
17638
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
17541
17639
|
return value[1];
|
|
17542
17640
|
});
|
|
17543
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17641
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L33, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
17544
17642
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
17545
17643
|
function InlineInterfacePropertyDelimiter(state) {
|
|
17546
17644
|
let eventData;
|
|
@@ -17564,10 +17662,10 @@ ${input.slice(result.pos)}
|
|
|
17564
17662
|
return result;
|
|
17565
17663
|
}
|
|
17566
17664
|
}
|
|
17567
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17665
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L84, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
17568
17666
|
return { $loc, token: "|" };
|
|
17569
17667
|
});
|
|
17570
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17668
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
17571
17669
|
return { $loc, token: "&" };
|
|
17572
17670
|
});
|
|
17573
17671
|
function TypeBinaryOp(state) {
|
|
@@ -17624,7 +17722,7 @@ ${input.slice(result.pos)}
|
|
|
17624
17722
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17625
17723
|
return { $loc, token: "=>" };
|
|
17626
17724
|
});
|
|
17627
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17725
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17628
17726
|
return { $loc, token: "=>" };
|
|
17629
17727
|
});
|
|
17630
17728
|
function TypeArrowFunction(state) {
|
|
@@ -17649,7 +17747,7 @@ ${input.slice(result.pos)}
|
|
|
17649
17747
|
return result;
|
|
17650
17748
|
}
|
|
17651
17749
|
}
|
|
17652
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17750
|
+
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17653
17751
|
return { ts: true, children: $0 };
|
|
17654
17752
|
});
|
|
17655
17753
|
function TypeArguments(state) {
|
|
@@ -17720,7 +17818,7 @@ ${input.slice(result.pos)}
|
|
|
17720
17818
|
return result;
|
|
17721
17819
|
}
|
|
17722
17820
|
}
|
|
17723
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17821
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L132, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17724
17822
|
var parameters = $3;
|
|
17725
17823
|
return {
|
|
17726
17824
|
type: "TypeParameters",
|
|
@@ -17774,7 +17872,7 @@ ${input.slice(result.pos)}
|
|
|
17774
17872
|
return result;
|
|
17775
17873
|
}
|
|
17776
17874
|
}
|
|
17777
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17875
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L120, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17778
17876
|
function TypeConstraint(state) {
|
|
17779
17877
|
let eventData;
|
|
17780
17878
|
if (state.events) {
|
|
@@ -17821,7 +17919,7 @@ ${input.slice(result.pos)}
|
|
|
17821
17919
|
}
|
|
17822
17920
|
}
|
|
17823
17921
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17824
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17922
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17825
17923
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17826
17924
|
return value[1];
|
|
17827
17925
|
});
|
|
@@ -17925,7 +18023,7 @@ ${input.slice(result.pos)}
|
|
|
17925
18023
|
return result;
|
|
17926
18024
|
}
|
|
17927
18025
|
}
|
|
17928
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
18026
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L178, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R61, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17929
18027
|
var options = $3;
|
|
17930
18028
|
return {
|
|
17931
18029
|
type: "CivetPrologue",
|
|
@@ -18086,7 +18184,7 @@ ${input.slice(result.pos)}
|
|
|
18086
18184
|
return result;
|
|
18087
18185
|
}
|
|
18088
18186
|
}
|
|
18089
|
-
var DebugHere$0 = $TV($EXPECT($
|
|
18187
|
+
var DebugHere$0 = $TV($EXPECT($L19, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
18090
18188
|
debugger;
|
|
18091
18189
|
});
|
|
18092
18190
|
function DebugHere(state) {
|
|
@@ -18111,7 +18209,7 @@ ${input.slice(result.pos)}
|
|
|
18111
18209
|
return result;
|
|
18112
18210
|
}
|
|
18113
18211
|
}
|
|
18114
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
18212
|
+
var InsertSemicolon$0 = $TV($EXPECT($L19, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
18115
18213
|
return { $loc, token: ";" };
|
|
18116
18214
|
});
|
|
18117
18215
|
function InsertSemicolon(state) {
|
|
@@ -18136,7 +18234,7 @@ ${input.slice(result.pos)}
|
|
|
18136
18234
|
return result;
|
|
18137
18235
|
}
|
|
18138
18236
|
}
|
|
18139
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
18237
|
+
var InsertOpenParen$0 = $TV($EXPECT($L19, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
18140
18238
|
return { $loc, token: "(" };
|
|
18141
18239
|
});
|
|
18142
18240
|
function InsertOpenParen(state) {
|
|
@@ -18161,7 +18259,7 @@ ${input.slice(result.pos)}
|
|
|
18161
18259
|
return result;
|
|
18162
18260
|
}
|
|
18163
18261
|
}
|
|
18164
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
18262
|
+
var InsertCloseParen$0 = $TV($EXPECT($L19, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
18165
18263
|
return { $loc, token: ")" };
|
|
18166
18264
|
});
|
|
18167
18265
|
function InsertCloseParen(state) {
|
|
@@ -18186,7 +18284,7 @@ ${input.slice(result.pos)}
|
|
|
18186
18284
|
return result;
|
|
18187
18285
|
}
|
|
18188
18286
|
}
|
|
18189
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
18287
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18190
18288
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
18191
18289
|
});
|
|
18192
18290
|
function InsertOpenBrace(state) {
|
|
@@ -18211,7 +18309,7 @@ ${input.slice(result.pos)}
|
|
|
18211
18309
|
return result;
|
|
18212
18310
|
}
|
|
18213
18311
|
}
|
|
18214
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
18312
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18215
18313
|
return { $loc, token: "{" };
|
|
18216
18314
|
});
|
|
18217
18315
|
function InsertInlineOpenBrace(state) {
|
|
@@ -18236,7 +18334,7 @@ ${input.slice(result.pos)}
|
|
|
18236
18334
|
return result;
|
|
18237
18335
|
}
|
|
18238
18336
|
}
|
|
18239
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
18337
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L19, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
18240
18338
|
return { $loc, token: "}" };
|
|
18241
18339
|
});
|
|
18242
18340
|
function InsertCloseBrace(state) {
|
|
@@ -18261,7 +18359,7 @@ ${input.slice(result.pos)}
|
|
|
18261
18359
|
return result;
|
|
18262
18360
|
}
|
|
18263
18361
|
}
|
|
18264
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
18362
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L19, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
18265
18363
|
return { $loc, token: "[" };
|
|
18266
18364
|
});
|
|
18267
18365
|
function InsertOpenBracket(state) {
|
|
@@ -18286,7 +18384,7 @@ ${input.slice(result.pos)}
|
|
|
18286
18384
|
return result;
|
|
18287
18385
|
}
|
|
18288
18386
|
}
|
|
18289
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
18387
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L19, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
18290
18388
|
return { $loc, token: "]" };
|
|
18291
18389
|
});
|
|
18292
18390
|
function InsertCloseBracket(state) {
|
|
@@ -18311,7 +18409,7 @@ ${input.slice(result.pos)}
|
|
|
18311
18409
|
return result;
|
|
18312
18410
|
}
|
|
18313
18411
|
}
|
|
18314
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
18412
|
+
var InsertComma$0 = $TV($EXPECT($L19, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
18315
18413
|
return { $loc, token: "," };
|
|
18316
18414
|
});
|
|
18317
18415
|
function InsertComma(state) {
|
|
@@ -18336,7 +18434,7 @@ ${input.slice(result.pos)}
|
|
|
18336
18434
|
return result;
|
|
18337
18435
|
}
|
|
18338
18436
|
}
|
|
18339
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
18437
|
+
var InsertConst$0 = $TV($EXPECT($L19, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
18340
18438
|
return { $loc, token: "const " };
|
|
18341
18439
|
});
|
|
18342
18440
|
function InsertConst(state) {
|
|
@@ -18361,7 +18459,7 @@ ${input.slice(result.pos)}
|
|
|
18361
18459
|
return result;
|
|
18362
18460
|
}
|
|
18363
18461
|
}
|
|
18364
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
18462
|
+
var InsertLet$0 = $TV($EXPECT($L19, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
18365
18463
|
return { $loc, token: "let " };
|
|
18366
18464
|
});
|
|
18367
18465
|
function InsertLet(state) {
|
|
@@ -18386,7 +18484,7 @@ ${input.slice(result.pos)}
|
|
|
18386
18484
|
return result;
|
|
18387
18485
|
}
|
|
18388
18486
|
}
|
|
18389
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
18487
|
+
var InsertReadonly$0 = $TV($EXPECT($L19, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
18390
18488
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
18391
18489
|
});
|
|
18392
18490
|
function InsertReadonly(state) {
|
|
@@ -18411,7 +18509,7 @@ ${input.slice(result.pos)}
|
|
|
18411
18509
|
return result;
|
|
18412
18510
|
}
|
|
18413
18511
|
}
|
|
18414
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
18512
|
+
var InsertNewline$0 = $TV($EXPECT($L19, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
18415
18513
|
return "\n";
|
|
18416
18514
|
});
|
|
18417
18515
|
function InsertNewline(state) {
|
|
@@ -18436,7 +18534,7 @@ ${input.slice(result.pos)}
|
|
|
18436
18534
|
return result;
|
|
18437
18535
|
}
|
|
18438
18536
|
}
|
|
18439
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
18537
|
+
var InsertIndent$0 = $TV($EXPECT($L19, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
18440
18538
|
return module.currentIndent.token;
|
|
18441
18539
|
});
|
|
18442
18540
|
function InsertIndent(state) {
|
|
@@ -18461,7 +18559,7 @@ ${input.slice(result.pos)}
|
|
|
18461
18559
|
return result;
|
|
18462
18560
|
}
|
|
18463
18561
|
}
|
|
18464
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
18562
|
+
var InsertSpace$0 = $TV($EXPECT($L19, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
18465
18563
|
return { $loc, token: " " };
|
|
18466
18564
|
});
|
|
18467
18565
|
function InsertSpace(state) {
|
|
@@ -18486,7 +18584,7 @@ ${input.slice(result.pos)}
|
|
|
18486
18584
|
return result;
|
|
18487
18585
|
}
|
|
18488
18586
|
}
|
|
18489
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
18587
|
+
var InsertDot$0 = $TV($EXPECT($L19, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
18490
18588
|
return { $loc, token: "." };
|
|
18491
18589
|
});
|
|
18492
18590
|
function InsertDot(state) {
|
|
@@ -18511,7 +18609,7 @@ ${input.slice(result.pos)}
|
|
|
18511
18609
|
return result;
|
|
18512
18610
|
}
|
|
18513
18611
|
}
|
|
18514
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18612
|
+
var InsertBreak$0 = $TV($EXPECT($L19, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
18515
18613
|
return { $loc, token: ";break;" };
|
|
18516
18614
|
});
|
|
18517
18615
|
function InsertBreak(state) {
|
|
@@ -18536,7 +18634,7 @@ ${input.slice(result.pos)}
|
|
|
18536
18634
|
return result;
|
|
18537
18635
|
}
|
|
18538
18636
|
}
|
|
18539
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18637
|
+
var InsertVar$0 = $TV($EXPECT($L19, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
18540
18638
|
return { $loc, token: "var " };
|
|
18541
18639
|
});
|
|
18542
18640
|
function InsertVar(state) {
|
|
@@ -18561,7 +18659,7 @@ ${input.slice(result.pos)}
|
|
|
18561
18659
|
return result;
|
|
18562
18660
|
}
|
|
18563
18661
|
}
|
|
18564
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18662
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18565
18663
|
if (module.config.coffeeBinaryExistential)
|
|
18566
18664
|
return;
|
|
18567
18665
|
return $skip;
|
|
@@ -18588,7 +18686,7 @@ ${input.slice(result.pos)}
|
|
|
18588
18686
|
return result;
|
|
18589
18687
|
}
|
|
18590
18688
|
}
|
|
18591
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18689
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18592
18690
|
if (module.config.coffeeBooleans)
|
|
18593
18691
|
return;
|
|
18594
18692
|
return $skip;
|
|
@@ -18615,7 +18713,7 @@ ${input.slice(result.pos)}
|
|
|
18615
18713
|
return result;
|
|
18616
18714
|
}
|
|
18617
18715
|
}
|
|
18618
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18716
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18619
18717
|
if (module.config.coffeeClasses)
|
|
18620
18718
|
return;
|
|
18621
18719
|
return $skip;
|
|
@@ -18642,7 +18740,7 @@ ${input.slice(result.pos)}
|
|
|
18642
18740
|
return result;
|
|
18643
18741
|
}
|
|
18644
18742
|
}
|
|
18645
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18743
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18646
18744
|
if (module.config.coffeeComment)
|
|
18647
18745
|
return;
|
|
18648
18746
|
return $skip;
|
|
@@ -18669,7 +18767,7 @@ ${input.slice(result.pos)}
|
|
|
18669
18767
|
return result;
|
|
18670
18768
|
}
|
|
18671
18769
|
}
|
|
18672
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18770
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18673
18771
|
if (module.config.coffeeDo)
|
|
18674
18772
|
return;
|
|
18675
18773
|
return $skip;
|
|
@@ -18696,7 +18794,7 @@ ${input.slice(result.pos)}
|
|
|
18696
18794
|
return result;
|
|
18697
18795
|
}
|
|
18698
18796
|
}
|
|
18699
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18797
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18700
18798
|
if (module.config.coffeeForLoops)
|
|
18701
18799
|
return;
|
|
18702
18800
|
return $skip;
|
|
@@ -18723,7 +18821,7 @@ ${input.slice(result.pos)}
|
|
|
18723
18821
|
return result;
|
|
18724
18822
|
}
|
|
18725
18823
|
}
|
|
18726
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18824
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18727
18825
|
if (module.config.coffeeInterpolation)
|
|
18728
18826
|
return;
|
|
18729
18827
|
return $skip;
|
|
@@ -18750,7 +18848,7 @@ ${input.slice(result.pos)}
|
|
|
18750
18848
|
return result;
|
|
18751
18849
|
}
|
|
18752
18850
|
}
|
|
18753
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18851
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18754
18852
|
if (module.config.coffeeIsnt)
|
|
18755
18853
|
return;
|
|
18756
18854
|
return $skip;
|
|
@@ -18777,7 +18875,7 @@ ${input.slice(result.pos)}
|
|
|
18777
18875
|
return result;
|
|
18778
18876
|
}
|
|
18779
18877
|
}
|
|
18780
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18878
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18781
18879
|
if (module.config.coffeeJSX)
|
|
18782
18880
|
return;
|
|
18783
18881
|
return $skip;
|
|
@@ -18804,7 +18902,7 @@ ${input.slice(result.pos)}
|
|
|
18804
18902
|
return result;
|
|
18805
18903
|
}
|
|
18806
18904
|
}
|
|
18807
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18905
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18808
18906
|
if (module.config.coffeeLineContinuation)
|
|
18809
18907
|
return;
|
|
18810
18908
|
return $skip;
|
|
@@ -18831,7 +18929,7 @@ ${input.slice(result.pos)}
|
|
|
18831
18929
|
return result;
|
|
18832
18930
|
}
|
|
18833
18931
|
}
|
|
18834
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18932
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18835
18933
|
if (module.config.coffeeNot)
|
|
18836
18934
|
return;
|
|
18837
18935
|
return $skip;
|
|
@@ -18858,7 +18956,7 @@ ${input.slice(result.pos)}
|
|
|
18858
18956
|
return result;
|
|
18859
18957
|
}
|
|
18860
18958
|
}
|
|
18861
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18959
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18862
18960
|
if (module.config.coffeeOf)
|
|
18863
18961
|
return;
|
|
18864
18962
|
return $skip;
|
|
@@ -18885,7 +18983,7 @@ ${input.slice(result.pos)}
|
|
|
18885
18983
|
return result;
|
|
18886
18984
|
}
|
|
18887
18985
|
}
|
|
18888
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18986
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18889
18987
|
if (module.config.coffeePrototype)
|
|
18890
18988
|
return;
|
|
18891
18989
|
return $skip;
|
|
@@ -18912,7 +19010,7 @@ ${input.slice(result.pos)}
|
|
|
18912
19010
|
return result;
|
|
18913
19011
|
}
|
|
18914
19012
|
}
|
|
18915
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
19013
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L19, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18916
19014
|
if (module.config.objectIs)
|
|
18917
19015
|
return;
|
|
18918
19016
|
return $skip;
|
|
@@ -18939,7 +19037,7 @@ ${input.slice(result.pos)}
|
|
|
18939
19037
|
return result;
|
|
18940
19038
|
}
|
|
18941
19039
|
}
|
|
18942
|
-
var Reset$0 = $TV($EXPECT($
|
|
19040
|
+
var Reset$0 = $TV($EXPECT($L19, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18943
19041
|
module.indentLevels = [{
|
|
18944
19042
|
level: 0,
|
|
18945
19043
|
token: ""
|
|
@@ -19246,7 +19344,7 @@ ${input.slice(result.pos)}
|
|
|
19246
19344
|
return result;
|
|
19247
19345
|
}
|
|
19248
19346
|
}
|
|
19249
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
19347
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L19, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
19250
19348
|
var directives = $2;
|
|
19251
19349
|
directives.forEach((directive) => {
|
|
19252
19350
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19549,6 +19647,12 @@ ${input.slice(result.pos)}
|
|
|
19549
19647
|
return;
|
|
19550
19648
|
}
|
|
19551
19649
|
}
|
|
19650
|
+
function getIndent(statement) {
|
|
19651
|
+
let indent = statement?.[0];
|
|
19652
|
+
if (Array.isArray(indent))
|
|
19653
|
+
indent = indent[indent.length - 1];
|
|
19654
|
+
return indent;
|
|
19655
|
+
}
|
|
19552
19656
|
function insertReturn(node) {
|
|
19553
19657
|
if (!node)
|
|
19554
19658
|
return;
|
|
@@ -19573,9 +19677,7 @@ ${input.slice(result.pos)}
|
|
|
19573
19677
|
const [, exp, semi] = node;
|
|
19574
19678
|
if (semi?.type === "SemicolonDelimiter")
|
|
19575
19679
|
return;
|
|
19576
|
-
let indent = node
|
|
19577
|
-
if (Array.isArray(indent))
|
|
19578
|
-
indent = indent[indent.length - 1];
|
|
19680
|
+
let indent = getIndent(node);
|
|
19579
19681
|
if (!exp)
|
|
19580
19682
|
return;
|
|
19581
19683
|
switch (exp.type) {
|
|
@@ -19995,12 +20097,14 @@ ${input.slice(result.pos)}
|
|
|
19995
20097
|
}
|
|
19996
20098
|
return [];
|
|
19997
20099
|
}
|
|
19998
|
-
function gatherRecursive(node, predicate) {
|
|
20100
|
+
function gatherRecursive(node, predicate, skipPredicate) {
|
|
19999
20101
|
if (node == null)
|
|
20000
20102
|
return [];
|
|
20001
20103
|
if (Array.isArray(node)) {
|
|
20002
20104
|
return node.flatMap((n) => gatherRecursive(n, predicate));
|
|
20003
20105
|
}
|
|
20106
|
+
if (skipPredicate?.(node))
|
|
20107
|
+
return [];
|
|
20004
20108
|
if (predicate(node)) {
|
|
20005
20109
|
return [node];
|
|
20006
20110
|
}
|
|
@@ -20018,6 +20122,36 @@ ${input.slice(result.pos)}
|
|
|
20018
20122
|
}
|
|
20019
20123
|
return nodes;
|
|
20020
20124
|
}
|
|
20125
|
+
function isFunction({ type }) {
|
|
20126
|
+
return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition";
|
|
20127
|
+
}
|
|
20128
|
+
function gatherRecursiveWithinFunction(node, predicate) {
|
|
20129
|
+
return gatherRecursive(node, predicate, isFunction);
|
|
20130
|
+
}
|
|
20131
|
+
function addParentPointers(node, parent) {
|
|
20132
|
+
if (node == null)
|
|
20133
|
+
return;
|
|
20134
|
+
if (typeof node !== "object")
|
|
20135
|
+
return;
|
|
20136
|
+
node.parent = parent;
|
|
20137
|
+
if (Array.isArray(node)) {
|
|
20138
|
+
for (const child of node) {
|
|
20139
|
+
addParentPointers(child, node);
|
|
20140
|
+
}
|
|
20141
|
+
} else if (node.children) {
|
|
20142
|
+
for (const child of node.children) {
|
|
20143
|
+
addParentPointers(child, node);
|
|
20144
|
+
}
|
|
20145
|
+
}
|
|
20146
|
+
}
|
|
20147
|
+
function findAncestor(node, predicate, stopPredicate) {
|
|
20148
|
+
node = node.parent;
|
|
20149
|
+
while (node && !stopPredicate?.(node)) {
|
|
20150
|
+
if (predicate(node))
|
|
20151
|
+
return node;
|
|
20152
|
+
node = node.parent;
|
|
20153
|
+
}
|
|
20154
|
+
}
|
|
20021
20155
|
function processParams(f) {
|
|
20022
20156
|
const { type, parameters, block } = f;
|
|
20023
20157
|
if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
|
|
@@ -20063,26 +20197,89 @@ ${input.slice(result.pos)}
|
|
|
20063
20197
|
}
|
|
20064
20198
|
});
|
|
20065
20199
|
}
|
|
20200
|
+
function processReturnValue(func) {
|
|
20201
|
+
const { block } = func;
|
|
20202
|
+
const values = gatherRecursiveWithinFunction(
|
|
20203
|
+
block,
|
|
20204
|
+
({ type }) => type === "ReturnValue"
|
|
20205
|
+
);
|
|
20206
|
+
if (!values.length)
|
|
20207
|
+
return false;
|
|
20208
|
+
const ref = {
|
|
20209
|
+
type: "Ref",
|
|
20210
|
+
base: "ret",
|
|
20211
|
+
id: "ret"
|
|
20212
|
+
};
|
|
20213
|
+
let declared;
|
|
20214
|
+
values.forEach((value) => {
|
|
20215
|
+
value.children = [ref];
|
|
20216
|
+
const ancestor = findAncestor(
|
|
20217
|
+
value,
|
|
20218
|
+
({ type }) => type === "Declaration",
|
|
20219
|
+
isFunction
|
|
20220
|
+
);
|
|
20221
|
+
if (ancestor)
|
|
20222
|
+
declared = true;
|
|
20223
|
+
});
|
|
20224
|
+
if (!declared) {
|
|
20225
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
20226
|
+
if (returnType) {
|
|
20227
|
+
const { t } = returnType;
|
|
20228
|
+
if (t.type === "TypePredicate") {
|
|
20229
|
+
returnType = ": boolean";
|
|
20230
|
+
} else if (t.type === "AssertsType") {
|
|
20231
|
+
returnType = void 0;
|
|
20232
|
+
}
|
|
20233
|
+
}
|
|
20234
|
+
block.expressions.unshift([
|
|
20235
|
+
getIndent(block.expressions[0]),
|
|
20236
|
+
{
|
|
20237
|
+
type: "Declaration",
|
|
20238
|
+
children: ["let ", ref, returnType, ";\n"],
|
|
20239
|
+
names: []
|
|
20240
|
+
}
|
|
20241
|
+
]);
|
|
20242
|
+
}
|
|
20243
|
+
gatherRecursiveWithinFunction(
|
|
20244
|
+
block,
|
|
20245
|
+
(r) => r.type === "ReturnStatement" && !r.expression
|
|
20246
|
+
).forEach((r) => {
|
|
20247
|
+
r.expression = ref;
|
|
20248
|
+
r.children.splice(-1, 1, " ", ref);
|
|
20249
|
+
});
|
|
20250
|
+
if (block.children.at(-2)?.type !== "ReturnStatement") {
|
|
20251
|
+
block.expressions.push([
|
|
20252
|
+
["\n", getIndent(block.expressions.at(-1))],
|
|
20253
|
+
{
|
|
20254
|
+
type: "ReturnStatement",
|
|
20255
|
+
expression: ref,
|
|
20256
|
+
children: ["return ", ref]
|
|
20257
|
+
}
|
|
20258
|
+
]);
|
|
20259
|
+
}
|
|
20260
|
+
return true;
|
|
20261
|
+
}
|
|
20262
|
+
function isVoidType(t) {
|
|
20263
|
+
return t?.type === "LiteralType" && t.t.type === "VoidType";
|
|
20264
|
+
}
|
|
20066
20265
|
function processFunctions(statements) {
|
|
20067
|
-
gatherRecursiveAll(statements, (
|
|
20068
|
-
return n.type === "FunctionExpression" || n.type === "ArrowFunction";
|
|
20069
|
-
}).forEach((f) => {
|
|
20266
|
+
gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
|
|
20070
20267
|
processParams(f);
|
|
20071
|
-
|
|
20072
|
-
|
|
20073
|
-
const isVoid = returnType
|
|
20268
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20269
|
+
const { block, returnType } = f;
|
|
20270
|
+
const isVoid = isVoidType(returnType?.t);
|
|
20074
20271
|
const isBlock = block?.type === "BlockStatement";
|
|
20075
20272
|
if (!isVoid && isBlock) {
|
|
20076
20273
|
insertReturn(block);
|
|
20077
20274
|
}
|
|
20078
20275
|
}
|
|
20079
20276
|
});
|
|
20080
|
-
gatherRecursiveAll(statements, (
|
|
20277
|
+
gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
|
|
20081
20278
|
processParams(f);
|
|
20082
|
-
|
|
20083
|
-
|
|
20279
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20280
|
+
const { signature, block } = f;
|
|
20084
20281
|
const isConstructor = signature.name === "constructor";
|
|
20085
|
-
const isVoid = signature.returnType
|
|
20282
|
+
const isVoid = isVoidType(signature.returnType?.t);
|
|
20086
20283
|
const isSet = signature.modifier === "set";
|
|
20087
20284
|
if (!isConstructor && !isSet && !isVoid) {
|
|
20088
20285
|
insertReturn(block);
|
|
@@ -20570,6 +20767,7 @@ ${input.slice(result.pos)}
|
|
|
20570
20767
|
});
|
|
20571
20768
|
}
|
|
20572
20769
|
module.processProgram = function(statements) {
|
|
20770
|
+
addParentPointers(statements);
|
|
20573
20771
|
processPipelineExpressions(statements);
|
|
20574
20772
|
processAssignments(statements);
|
|
20575
20773
|
processFunctions(statements);
|
|
@@ -20596,18 +20794,7 @@ ${input.slice(result.pos)}
|
|
|
20596
20794
|
return new Set(declarationNames);
|
|
20597
20795
|
}
|
|
20598
20796
|
function populateRefs(statements) {
|
|
20599
|
-
const refNodes =
|
|
20600
|
-
const blockNodes = new Set(gatherNodes(statements, ({ type }) => type === "BlockStatement"));
|
|
20601
|
-
const forNodes = gatherNodes(statements, ({ type }) => type === "ForStatement");
|
|
20602
|
-
forNodes.forEach(({ declaration, block }) => {
|
|
20603
|
-
if (block.type === "BlockStatement") {
|
|
20604
|
-
populateRefs([declaration, ...block.children]);
|
|
20605
|
-
} else {
|
|
20606
|
-
populateRefs([declaration, ...block]);
|
|
20607
|
-
}
|
|
20608
|
-
blockNodes.delete(block);
|
|
20609
|
-
});
|
|
20610
|
-
blockNodes.forEach(({ expressions }) => populateRefs(expressions));
|
|
20797
|
+
const refNodes = gatherRecursive(statements, ({ type }) => type === "Ref");
|
|
20611
20798
|
if (refNodes.length) {
|
|
20612
20799
|
const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
|
|
20613
20800
|
const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
|
|
@@ -21013,7 +21200,7 @@ ${input.slice(result.pos)}
|
|
|
21013
21200
|
return result;
|
|
21014
21201
|
}
|
|
21015
21202
|
}
|
|
21016
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
21203
|
+
var PopIndent$0 = $TV($EXPECT($L19, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
21017
21204
|
if (module.config.verbose) {
|
|
21018
21205
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
21019
21206
|
}
|
|
@@ -21161,6 +21348,9 @@ ${input.slice(result.pos)}
|
|
|
21161
21348
|
if (node.length === 0) {
|
|
21162
21349
|
return;
|
|
21163
21350
|
}
|
|
21351
|
+
if (node.parent != null) {
|
|
21352
|
+
delete node.parent;
|
|
21353
|
+
}
|
|
21164
21354
|
if (Array.isArray(node)) {
|
|
21165
21355
|
a = node.map(function(n) {
|
|
21166
21356
|
return prune(n);
|