@danielx/civet 0.5.70 → 0.5.72
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 +729 -510
- package/dist/civet +8 -1
- package/dist/main.js +729 -510
- package/dist/main.mjs +729 -510
- 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;
|
|
@@ -3644,6 +3700,20 @@ ${input.slice(result.pos)}
|
|
|
3644
3700
|
children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
|
|
3645
3701
|
};
|
|
3646
3702
|
});
|
|
3703
|
+
var SliceParameters$2 = $TS($S(Loc, __, $C(DotDot, DotDotDot), $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3704
|
+
var l = $1;
|
|
3705
|
+
var ws = $2;
|
|
3706
|
+
const start = {
|
|
3707
|
+
$loc: l.$loc,
|
|
3708
|
+
token: "0"
|
|
3709
|
+
};
|
|
3710
|
+
return {
|
|
3711
|
+
type: "SliceParameters",
|
|
3712
|
+
start,
|
|
3713
|
+
end: void 0,
|
|
3714
|
+
children: [start, ws]
|
|
3715
|
+
};
|
|
3716
|
+
});
|
|
3647
3717
|
function SliceParameters(state) {
|
|
3648
3718
|
let eventData;
|
|
3649
3719
|
if (state.events) {
|
|
@@ -3655,12 +3725,12 @@ ${input.slice(result.pos)}
|
|
|
3655
3725
|
}
|
|
3656
3726
|
}
|
|
3657
3727
|
if (state.tokenize) {
|
|
3658
|
-
const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
|
|
3728
|
+
const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state));
|
|
3659
3729
|
if (state.events)
|
|
3660
3730
|
state.events.exit?.("SliceParameters", state, result, eventData);
|
|
3661
3731
|
return result;
|
|
3662
3732
|
} else {
|
|
3663
|
-
const result = SliceParameters$0(state) || SliceParameters$1(state);
|
|
3733
|
+
const result = SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state);
|
|
3664
3734
|
if (state.events)
|
|
3665
3735
|
state.events.exit?.("SliceParameters", state, result, eventData);
|
|
3666
3736
|
return result;
|
|
@@ -3764,7 +3834,7 @@ ${input.slice(result.pos)}
|
|
|
3764
3834
|
}
|
|
3765
3835
|
}
|
|
3766
3836
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3767
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3837
|
+
var MetaProperty$1 = $TS($S($EXPECT($L18, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3768
3838
|
return { $loc, token: $1 };
|
|
3769
3839
|
});
|
|
3770
3840
|
function MetaProperty(state) {
|
|
@@ -3790,7 +3860,7 @@ ${input.slice(result.pos)}
|
|
|
3790
3860
|
}
|
|
3791
3861
|
}
|
|
3792
3862
|
var Parameters$0 = NonEmptyParameters;
|
|
3793
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3863
|
+
var Parameters$1 = $TV($EXPECT($L19, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3794
3864
|
return {
|
|
3795
3865
|
type: "Parameters",
|
|
3796
3866
|
children: [{ $loc, token: "()" }],
|
|
@@ -4013,6 +4083,9 @@ ${input.slice(result.pos)}
|
|
|
4013
4083
|
};
|
|
4014
4084
|
});
|
|
4015
4085
|
var NWBindingIdentifier$1 = Identifier;
|
|
4086
|
+
var NWBindingIdentifier$2 = $TS($S(ReturnValue), function($skip, $loc, $0, $1) {
|
|
4087
|
+
return { children: [$1], names: [] };
|
|
4088
|
+
});
|
|
4016
4089
|
function NWBindingIdentifier(state) {
|
|
4017
4090
|
let eventData;
|
|
4018
4091
|
if (state.events) {
|
|
@@ -4024,12 +4097,12 @@ ${input.slice(result.pos)}
|
|
|
4024
4097
|
}
|
|
4025
4098
|
}
|
|
4026
4099
|
if (state.tokenize) {
|
|
4027
|
-
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state));
|
|
4100
|
+
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state));
|
|
4028
4101
|
if (state.events)
|
|
4029
4102
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4030
4103
|
return result;
|
|
4031
4104
|
} else {
|
|
4032
|
-
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state);
|
|
4105
|
+
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state);
|
|
4033
4106
|
if (state.events)
|
|
4034
4107
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4035
4108
|
return result;
|
|
@@ -4410,7 +4483,7 @@ ${input.slice(result.pos)}
|
|
|
4410
4483
|
}
|
|
4411
4484
|
}
|
|
4412
4485
|
var BindingProperty$0 = BindingRestProperty;
|
|
4413
|
-
var BindingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4486
|
+
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
4487
|
var name = $2;
|
|
4415
4488
|
var b = $5;
|
|
4416
4489
|
var init = $6;
|
|
@@ -4571,7 +4644,7 @@ ${input.slice(result.pos)}
|
|
|
4571
4644
|
children: $0
|
|
4572
4645
|
};
|
|
4573
4646
|
});
|
|
4574
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4647
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4575
4648
|
return {
|
|
4576
4649
|
children: [{
|
|
4577
4650
|
type: "ElisionElement",
|
|
@@ -4644,7 +4717,7 @@ ${input.slice(result.pos)}
|
|
|
4644
4717
|
return result;
|
|
4645
4718
|
}
|
|
4646
4719
|
}
|
|
4647
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4720
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L19, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4648
4721
|
const ref = {
|
|
4649
4722
|
type: "Ref",
|
|
4650
4723
|
base: "ref",
|
|
@@ -4862,7 +4935,7 @@ ${input.slice(result.pos)}
|
|
|
4862
4935
|
}
|
|
4863
4936
|
}
|
|
4864
4937
|
var MatchingProperty$0 = MatchingRestProperty;
|
|
4865
|
-
var MatchingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4938
|
+
var MatchingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4866
4939
|
var name = $2;
|
|
4867
4940
|
var match = $6;
|
|
4868
4941
|
return {
|
|
@@ -5088,7 +5161,7 @@ ${input.slice(result.pos)}
|
|
|
5088
5161
|
}
|
|
5089
5162
|
}
|
|
5090
5163
|
var MatchingElement$0 = MatchingRestElement;
|
|
5091
|
-
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier,
|
|
5164
|
+
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5092
5165
|
var ws = $1;
|
|
5093
5166
|
var name = $2;
|
|
5094
5167
|
var match = $6;
|
|
@@ -5120,7 +5193,7 @@ ${input.slice(result.pos)}
|
|
|
5120
5193
|
children: [ws, binding]
|
|
5121
5194
|
};
|
|
5122
5195
|
});
|
|
5123
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5196
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5124
5197
|
return {
|
|
5125
5198
|
children: [{
|
|
5126
5199
|
type: "ElisionElement",
|
|
@@ -5213,7 +5286,7 @@ ${input.slice(result.pos)}
|
|
|
5213
5286
|
type: "FunctionSignature",
|
|
5214
5287
|
id: wid?.[1],
|
|
5215
5288
|
parameters,
|
|
5216
|
-
returnType: suffix
|
|
5289
|
+
returnType: suffix,
|
|
5217
5290
|
ts: false,
|
|
5218
5291
|
block: null,
|
|
5219
5292
|
children: !parameters.implicit ? $0 : [async, func, star, wid, parameters, w, suffix]
|
|
@@ -5268,19 +5341,15 @@ ${input.slice(result.pos)}
|
|
|
5268
5341
|
};
|
|
5269
5342
|
return {
|
|
5270
5343
|
type: "ArrowFunction",
|
|
5271
|
-
children: [ref2, " => ", prefix, ref2]
|
|
5344
|
+
children: [ref2, " => ", prefix, ref2],
|
|
5345
|
+
ampersandBlock: true
|
|
5272
5346
|
};
|
|
5273
5347
|
}
|
|
5274
5348
|
const { ref } = rhs;
|
|
5275
|
-
if (!prefix) {
|
|
5276
|
-
return {
|
|
5277
|
-
type: "ArrowFunction",
|
|
5278
|
-
children: [ref, " => ", rhs]
|
|
5279
|
-
};
|
|
5280
|
-
}
|
|
5281
5349
|
return {
|
|
5282
5350
|
type: "ArrowFunction",
|
|
5283
|
-
children: [ref, " => ", prefix, rhs]
|
|
5351
|
+
children: [ref, " => ", prefix, rhs],
|
|
5352
|
+
ampersandBlock: true
|
|
5284
5353
|
};
|
|
5285
5354
|
});
|
|
5286
5355
|
function FunctionExpression(state) {
|
|
@@ -5372,7 +5441,7 @@ ${input.slice(result.pos)}
|
|
|
5372
5441
|
type: "FunctionSignature",
|
|
5373
5442
|
id,
|
|
5374
5443
|
parameters,
|
|
5375
|
-
returnType: suffix
|
|
5444
|
+
returnType: suffix,
|
|
5376
5445
|
ts: false,
|
|
5377
5446
|
block: null,
|
|
5378
5447
|
children: [func, w1, id, w2, parameters, suffix]
|
|
@@ -5481,7 +5550,7 @@ ${input.slice(result.pos)}
|
|
|
5481
5550
|
type: "FunctionExpression",
|
|
5482
5551
|
id: void 0,
|
|
5483
5552
|
parameters,
|
|
5484
|
-
returnType: suffix
|
|
5553
|
+
returnType: suffix,
|
|
5485
5554
|
ts: false,
|
|
5486
5555
|
block,
|
|
5487
5556
|
children: [
|
|
@@ -5514,7 +5583,7 @@ ${input.slice(result.pos)}
|
|
|
5514
5583
|
return result;
|
|
5515
5584
|
}
|
|
5516
5585
|
}
|
|
5517
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5586
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5518
5587
|
return { $loc, token: $1 };
|
|
5519
5588
|
});
|
|
5520
5589
|
function Arrow(state) {
|
|
@@ -5578,12 +5647,16 @@ ${input.slice(result.pos)}
|
|
|
5578
5647
|
return result;
|
|
5579
5648
|
}
|
|
5580
5649
|
}
|
|
5581
|
-
var ImplicitNestedBlock$0 = $TS($S(InsertOpenBrace, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5582
|
-
var
|
|
5583
|
-
|
|
5584
|
-
|
|
5650
|
+
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) {
|
|
5651
|
+
var open = $2;
|
|
5652
|
+
if (!$4)
|
|
5653
|
+
return $skip;
|
|
5654
|
+
const [block, ...tail] = $4;
|
|
5655
|
+
return {
|
|
5656
|
+
...block,
|
|
5657
|
+
children: [open, ...block.children, ...tail],
|
|
5585
5658
|
bare: false
|
|
5586
|
-
}
|
|
5659
|
+
};
|
|
5587
5660
|
});
|
|
5588
5661
|
function ImplicitNestedBlock(state) {
|
|
5589
5662
|
let eventData;
|
|
@@ -5748,7 +5821,7 @@ ${input.slice(result.pos)}
|
|
|
5748
5821
|
return result;
|
|
5749
5822
|
}
|
|
5750
5823
|
}
|
|
5751
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5824
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L19, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5752
5825
|
const expressions = [];
|
|
5753
5826
|
return {
|
|
5754
5827
|
type: "BlockStatement",
|
|
@@ -5851,12 +5924,16 @@ ${input.slice(result.pos)}
|
|
|
5851
5924
|
return result;
|
|
5852
5925
|
}
|
|
5853
5926
|
}
|
|
5854
|
-
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5855
|
-
var
|
|
5927
|
+
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5928
|
+
var ws1 = $1;
|
|
5929
|
+
var open = $2;
|
|
5930
|
+
if (!$4)
|
|
5931
|
+
return $skip;
|
|
5932
|
+
const [block, ws2, close] = $4;
|
|
5856
5933
|
return {
|
|
5857
5934
|
type: "BlockStatement",
|
|
5858
5935
|
expressions: block.expressions,
|
|
5859
|
-
children: [
|
|
5936
|
+
children: [ws1, open, ...block.children, ws2, close],
|
|
5860
5937
|
bare: false
|
|
5861
5938
|
};
|
|
5862
5939
|
return block;
|
|
@@ -5971,7 +6048,7 @@ ${input.slice(result.pos)}
|
|
|
5971
6048
|
children: [$1, expressions]
|
|
5972
6049
|
};
|
|
5973
6050
|
});
|
|
5974
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6051
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5975
6052
|
const expressions = [];
|
|
5976
6053
|
return {
|
|
5977
6054
|
type: "BlockStatement",
|
|
@@ -6116,7 +6193,7 @@ ${input.slice(result.pos)}
|
|
|
6116
6193
|
return result;
|
|
6117
6194
|
}
|
|
6118
6195
|
}
|
|
6119
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6196
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6120
6197
|
return { $loc, token: $1 };
|
|
6121
6198
|
});
|
|
6122
6199
|
function NullLiteral(state) {
|
|
@@ -6144,7 +6221,7 @@ ${input.slice(result.pos)}
|
|
|
6144
6221
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6145
6222
|
return value[1];
|
|
6146
6223
|
});
|
|
6147
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6224
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6148
6225
|
return { $loc, token: $1 };
|
|
6149
6226
|
});
|
|
6150
6227
|
function BooleanLiteral(state) {
|
|
@@ -6169,10 +6246,10 @@ ${input.slice(result.pos)}
|
|
|
6169
6246
|
return result;
|
|
6170
6247
|
}
|
|
6171
6248
|
}
|
|
6172
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6249
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6173
6250
|
return { $loc, token: "true" };
|
|
6174
6251
|
});
|
|
6175
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6252
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6176
6253
|
return { $loc, token: "false" };
|
|
6177
6254
|
});
|
|
6178
6255
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6278,7 +6355,7 @@ ${input.slice(result.pos)}
|
|
|
6278
6355
|
return result;
|
|
6279
6356
|
}
|
|
6280
6357
|
}
|
|
6281
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6358
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6282
6359
|
function UpcomingAssignment(state) {
|
|
6283
6360
|
let eventData;
|
|
6284
6361
|
if (state.events) {
|
|
@@ -6544,7 +6621,7 @@ ${input.slice(result.pos)}
|
|
|
6544
6621
|
}
|
|
6545
6622
|
}
|
|
6546
6623
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6547
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6624
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6548
6625
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6549
6626
|
return value[1];
|
|
6550
6627
|
});
|
|
@@ -6971,7 +7048,7 @@ ${input.slice(result.pos)}
|
|
|
6971
7048
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6972
7049
|
return value[1];
|
|
6973
7050
|
});
|
|
6974
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
7051
|
+
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
7052
|
return "";
|
|
6976
7053
|
});
|
|
6977
7054
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -7000,7 +7077,7 @@ ${input.slice(result.pos)}
|
|
|
7000
7077
|
}
|
|
7001
7078
|
}
|
|
7002
7079
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
7003
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7080
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
7004
7081
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7005
7082
|
return value[1];
|
|
7006
7083
|
});
|
|
@@ -7170,7 +7247,7 @@ ${input.slice(result.pos)}
|
|
|
7170
7247
|
return result;
|
|
7171
7248
|
}
|
|
7172
7249
|
}
|
|
7173
|
-
var NamedProperty$0 = $TS($S(PropertyName,
|
|
7250
|
+
var NamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7174
7251
|
var name = $1;
|
|
7175
7252
|
var exp = $4;
|
|
7176
7253
|
return {
|
|
@@ -7203,7 +7280,7 @@ ${input.slice(result.pos)}
|
|
|
7203
7280
|
return result;
|
|
7204
7281
|
}
|
|
7205
7282
|
}
|
|
7206
|
-
var ImplicitNamedProperty$0 = $TS($S(PropertyName,
|
|
7283
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7207
7284
|
var name = $1;
|
|
7208
7285
|
var exp = $5;
|
|
7209
7286
|
return {
|
|
@@ -7310,7 +7387,7 @@ ${input.slice(result.pos)}
|
|
|
7310
7387
|
expression
|
|
7311
7388
|
};
|
|
7312
7389
|
});
|
|
7313
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7390
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L17, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7314
7391
|
return {
|
|
7315
7392
|
type: "ComputedPropertyName",
|
|
7316
7393
|
children: $0
|
|
@@ -7478,7 +7555,7 @@ ${input.slice(result.pos)}
|
|
|
7478
7555
|
children: $0,
|
|
7479
7556
|
name,
|
|
7480
7557
|
modifier: $1?.[0]?.token,
|
|
7481
|
-
returnType:
|
|
7558
|
+
returnType: suffix,
|
|
7482
7559
|
parameters
|
|
7483
7560
|
};
|
|
7484
7561
|
});
|
|
@@ -7659,22 +7736,22 @@ ${input.slice(result.pos)}
|
|
|
7659
7736
|
return result;
|
|
7660
7737
|
}
|
|
7661
7738
|
}
|
|
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($
|
|
7739
|
+
var AssignmentOpSymbol$0 = $EXPECT($L34, fail, 'AssignmentOpSymbol "**="');
|
|
7740
|
+
var AssignmentOpSymbol$1 = $EXPECT($L35, fail, 'AssignmentOpSymbol "*="');
|
|
7741
|
+
var AssignmentOpSymbol$2 = $EXPECT($L36, fail, 'AssignmentOpSymbol "/="');
|
|
7742
|
+
var AssignmentOpSymbol$3 = $EXPECT($L37, fail, 'AssignmentOpSymbol "%="');
|
|
7743
|
+
var AssignmentOpSymbol$4 = $EXPECT($L38, fail, 'AssignmentOpSymbol "+="');
|
|
7744
|
+
var AssignmentOpSymbol$5 = $EXPECT($L39, fail, 'AssignmentOpSymbol "-="');
|
|
7745
|
+
var AssignmentOpSymbol$6 = $EXPECT($L40, fail, 'AssignmentOpSymbol "<<="');
|
|
7746
|
+
var AssignmentOpSymbol$7 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>>="');
|
|
7747
|
+
var AssignmentOpSymbol$8 = $EXPECT($L42, fail, 'AssignmentOpSymbol ">>="');
|
|
7748
|
+
var AssignmentOpSymbol$9 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&&="');
|
|
7749
|
+
var AssignmentOpSymbol$10 = $EXPECT($L44, fail, 'AssignmentOpSymbol "&="');
|
|
7750
|
+
var AssignmentOpSymbol$11 = $EXPECT($L45, fail, 'AssignmentOpSymbol "^="');
|
|
7751
|
+
var AssignmentOpSymbol$12 = $EXPECT($L46, fail, 'AssignmentOpSymbol "||="');
|
|
7752
|
+
var AssignmentOpSymbol$13 = $EXPECT($L47, fail, 'AssignmentOpSymbol "|="');
|
|
7753
|
+
var AssignmentOpSymbol$14 = $EXPECT($L48, fail, 'AssignmentOpSymbol "??="');
|
|
7754
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L49, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7678
7755
|
return "??=";
|
|
7679
7756
|
});
|
|
7680
7757
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7705,10 +7782,10 @@ ${input.slice(result.pos)}
|
|
|
7705
7782
|
return result;
|
|
7706
7783
|
}
|
|
7707
7784
|
}
|
|
7708
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7785
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7709
7786
|
return "&&=";
|
|
7710
7787
|
});
|
|
7711
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7788
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L51, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7712
7789
|
return "||=";
|
|
7713
7790
|
});
|
|
7714
7791
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7747,7 +7824,7 @@ ${input.slice(result.pos)}
|
|
|
7747
7824
|
special: true
|
|
7748
7825
|
};
|
|
7749
7826
|
});
|
|
7750
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7827
|
+
var BinaryOp$2 = $TS($S($EXPECT($L52, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7751
7828
|
var id = $4;
|
|
7752
7829
|
if (!module.operators.has(id.name))
|
|
7753
7830
|
return $skip;
|
|
@@ -7779,21 +7856,21 @@ ${input.slice(result.pos)}
|
|
|
7779
7856
|
return result;
|
|
7780
7857
|
}
|
|
7781
7858
|
}
|
|
7782
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7783
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7784
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7785
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7859
|
+
var BinaryOpSymbol$0 = $EXPECT($L53, fail, 'BinaryOpSymbol "**"');
|
|
7860
|
+
var BinaryOpSymbol$1 = $EXPECT($L54, fail, 'BinaryOpSymbol "*"');
|
|
7861
|
+
var BinaryOpSymbol$2 = $EXPECT($L55, fail, 'BinaryOpSymbol "/"');
|
|
7862
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7786
7863
|
return {
|
|
7787
7864
|
call: module.getRef("modulo"),
|
|
7788
7865
|
special: true
|
|
7789
7866
|
};
|
|
7790
7867
|
});
|
|
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($
|
|
7868
|
+
var BinaryOpSymbol$4 = $EXPECT($L57, fail, 'BinaryOpSymbol "%"');
|
|
7869
|
+
var BinaryOpSymbol$5 = $EXPECT($L58, fail, 'BinaryOpSymbol "+"');
|
|
7870
|
+
var BinaryOpSymbol$6 = $EXPECT($L17, fail, 'BinaryOpSymbol "-"');
|
|
7871
|
+
var BinaryOpSymbol$7 = $EXPECT($L59, fail, 'BinaryOpSymbol "<="');
|
|
7872
|
+
var BinaryOpSymbol$8 = $EXPECT($L60, fail, 'BinaryOpSymbol ">="');
|
|
7873
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7797
7874
|
return {
|
|
7798
7875
|
$loc,
|
|
7799
7876
|
token: "instanceof",
|
|
@@ -7801,7 +7878,7 @@ ${input.slice(result.pos)}
|
|
|
7801
7878
|
special: true
|
|
7802
7879
|
};
|
|
7803
7880
|
});
|
|
7804
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7881
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L62, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7805
7882
|
return {
|
|
7806
7883
|
$loc,
|
|
7807
7884
|
token: "instanceof",
|
|
@@ -7810,58 +7887,58 @@ ${input.slice(result.pos)}
|
|
|
7810
7887
|
negated: true
|
|
7811
7888
|
};
|
|
7812
7889
|
});
|
|
7813
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7890
|
+
var BinaryOpSymbol$11 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
7814
7891
|
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
7892
|
return "<";
|
|
7816
7893
|
});
|
|
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($
|
|
7894
|
+
var BinaryOpSymbol$13 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
7895
|
+
var BinaryOpSymbol$14 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
7896
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7897
|
+
var BinaryOpSymbol$16 = $EXPECT($L66, fail, 'BinaryOpSymbol "!=="');
|
|
7898
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L67, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7822
7899
|
if (module.config.coffeeEq)
|
|
7823
7900
|
return "!==";
|
|
7824
7901
|
return $1;
|
|
7825
7902
|
});
|
|
7826
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7903
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7827
7904
|
if (module.config.coffeeIsnt)
|
|
7828
7905
|
return "!==";
|
|
7829
7906
|
return $skip;
|
|
7830
7907
|
});
|
|
7831
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7832
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7908
|
+
var BinaryOpSymbol$19 = $EXPECT($L69, fail, 'BinaryOpSymbol "==="');
|
|
7909
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7833
7910
|
if (module.config.coffeeEq)
|
|
7834
7911
|
return "===";
|
|
7835
7912
|
return $1;
|
|
7836
7913
|
});
|
|
7837
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7914
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7838
7915
|
return "&&";
|
|
7839
7916
|
});
|
|
7840
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7841
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7917
|
+
var BinaryOpSymbol$22 = $EXPECT($L72, fail, 'BinaryOpSymbol "&&"');
|
|
7918
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7842
7919
|
return "in";
|
|
7843
7920
|
});
|
|
7844
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7921
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7845
7922
|
return "||";
|
|
7846
7923
|
});
|
|
7847
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7848
|
-
var BinaryOpSymbol$26 = $TV($C($EXPECT($
|
|
7924
|
+
var BinaryOpSymbol$25 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
7925
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L76, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7849
7926
|
return {
|
|
7850
7927
|
call: module.getRef("xor"),
|
|
7851
7928
|
special: true
|
|
7852
7929
|
};
|
|
7853
7930
|
});
|
|
7854
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
7931
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L78, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7855
7932
|
return {
|
|
7856
7933
|
call: module.getRef("xnor"),
|
|
7857
7934
|
special: true
|
|
7858
7935
|
};
|
|
7859
7936
|
});
|
|
7860
|
-
var BinaryOpSymbol$28 = $EXPECT($
|
|
7937
|
+
var BinaryOpSymbol$28 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
|
|
7861
7938
|
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7862
7939
|
return "??";
|
|
7863
7940
|
});
|
|
7864
|
-
var BinaryOpSymbol$30 = $TS($S($EXPECT($
|
|
7941
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7865
7942
|
return {
|
|
7866
7943
|
$loc,
|
|
7867
7944
|
token: $1,
|
|
@@ -7869,7 +7946,7 @@ ${input.slice(result.pos)}
|
|
|
7869
7946
|
special: true
|
|
7870
7947
|
};
|
|
7871
7948
|
});
|
|
7872
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
7949
|
+
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
7950
|
return {
|
|
7874
7951
|
$loc,
|
|
7875
7952
|
token: "instanceof",
|
|
@@ -7878,7 +7955,7 @@ ${input.slice(result.pos)}
|
|
|
7878
7955
|
negated: true
|
|
7879
7956
|
};
|
|
7880
7957
|
});
|
|
7881
|
-
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($
|
|
7958
|
+
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
7959
|
return {
|
|
7883
7960
|
$loc,
|
|
7884
7961
|
token: "in",
|
|
@@ -7886,7 +7963,7 @@ ${input.slice(result.pos)}
|
|
|
7886
7963
|
negated: true
|
|
7887
7964
|
};
|
|
7888
7965
|
});
|
|
7889
|
-
var BinaryOpSymbol$33 = $TS($S($EXPECT($
|
|
7966
|
+
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
7967
|
return {
|
|
7891
7968
|
method: "includes",
|
|
7892
7969
|
relational: true,
|
|
@@ -7894,7 +7971,7 @@ ${input.slice(result.pos)}
|
|
|
7894
7971
|
special: true
|
|
7895
7972
|
};
|
|
7896
7973
|
});
|
|
7897
|
-
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7974
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7898
7975
|
return {
|
|
7899
7976
|
call: [module.getRef("indexOf"), ".call"],
|
|
7900
7977
|
relational: true,
|
|
@@ -7903,7 +7980,7 @@ ${input.slice(result.pos)}
|
|
|
7903
7980
|
special: true
|
|
7904
7981
|
};
|
|
7905
7982
|
});
|
|
7906
|
-
var BinaryOpSymbol$35 = $TS($S($EXPECT($
|
|
7983
|
+
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
7984
|
return {
|
|
7908
7985
|
method: "includes",
|
|
7909
7986
|
relational: true,
|
|
@@ -7912,7 +7989,7 @@ ${input.slice(result.pos)}
|
|
|
7912
7989
|
negated: true
|
|
7913
7990
|
};
|
|
7914
7991
|
});
|
|
7915
|
-
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7992
|
+
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
7993
|
return {
|
|
7917
7994
|
call: [module.getRef("indexOf"), ".call"],
|
|
7918
7995
|
relational: true,
|
|
@@ -7921,7 +7998,7 @@ ${input.slice(result.pos)}
|
|
|
7921
7998
|
special: true
|
|
7922
7999
|
};
|
|
7923
8000
|
});
|
|
7924
|
-
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($
|
|
8001
|
+
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
8002
|
if (module.config.objectIs) {
|
|
7926
8003
|
return {
|
|
7927
8004
|
call: module.getRef("is"),
|
|
@@ -7933,7 +8010,7 @@ ${input.slice(result.pos)}
|
|
|
7933
8010
|
}
|
|
7934
8011
|
return "!==";
|
|
7935
8012
|
});
|
|
7936
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8013
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7937
8014
|
if (module.config.objectIs) {
|
|
7938
8015
|
return {
|
|
7939
8016
|
call: module.getRef("is"),
|
|
@@ -7944,12 +8021,12 @@ ${input.slice(result.pos)}
|
|
|
7944
8021
|
}
|
|
7945
8022
|
return "===";
|
|
7946
8023
|
});
|
|
7947
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
8024
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7948
8025
|
return $1;
|
|
7949
8026
|
});
|
|
7950
|
-
var BinaryOpSymbol$40 = $EXPECT($
|
|
7951
|
-
var BinaryOpSymbol$41 = $EXPECT($
|
|
7952
|
-
var BinaryOpSymbol$42 = $EXPECT($
|
|
8027
|
+
var BinaryOpSymbol$40 = $EXPECT($L83, fail, 'BinaryOpSymbol "&"');
|
|
8028
|
+
var BinaryOpSymbol$41 = $EXPECT($L16, fail, 'BinaryOpSymbol "^"');
|
|
8029
|
+
var BinaryOpSymbol$42 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
|
|
7953
8030
|
function BinaryOpSymbol(state) {
|
|
7954
8031
|
let eventData;
|
|
7955
8032
|
if (state.events) {
|
|
@@ -7972,8 +8049,8 @@ ${input.slice(result.pos)}
|
|
|
7972
8049
|
return result;
|
|
7973
8050
|
}
|
|
7974
8051
|
}
|
|
7975
|
-
var Xor$0 = $EXPECT($
|
|
7976
|
-
var Xor$1 = $S($EXPECT($
|
|
8052
|
+
var Xor$0 = $EXPECT($L76, fail, 'Xor "^^"');
|
|
8053
|
+
var Xor$1 = $S($EXPECT($L77, fail, 'Xor "xor"'), NonIdContinue);
|
|
7977
8054
|
function Xor(state) {
|
|
7978
8055
|
let eventData;
|
|
7979
8056
|
if (state.events) {
|
|
@@ -7997,7 +8074,7 @@ ${input.slice(result.pos)}
|
|
|
7997
8074
|
}
|
|
7998
8075
|
}
|
|
7999
8076
|
var Xnor$0 = $R$0($EXPECT($R8, fail, "Xnor /!\\^\\^?/"));
|
|
8000
|
-
var Xnor$1 = $EXPECT($
|
|
8077
|
+
var Xnor$1 = $EXPECT($L78, fail, 'Xnor "xnor"');
|
|
8001
8078
|
function Xnor(state) {
|
|
8002
8079
|
let eventData;
|
|
8003
8080
|
if (state.events) {
|
|
@@ -8218,7 +8295,7 @@ ${input.slice(result.pos)}
|
|
|
8218
8295
|
return result;
|
|
8219
8296
|
}
|
|
8220
8297
|
}
|
|
8221
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8298
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8222
8299
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8223
8300
|
});
|
|
8224
8301
|
function EmptyStatement(state) {
|
|
@@ -8297,7 +8374,7 @@ ${input.slice(result.pos)}
|
|
|
8297
8374
|
var w = $3;
|
|
8298
8375
|
return [id, colon, w];
|
|
8299
8376
|
});
|
|
8300
|
-
var Label$1 = $S($EXPECT($
|
|
8377
|
+
var Label$1 = $S($EXPECT($L86, fail, 'Label "$:"'), Whitespace);
|
|
8301
8378
|
function Label(state) {
|
|
8302
8379
|
let eventData;
|
|
8303
8380
|
if (state.events) {
|
|
@@ -9249,7 +9326,7 @@ ${input.slice(result.pos)}
|
|
|
9249
9326
|
return result;
|
|
9250
9327
|
}
|
|
9251
9328
|
}
|
|
9252
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9329
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L87, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9253
9330
|
var own = $1;
|
|
9254
9331
|
var binding = $2;
|
|
9255
9332
|
return {
|
|
@@ -9512,7 +9589,8 @@ ${input.slice(result.pos)}
|
|
|
9512
9589
|
return {
|
|
9513
9590
|
type: "SwitchExpression",
|
|
9514
9591
|
children: ["(()=>{", e.children, "})()"],
|
|
9515
|
-
|
|
9592
|
+
expression: e.expression,
|
|
9593
|
+
caseBlock: e.caseBlock
|
|
9516
9594
|
};
|
|
9517
9595
|
});
|
|
9518
9596
|
function SwitchExpression(state) {
|
|
@@ -9733,8 +9811,8 @@ ${input.slice(result.pos)}
|
|
|
9733
9811
|
return result;
|
|
9734
9812
|
}
|
|
9735
9813
|
}
|
|
9736
|
-
var ImpliedColon$0 = $S(
|
|
9737
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9814
|
+
var ImpliedColon$0 = $S($E(_), Colon);
|
|
9815
|
+
var ImpliedColon$1 = $TV($EXPECT($L19, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9738
9816
|
return { $loc, token: ":" };
|
|
9739
9817
|
});
|
|
9740
9818
|
function ImpliedColon(state) {
|
|
@@ -9987,7 +10065,7 @@ ${input.slice(result.pos)}
|
|
|
9987
10065
|
return result;
|
|
9988
10066
|
}
|
|
9989
10067
|
}
|
|
9990
|
-
var ForbidIndentedApplication$0 = $TV($EXPECT($
|
|
10068
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L19, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9991
10069
|
module.forbidIndentedApplication.push(true);
|
|
9992
10070
|
});
|
|
9993
10071
|
function ForbidIndentedApplication(state) {
|
|
@@ -10012,7 +10090,7 @@ ${input.slice(result.pos)}
|
|
|
10012
10090
|
return result;
|
|
10013
10091
|
}
|
|
10014
10092
|
}
|
|
10015
|
-
var AllowIndentedApplication$0 = $TV($EXPECT($
|
|
10093
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L19, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10016
10094
|
module.forbidIndentedApplication.push(false);
|
|
10017
10095
|
});
|
|
10018
10096
|
function AllowIndentedApplication(state) {
|
|
@@ -10037,7 +10115,7 @@ ${input.slice(result.pos)}
|
|
|
10037
10115
|
return result;
|
|
10038
10116
|
}
|
|
10039
10117
|
}
|
|
10040
|
-
var RestoreIndentedApplication$0 = $TV($EXPECT($
|
|
10118
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L19, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10041
10119
|
module.forbidIndentedApplication.pop();
|
|
10042
10120
|
});
|
|
10043
10121
|
function RestoreIndentedApplication(state) {
|
|
@@ -10062,7 +10140,7 @@ ${input.slice(result.pos)}
|
|
|
10062
10140
|
return result;
|
|
10063
10141
|
}
|
|
10064
10142
|
}
|
|
10065
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
10143
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L19, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10066
10144
|
if (module.config.verbose) {
|
|
10067
10145
|
console.log("forbidIndentedApplication:", module.forbidIndentedApplication);
|
|
10068
10146
|
}
|
|
@@ -10092,7 +10170,7 @@ ${input.slice(result.pos)}
|
|
|
10092
10170
|
return result;
|
|
10093
10171
|
}
|
|
10094
10172
|
}
|
|
10095
|
-
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10173
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10096
10174
|
module.forbidTrailingMemberProperty.push(true);
|
|
10097
10175
|
});
|
|
10098
10176
|
function ForbidTrailingMemberProperty(state) {
|
|
@@ -10117,7 +10195,7 @@ ${input.slice(result.pos)}
|
|
|
10117
10195
|
return result;
|
|
10118
10196
|
}
|
|
10119
10197
|
}
|
|
10120
|
-
var AllowTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10198
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10121
10199
|
module.forbidTrailingMemberProperty.push(false);
|
|
10122
10200
|
});
|
|
10123
10201
|
function AllowTrailingMemberProperty(state) {
|
|
@@ -10142,7 +10220,7 @@ ${input.slice(result.pos)}
|
|
|
10142
10220
|
return result;
|
|
10143
10221
|
}
|
|
10144
10222
|
}
|
|
10145
|
-
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10223
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10146
10224
|
module.forbidTrailingMemberProperty.pop();
|
|
10147
10225
|
});
|
|
10148
10226
|
function RestoreTrailingMemberProperty(state) {
|
|
@@ -10167,7 +10245,7 @@ ${input.slice(result.pos)}
|
|
|
10167
10245
|
return result;
|
|
10168
10246
|
}
|
|
10169
10247
|
}
|
|
10170
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
10248
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L19, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10171
10249
|
if (module.config.verbose) {
|
|
10172
10250
|
console.log("forbidTrailingMemberProperty:", module.forbidTrailingMemberProperty);
|
|
10173
10251
|
}
|
|
@@ -10196,7 +10274,7 @@ ${input.slice(result.pos)}
|
|
|
10196
10274
|
return result;
|
|
10197
10275
|
}
|
|
10198
10276
|
}
|
|
10199
|
-
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10277
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10200
10278
|
module.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10201
10279
|
});
|
|
10202
10280
|
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10221,7 +10299,7 @@ ${input.slice(result.pos)}
|
|
|
10221
10299
|
return result;
|
|
10222
10300
|
}
|
|
10223
10301
|
}
|
|
10224
|
-
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10302
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10225
10303
|
module.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10226
10304
|
});
|
|
10227
10305
|
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10246,7 +10324,7 @@ ${input.slice(result.pos)}
|
|
|
10246
10324
|
return result;
|
|
10247
10325
|
}
|
|
10248
10326
|
}
|
|
10249
|
-
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10327
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10250
10328
|
module.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10251
10329
|
});
|
|
10252
10330
|
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10271,7 +10349,7 @@ ${input.slice(result.pos)}
|
|
|
10271
10349
|
return result;
|
|
10272
10350
|
}
|
|
10273
10351
|
}
|
|
10274
|
-
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($
|
|
10352
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L19, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10275
10353
|
if (module.config.verbose) {
|
|
10276
10354
|
console.log("forbidMultiLineImplicitObjectLiteral:", module.forbidMultiLineImplicitObjectLiteral);
|
|
10277
10355
|
}
|
|
@@ -10384,8 +10462,9 @@ ${input.slice(result.pos)}
|
|
|
10384
10462
|
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
10385
10463
|
return { "type": "DebuggerStatement", "children": value };
|
|
10386
10464
|
});
|
|
10387
|
-
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
10388
|
-
|
|
10465
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L4, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10466
|
+
var expression = value[2];
|
|
10467
|
+
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10389
10468
|
});
|
|
10390
10469
|
var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
|
|
10391
10470
|
return { "type": "ThrowStatement", "children": value };
|
|
@@ -10412,7 +10491,7 @@ ${input.slice(result.pos)}
|
|
|
10412
10491
|
return result;
|
|
10413
10492
|
}
|
|
10414
10493
|
}
|
|
10415
|
-
var Break$0 = $TS($S($EXPECT($
|
|
10494
|
+
var Break$0 = $TS($S($EXPECT($L88, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10416
10495
|
return { $loc, token: $1 };
|
|
10417
10496
|
});
|
|
10418
10497
|
function Break(state) {
|
|
@@ -10437,7 +10516,7 @@ ${input.slice(result.pos)}
|
|
|
10437
10516
|
return result;
|
|
10438
10517
|
}
|
|
10439
10518
|
}
|
|
10440
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
10519
|
+
var Continue$0 = $TS($S($EXPECT($L89, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10441
10520
|
return { $loc, token: $1 };
|
|
10442
10521
|
});
|
|
10443
10522
|
function Continue(state) {
|
|
@@ -10462,7 +10541,7 @@ ${input.slice(result.pos)}
|
|
|
10462
10541
|
return result;
|
|
10463
10542
|
}
|
|
10464
10543
|
}
|
|
10465
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
10544
|
+
var Debugger$0 = $TS($S($EXPECT($L90, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10466
10545
|
return { $loc, token: $1 };
|
|
10467
10546
|
});
|
|
10468
10547
|
function Debugger(state) {
|
|
@@ -10615,7 +10694,7 @@ ${input.slice(result.pos)}
|
|
|
10615
10694
|
return result;
|
|
10616
10695
|
}
|
|
10617
10696
|
}
|
|
10618
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10697
|
+
var ImpliedImport$0 = $TV($EXPECT($L19, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10619
10698
|
return { $loc, token: "import " };
|
|
10620
10699
|
});
|
|
10621
10700
|
function ImpliedImport(state) {
|
|
@@ -10764,7 +10843,7 @@ ${input.slice(result.pos)}
|
|
|
10764
10843
|
return result;
|
|
10765
10844
|
}
|
|
10766
10845
|
}
|
|
10767
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10846
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L91, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10768
10847
|
function ImportAssertion(state) {
|
|
10769
10848
|
let eventData;
|
|
10770
10849
|
if (state.events) {
|
|
@@ -11368,7 +11447,7 @@ ${input.slice(result.pos)}
|
|
|
11368
11447
|
return result;
|
|
11369
11448
|
}
|
|
11370
11449
|
}
|
|
11371
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11450
|
+
var ConstAssignment$0 = $TV($EXPECT($L92, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
11372
11451
|
return { $loc, token: "=" };
|
|
11373
11452
|
});
|
|
11374
11453
|
function ConstAssignment(state) {
|
|
@@ -11393,7 +11472,7 @@ ${input.slice(result.pos)}
|
|
|
11393
11472
|
return result;
|
|
11394
11473
|
}
|
|
11395
11474
|
}
|
|
11396
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11475
|
+
var LetAssignment$0 = $TV($EXPECT($L93, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
11397
11476
|
return { $loc, token: "=" };
|
|
11398
11477
|
});
|
|
11399
11478
|
function LetAssignment(state) {
|
|
@@ -12091,7 +12170,7 @@ ${input.slice(result.pos)}
|
|
|
12091
12170
|
}
|
|
12092
12171
|
}
|
|
12093
12172
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
12094
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
12173
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
12095
12174
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
12096
12175
|
});
|
|
12097
12176
|
function RegularExpressionLiteral(state) {
|
|
@@ -12658,7 +12737,7 @@ ${input.slice(result.pos)}
|
|
|
12658
12737
|
return result;
|
|
12659
12738
|
}
|
|
12660
12739
|
}
|
|
12661
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12740
|
+
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
12741
|
return { $loc, token: $1 };
|
|
12663
12742
|
});
|
|
12664
12743
|
function JSMultiLineComment(state) {
|
|
@@ -12757,7 +12836,7 @@ ${input.slice(result.pos)}
|
|
|
12757
12836
|
return result;
|
|
12758
12837
|
}
|
|
12759
12838
|
}
|
|
12760
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12839
|
+
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
12840
|
return { $loc, token: $1 };
|
|
12762
12841
|
});
|
|
12763
12842
|
function InlineComment(state) {
|
|
@@ -12856,7 +12935,7 @@ ${input.slice(result.pos)}
|
|
|
12856
12935
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12857
12936
|
return { $loc, token: $0 };
|
|
12858
12937
|
});
|
|
12859
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12938
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L96, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12860
12939
|
return "";
|
|
12861
12940
|
});
|
|
12862
12941
|
function NonNewlineWhitespace(state) {
|
|
@@ -13008,7 +13087,7 @@ ${input.slice(result.pos)}
|
|
|
13008
13087
|
}
|
|
13009
13088
|
}
|
|
13010
13089
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
13011
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13090
|
+
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
13091
|
var StatementDelimiter$2 = $Y(EOS);
|
|
13013
13092
|
function StatementDelimiter(state) {
|
|
13014
13093
|
let eventData;
|
|
@@ -13083,7 +13162,7 @@ ${input.slice(result.pos)}
|
|
|
13083
13162
|
return result;
|
|
13084
13163
|
}
|
|
13085
13164
|
}
|
|
13086
|
-
var Loc$0 = $TV($EXPECT($
|
|
13165
|
+
var Loc$0 = $TV($EXPECT($L19, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
13087
13166
|
return { $loc, token: "" };
|
|
13088
13167
|
});
|
|
13089
13168
|
function Loc(state) {
|
|
@@ -13108,7 +13187,7 @@ ${input.slice(result.pos)}
|
|
|
13108
13187
|
return result;
|
|
13109
13188
|
}
|
|
13110
13189
|
}
|
|
13111
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13190
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
13112
13191
|
return { $loc, token: $1, ts: true };
|
|
13113
13192
|
});
|
|
13114
13193
|
function Abstract(state) {
|
|
@@ -13133,7 +13212,7 @@ ${input.slice(result.pos)}
|
|
|
13133
13212
|
return result;
|
|
13134
13213
|
}
|
|
13135
13214
|
}
|
|
13136
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
13215
|
+
var Ampersand$0 = $TV($EXPECT($L83, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
13137
13216
|
return { $loc, token: $1 };
|
|
13138
13217
|
});
|
|
13139
13218
|
function Ampersand(state) {
|
|
@@ -13158,7 +13237,7 @@ ${input.slice(result.pos)}
|
|
|
13158
13237
|
return result;
|
|
13159
13238
|
}
|
|
13160
13239
|
}
|
|
13161
|
-
var As$0 = $TS($S($EXPECT($
|
|
13240
|
+
var As$0 = $TS($S($EXPECT($L100, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13162
13241
|
return { $loc, token: $1 };
|
|
13163
13242
|
});
|
|
13164
13243
|
function As(state) {
|
|
@@ -13183,7 +13262,7 @@ ${input.slice(result.pos)}
|
|
|
13183
13262
|
return result;
|
|
13184
13263
|
}
|
|
13185
13264
|
}
|
|
13186
|
-
var At$0 = $TV($EXPECT($
|
|
13265
|
+
var At$0 = $TV($EXPECT($L101, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
13187
13266
|
return { $loc, token: $1 };
|
|
13188
13267
|
});
|
|
13189
13268
|
function At(state) {
|
|
@@ -13208,7 +13287,7 @@ ${input.slice(result.pos)}
|
|
|
13208
13287
|
return result;
|
|
13209
13288
|
}
|
|
13210
13289
|
}
|
|
13211
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13290
|
+
var AtAt$0 = $TV($EXPECT($L102, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
13212
13291
|
return { $loc, token: "@" };
|
|
13213
13292
|
});
|
|
13214
13293
|
function AtAt(state) {
|
|
@@ -13233,7 +13312,7 @@ ${input.slice(result.pos)}
|
|
|
13233
13312
|
return result;
|
|
13234
13313
|
}
|
|
13235
13314
|
}
|
|
13236
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13315
|
+
var Async$0 = $TS($S($EXPECT($L103, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13237
13316
|
return { $loc, token: $1, type: "Async" };
|
|
13238
13317
|
});
|
|
13239
13318
|
function Async(state) {
|
|
@@ -13258,7 +13337,7 @@ ${input.slice(result.pos)}
|
|
|
13258
13337
|
return result;
|
|
13259
13338
|
}
|
|
13260
13339
|
}
|
|
13261
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13340
|
+
var Await$0 = $TS($S($EXPECT($L104, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13262
13341
|
return { $loc, token: $1 };
|
|
13263
13342
|
});
|
|
13264
13343
|
function Await(state) {
|
|
@@ -13283,7 +13362,7 @@ ${input.slice(result.pos)}
|
|
|
13283
13362
|
return result;
|
|
13284
13363
|
}
|
|
13285
13364
|
}
|
|
13286
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13365
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
13287
13366
|
return { $loc, token: $1 };
|
|
13288
13367
|
});
|
|
13289
13368
|
function Backtick(state) {
|
|
@@ -13308,7 +13387,7 @@ ${input.slice(result.pos)}
|
|
|
13308
13387
|
return result;
|
|
13309
13388
|
}
|
|
13310
13389
|
}
|
|
13311
|
-
var By$0 = $TS($S($EXPECT($
|
|
13390
|
+
var By$0 = $TS($S($EXPECT($L105, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13312
13391
|
return { $loc, token: $1 };
|
|
13313
13392
|
});
|
|
13314
13393
|
function By(state) {
|
|
@@ -13333,7 +13412,7 @@ ${input.slice(result.pos)}
|
|
|
13333
13412
|
return result;
|
|
13334
13413
|
}
|
|
13335
13414
|
}
|
|
13336
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13415
|
+
var Case$0 = $TS($S($EXPECT($L106, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13337
13416
|
return { $loc, token: $1 };
|
|
13338
13417
|
});
|
|
13339
13418
|
function Case(state) {
|
|
@@ -13358,7 +13437,7 @@ ${input.slice(result.pos)}
|
|
|
13358
13437
|
return result;
|
|
13359
13438
|
}
|
|
13360
13439
|
}
|
|
13361
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13440
|
+
var Catch$0 = $TS($S($EXPECT($L107, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13362
13441
|
return { $loc, token: $1 };
|
|
13363
13442
|
});
|
|
13364
13443
|
function Catch(state) {
|
|
@@ -13383,7 +13462,7 @@ ${input.slice(result.pos)}
|
|
|
13383
13462
|
return result;
|
|
13384
13463
|
}
|
|
13385
13464
|
}
|
|
13386
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13465
|
+
var Class$0 = $TS($S($EXPECT($L108, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13387
13466
|
return { $loc, token: $1 };
|
|
13388
13467
|
});
|
|
13389
13468
|
function Class(state) {
|
|
@@ -13408,7 +13487,7 @@ ${input.slice(result.pos)}
|
|
|
13408
13487
|
return result;
|
|
13409
13488
|
}
|
|
13410
13489
|
}
|
|
13411
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
13490
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
13412
13491
|
return { $loc, token: $1 };
|
|
13413
13492
|
});
|
|
13414
13493
|
function CloseBrace(state) {
|
|
@@ -13433,7 +13512,7 @@ ${input.slice(result.pos)}
|
|
|
13433
13512
|
return result;
|
|
13434
13513
|
}
|
|
13435
13514
|
}
|
|
13436
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
13515
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
13437
13516
|
return { $loc, token: $1 };
|
|
13438
13517
|
});
|
|
13439
13518
|
function CloseBracket(state) {
|
|
@@ -13458,7 +13537,7 @@ ${input.slice(result.pos)}
|
|
|
13458
13537
|
return result;
|
|
13459
13538
|
}
|
|
13460
13539
|
}
|
|
13461
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
13540
|
+
var CloseParen$0 = $TV($EXPECT($L33, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
13462
13541
|
return { $loc, token: $1 };
|
|
13463
13542
|
});
|
|
13464
13543
|
function CloseParen(state) {
|
|
@@ -13483,7 +13562,7 @@ ${input.slice(result.pos)}
|
|
|
13483
13562
|
return result;
|
|
13484
13563
|
}
|
|
13485
13564
|
}
|
|
13486
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13565
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L109, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
13487
13566
|
return { $loc, token: "${" };
|
|
13488
13567
|
});
|
|
13489
13568
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13508,7 +13587,7 @@ ${input.slice(result.pos)}
|
|
|
13508
13587
|
return result;
|
|
13509
13588
|
}
|
|
13510
13589
|
}
|
|
13511
|
-
var Colon$0 = $TV($EXPECT($
|
|
13590
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
13512
13591
|
return { $loc, token: $1 };
|
|
13513
13592
|
});
|
|
13514
13593
|
function Colon(state) {
|
|
@@ -13533,7 +13612,7 @@ ${input.slice(result.pos)}
|
|
|
13533
13612
|
return result;
|
|
13534
13613
|
}
|
|
13535
13614
|
}
|
|
13536
|
-
var Comma$0 = $TV($EXPECT($
|
|
13615
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
13537
13616
|
return { $loc, token: $1 };
|
|
13538
13617
|
});
|
|
13539
13618
|
function Comma(state) {
|
|
@@ -13558,7 +13637,7 @@ ${input.slice(result.pos)}
|
|
|
13558
13637
|
return result;
|
|
13559
13638
|
}
|
|
13560
13639
|
}
|
|
13561
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13640
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L101, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13562
13641
|
return { $loc, token: "constructor" };
|
|
13563
13642
|
});
|
|
13564
13643
|
function ConstructorShorthand(state) {
|
|
@@ -13583,7 +13662,7 @@ ${input.slice(result.pos)}
|
|
|
13583
13662
|
return result;
|
|
13584
13663
|
}
|
|
13585
13664
|
}
|
|
13586
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13665
|
+
var Declare$0 = $TS($S($EXPECT($L110, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13587
13666
|
return { $loc, token: $1 };
|
|
13588
13667
|
});
|
|
13589
13668
|
function Declare(state) {
|
|
@@ -13608,7 +13687,7 @@ ${input.slice(result.pos)}
|
|
|
13608
13687
|
return result;
|
|
13609
13688
|
}
|
|
13610
13689
|
}
|
|
13611
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13690
|
+
var Default$0 = $TS($S($EXPECT($L111, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13612
13691
|
return { $loc, token: $1 };
|
|
13613
13692
|
});
|
|
13614
13693
|
function Default(state) {
|
|
@@ -13633,7 +13712,7 @@ ${input.slice(result.pos)}
|
|
|
13633
13712
|
return result;
|
|
13634
13713
|
}
|
|
13635
13714
|
}
|
|
13636
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13715
|
+
var Delete$0 = $TS($S($EXPECT($L112, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13637
13716
|
return { $loc, token: $1 };
|
|
13638
13717
|
});
|
|
13639
13718
|
function Delete(state) {
|
|
@@ -13658,7 +13737,7 @@ ${input.slice(result.pos)}
|
|
|
13658
13737
|
return result;
|
|
13659
13738
|
}
|
|
13660
13739
|
}
|
|
13661
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13740
|
+
var Do$0 = $TS($S($EXPECT($L113, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13662
13741
|
return { $loc, token: $1 };
|
|
13663
13742
|
});
|
|
13664
13743
|
function Do(state) {
|
|
@@ -13708,7 +13787,7 @@ ${input.slice(result.pos)}
|
|
|
13708
13787
|
return result;
|
|
13709
13788
|
}
|
|
13710
13789
|
}
|
|
13711
|
-
var DotDot$0 = $
|
|
13790
|
+
var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L4, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
13712
13791
|
return { $loc, token: $1 };
|
|
13713
13792
|
});
|
|
13714
13793
|
function DotDot(state) {
|
|
@@ -13733,7 +13812,7 @@ ${input.slice(result.pos)}
|
|
|
13733
13812
|
return result;
|
|
13734
13813
|
}
|
|
13735
13814
|
}
|
|
13736
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13815
|
+
var DotDotDot$0 = $TV($EXPECT($L115, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13737
13816
|
return { $loc, token: $1 };
|
|
13738
13817
|
});
|
|
13739
13818
|
function DotDotDot(state) {
|
|
@@ -13758,7 +13837,7 @@ ${input.slice(result.pos)}
|
|
|
13758
13837
|
return result;
|
|
13759
13838
|
}
|
|
13760
13839
|
}
|
|
13761
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13840
|
+
var DoubleColon$0 = $TV($EXPECT($L116, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13762
13841
|
return { $loc, token: $1 };
|
|
13763
13842
|
});
|
|
13764
13843
|
function DoubleColon(state) {
|
|
@@ -13783,7 +13862,7 @@ ${input.slice(result.pos)}
|
|
|
13783
13862
|
return result;
|
|
13784
13863
|
}
|
|
13785
13864
|
}
|
|
13786
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13865
|
+
var DoubleQuote$0 = $TV($EXPECT($L117, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13787
13866
|
return { $loc, token: $1 };
|
|
13788
13867
|
});
|
|
13789
13868
|
function DoubleQuote(state) {
|
|
@@ -13808,7 +13887,7 @@ ${input.slice(result.pos)}
|
|
|
13808
13887
|
return result;
|
|
13809
13888
|
}
|
|
13810
13889
|
}
|
|
13811
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13890
|
+
var Else$0 = $TS($S($EXPECT($L118, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13812
13891
|
return { $loc, token: $1 };
|
|
13813
13892
|
});
|
|
13814
13893
|
function Else(state) {
|
|
@@ -13858,7 +13937,7 @@ ${input.slice(result.pos)}
|
|
|
13858
13937
|
return result;
|
|
13859
13938
|
}
|
|
13860
13939
|
}
|
|
13861
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13940
|
+
var Export$0 = $TS($S($EXPECT($L119, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13862
13941
|
return { $loc, token: $1 };
|
|
13863
13942
|
});
|
|
13864
13943
|
function Export(state) {
|
|
@@ -13883,7 +13962,7 @@ ${input.slice(result.pos)}
|
|
|
13883
13962
|
return result;
|
|
13884
13963
|
}
|
|
13885
13964
|
}
|
|
13886
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13965
|
+
var Extends$0 = $TS($S($EXPECT($L120, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13887
13966
|
return { $loc, token: $1 };
|
|
13888
13967
|
});
|
|
13889
13968
|
function Extends(state) {
|
|
@@ -13908,7 +13987,7 @@ ${input.slice(result.pos)}
|
|
|
13908
13987
|
return result;
|
|
13909
13988
|
}
|
|
13910
13989
|
}
|
|
13911
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13990
|
+
var Finally$0 = $TS($S($EXPECT($L121, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13912
13991
|
return { $loc, token: $1 };
|
|
13913
13992
|
});
|
|
13914
13993
|
function Finally(state) {
|
|
@@ -13933,7 +14012,7 @@ ${input.slice(result.pos)}
|
|
|
13933
14012
|
return result;
|
|
13934
14013
|
}
|
|
13935
14014
|
}
|
|
13936
|
-
var For$0 = $TS($S($EXPECT($
|
|
14015
|
+
var For$0 = $TS($S($EXPECT($L122, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13937
14016
|
return { $loc, token: $1 };
|
|
13938
14017
|
});
|
|
13939
14018
|
function For(state) {
|
|
@@ -13958,7 +14037,7 @@ ${input.slice(result.pos)}
|
|
|
13958
14037
|
return result;
|
|
13959
14038
|
}
|
|
13960
14039
|
}
|
|
13961
|
-
var From$0 = $TS($S($EXPECT($
|
|
14040
|
+
var From$0 = $TS($S($EXPECT($L123, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13962
14041
|
return { $loc, token: $1 };
|
|
13963
14042
|
});
|
|
13964
14043
|
function From(state) {
|
|
@@ -13983,7 +14062,7 @@ ${input.slice(result.pos)}
|
|
|
13983
14062
|
return result;
|
|
13984
14063
|
}
|
|
13985
14064
|
}
|
|
13986
|
-
var Function$0 = $TS($S($EXPECT($
|
|
14065
|
+
var Function$0 = $TS($S($EXPECT($L124, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13987
14066
|
return { $loc, token: $1 };
|
|
13988
14067
|
});
|
|
13989
14068
|
function Function(state) {
|
|
@@ -14008,7 +14087,7 @@ ${input.slice(result.pos)}
|
|
|
14008
14087
|
return result;
|
|
14009
14088
|
}
|
|
14010
14089
|
}
|
|
14011
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14090
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L125, fail, 'GetOrSet "get"'), $EXPECT($L126, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14012
14091
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
14013
14092
|
});
|
|
14014
14093
|
function GetOrSet(state) {
|
|
@@ -14033,7 +14112,7 @@ ${input.slice(result.pos)}
|
|
|
14033
14112
|
return result;
|
|
14034
14113
|
}
|
|
14035
14114
|
}
|
|
14036
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14115
|
+
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
14037
14116
|
return { $loc, token: $1 };
|
|
14038
14117
|
});
|
|
14039
14118
|
function If(state) {
|
|
@@ -14083,7 +14162,7 @@ ${input.slice(result.pos)}
|
|
|
14083
14162
|
return result;
|
|
14084
14163
|
}
|
|
14085
14164
|
}
|
|
14086
|
-
var In$0 = $TS($S($EXPECT($
|
|
14165
|
+
var In$0 = $TS($S($EXPECT($L81, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14087
14166
|
return { $loc, token: $1 };
|
|
14088
14167
|
});
|
|
14089
14168
|
function In(state) {
|
|
@@ -14108,7 +14187,7 @@ ${input.slice(result.pos)}
|
|
|
14108
14187
|
return result;
|
|
14109
14188
|
}
|
|
14110
14189
|
}
|
|
14111
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14190
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L128, fail, 'LetOrConst "let"'), $EXPECT($L129, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14112
14191
|
return { $loc, token: $1 };
|
|
14113
14192
|
});
|
|
14114
14193
|
function LetOrConst(state) {
|
|
@@ -14133,7 +14212,7 @@ ${input.slice(result.pos)}
|
|
|
14133
14212
|
return result;
|
|
14134
14213
|
}
|
|
14135
14214
|
}
|
|
14136
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14215
|
+
var Loop$0 = $TS($S($EXPECT($L130, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14137
14216
|
return { $loc, token: "while(true)" };
|
|
14138
14217
|
});
|
|
14139
14218
|
function Loop(state) {
|
|
@@ -14158,7 +14237,7 @@ ${input.slice(result.pos)}
|
|
|
14158
14237
|
return result;
|
|
14159
14238
|
}
|
|
14160
14239
|
}
|
|
14161
|
-
var New$0 = $TS($S($EXPECT($
|
|
14240
|
+
var New$0 = $TS($S($EXPECT($L131, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14162
14241
|
return { $loc, token: $1 };
|
|
14163
14242
|
});
|
|
14164
14243
|
function New(state) {
|
|
@@ -14183,7 +14262,7 @@ ${input.slice(result.pos)}
|
|
|
14183
14262
|
return result;
|
|
14184
14263
|
}
|
|
14185
14264
|
}
|
|
14186
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
14265
|
+
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
14266
|
return { $loc, token: "!" };
|
|
14188
14267
|
});
|
|
14189
14268
|
function Not(state) {
|
|
@@ -14208,7 +14287,7 @@ ${input.slice(result.pos)}
|
|
|
14208
14287
|
return result;
|
|
14209
14288
|
}
|
|
14210
14289
|
}
|
|
14211
|
-
var Of$0 = $TS($S($EXPECT($
|
|
14290
|
+
var Of$0 = $TS($S($EXPECT($L73, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14212
14291
|
return { $loc, token: $1 };
|
|
14213
14292
|
});
|
|
14214
14293
|
function Of(state) {
|
|
@@ -14233,7 +14312,7 @@ ${input.slice(result.pos)}
|
|
|
14233
14312
|
return result;
|
|
14234
14313
|
}
|
|
14235
14314
|
}
|
|
14236
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14315
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L132, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
14237
14316
|
return { $loc, token: $1 };
|
|
14238
14317
|
});
|
|
14239
14318
|
function OpenAngleBracket(state) {
|
|
@@ -14258,7 +14337,7 @@ ${input.slice(result.pos)}
|
|
|
14258
14337
|
return result;
|
|
14259
14338
|
}
|
|
14260
14339
|
}
|
|
14261
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14340
|
+
var OpenBrace$0 = $TV($EXPECT($L133, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
14262
14341
|
return { $loc, token: $1 };
|
|
14263
14342
|
});
|
|
14264
14343
|
function OpenBrace(state) {
|
|
@@ -14283,7 +14362,7 @@ ${input.slice(result.pos)}
|
|
|
14283
14362
|
return result;
|
|
14284
14363
|
}
|
|
14285
14364
|
}
|
|
14286
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14365
|
+
var OpenBracket$0 = $TV($EXPECT($L97, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
14287
14366
|
return { $loc, token: $1 };
|
|
14288
14367
|
});
|
|
14289
14368
|
function OpenBracket(state) {
|
|
@@ -14333,7 +14412,7 @@ ${input.slice(result.pos)}
|
|
|
14333
14412
|
return result;
|
|
14334
14413
|
}
|
|
14335
14414
|
}
|
|
14336
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14415
|
+
var Operator$0 = $TS($S($EXPECT($L134, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14337
14416
|
return { $loc, token: $1 };
|
|
14338
14417
|
});
|
|
14339
14418
|
function Operator(state) {
|
|
@@ -14358,7 +14437,7 @@ ${input.slice(result.pos)}
|
|
|
14358
14437
|
return result;
|
|
14359
14438
|
}
|
|
14360
14439
|
}
|
|
14361
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14440
|
+
var Public$0 = $TS($S($EXPECT($L135, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14362
14441
|
return { $loc, token: $1 };
|
|
14363
14442
|
});
|
|
14364
14443
|
function Public(state) {
|
|
@@ -14383,7 +14462,7 @@ ${input.slice(result.pos)}
|
|
|
14383
14462
|
return result;
|
|
14384
14463
|
}
|
|
14385
14464
|
}
|
|
14386
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14465
|
+
var Private$0 = $TS($S($EXPECT($L136, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14387
14466
|
return { $loc, token: $1 };
|
|
14388
14467
|
});
|
|
14389
14468
|
function Private(state) {
|
|
@@ -14408,7 +14487,7 @@ ${input.slice(result.pos)}
|
|
|
14408
14487
|
return result;
|
|
14409
14488
|
}
|
|
14410
14489
|
}
|
|
14411
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14490
|
+
var Protected$0 = $TS($S($EXPECT($L137, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14412
14491
|
return { $loc, token: $1 };
|
|
14413
14492
|
});
|
|
14414
14493
|
function Protected(state) {
|
|
@@ -14433,13 +14512,13 @@ ${input.slice(result.pos)}
|
|
|
14433
14512
|
return result;
|
|
14434
14513
|
}
|
|
14435
14514
|
}
|
|
14436
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14515
|
+
var Pipe$0 = $TV($EXPECT($L138, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
14437
14516
|
return { $loc, token: $1 };
|
|
14438
14517
|
});
|
|
14439
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14518
|
+
var Pipe$1 = $TV($EXPECT($L139, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
14440
14519
|
return { $loc, token: $1 };
|
|
14441
14520
|
});
|
|
14442
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14521
|
+
var Pipe$2 = $TV($EXPECT($L140, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
14443
14522
|
return { $loc, token: $1 };
|
|
14444
14523
|
});
|
|
14445
14524
|
function Pipe(state) {
|
|
@@ -14489,7 +14568,7 @@ ${input.slice(result.pos)}
|
|
|
14489
14568
|
return result;
|
|
14490
14569
|
}
|
|
14491
14570
|
}
|
|
14492
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14571
|
+
var Readonly$0 = $TS($S($EXPECT($L141, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14493
14572
|
return { $loc, token: $1, ts: true };
|
|
14494
14573
|
});
|
|
14495
14574
|
function Readonly(state) {
|
|
@@ -14514,7 +14593,7 @@ ${input.slice(result.pos)}
|
|
|
14514
14593
|
return result;
|
|
14515
14594
|
}
|
|
14516
14595
|
}
|
|
14517
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14596
|
+
var Return$0 = $TS($S($EXPECT($L142, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14518
14597
|
return { $loc, token: $1 };
|
|
14519
14598
|
});
|
|
14520
14599
|
function Return(state) {
|
|
@@ -14539,7 +14618,7 @@ ${input.slice(result.pos)}
|
|
|
14539
14618
|
return result;
|
|
14540
14619
|
}
|
|
14541
14620
|
}
|
|
14542
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14621
|
+
var Satisfies$0 = $TS($S($EXPECT($L143, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14543
14622
|
return { $loc, token: $1 };
|
|
14544
14623
|
});
|
|
14545
14624
|
function Satisfies(state) {
|
|
@@ -14564,7 +14643,7 @@ ${input.slice(result.pos)}
|
|
|
14564
14643
|
return result;
|
|
14565
14644
|
}
|
|
14566
14645
|
}
|
|
14567
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14646
|
+
var Semicolon$0 = $TV($EXPECT($L85, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
14568
14647
|
return { $loc, token: $1 };
|
|
14569
14648
|
});
|
|
14570
14649
|
function Semicolon(state) {
|
|
@@ -14589,7 +14668,7 @@ ${input.slice(result.pos)}
|
|
|
14589
14668
|
return result;
|
|
14590
14669
|
}
|
|
14591
14670
|
}
|
|
14592
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14671
|
+
var SingleQuote$0 = $TV($EXPECT($L144, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14593
14672
|
return { $loc, token: $1 };
|
|
14594
14673
|
});
|
|
14595
14674
|
function SingleQuote(state) {
|
|
@@ -14614,7 +14693,7 @@ ${input.slice(result.pos)}
|
|
|
14614
14693
|
return result;
|
|
14615
14694
|
}
|
|
14616
14695
|
}
|
|
14617
|
-
var Star$0 = $TV($EXPECT($
|
|
14696
|
+
var Star$0 = $TV($EXPECT($L54, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14618
14697
|
return { $loc, token: $1 };
|
|
14619
14698
|
});
|
|
14620
14699
|
function Star(state) {
|
|
@@ -14639,10 +14718,10 @@ ${input.slice(result.pos)}
|
|
|
14639
14718
|
return result;
|
|
14640
14719
|
}
|
|
14641
14720
|
}
|
|
14642
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14721
|
+
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14643
14722
|
return { $loc, token: $1 };
|
|
14644
14723
|
});
|
|
14645
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14724
|
+
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
14725
|
return { $loc, token: "static " };
|
|
14647
14726
|
});
|
|
14648
14727
|
function Static(state) {
|
|
@@ -14667,7 +14746,7 @@ ${input.slice(result.pos)}
|
|
|
14667
14746
|
return result;
|
|
14668
14747
|
}
|
|
14669
14748
|
}
|
|
14670
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14749
|
+
var SubstitutionStart$0 = $TV($EXPECT($L146, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14671
14750
|
return { $loc, token: $1 };
|
|
14672
14751
|
});
|
|
14673
14752
|
function SubstitutionStart(state) {
|
|
@@ -14692,7 +14771,7 @@ ${input.slice(result.pos)}
|
|
|
14692
14771
|
return result;
|
|
14693
14772
|
}
|
|
14694
14773
|
}
|
|
14695
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14774
|
+
var Switch$0 = $TS($S($EXPECT($L147, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14696
14775
|
return { $loc, token: $1 };
|
|
14697
14776
|
});
|
|
14698
14777
|
function Switch(state) {
|
|
@@ -14717,7 +14796,7 @@ ${input.slice(result.pos)}
|
|
|
14717
14796
|
return result;
|
|
14718
14797
|
}
|
|
14719
14798
|
}
|
|
14720
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14799
|
+
var Target$0 = $TS($S($EXPECT($L148, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14721
14800
|
return { $loc, token: $1 };
|
|
14722
14801
|
});
|
|
14723
14802
|
function Target(state) {
|
|
@@ -14742,7 +14821,7 @@ ${input.slice(result.pos)}
|
|
|
14742
14821
|
return result;
|
|
14743
14822
|
}
|
|
14744
14823
|
}
|
|
14745
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14824
|
+
var Then$0 = $TS($S(__, $EXPECT($L149, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14746
14825
|
return { $loc, token: "" };
|
|
14747
14826
|
});
|
|
14748
14827
|
function Then(state) {
|
|
@@ -14767,7 +14846,7 @@ ${input.slice(result.pos)}
|
|
|
14767
14846
|
return result;
|
|
14768
14847
|
}
|
|
14769
14848
|
}
|
|
14770
|
-
var This$0 = $TS($S($EXPECT($
|
|
14849
|
+
var This$0 = $TS($S($EXPECT($L150, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14771
14850
|
return { $loc, token: $1 };
|
|
14772
14851
|
});
|
|
14773
14852
|
function This(state) {
|
|
@@ -14792,7 +14871,7 @@ ${input.slice(result.pos)}
|
|
|
14792
14871
|
return result;
|
|
14793
14872
|
}
|
|
14794
14873
|
}
|
|
14795
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14874
|
+
var Throw$0 = $TS($S($EXPECT($L151, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14796
14875
|
return { $loc, token: $1 };
|
|
14797
14876
|
});
|
|
14798
14877
|
function Throw(state) {
|
|
@@ -14817,7 +14896,7 @@ ${input.slice(result.pos)}
|
|
|
14817
14896
|
return result;
|
|
14818
14897
|
}
|
|
14819
14898
|
}
|
|
14820
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14899
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L152, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14821
14900
|
return { $loc, token: "`" };
|
|
14822
14901
|
});
|
|
14823
14902
|
function TripleDoubleQuote(state) {
|
|
@@ -14842,7 +14921,7 @@ ${input.slice(result.pos)}
|
|
|
14842
14921
|
return result;
|
|
14843
14922
|
}
|
|
14844
14923
|
}
|
|
14845
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14924
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L153, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14846
14925
|
return { $loc, token: "`" };
|
|
14847
14926
|
});
|
|
14848
14927
|
function TripleSingleQuote(state) {
|
|
@@ -14867,7 +14946,7 @@ ${input.slice(result.pos)}
|
|
|
14867
14946
|
return result;
|
|
14868
14947
|
}
|
|
14869
14948
|
}
|
|
14870
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14949
|
+
var TripleSlash$0 = $TV($EXPECT($L154, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14871
14950
|
return { $loc, token: "/" };
|
|
14872
14951
|
});
|
|
14873
14952
|
function TripleSlash(state) {
|
|
@@ -14892,7 +14971,7 @@ ${input.slice(result.pos)}
|
|
|
14892
14971
|
return result;
|
|
14893
14972
|
}
|
|
14894
14973
|
}
|
|
14895
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14974
|
+
var TripleTick$0 = $TV($EXPECT($L155, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14896
14975
|
return { $loc, token: "`" };
|
|
14897
14976
|
});
|
|
14898
14977
|
function TripleTick(state) {
|
|
@@ -14917,7 +14996,7 @@ ${input.slice(result.pos)}
|
|
|
14917
14996
|
return result;
|
|
14918
14997
|
}
|
|
14919
14998
|
}
|
|
14920
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14999
|
+
var Try$0 = $TS($S($EXPECT($L156, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14921
15000
|
return { $loc, token: $1 };
|
|
14922
15001
|
});
|
|
14923
15002
|
function Try(state) {
|
|
@@ -14942,7 +15021,7 @@ ${input.slice(result.pos)}
|
|
|
14942
15021
|
return result;
|
|
14943
15022
|
}
|
|
14944
15023
|
}
|
|
14945
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
15024
|
+
var Typeof$0 = $TS($S($EXPECT($L157, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14946
15025
|
return { $loc, token: $1 };
|
|
14947
15026
|
});
|
|
14948
15027
|
function Typeof(state) {
|
|
@@ -14967,7 +15046,7 @@ ${input.slice(result.pos)}
|
|
|
14967
15046
|
return result;
|
|
14968
15047
|
}
|
|
14969
15048
|
}
|
|
14970
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
15049
|
+
var Unless$0 = $TS($S($EXPECT($L158, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14971
15050
|
return { $loc, token: $1 };
|
|
14972
15051
|
});
|
|
14973
15052
|
function Unless(state) {
|
|
@@ -14992,7 +15071,7 @@ ${input.slice(result.pos)}
|
|
|
14992
15071
|
return result;
|
|
14993
15072
|
}
|
|
14994
15073
|
}
|
|
14995
|
-
var Until$0 = $TS($S($EXPECT($
|
|
15074
|
+
var Until$0 = $TS($S($EXPECT($L159, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14996
15075
|
return { $loc, token: $1 };
|
|
14997
15076
|
});
|
|
14998
15077
|
function Until(state) {
|
|
@@ -15017,7 +15096,7 @@ ${input.slice(result.pos)}
|
|
|
15017
15096
|
return result;
|
|
15018
15097
|
}
|
|
15019
15098
|
}
|
|
15020
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15099
|
+
var Var$0 = $TS($S($EXPECT($L160, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15021
15100
|
return { $loc, token: $1 };
|
|
15022
15101
|
});
|
|
15023
15102
|
function Var(state) {
|
|
@@ -15042,7 +15121,7 @@ ${input.slice(result.pos)}
|
|
|
15042
15121
|
return result;
|
|
15043
15122
|
}
|
|
15044
15123
|
}
|
|
15045
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15124
|
+
var Void$0 = $TS($S($EXPECT($L161, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15046
15125
|
return { $loc, token: $1 };
|
|
15047
15126
|
});
|
|
15048
15127
|
function Void(state) {
|
|
@@ -15067,7 +15146,7 @@ ${input.slice(result.pos)}
|
|
|
15067
15146
|
return result;
|
|
15068
15147
|
}
|
|
15069
15148
|
}
|
|
15070
|
-
var When$0 = $TS($S($EXPECT($
|
|
15149
|
+
var When$0 = $TS($S($EXPECT($L162, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15071
15150
|
return { $loc, token: "case" };
|
|
15072
15151
|
});
|
|
15073
15152
|
function When(state) {
|
|
@@ -15092,7 +15171,7 @@ ${input.slice(result.pos)}
|
|
|
15092
15171
|
return result;
|
|
15093
15172
|
}
|
|
15094
15173
|
}
|
|
15095
|
-
var While$0 = $TS($S($EXPECT($
|
|
15174
|
+
var While$0 = $TS($S($EXPECT($L163, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15096
15175
|
return { $loc, token: $1 };
|
|
15097
15176
|
});
|
|
15098
15177
|
function While(state) {
|
|
@@ -15117,7 +15196,7 @@ ${input.slice(result.pos)}
|
|
|
15117
15196
|
return result;
|
|
15118
15197
|
}
|
|
15119
15198
|
}
|
|
15120
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15199
|
+
var Yield$0 = $TS($S($EXPECT($L164, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15121
15200
|
return { $loc, token: $1 };
|
|
15122
15201
|
});
|
|
15123
15202
|
function Yield(state) {
|
|
@@ -15262,7 +15341,7 @@ ${input.slice(result.pos)}
|
|
|
15262
15341
|
return result;
|
|
15263
15342
|
}
|
|
15264
15343
|
}
|
|
15265
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15344
|
+
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
15345
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
15267
15346
|
});
|
|
15268
15347
|
function JSXSelfClosingElement(state) {
|
|
@@ -15313,7 +15392,7 @@ ${input.slice(result.pos)}
|
|
|
15313
15392
|
return result;
|
|
15314
15393
|
}
|
|
15315
15394
|
}
|
|
15316
|
-
var PopJSXStack$0 = $TV($EXPECT($
|
|
15395
|
+
var PopJSXStack$0 = $TV($EXPECT($L19, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15317
15396
|
module.JSXTagStack.pop();
|
|
15318
15397
|
});
|
|
15319
15398
|
function PopJSXStack(state) {
|
|
@@ -15338,7 +15417,7 @@ ${input.slice(result.pos)}
|
|
|
15338
15417
|
return result;
|
|
15339
15418
|
}
|
|
15340
15419
|
}
|
|
15341
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
15420
|
+
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
15342
15421
|
function JSXOpeningElement(state) {
|
|
15343
15422
|
let eventData;
|
|
15344
15423
|
if (state.events) {
|
|
@@ -15367,7 +15446,7 @@ ${input.slice(result.pos)}
|
|
|
15367
15446
|
return $skip;
|
|
15368
15447
|
return $0;
|
|
15369
15448
|
});
|
|
15370
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
15449
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L19, fail, 'JSXOptionalClosingElement ""');
|
|
15371
15450
|
function JSXOptionalClosingElement(state) {
|
|
15372
15451
|
let eventData;
|
|
15373
15452
|
if (state.events) {
|
|
@@ -15390,7 +15469,7 @@ ${input.slice(result.pos)}
|
|
|
15390
15469
|
return result;
|
|
15391
15470
|
}
|
|
15392
15471
|
}
|
|
15393
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15472
|
+
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
15394
15473
|
function JSXClosingElement(state) {
|
|
15395
15474
|
let eventData;
|
|
15396
15475
|
if (state.events) {
|
|
@@ -15428,7 +15507,7 @@ ${input.slice(result.pos)}
|
|
|
15428
15507
|
];
|
|
15429
15508
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
15430
15509
|
});
|
|
15431
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15510
|
+
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
15511
|
var children = $3;
|
|
15433
15512
|
$0 = $0.slice(1);
|
|
15434
15513
|
return {
|
|
@@ -15459,7 +15538,7 @@ ${input.slice(result.pos)}
|
|
|
15459
15538
|
return result;
|
|
15460
15539
|
}
|
|
15461
15540
|
}
|
|
15462
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15541
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L167, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
15463
15542
|
module.JSXTagStack.push("");
|
|
15464
15543
|
return $1;
|
|
15465
15544
|
});
|
|
@@ -15490,7 +15569,7 @@ ${input.slice(result.pos)}
|
|
|
15490
15569
|
return $skip;
|
|
15491
15570
|
return $0;
|
|
15492
15571
|
});
|
|
15493
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
15572
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L19, fail, 'JSXOptionalClosingFragment ""');
|
|
15494
15573
|
function JSXOptionalClosingFragment(state) {
|
|
15495
15574
|
let eventData;
|
|
15496
15575
|
if (state.events) {
|
|
@@ -15513,7 +15592,7 @@ ${input.slice(result.pos)}
|
|
|
15513
15592
|
return result;
|
|
15514
15593
|
}
|
|
15515
15594
|
}
|
|
15516
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15595
|
+
var JSXClosingFragment$0 = $EXPECT($L168, fail, 'JSXClosingFragment "</>"');
|
|
15517
15596
|
function JSXClosingFragment(state) {
|
|
15518
15597
|
let eventData;
|
|
15519
15598
|
if (state.events) {
|
|
@@ -16280,7 +16359,7 @@ ${input.slice(result.pos)}
|
|
|
16280
16359
|
}
|
|
16281
16360
|
return $skip;
|
|
16282
16361
|
});
|
|
16283
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
16362
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
16284
16363
|
return { children: [], jsxChildren: [] };
|
|
16285
16364
|
});
|
|
16286
16365
|
function JSXNestedChildren(state) {
|
|
@@ -16409,7 +16488,7 @@ ${input.slice(result.pos)}
|
|
|
16409
16488
|
return result;
|
|
16410
16489
|
}
|
|
16411
16490
|
}
|
|
16412
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16491
|
+
var JSXComment$0 = $TS($S($EXPECT($L169, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L170, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16413
16492
|
return ["{/*", $2, "*/}"];
|
|
16414
16493
|
});
|
|
16415
16494
|
function JSXComment(state) {
|
|
@@ -16707,7 +16786,7 @@ ${input.slice(result.pos)}
|
|
|
16707
16786
|
return result;
|
|
16708
16787
|
}
|
|
16709
16788
|
}
|
|
16710
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16789
|
+
var TypeKeyword$0 = $S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16711
16790
|
function TypeKeyword(state) {
|
|
16712
16791
|
let eventData;
|
|
16713
16792
|
if (state.events) {
|
|
@@ -16730,7 +16809,7 @@ ${input.slice(result.pos)}
|
|
|
16730
16809
|
return result;
|
|
16731
16810
|
}
|
|
16732
16811
|
}
|
|
16733
|
-
var Interface$0 = $S($EXPECT($
|
|
16812
|
+
var Interface$0 = $S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue);
|
|
16734
16813
|
function Interface(state) {
|
|
16735
16814
|
let eventData;
|
|
16736
16815
|
if (state.events) {
|
|
@@ -16753,7 +16832,7 @@ ${input.slice(result.pos)}
|
|
|
16753
16832
|
return result;
|
|
16754
16833
|
}
|
|
16755
16834
|
}
|
|
16756
|
-
var Namespace$0 = $S($EXPECT($
|
|
16835
|
+
var Namespace$0 = $S($EXPECT($L173, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16757
16836
|
function Namespace(state) {
|
|
16758
16837
|
let eventData;
|
|
16759
16838
|
if (state.events) {
|
|
@@ -17001,7 +17080,7 @@ ${input.slice(result.pos)}
|
|
|
17001
17080
|
return result;
|
|
17002
17081
|
}
|
|
17003
17082
|
}
|
|
17004
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
17083
|
+
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
17084
|
function TypeIndexSignature(state) {
|
|
17006
17085
|
let eventData;
|
|
17007
17086
|
if (state.events) {
|
|
@@ -17048,7 +17127,7 @@ ${input.slice(result.pos)}
|
|
|
17048
17127
|
return result;
|
|
17049
17128
|
}
|
|
17050
17129
|
}
|
|
17051
|
-
var TypeSuffix$0 = $T($S($E(QuestionMark),
|
|
17130
|
+
var TypeSuffix$0 = $T($S($E(QuestionMark), $E(_), Colon, Type), function(value) {
|
|
17052
17131
|
return { "type": "TypeSuffix", "ts": true, "children": value };
|
|
17053
17132
|
});
|
|
17054
17133
|
function TypeSuffix(state) {
|
|
@@ -17073,14 +17152,20 @@ ${input.slice(result.pos)}
|
|
|
17073
17152
|
return result;
|
|
17074
17153
|
}
|
|
17075
17154
|
}
|
|
17076
|
-
var ReturnTypeSuffix$0 = $TS($S(
|
|
17077
|
-
|
|
17078
|
-
|
|
17079
|
-
|
|
17080
|
-
|
|
17155
|
+
var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L174, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17156
|
+
var asserts = $3;
|
|
17157
|
+
var t = $4;
|
|
17158
|
+
if (asserts) {
|
|
17159
|
+
t = {
|
|
17160
|
+
type: "AssertsType",
|
|
17161
|
+
t,
|
|
17162
|
+
children: [asserts[0], asserts[1], t]
|
|
17163
|
+
};
|
|
17164
|
+
}
|
|
17081
17165
|
return {
|
|
17082
17166
|
type: "ReturnTypeAnnotation",
|
|
17083
|
-
children,
|
|
17167
|
+
children: [$1, $2, t],
|
|
17168
|
+
t,
|
|
17084
17169
|
ts: true
|
|
17085
17170
|
};
|
|
17086
17171
|
});
|
|
@@ -17106,10 +17191,17 @@ ${input.slice(result.pos)}
|
|
|
17106
17191
|
return result;
|
|
17107
17192
|
}
|
|
17108
17193
|
}
|
|
17109
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
17110
|
-
|
|
17111
|
-
|
|
17112
|
-
|
|
17194
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L82, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
17195
|
+
var lhs = $1;
|
|
17196
|
+
var rhs = $2;
|
|
17197
|
+
if (!rhs)
|
|
17198
|
+
return lhs;
|
|
17199
|
+
return {
|
|
17200
|
+
type: "TypePredicate",
|
|
17201
|
+
lhs,
|
|
17202
|
+
rhs: rhs[3],
|
|
17203
|
+
children: [lhs, ...rhs]
|
|
17204
|
+
};
|
|
17113
17205
|
});
|
|
17114
17206
|
function TypePredicate(state) {
|
|
17115
17207
|
let eventData;
|
|
@@ -17184,6 +17276,8 @@ ${input.slice(result.pos)}
|
|
|
17184
17276
|
}
|
|
17185
17277
|
}
|
|
17186
17278
|
var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
17279
|
+
if (!$1.length && !$3.length)
|
|
17280
|
+
return $2;
|
|
17187
17281
|
return [...$1, $2, ...$3];
|
|
17188
17282
|
});
|
|
17189
17283
|
function TypeUnary(state) {
|
|
@@ -17232,10 +17326,10 @@ ${input.slice(result.pos)}
|
|
|
17232
17326
|
return result;
|
|
17233
17327
|
}
|
|
17234
17328
|
}
|
|
17235
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
17236
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
17237
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
17238
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17329
|
+
var TypeUnaryOp$0 = $S($EXPECT($L175, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17330
|
+
var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17331
|
+
var TypeUnaryOp$2 = $S($EXPECT($L176, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17332
|
+
var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
17239
17333
|
function TypeUnaryOp(state) {
|
|
17240
17334
|
let eventData;
|
|
17241
17335
|
if (state.events) {
|
|
@@ -17286,8 +17380,23 @@ ${input.slice(result.pos)}
|
|
|
17286
17380
|
var TypePrimary$2 = $S($E(_), InlineInterfaceLiteral);
|
|
17287
17381
|
var TypePrimary$3 = $S($E(_), TypeTuple);
|
|
17288
17382
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
17289
|
-
var TypePrimary$5 = $S($E(_), TypeLiteral)
|
|
17290
|
-
|
|
17383
|
+
var TypePrimary$5 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
|
|
17384
|
+
var t = $2;
|
|
17385
|
+
return {
|
|
17386
|
+
type: "LiteralType",
|
|
17387
|
+
t,
|
|
17388
|
+
children: $0
|
|
17389
|
+
};
|
|
17390
|
+
});
|
|
17391
|
+
var TypePrimary$6 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17392
|
+
var args = $4;
|
|
17393
|
+
return {
|
|
17394
|
+
type: "IdentifierType",
|
|
17395
|
+
children: $0,
|
|
17396
|
+
raw: [$2.name, ...$3.map(([dot, id]) => dot.token + id.name)].join(""),
|
|
17397
|
+
args
|
|
17398
|
+
};
|
|
17399
|
+
});
|
|
17291
17400
|
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
17292
17401
|
function TypePrimary(state) {
|
|
17293
17402
|
let eventData;
|
|
@@ -17433,7 +17542,7 @@ ${input.slice(result.pos)}
|
|
|
17433
17542
|
return result;
|
|
17434
17543
|
}
|
|
17435
17544
|
}
|
|
17436
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17545
|
+
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
17546
|
if ($2)
|
|
17438
17547
|
return $0;
|
|
17439
17548
|
return $1;
|
|
@@ -17462,10 +17571,10 @@ ${input.slice(result.pos)}
|
|
|
17462
17571
|
}
|
|
17463
17572
|
var TypeLiteral$0 = TemplateLiteral;
|
|
17464
17573
|
var TypeLiteral$1 = Literal;
|
|
17465
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17466
|
-
return { $loc, token:
|
|
17574
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
17575
|
+
return { type: "VoidType", $loc, token: $1 };
|
|
17467
17576
|
});
|
|
17468
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17577
|
+
var TypeLiteral$3 = $TV($EXPECT($L177, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
17469
17578
|
return { $loc, token: "[]" };
|
|
17470
17579
|
});
|
|
17471
17580
|
function TypeLiteral(state) {
|
|
@@ -17540,7 +17649,7 @@ ${input.slice(result.pos)}
|
|
|
17540
17649
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
17541
17650
|
return value[1];
|
|
17542
17651
|
});
|
|
17543
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17652
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L33, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
17544
17653
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
17545
17654
|
function InlineInterfacePropertyDelimiter(state) {
|
|
17546
17655
|
let eventData;
|
|
@@ -17564,10 +17673,10 @@ ${input.slice(result.pos)}
|
|
|
17564
17673
|
return result;
|
|
17565
17674
|
}
|
|
17566
17675
|
}
|
|
17567
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17676
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L84, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
17568
17677
|
return { $loc, token: "|" };
|
|
17569
17678
|
});
|
|
17570
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17679
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
17571
17680
|
return { $loc, token: "&" };
|
|
17572
17681
|
});
|
|
17573
17682
|
function TypeBinaryOp(state) {
|
|
@@ -17624,7 +17733,7 @@ ${input.slice(result.pos)}
|
|
|
17624
17733
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17625
17734
|
return { $loc, token: "=>" };
|
|
17626
17735
|
});
|
|
17627
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17736
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17628
17737
|
return { $loc, token: "=>" };
|
|
17629
17738
|
});
|
|
17630
17739
|
function TypeArrowFunction(state) {
|
|
@@ -17649,7 +17758,7 @@ ${input.slice(result.pos)}
|
|
|
17649
17758
|
return result;
|
|
17650
17759
|
}
|
|
17651
17760
|
}
|
|
17652
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17761
|
+
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17653
17762
|
return { ts: true, children: $0 };
|
|
17654
17763
|
});
|
|
17655
17764
|
function TypeArguments(state) {
|
|
@@ -17720,7 +17829,7 @@ ${input.slice(result.pos)}
|
|
|
17720
17829
|
return result;
|
|
17721
17830
|
}
|
|
17722
17831
|
}
|
|
17723
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17832
|
+
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
17833
|
var parameters = $3;
|
|
17725
17834
|
return {
|
|
17726
17835
|
type: "TypeParameters",
|
|
@@ -17774,7 +17883,7 @@ ${input.slice(result.pos)}
|
|
|
17774
17883
|
return result;
|
|
17775
17884
|
}
|
|
17776
17885
|
}
|
|
17777
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17886
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L120, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17778
17887
|
function TypeConstraint(state) {
|
|
17779
17888
|
let eventData;
|
|
17780
17889
|
if (state.events) {
|
|
@@ -17821,7 +17930,7 @@ ${input.slice(result.pos)}
|
|
|
17821
17930
|
}
|
|
17822
17931
|
}
|
|
17823
17932
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17824
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17933
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17825
17934
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17826
17935
|
return value[1];
|
|
17827
17936
|
});
|
|
@@ -17925,7 +18034,7 @@ ${input.slice(result.pos)}
|
|
|
17925
18034
|
return result;
|
|
17926
18035
|
}
|
|
17927
18036
|
}
|
|
17928
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
18037
|
+
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
18038
|
var options = $3;
|
|
17930
18039
|
return {
|
|
17931
18040
|
type: "CivetPrologue",
|
|
@@ -18086,7 +18195,7 @@ ${input.slice(result.pos)}
|
|
|
18086
18195
|
return result;
|
|
18087
18196
|
}
|
|
18088
18197
|
}
|
|
18089
|
-
var DebugHere$0 = $TV($EXPECT($
|
|
18198
|
+
var DebugHere$0 = $TV($EXPECT($L19, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
18090
18199
|
debugger;
|
|
18091
18200
|
});
|
|
18092
18201
|
function DebugHere(state) {
|
|
@@ -18111,7 +18220,7 @@ ${input.slice(result.pos)}
|
|
|
18111
18220
|
return result;
|
|
18112
18221
|
}
|
|
18113
18222
|
}
|
|
18114
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
18223
|
+
var InsertSemicolon$0 = $TV($EXPECT($L19, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
18115
18224
|
return { $loc, token: ";" };
|
|
18116
18225
|
});
|
|
18117
18226
|
function InsertSemicolon(state) {
|
|
@@ -18136,7 +18245,7 @@ ${input.slice(result.pos)}
|
|
|
18136
18245
|
return result;
|
|
18137
18246
|
}
|
|
18138
18247
|
}
|
|
18139
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
18248
|
+
var InsertOpenParen$0 = $TV($EXPECT($L19, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
18140
18249
|
return { $loc, token: "(" };
|
|
18141
18250
|
});
|
|
18142
18251
|
function InsertOpenParen(state) {
|
|
@@ -18161,7 +18270,7 @@ ${input.slice(result.pos)}
|
|
|
18161
18270
|
return result;
|
|
18162
18271
|
}
|
|
18163
18272
|
}
|
|
18164
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
18273
|
+
var InsertCloseParen$0 = $TV($EXPECT($L19, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
18165
18274
|
return { $loc, token: ")" };
|
|
18166
18275
|
});
|
|
18167
18276
|
function InsertCloseParen(state) {
|
|
@@ -18186,7 +18295,7 @@ ${input.slice(result.pos)}
|
|
|
18186
18295
|
return result;
|
|
18187
18296
|
}
|
|
18188
18297
|
}
|
|
18189
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
18298
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18190
18299
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
18191
18300
|
});
|
|
18192
18301
|
function InsertOpenBrace(state) {
|
|
@@ -18211,7 +18320,7 @@ ${input.slice(result.pos)}
|
|
|
18211
18320
|
return result;
|
|
18212
18321
|
}
|
|
18213
18322
|
}
|
|
18214
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
18323
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18215
18324
|
return { $loc, token: "{" };
|
|
18216
18325
|
});
|
|
18217
18326
|
function InsertInlineOpenBrace(state) {
|
|
@@ -18236,7 +18345,7 @@ ${input.slice(result.pos)}
|
|
|
18236
18345
|
return result;
|
|
18237
18346
|
}
|
|
18238
18347
|
}
|
|
18239
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
18348
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L19, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
18240
18349
|
return { $loc, token: "}" };
|
|
18241
18350
|
});
|
|
18242
18351
|
function InsertCloseBrace(state) {
|
|
@@ -18261,7 +18370,7 @@ ${input.slice(result.pos)}
|
|
|
18261
18370
|
return result;
|
|
18262
18371
|
}
|
|
18263
18372
|
}
|
|
18264
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
18373
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L19, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
18265
18374
|
return { $loc, token: "[" };
|
|
18266
18375
|
});
|
|
18267
18376
|
function InsertOpenBracket(state) {
|
|
@@ -18286,7 +18395,7 @@ ${input.slice(result.pos)}
|
|
|
18286
18395
|
return result;
|
|
18287
18396
|
}
|
|
18288
18397
|
}
|
|
18289
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
18398
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L19, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
18290
18399
|
return { $loc, token: "]" };
|
|
18291
18400
|
});
|
|
18292
18401
|
function InsertCloseBracket(state) {
|
|
@@ -18311,7 +18420,7 @@ ${input.slice(result.pos)}
|
|
|
18311
18420
|
return result;
|
|
18312
18421
|
}
|
|
18313
18422
|
}
|
|
18314
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
18423
|
+
var InsertComma$0 = $TV($EXPECT($L19, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
18315
18424
|
return { $loc, token: "," };
|
|
18316
18425
|
});
|
|
18317
18426
|
function InsertComma(state) {
|
|
@@ -18336,7 +18445,7 @@ ${input.slice(result.pos)}
|
|
|
18336
18445
|
return result;
|
|
18337
18446
|
}
|
|
18338
18447
|
}
|
|
18339
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
18448
|
+
var InsertConst$0 = $TV($EXPECT($L19, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
18340
18449
|
return { $loc, token: "const " };
|
|
18341
18450
|
});
|
|
18342
18451
|
function InsertConst(state) {
|
|
@@ -18361,7 +18470,7 @@ ${input.slice(result.pos)}
|
|
|
18361
18470
|
return result;
|
|
18362
18471
|
}
|
|
18363
18472
|
}
|
|
18364
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
18473
|
+
var InsertLet$0 = $TV($EXPECT($L19, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
18365
18474
|
return { $loc, token: "let " };
|
|
18366
18475
|
});
|
|
18367
18476
|
function InsertLet(state) {
|
|
@@ -18386,7 +18495,7 @@ ${input.slice(result.pos)}
|
|
|
18386
18495
|
return result;
|
|
18387
18496
|
}
|
|
18388
18497
|
}
|
|
18389
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
18498
|
+
var InsertReadonly$0 = $TV($EXPECT($L19, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
18390
18499
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
18391
18500
|
});
|
|
18392
18501
|
function InsertReadonly(state) {
|
|
@@ -18411,7 +18520,7 @@ ${input.slice(result.pos)}
|
|
|
18411
18520
|
return result;
|
|
18412
18521
|
}
|
|
18413
18522
|
}
|
|
18414
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
18523
|
+
var InsertNewline$0 = $TV($EXPECT($L19, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
18415
18524
|
return "\n";
|
|
18416
18525
|
});
|
|
18417
18526
|
function InsertNewline(state) {
|
|
@@ -18436,7 +18545,7 @@ ${input.slice(result.pos)}
|
|
|
18436
18545
|
return result;
|
|
18437
18546
|
}
|
|
18438
18547
|
}
|
|
18439
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
18548
|
+
var InsertIndent$0 = $TV($EXPECT($L19, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
18440
18549
|
return module.currentIndent.token;
|
|
18441
18550
|
});
|
|
18442
18551
|
function InsertIndent(state) {
|
|
@@ -18461,7 +18570,7 @@ ${input.slice(result.pos)}
|
|
|
18461
18570
|
return result;
|
|
18462
18571
|
}
|
|
18463
18572
|
}
|
|
18464
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
18573
|
+
var InsertSpace$0 = $TV($EXPECT($L19, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
18465
18574
|
return { $loc, token: " " };
|
|
18466
18575
|
});
|
|
18467
18576
|
function InsertSpace(state) {
|
|
@@ -18486,7 +18595,7 @@ ${input.slice(result.pos)}
|
|
|
18486
18595
|
return result;
|
|
18487
18596
|
}
|
|
18488
18597
|
}
|
|
18489
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
18598
|
+
var InsertDot$0 = $TV($EXPECT($L19, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
18490
18599
|
return { $loc, token: "." };
|
|
18491
18600
|
});
|
|
18492
18601
|
function InsertDot(state) {
|
|
@@ -18511,7 +18620,7 @@ ${input.slice(result.pos)}
|
|
|
18511
18620
|
return result;
|
|
18512
18621
|
}
|
|
18513
18622
|
}
|
|
18514
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18623
|
+
var InsertBreak$0 = $TV($EXPECT($L19, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
18515
18624
|
return { $loc, token: ";break;" };
|
|
18516
18625
|
});
|
|
18517
18626
|
function InsertBreak(state) {
|
|
@@ -18536,7 +18645,7 @@ ${input.slice(result.pos)}
|
|
|
18536
18645
|
return result;
|
|
18537
18646
|
}
|
|
18538
18647
|
}
|
|
18539
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18648
|
+
var InsertVar$0 = $TV($EXPECT($L19, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
18540
18649
|
return { $loc, token: "var " };
|
|
18541
18650
|
});
|
|
18542
18651
|
function InsertVar(state) {
|
|
@@ -18561,7 +18670,7 @@ ${input.slice(result.pos)}
|
|
|
18561
18670
|
return result;
|
|
18562
18671
|
}
|
|
18563
18672
|
}
|
|
18564
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18673
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18565
18674
|
if (module.config.coffeeBinaryExistential)
|
|
18566
18675
|
return;
|
|
18567
18676
|
return $skip;
|
|
@@ -18588,7 +18697,7 @@ ${input.slice(result.pos)}
|
|
|
18588
18697
|
return result;
|
|
18589
18698
|
}
|
|
18590
18699
|
}
|
|
18591
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18700
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18592
18701
|
if (module.config.coffeeBooleans)
|
|
18593
18702
|
return;
|
|
18594
18703
|
return $skip;
|
|
@@ -18615,7 +18724,7 @@ ${input.slice(result.pos)}
|
|
|
18615
18724
|
return result;
|
|
18616
18725
|
}
|
|
18617
18726
|
}
|
|
18618
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18727
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18619
18728
|
if (module.config.coffeeClasses)
|
|
18620
18729
|
return;
|
|
18621
18730
|
return $skip;
|
|
@@ -18642,7 +18751,7 @@ ${input.slice(result.pos)}
|
|
|
18642
18751
|
return result;
|
|
18643
18752
|
}
|
|
18644
18753
|
}
|
|
18645
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18754
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18646
18755
|
if (module.config.coffeeComment)
|
|
18647
18756
|
return;
|
|
18648
18757
|
return $skip;
|
|
@@ -18669,7 +18778,7 @@ ${input.slice(result.pos)}
|
|
|
18669
18778
|
return result;
|
|
18670
18779
|
}
|
|
18671
18780
|
}
|
|
18672
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18781
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18673
18782
|
if (module.config.coffeeDo)
|
|
18674
18783
|
return;
|
|
18675
18784
|
return $skip;
|
|
@@ -18696,7 +18805,7 @@ ${input.slice(result.pos)}
|
|
|
18696
18805
|
return result;
|
|
18697
18806
|
}
|
|
18698
18807
|
}
|
|
18699
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18808
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18700
18809
|
if (module.config.coffeeForLoops)
|
|
18701
18810
|
return;
|
|
18702
18811
|
return $skip;
|
|
@@ -18723,7 +18832,7 @@ ${input.slice(result.pos)}
|
|
|
18723
18832
|
return result;
|
|
18724
18833
|
}
|
|
18725
18834
|
}
|
|
18726
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18835
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18727
18836
|
if (module.config.coffeeInterpolation)
|
|
18728
18837
|
return;
|
|
18729
18838
|
return $skip;
|
|
@@ -18750,7 +18859,7 @@ ${input.slice(result.pos)}
|
|
|
18750
18859
|
return result;
|
|
18751
18860
|
}
|
|
18752
18861
|
}
|
|
18753
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18862
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18754
18863
|
if (module.config.coffeeIsnt)
|
|
18755
18864
|
return;
|
|
18756
18865
|
return $skip;
|
|
@@ -18777,7 +18886,7 @@ ${input.slice(result.pos)}
|
|
|
18777
18886
|
return result;
|
|
18778
18887
|
}
|
|
18779
18888
|
}
|
|
18780
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18889
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18781
18890
|
if (module.config.coffeeJSX)
|
|
18782
18891
|
return;
|
|
18783
18892
|
return $skip;
|
|
@@ -18804,7 +18913,7 @@ ${input.slice(result.pos)}
|
|
|
18804
18913
|
return result;
|
|
18805
18914
|
}
|
|
18806
18915
|
}
|
|
18807
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18916
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18808
18917
|
if (module.config.coffeeLineContinuation)
|
|
18809
18918
|
return;
|
|
18810
18919
|
return $skip;
|
|
@@ -18831,7 +18940,7 @@ ${input.slice(result.pos)}
|
|
|
18831
18940
|
return result;
|
|
18832
18941
|
}
|
|
18833
18942
|
}
|
|
18834
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18943
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18835
18944
|
if (module.config.coffeeNot)
|
|
18836
18945
|
return;
|
|
18837
18946
|
return $skip;
|
|
@@ -18858,7 +18967,7 @@ ${input.slice(result.pos)}
|
|
|
18858
18967
|
return result;
|
|
18859
18968
|
}
|
|
18860
18969
|
}
|
|
18861
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18970
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18862
18971
|
if (module.config.coffeeOf)
|
|
18863
18972
|
return;
|
|
18864
18973
|
return $skip;
|
|
@@ -18885,7 +18994,7 @@ ${input.slice(result.pos)}
|
|
|
18885
18994
|
return result;
|
|
18886
18995
|
}
|
|
18887
18996
|
}
|
|
18888
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18997
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18889
18998
|
if (module.config.coffeePrototype)
|
|
18890
18999
|
return;
|
|
18891
19000
|
return $skip;
|
|
@@ -18912,7 +19021,7 @@ ${input.slice(result.pos)}
|
|
|
18912
19021
|
return result;
|
|
18913
19022
|
}
|
|
18914
19023
|
}
|
|
18915
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
19024
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L19, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18916
19025
|
if (module.config.objectIs)
|
|
18917
19026
|
return;
|
|
18918
19027
|
return $skip;
|
|
@@ -18939,7 +19048,7 @@ ${input.slice(result.pos)}
|
|
|
18939
19048
|
return result;
|
|
18940
19049
|
}
|
|
18941
19050
|
}
|
|
18942
|
-
var Reset$0 = $TV($EXPECT($
|
|
19051
|
+
var Reset$0 = $TV($EXPECT($L19, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18943
19052
|
module.indentLevels = [{
|
|
18944
19053
|
level: 0,
|
|
18945
19054
|
token: ""
|
|
@@ -19246,7 +19355,7 @@ ${input.slice(result.pos)}
|
|
|
19246
19355
|
return result;
|
|
19247
19356
|
}
|
|
19248
19357
|
}
|
|
19249
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
19358
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L19, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
19250
19359
|
var directives = $2;
|
|
19251
19360
|
directives.forEach((directive) => {
|
|
19252
19361
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19518,6 +19627,9 @@ ${input.slice(result.pos)}
|
|
|
19518
19627
|
else
|
|
19519
19628
|
exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
|
|
19520
19629
|
return;
|
|
19630
|
+
case "PatternMatchingStatement":
|
|
19631
|
+
insertPush(exp.children[0][0], ref);
|
|
19632
|
+
return;
|
|
19521
19633
|
case "SwitchStatement":
|
|
19522
19634
|
insertPush(exp.children[2], ref);
|
|
19523
19635
|
return;
|
|
@@ -19549,6 +19661,12 @@ ${input.slice(result.pos)}
|
|
|
19549
19661
|
return;
|
|
19550
19662
|
}
|
|
19551
19663
|
}
|
|
19664
|
+
function getIndent(statement) {
|
|
19665
|
+
let indent = statement?.[0];
|
|
19666
|
+
if (Array.isArray(indent))
|
|
19667
|
+
indent = indent[indent.length - 1];
|
|
19668
|
+
return indent;
|
|
19669
|
+
}
|
|
19552
19670
|
function insertReturn(node) {
|
|
19553
19671
|
if (!node)
|
|
19554
19672
|
return;
|
|
@@ -19573,9 +19691,7 @@ ${input.slice(result.pos)}
|
|
|
19573
19691
|
const [, exp, semi] = node;
|
|
19574
19692
|
if (semi?.type === "SemicolonDelimiter")
|
|
19575
19693
|
return;
|
|
19576
|
-
let indent = node
|
|
19577
|
-
if (Array.isArray(indent))
|
|
19578
|
-
indent = indent[indent.length - 1];
|
|
19694
|
+
let indent = getIndent(node);
|
|
19579
19695
|
if (!exp)
|
|
19580
19696
|
return;
|
|
19581
19697
|
switch (exp.type) {
|
|
@@ -19601,6 +19717,9 @@ ${input.slice(result.pos)}
|
|
|
19601
19717
|
else
|
|
19602
19718
|
exp.children.push(["\n", indent, wrapWithReturn()]);
|
|
19603
19719
|
return;
|
|
19720
|
+
case "PatternMatchingStatement":
|
|
19721
|
+
insertReturn(exp.children[0][0]);
|
|
19722
|
+
return;
|
|
19604
19723
|
case "SwitchStatement":
|
|
19605
19724
|
insertSwitchReturns(exp);
|
|
19606
19725
|
return;
|
|
@@ -19995,12 +20114,14 @@ ${input.slice(result.pos)}
|
|
|
19995
20114
|
}
|
|
19996
20115
|
return [];
|
|
19997
20116
|
}
|
|
19998
|
-
function gatherRecursive(node, predicate) {
|
|
20117
|
+
function gatherRecursive(node, predicate, skipPredicate) {
|
|
19999
20118
|
if (node == null)
|
|
20000
20119
|
return [];
|
|
20001
20120
|
if (Array.isArray(node)) {
|
|
20002
20121
|
return node.flatMap((n) => gatherRecursive(n, predicate));
|
|
20003
20122
|
}
|
|
20123
|
+
if (skipPredicate?.(node))
|
|
20124
|
+
return [];
|
|
20004
20125
|
if (predicate(node)) {
|
|
20005
20126
|
return [node];
|
|
20006
20127
|
}
|
|
@@ -20018,6 +20139,36 @@ ${input.slice(result.pos)}
|
|
|
20018
20139
|
}
|
|
20019
20140
|
return nodes;
|
|
20020
20141
|
}
|
|
20142
|
+
function isFunction({ type }) {
|
|
20143
|
+
return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition";
|
|
20144
|
+
}
|
|
20145
|
+
function gatherRecursiveWithinFunction(node, predicate) {
|
|
20146
|
+
return gatherRecursive(node, predicate, isFunction);
|
|
20147
|
+
}
|
|
20148
|
+
function addParentPointers(node, parent) {
|
|
20149
|
+
if (node == null)
|
|
20150
|
+
return;
|
|
20151
|
+
if (typeof node !== "object")
|
|
20152
|
+
return;
|
|
20153
|
+
node.parent = parent;
|
|
20154
|
+
if (Array.isArray(node)) {
|
|
20155
|
+
for (const child of node) {
|
|
20156
|
+
addParentPointers(child, node);
|
|
20157
|
+
}
|
|
20158
|
+
} else if (node.children) {
|
|
20159
|
+
for (const child of node.children) {
|
|
20160
|
+
addParentPointers(child, node);
|
|
20161
|
+
}
|
|
20162
|
+
}
|
|
20163
|
+
}
|
|
20164
|
+
function findAncestor(node, predicate, stopPredicate) {
|
|
20165
|
+
node = node.parent;
|
|
20166
|
+
while (node && !stopPredicate?.(node)) {
|
|
20167
|
+
if (predicate(node))
|
|
20168
|
+
return node;
|
|
20169
|
+
node = node.parent;
|
|
20170
|
+
}
|
|
20171
|
+
}
|
|
20021
20172
|
function processParams(f) {
|
|
20022
20173
|
const { type, parameters, block } = f;
|
|
20023
20174
|
if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
|
|
@@ -20063,26 +20214,89 @@ ${input.slice(result.pos)}
|
|
|
20063
20214
|
}
|
|
20064
20215
|
});
|
|
20065
20216
|
}
|
|
20217
|
+
function processReturnValue(func) {
|
|
20218
|
+
const { block } = func;
|
|
20219
|
+
const values = gatherRecursiveWithinFunction(
|
|
20220
|
+
block,
|
|
20221
|
+
({ type }) => type === "ReturnValue"
|
|
20222
|
+
);
|
|
20223
|
+
if (!values.length)
|
|
20224
|
+
return false;
|
|
20225
|
+
const ref = {
|
|
20226
|
+
type: "Ref",
|
|
20227
|
+
base: "ret",
|
|
20228
|
+
id: "ret"
|
|
20229
|
+
};
|
|
20230
|
+
let declared;
|
|
20231
|
+
values.forEach((value) => {
|
|
20232
|
+
value.children = [ref];
|
|
20233
|
+
const ancestor = findAncestor(
|
|
20234
|
+
value,
|
|
20235
|
+
({ type }) => type === "Declaration",
|
|
20236
|
+
isFunction
|
|
20237
|
+
);
|
|
20238
|
+
if (ancestor)
|
|
20239
|
+
declared = true;
|
|
20240
|
+
});
|
|
20241
|
+
if (!declared) {
|
|
20242
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
20243
|
+
if (returnType) {
|
|
20244
|
+
const { t } = returnType;
|
|
20245
|
+
if (t.type === "TypePredicate") {
|
|
20246
|
+
returnType = ": boolean";
|
|
20247
|
+
} else if (t.type === "AssertsType") {
|
|
20248
|
+
returnType = void 0;
|
|
20249
|
+
}
|
|
20250
|
+
}
|
|
20251
|
+
block.expressions.unshift([
|
|
20252
|
+
getIndent(block.expressions[0]),
|
|
20253
|
+
{
|
|
20254
|
+
type: "Declaration",
|
|
20255
|
+
children: ["let ", ref, returnType, ";\n"],
|
|
20256
|
+
names: []
|
|
20257
|
+
}
|
|
20258
|
+
]);
|
|
20259
|
+
}
|
|
20260
|
+
gatherRecursiveWithinFunction(
|
|
20261
|
+
block,
|
|
20262
|
+
(r) => r.type === "ReturnStatement" && !r.expression
|
|
20263
|
+
).forEach((r) => {
|
|
20264
|
+
r.expression = ref;
|
|
20265
|
+
r.children.splice(-1, 1, " ", ref);
|
|
20266
|
+
});
|
|
20267
|
+
if (block.children.at(-2)?.type !== "ReturnStatement") {
|
|
20268
|
+
block.expressions.push([
|
|
20269
|
+
["\n", getIndent(block.expressions.at(-1))],
|
|
20270
|
+
{
|
|
20271
|
+
type: "ReturnStatement",
|
|
20272
|
+
expression: ref,
|
|
20273
|
+
children: ["return ", ref]
|
|
20274
|
+
}
|
|
20275
|
+
]);
|
|
20276
|
+
}
|
|
20277
|
+
return true;
|
|
20278
|
+
}
|
|
20279
|
+
function isVoidType(t) {
|
|
20280
|
+
return t?.type === "LiteralType" && t.t.type === "VoidType";
|
|
20281
|
+
}
|
|
20066
20282
|
function processFunctions(statements) {
|
|
20067
|
-
gatherRecursiveAll(statements, (
|
|
20068
|
-
return n.type === "FunctionExpression" || n.type === "ArrowFunction";
|
|
20069
|
-
}).forEach((f) => {
|
|
20283
|
+
gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
|
|
20070
20284
|
processParams(f);
|
|
20071
|
-
|
|
20072
|
-
|
|
20073
|
-
const isVoid = returnType
|
|
20285
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20286
|
+
const { block, returnType } = f;
|
|
20287
|
+
const isVoid = isVoidType(returnType?.t);
|
|
20074
20288
|
const isBlock = block?.type === "BlockStatement";
|
|
20075
20289
|
if (!isVoid && isBlock) {
|
|
20076
20290
|
insertReturn(block);
|
|
20077
20291
|
}
|
|
20078
20292
|
}
|
|
20079
20293
|
});
|
|
20080
|
-
gatherRecursiveAll(statements, (
|
|
20294
|
+
gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
|
|
20081
20295
|
processParams(f);
|
|
20082
|
-
|
|
20083
|
-
|
|
20296
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20297
|
+
const { signature, block } = f;
|
|
20084
20298
|
const isConstructor = signature.name === "constructor";
|
|
20085
|
-
const isVoid = signature.returnType
|
|
20299
|
+
const isVoid = isVoidType(signature.returnType?.t);
|
|
20086
20300
|
const isSet = signature.modifier === "set";
|
|
20087
20301
|
if (!isConstructor && !isSet && !isVoid) {
|
|
20088
20302
|
insertReturn(block);
|
|
@@ -20433,7 +20647,7 @@ ${input.slice(result.pos)}
|
|
|
20433
20647
|
}
|
|
20434
20648
|
}
|
|
20435
20649
|
function processPatternMatching(statements) {
|
|
20436
|
-
gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
|
|
20650
|
+
gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
|
|
20437
20651
|
const { caseBlock } = s;
|
|
20438
20652
|
const { clauses } = caseBlock;
|
|
20439
20653
|
let errors = false;
|
|
@@ -20512,15 +20726,21 @@ ${input.slice(result.pos)}
|
|
|
20512
20726
|
block.children.push("}");
|
|
20513
20727
|
block.bare = false;
|
|
20514
20728
|
}
|
|
20515
|
-
|
|
20516
|
-
|
|
20729
|
+
if (i < l - 1)
|
|
20730
|
+
next.push("\n", "else ");
|
|
20731
|
+
prev.push(["", {
|
|
20517
20732
|
type: "IfStatement",
|
|
20518
|
-
children: ["if", condition, block,
|
|
20733
|
+
children: ["if", condition, block, next],
|
|
20519
20734
|
then: block,
|
|
20520
|
-
else:
|
|
20521
|
-
});
|
|
20735
|
+
else: next
|
|
20736
|
+
}]);
|
|
20522
20737
|
prev = next;
|
|
20523
20738
|
});
|
|
20739
|
+
if (module.config.implicitReturns && s.type === "SwitchExpression") {
|
|
20740
|
+
insertReturn(root[0]);
|
|
20741
|
+
root.unshift("(()=>{");
|
|
20742
|
+
root.push("})()");
|
|
20743
|
+
}
|
|
20524
20744
|
s.type = "PatternMatchingStatement";
|
|
20525
20745
|
s.children = [root];
|
|
20526
20746
|
});
|
|
@@ -20570,12 +20790,13 @@ ${input.slice(result.pos)}
|
|
|
20570
20790
|
});
|
|
20571
20791
|
}
|
|
20572
20792
|
module.processProgram = function(statements) {
|
|
20793
|
+
addParentPointers(statements);
|
|
20573
20794
|
processPipelineExpressions(statements);
|
|
20574
20795
|
processAssignments(statements);
|
|
20796
|
+
processPatternMatching(statements);
|
|
20575
20797
|
processFunctions(statements);
|
|
20576
20798
|
processSwitchExpressions(statements);
|
|
20577
20799
|
processTryExpressions(statements);
|
|
20578
|
-
processPatternMatching(statements);
|
|
20579
20800
|
gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
|
|
20580
20801
|
checkSpliceRef(statements);
|
|
20581
20802
|
statements.unshift(...module.prelude);
|
|
@@ -20596,18 +20817,7 @@ ${input.slice(result.pos)}
|
|
|
20596
20817
|
return new Set(declarationNames);
|
|
20597
20818
|
}
|
|
20598
20819
|
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));
|
|
20820
|
+
const refNodes = gatherRecursive(statements, ({ type }) => type === "Ref");
|
|
20611
20821
|
if (refNodes.length) {
|
|
20612
20822
|
const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
|
|
20613
20823
|
const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
|
|
@@ -20785,6 +20995,15 @@ ${input.slice(result.pos)}
|
|
|
20785
20995
|
module.gatherBindingCode = gatherBindingCode;
|
|
20786
20996
|
module.constructInvocation = function(fn, arg) {
|
|
20787
20997
|
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20998
|
+
if (fn.expr.ampersandBlock) {
|
|
20999
|
+
const [ref, , prefix, rhs] = fn.expr.children;
|
|
21000
|
+
ref.type = "PipedExpression";
|
|
21001
|
+
ref.children = [module.makeLeftHandSideExpression(arg)];
|
|
21002
|
+
return {
|
|
21003
|
+
type: "UnwrappedExpression",
|
|
21004
|
+
children: [module.skipIfOnlyWS(fn.leadingComment), prefix, rhs, module.skipIfOnlyWS(fn.trailingComment)]
|
|
21005
|
+
};
|
|
21006
|
+
}
|
|
20788
21007
|
const lhs = module.makeLeftHandSideExpression(fn.expr);
|
|
20789
21008
|
let comment = module.skipIfOnlyWS(fn.trailingComment);
|
|
20790
21009
|
if (comment)
|
|
@@ -20794,10 +21013,7 @@ ${input.slice(result.pos)}
|
|
|
20794
21013
|
lhs.children.splice(1, 0, comment);
|
|
20795
21014
|
switch (arg.type) {
|
|
20796
21015
|
case "CommaExpression":
|
|
20797
|
-
arg =
|
|
20798
|
-
type: "ParenthesizedExpression",
|
|
20799
|
-
children: ["(", arg, ")"]
|
|
20800
|
-
};
|
|
21016
|
+
arg = module.makeLeftHandSideExpression(arg);
|
|
20801
21017
|
break;
|
|
20802
21018
|
}
|
|
20803
21019
|
return {
|
|
@@ -21013,7 +21229,7 @@ ${input.slice(result.pos)}
|
|
|
21013
21229
|
return result;
|
|
21014
21230
|
}
|
|
21015
21231
|
}
|
|
21016
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
21232
|
+
var PopIndent$0 = $TV($EXPECT($L19, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
21017
21233
|
if (module.config.verbose) {
|
|
21018
21234
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
21019
21235
|
}
|
|
@@ -21161,6 +21377,9 @@ ${input.slice(result.pos)}
|
|
|
21161
21377
|
if (node.length === 0) {
|
|
21162
21378
|
return;
|
|
21163
21379
|
}
|
|
21380
|
+
if (node.parent != null) {
|
|
21381
|
+
delete node.parent;
|
|
21382
|
+
}
|
|
21164
21383
|
if (Array.isArray(node)) {
|
|
21165
21384
|
a = node.map(function(n) {
|
|
21166
21385
|
return prune(n);
|