@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/main.mjs
CHANGED
|
@@ -497,6 +497,8 @@ ${input.slice(result.pos)}
|
|
|
497
497
|
AtThis,
|
|
498
498
|
LeftHandSideExpression,
|
|
499
499
|
CallExpression,
|
|
500
|
+
ReturnValue,
|
|
501
|
+
AfterReturnShorthand,
|
|
500
502
|
CallExpressionRest,
|
|
501
503
|
OptionalShorthand,
|
|
502
504
|
OptionalDot,
|
|
@@ -1039,170 +1041,171 @@ ${input.slice(result.pos)}
|
|
|
1039
1041
|
var $L11 = $L("#");
|
|
1040
1042
|
var $L12 = $L("super");
|
|
1041
1043
|
var $L13 = $L("import");
|
|
1042
|
-
var $L14 = $L("
|
|
1043
|
-
var $L15 = $L("
|
|
1044
|
-
var $L16 = $L("
|
|
1045
|
-
var $L17 = $L("
|
|
1046
|
-
var $L18 = $L("");
|
|
1047
|
-
var $L19 = $L("
|
|
1048
|
-
var $L20 = $L("
|
|
1049
|
-
var $L21 = $L("
|
|
1050
|
-
var $L22 = $L("
|
|
1051
|
-
var $L23 = $L("
|
|
1052
|
-
var $L24 = $L("
|
|
1053
|
-
var $L25 = $L("
|
|
1054
|
-
var $L26 = $L("
|
|
1055
|
-
var $L27 = $L("
|
|
1056
|
-
var $L28 = $L("
|
|
1057
|
-
var $L29 = $L("
|
|
1058
|
-
var $L30 = $L("
|
|
1059
|
-
var $L31 = $L("
|
|
1060
|
-
var $L32 = $L("
|
|
1061
|
-
var $L33 = $L("
|
|
1062
|
-
var $L34 = $L("
|
|
1063
|
-
var $L35 = $L("
|
|
1064
|
-
var $L36 = $L("
|
|
1065
|
-
var $L37 = $L("
|
|
1066
|
-
var $L38 = $L("
|
|
1067
|
-
var $L39 = $L("
|
|
1068
|
-
var $L40 = $L("
|
|
1069
|
-
var $L41 = $L("
|
|
1070
|
-
var $L42 = $L("
|
|
1071
|
-
var $L43 = $L("
|
|
1072
|
-
var $L44 = $L("
|
|
1073
|
-
var $L45 = $L("
|
|
1074
|
-
var $L46 = $L("
|
|
1075
|
-
var $L47 = $L("
|
|
1076
|
-
var $L48 = $L("
|
|
1077
|
-
var $L49 = $L("
|
|
1078
|
-
var $L50 = $L("
|
|
1079
|
-
var $L51 = $L("
|
|
1080
|
-
var $L52 = $L("
|
|
1081
|
-
var $L53 = $L("
|
|
1082
|
-
var $L54 = $L("
|
|
1083
|
-
var $L55 = $L("
|
|
1084
|
-
var $L56 = $L("
|
|
1085
|
-
var $L57 = $L("
|
|
1086
|
-
var $L58 = $L("
|
|
1087
|
-
var $L59 = $L("
|
|
1088
|
-
var $L60 = $L("
|
|
1089
|
-
var $L61 = $L("
|
|
1090
|
-
var $L62 = $L("
|
|
1091
|
-
var $L63 = $L("
|
|
1092
|
-
var $L64 = $L("
|
|
1093
|
-
var $L65 = $L("
|
|
1094
|
-
var $L66 = $L("
|
|
1095
|
-
var $L67 = $L("
|
|
1096
|
-
var $L68 = $L("
|
|
1097
|
-
var $L69 = $L("
|
|
1098
|
-
var $L70 = $L("
|
|
1099
|
-
var $L71 = $L("
|
|
1100
|
-
var $L72 = $L("
|
|
1101
|
-
var $L73 = $L("
|
|
1102
|
-
var $L74 = $L("
|
|
1103
|
-
var $L75 = $L("
|
|
1104
|
-
var $L76 = $L("
|
|
1105
|
-
var $L77 = $L("
|
|
1106
|
-
var $L78 = $L("
|
|
1107
|
-
var $L79 = $L("
|
|
1108
|
-
var $L80 = $L("
|
|
1109
|
-
var $L81 = $L("
|
|
1110
|
-
var $L82 = $L("
|
|
1111
|
-
var $L83 = $L("
|
|
1112
|
-
var $L84 = $L("
|
|
1113
|
-
var $L85 = $L("
|
|
1114
|
-
var $L86 = $L("
|
|
1115
|
-
var $L87 = $L("
|
|
1116
|
-
var $L88 = $L("
|
|
1117
|
-
var $L89 = $L("
|
|
1118
|
-
var $L90 = $L("
|
|
1119
|
-
var $L91 = $L("
|
|
1120
|
-
var $L92 = $L("
|
|
1121
|
-
var $L93 = $L("
|
|
1122
|
-
var $L94 = $L("
|
|
1123
|
-
var $L95 = $L("
|
|
1124
|
-
var $L96 = $L("
|
|
1125
|
-
var $L97 = $L("
|
|
1126
|
-
var $L98 = $L("
|
|
1127
|
-
var $L99 = $L("
|
|
1128
|
-
var $L100 = $L("
|
|
1129
|
-
var $L101 = $L("
|
|
1130
|
-
var $L102 = $L("
|
|
1131
|
-
var $L103 = $L("
|
|
1132
|
-
var $L104 = $L("
|
|
1133
|
-
var $L105 = $L("
|
|
1134
|
-
var $L106 = $L("
|
|
1135
|
-
var $L107 = $L("
|
|
1136
|
-
var $L108 = $L("
|
|
1137
|
-
var $L109 = $L("
|
|
1138
|
-
var $L110 = $L("
|
|
1139
|
-
var $L111 = $L("
|
|
1140
|
-
var $L112 = $L("
|
|
1141
|
-
var $L113 = $L("
|
|
1142
|
-
var $L114 = $L("
|
|
1143
|
-
var $L115 = $L("
|
|
1144
|
-
var $L116 = $L(
|
|
1145
|
-
var $L117 = $L("
|
|
1146
|
-
var $L118 = $L("
|
|
1147
|
-
var $L119 = $L("
|
|
1148
|
-
var $L120 = $L("
|
|
1149
|
-
var $L121 = $L("
|
|
1150
|
-
var $L122 = $L("
|
|
1151
|
-
var $L123 = $L("
|
|
1152
|
-
var $L124 = $L("
|
|
1153
|
-
var $L125 = $L("
|
|
1154
|
-
var $L126 = $L("
|
|
1155
|
-
var $L127 = $L("
|
|
1156
|
-
var $L128 = $L("
|
|
1157
|
-
var $L129 = $L("
|
|
1158
|
-
var $L130 = $L("
|
|
1159
|
-
var $L131 = $L("
|
|
1160
|
-
var $L132 = $L("
|
|
1161
|
-
var $L133 = $L("
|
|
1162
|
-
var $L134 = $L("
|
|
1163
|
-
var $L135 = $L("
|
|
1164
|
-
var $L136 = $L("
|
|
1165
|
-
var $L137 = $L("
|
|
1166
|
-
var $L138 = $L("
|
|
1167
|
-
var $L139 = $L("
|
|
1168
|
-
var $L140 = $L("
|
|
1169
|
-
var $L141 = $L("
|
|
1170
|
-
var $L142 = $L("
|
|
1171
|
-
var $L143 = $L("
|
|
1172
|
-
var $L144 = $L("
|
|
1173
|
-
var $L145 = $L("
|
|
1174
|
-
var $L146 = $L("
|
|
1175
|
-
var $L147 = $L("
|
|
1176
|
-
var $L148 = $L("
|
|
1177
|
-
var $L149 = $L("
|
|
1178
|
-
var $L150 = $L("
|
|
1179
|
-
var $L151 = $L(
|
|
1180
|
-
var $L152 = $L("'
|
|
1181
|
-
var $L153 = $L("
|
|
1182
|
-
var $L154 = $L("
|
|
1183
|
-
var $L155 = $L("
|
|
1184
|
-
var $L156 = $L("
|
|
1185
|
-
var $L157 = $L("
|
|
1186
|
-
var $L158 = $L("
|
|
1187
|
-
var $L159 = $L("
|
|
1188
|
-
var $L160 = $L("
|
|
1189
|
-
var $L161 = $L("
|
|
1190
|
-
var $L162 = $L("
|
|
1191
|
-
var $L163 = $L("
|
|
1192
|
-
var $L164 = $L("
|
|
1193
|
-
var $L165 = $L("
|
|
1194
|
-
var $L166 = $L("
|
|
1195
|
-
var $L167 = $L("
|
|
1196
|
-
var $L168 = $L("
|
|
1197
|
-
var $L169 = $L("
|
|
1198
|
-
var $L170 = $L("
|
|
1199
|
-
var $L171 = $L("
|
|
1200
|
-
var $L172 = $L("
|
|
1201
|
-
var $L173 = $L("
|
|
1202
|
-
var $L174 = $L("
|
|
1203
|
-
var $L175 = $L("
|
|
1204
|
-
var $L176 = $L("
|
|
1205
|
-
var $L177 = $L("
|
|
1044
|
+
var $L14 = $L("return.value");
|
|
1045
|
+
var $L15 = $L("!");
|
|
1046
|
+
var $L16 = $L("^");
|
|
1047
|
+
var $L17 = $L("-");
|
|
1048
|
+
var $L18 = $L("import.meta");
|
|
1049
|
+
var $L19 = $L("");
|
|
1050
|
+
var $L20 = $L(",");
|
|
1051
|
+
var $L21 = $L("->");
|
|
1052
|
+
var $L22 = $L("}");
|
|
1053
|
+
var $L23 = $L("null");
|
|
1054
|
+
var $L24 = $L("true");
|
|
1055
|
+
var $L25 = $L("false");
|
|
1056
|
+
var $L26 = $L("yes");
|
|
1057
|
+
var $L27 = $L("on");
|
|
1058
|
+
var $L28 = $L("no");
|
|
1059
|
+
var $L29 = $L("off");
|
|
1060
|
+
var $L30 = $L(">");
|
|
1061
|
+
var $L31 = $L("]");
|
|
1062
|
+
var $L32 = $L(":");
|
|
1063
|
+
var $L33 = $L(")");
|
|
1064
|
+
var $L34 = $L("**=");
|
|
1065
|
+
var $L35 = $L("*=");
|
|
1066
|
+
var $L36 = $L("/=");
|
|
1067
|
+
var $L37 = $L("%=");
|
|
1068
|
+
var $L38 = $L("+=");
|
|
1069
|
+
var $L39 = $L("-=");
|
|
1070
|
+
var $L40 = $L("<<=");
|
|
1071
|
+
var $L41 = $L(">>>=");
|
|
1072
|
+
var $L42 = $L(">>=");
|
|
1073
|
+
var $L43 = $L("&&=");
|
|
1074
|
+
var $L44 = $L("&=");
|
|
1075
|
+
var $L45 = $L("^=");
|
|
1076
|
+
var $L46 = $L("||=");
|
|
1077
|
+
var $L47 = $L("|=");
|
|
1078
|
+
var $L48 = $L("??=");
|
|
1079
|
+
var $L49 = $L("?=");
|
|
1080
|
+
var $L50 = $L("and=");
|
|
1081
|
+
var $L51 = $L("or=");
|
|
1082
|
+
var $L52 = $L("not");
|
|
1083
|
+
var $L53 = $L("**");
|
|
1084
|
+
var $L54 = $L("*");
|
|
1085
|
+
var $L55 = $L("/");
|
|
1086
|
+
var $L56 = $L("%%");
|
|
1087
|
+
var $L57 = $L("%");
|
|
1088
|
+
var $L58 = $L("+");
|
|
1089
|
+
var $L59 = $L("<=");
|
|
1090
|
+
var $L60 = $L(">=");
|
|
1091
|
+
var $L61 = $L("<?");
|
|
1092
|
+
var $L62 = $L("!<?");
|
|
1093
|
+
var $L63 = $L("<<");
|
|
1094
|
+
var $L64 = $L(">>>");
|
|
1095
|
+
var $L65 = $L(">>");
|
|
1096
|
+
var $L66 = $L("!==");
|
|
1097
|
+
var $L67 = $L("!=");
|
|
1098
|
+
var $L68 = $L("isnt");
|
|
1099
|
+
var $L69 = $L("===");
|
|
1100
|
+
var $L70 = $L("==");
|
|
1101
|
+
var $L71 = $L("and");
|
|
1102
|
+
var $L72 = $L("&&");
|
|
1103
|
+
var $L73 = $L("of");
|
|
1104
|
+
var $L74 = $L("or");
|
|
1105
|
+
var $L75 = $L("||");
|
|
1106
|
+
var $L76 = $L("^^");
|
|
1107
|
+
var $L77 = $L("xor");
|
|
1108
|
+
var $L78 = $L("xnor");
|
|
1109
|
+
var $L79 = $L("??");
|
|
1110
|
+
var $L80 = $L("instanceof");
|
|
1111
|
+
var $L81 = $L("in");
|
|
1112
|
+
var $L82 = $L("is");
|
|
1113
|
+
var $L83 = $L("&");
|
|
1114
|
+
var $L84 = $L("|");
|
|
1115
|
+
var $L85 = $L(";");
|
|
1116
|
+
var $L86 = $L("$:");
|
|
1117
|
+
var $L87 = $L("own");
|
|
1118
|
+
var $L88 = $L("break");
|
|
1119
|
+
var $L89 = $L("continue");
|
|
1120
|
+
var $L90 = $L("debugger");
|
|
1121
|
+
var $L91 = $L("assert");
|
|
1122
|
+
var $L92 = $L(":=");
|
|
1123
|
+
var $L93 = $L(".=");
|
|
1124
|
+
var $L94 = $L("/*");
|
|
1125
|
+
var $L95 = $L("*/");
|
|
1126
|
+
var $L96 = $L("\\");
|
|
1127
|
+
var $L97 = $L("[");
|
|
1128
|
+
var $L98 = $L("`");
|
|
1129
|
+
var $L99 = $L("abstract");
|
|
1130
|
+
var $L100 = $L("as");
|
|
1131
|
+
var $L101 = $L("@");
|
|
1132
|
+
var $L102 = $L("@@");
|
|
1133
|
+
var $L103 = $L("async");
|
|
1134
|
+
var $L104 = $L("await");
|
|
1135
|
+
var $L105 = $L("by");
|
|
1136
|
+
var $L106 = $L("case");
|
|
1137
|
+
var $L107 = $L("catch");
|
|
1138
|
+
var $L108 = $L("class");
|
|
1139
|
+
var $L109 = $L("#{");
|
|
1140
|
+
var $L110 = $L("declare");
|
|
1141
|
+
var $L111 = $L("default");
|
|
1142
|
+
var $L112 = $L("delete");
|
|
1143
|
+
var $L113 = $L("do");
|
|
1144
|
+
var $L114 = $L("..");
|
|
1145
|
+
var $L115 = $L("...");
|
|
1146
|
+
var $L116 = $L("::");
|
|
1147
|
+
var $L117 = $L('"');
|
|
1148
|
+
var $L118 = $L("else");
|
|
1149
|
+
var $L119 = $L("export");
|
|
1150
|
+
var $L120 = $L("extends");
|
|
1151
|
+
var $L121 = $L("finally");
|
|
1152
|
+
var $L122 = $L("for");
|
|
1153
|
+
var $L123 = $L("from");
|
|
1154
|
+
var $L124 = $L("function");
|
|
1155
|
+
var $L125 = $L("get");
|
|
1156
|
+
var $L126 = $L("set");
|
|
1157
|
+
var $L127 = $L("if");
|
|
1158
|
+
var $L128 = $L("let");
|
|
1159
|
+
var $L129 = $L("const");
|
|
1160
|
+
var $L130 = $L("loop");
|
|
1161
|
+
var $L131 = $L("new");
|
|
1162
|
+
var $L132 = $L("<");
|
|
1163
|
+
var $L133 = $L("{");
|
|
1164
|
+
var $L134 = $L("operator");
|
|
1165
|
+
var $L135 = $L("public");
|
|
1166
|
+
var $L136 = $L("private");
|
|
1167
|
+
var $L137 = $L("protected");
|
|
1168
|
+
var $L138 = $L("||>");
|
|
1169
|
+
var $L139 = $L("|>=");
|
|
1170
|
+
var $L140 = $L("|>");
|
|
1171
|
+
var $L141 = $L("readonly");
|
|
1172
|
+
var $L142 = $L("return");
|
|
1173
|
+
var $L143 = $L("satisfies");
|
|
1174
|
+
var $L144 = $L("'");
|
|
1175
|
+
var $L145 = $L("static");
|
|
1176
|
+
var $L146 = $L("${");
|
|
1177
|
+
var $L147 = $L("switch");
|
|
1178
|
+
var $L148 = $L("target");
|
|
1179
|
+
var $L149 = $L("then");
|
|
1180
|
+
var $L150 = $L("this");
|
|
1181
|
+
var $L151 = $L("throw");
|
|
1182
|
+
var $L152 = $L('"""');
|
|
1183
|
+
var $L153 = $L("'''");
|
|
1184
|
+
var $L154 = $L("///");
|
|
1185
|
+
var $L155 = $L("```");
|
|
1186
|
+
var $L156 = $L("try");
|
|
1187
|
+
var $L157 = $L("typeof");
|
|
1188
|
+
var $L158 = $L("unless");
|
|
1189
|
+
var $L159 = $L("until");
|
|
1190
|
+
var $L160 = $L("var");
|
|
1191
|
+
var $L161 = $L("void");
|
|
1192
|
+
var $L162 = $L("when");
|
|
1193
|
+
var $L163 = $L("while");
|
|
1194
|
+
var $L164 = $L("yield");
|
|
1195
|
+
var $L165 = $L("/>");
|
|
1196
|
+
var $L166 = $L("</");
|
|
1197
|
+
var $L167 = $L("<>");
|
|
1198
|
+
var $L168 = $L("</>");
|
|
1199
|
+
var $L169 = $L("<!--");
|
|
1200
|
+
var $L170 = $L("-->");
|
|
1201
|
+
var $L171 = $L("type");
|
|
1202
|
+
var $L172 = $L("interface");
|
|
1203
|
+
var $L173 = $L("namespace");
|
|
1204
|
+
var $L174 = $L("asserts");
|
|
1205
|
+
var $L175 = $L("keyof");
|
|
1206
|
+
var $L176 = $L("infer");
|
|
1207
|
+
var $L177 = $L("[]");
|
|
1208
|
+
var $L178 = $L("civet");
|
|
1206
1209
|
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1207
1210
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1208
1211
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -2372,7 +2375,7 @@ ${input.slice(result.pos)}
|
|
|
2372
2375
|
return {
|
|
2373
2376
|
type: "ArrowFunction",
|
|
2374
2377
|
parameters,
|
|
2375
|
-
returnType: suffix
|
|
2378
|
+
returnType: suffix,
|
|
2376
2379
|
ts: false,
|
|
2377
2380
|
block: expOrBlock,
|
|
2378
2381
|
children: $0
|
|
@@ -3160,7 +3163,7 @@ ${input.slice(result.pos)}
|
|
|
3160
3163
|
return result;
|
|
3161
3164
|
}
|
|
3162
3165
|
}
|
|
3163
|
-
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName,
|
|
3166
|
+
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, $E(_), Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3164
3167
|
var id = $2;
|
|
3165
3168
|
var exp = $6;
|
|
3166
3169
|
switch (exp.type) {
|
|
@@ -3305,7 +3308,8 @@ ${input.slice(result.pos)}
|
|
|
3305
3308
|
children: [$1, ...$2, ...rest.flat()]
|
|
3306
3309
|
});
|
|
3307
3310
|
});
|
|
3308
|
-
var CallExpression$2 =
|
|
3311
|
+
var CallExpression$2 = ReturnValue;
|
|
3312
|
+
var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3309
3313
|
var member = $1;
|
|
3310
3314
|
var trailing = $2;
|
|
3311
3315
|
var rest = $3;
|
|
@@ -3329,17 +3333,69 @@ ${input.slice(result.pos)}
|
|
|
3329
3333
|
}
|
|
3330
3334
|
}
|
|
3331
3335
|
if (state.tokenize) {
|
|
3332
|
-
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
3336
|
+
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state));
|
|
3333
3337
|
if (state.events)
|
|
3334
3338
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3335
3339
|
return result;
|
|
3336
3340
|
} else {
|
|
3337
|
-
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
|
|
3341
|
+
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state);
|
|
3338
3342
|
if (state.events)
|
|
3339
3343
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3340
3344
|
return result;
|
|
3341
3345
|
}
|
|
3342
3346
|
}
|
|
3347
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L14, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
3348
|
+
return { type: "ReturnValue", children: [$1[0]] };
|
|
3349
|
+
});
|
|
3350
|
+
function ReturnValue(state) {
|
|
3351
|
+
let eventData;
|
|
3352
|
+
if (state.events) {
|
|
3353
|
+
const result = state.events.enter?.("ReturnValue", state);
|
|
3354
|
+
if (result) {
|
|
3355
|
+
if (result.cache)
|
|
3356
|
+
return result.cache;
|
|
3357
|
+
eventData = result.data;
|
|
3358
|
+
}
|
|
3359
|
+
}
|
|
3360
|
+
if (state.tokenize) {
|
|
3361
|
+
const result = $TOKEN("ReturnValue", state, ReturnValue$0(state));
|
|
3362
|
+
if (state.events)
|
|
3363
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3364
|
+
return result;
|
|
3365
|
+
} else {
|
|
3366
|
+
const result = ReturnValue$0(state);
|
|
3367
|
+
if (state.events)
|
|
3368
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3369
|
+
return result;
|
|
3370
|
+
}
|
|
3371
|
+
}
|
|
3372
|
+
var AfterReturnShorthand$0 = WAssignmentOp;
|
|
3373
|
+
var AfterReturnShorthand$1 = UpdateExpressionSymbol;
|
|
3374
|
+
var AfterReturnShorthand$2 = TypeSuffix;
|
|
3375
|
+
var AfterReturnShorthand$3 = $S(__, LetAssignment);
|
|
3376
|
+
var AfterReturnShorthand$4 = $S(__, ConstAssignment);
|
|
3377
|
+
function AfterReturnShorthand(state) {
|
|
3378
|
+
let eventData;
|
|
3379
|
+
if (state.events) {
|
|
3380
|
+
const result = state.events.enter?.("AfterReturnShorthand", state);
|
|
3381
|
+
if (result) {
|
|
3382
|
+
if (result.cache)
|
|
3383
|
+
return result.cache;
|
|
3384
|
+
eventData = result.data;
|
|
3385
|
+
}
|
|
3386
|
+
}
|
|
3387
|
+
if (state.tokenize) {
|
|
3388
|
+
const result = $TOKEN("AfterReturnShorthand", state, AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state));
|
|
3389
|
+
if (state.events)
|
|
3390
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3391
|
+
return result;
|
|
3392
|
+
} else {
|
|
3393
|
+
const result = AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state);
|
|
3394
|
+
if (state.events)
|
|
3395
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3396
|
+
return result;
|
|
3397
|
+
}
|
|
3398
|
+
}
|
|
3343
3399
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
3344
3400
|
var CallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
|
|
3345
3401
|
if ($1.type === "StringLiteral") {
|
|
@@ -3426,7 +3482,7 @@ ${input.slice(result.pos)}
|
|
|
3426
3482
|
return result;
|
|
3427
3483
|
}
|
|
3428
3484
|
}
|
|
3429
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
3485
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L15, fail, 'NonNullAssertion "!"'), $N($EXPECT($L16, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3430
3486
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3431
3487
|
});
|
|
3432
3488
|
function NonNullAssertion(state) {
|
|
@@ -3564,7 +3620,7 @@ ${input.slice(result.pos)}
|
|
|
3564
3620
|
]
|
|
3565
3621
|
};
|
|
3566
3622
|
});
|
|
3567
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3623
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L17, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3568
3624
|
var dot = $1;
|
|
3569
3625
|
var neg = $2;
|
|
3570
3626
|
var num = $3;
|
|
@@ -3641,6 +3697,20 @@ ${input.slice(result.pos)}
|
|
|
3641
3697
|
children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
|
|
3642
3698
|
};
|
|
3643
3699
|
});
|
|
3700
|
+
var SliceParameters$2 = $TS($S(Loc, __, $C(DotDot, DotDotDot), $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3701
|
+
var l = $1;
|
|
3702
|
+
var ws = $2;
|
|
3703
|
+
const start = {
|
|
3704
|
+
$loc: l.$loc,
|
|
3705
|
+
token: "0"
|
|
3706
|
+
};
|
|
3707
|
+
return {
|
|
3708
|
+
type: "SliceParameters",
|
|
3709
|
+
start,
|
|
3710
|
+
end: void 0,
|
|
3711
|
+
children: [start, ws]
|
|
3712
|
+
};
|
|
3713
|
+
});
|
|
3644
3714
|
function SliceParameters(state) {
|
|
3645
3715
|
let eventData;
|
|
3646
3716
|
if (state.events) {
|
|
@@ -3652,12 +3722,12 @@ ${input.slice(result.pos)}
|
|
|
3652
3722
|
}
|
|
3653
3723
|
}
|
|
3654
3724
|
if (state.tokenize) {
|
|
3655
|
-
const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
|
|
3725
|
+
const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state));
|
|
3656
3726
|
if (state.events)
|
|
3657
3727
|
state.events.exit?.("SliceParameters", state, result, eventData);
|
|
3658
3728
|
return result;
|
|
3659
3729
|
} else {
|
|
3660
|
-
const result = SliceParameters$0(state) || SliceParameters$1(state);
|
|
3730
|
+
const result = SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state);
|
|
3661
3731
|
if (state.events)
|
|
3662
3732
|
state.events.exit?.("SliceParameters", state, result, eventData);
|
|
3663
3733
|
return result;
|
|
@@ -3761,7 +3831,7 @@ ${input.slice(result.pos)}
|
|
|
3761
3831
|
}
|
|
3762
3832
|
}
|
|
3763
3833
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3764
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3834
|
+
var MetaProperty$1 = $TS($S($EXPECT($L18, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3765
3835
|
return { $loc, token: $1 };
|
|
3766
3836
|
});
|
|
3767
3837
|
function MetaProperty(state) {
|
|
@@ -3787,7 +3857,7 @@ ${input.slice(result.pos)}
|
|
|
3787
3857
|
}
|
|
3788
3858
|
}
|
|
3789
3859
|
var Parameters$0 = NonEmptyParameters;
|
|
3790
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3860
|
+
var Parameters$1 = $TV($EXPECT($L19, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3791
3861
|
return {
|
|
3792
3862
|
type: "Parameters",
|
|
3793
3863
|
children: [{ $loc, token: "()" }],
|
|
@@ -4010,6 +4080,9 @@ ${input.slice(result.pos)}
|
|
|
4010
4080
|
};
|
|
4011
4081
|
});
|
|
4012
4082
|
var NWBindingIdentifier$1 = Identifier;
|
|
4083
|
+
var NWBindingIdentifier$2 = $TS($S(ReturnValue), function($skip, $loc, $0, $1) {
|
|
4084
|
+
return { children: [$1], names: [] };
|
|
4085
|
+
});
|
|
4013
4086
|
function NWBindingIdentifier(state) {
|
|
4014
4087
|
let eventData;
|
|
4015
4088
|
if (state.events) {
|
|
@@ -4021,12 +4094,12 @@ ${input.slice(result.pos)}
|
|
|
4021
4094
|
}
|
|
4022
4095
|
}
|
|
4023
4096
|
if (state.tokenize) {
|
|
4024
|
-
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state));
|
|
4097
|
+
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state));
|
|
4025
4098
|
if (state.events)
|
|
4026
4099
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4027
4100
|
return result;
|
|
4028
4101
|
} else {
|
|
4029
|
-
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state);
|
|
4102
|
+
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state);
|
|
4030
4103
|
if (state.events)
|
|
4031
4104
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4032
4105
|
return result;
|
|
@@ -4407,7 +4480,7 @@ ${input.slice(result.pos)}
|
|
|
4407
4480
|
}
|
|
4408
4481
|
}
|
|
4409
4482
|
var BindingProperty$0 = BindingRestProperty;
|
|
4410
|
-
var BindingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4483
|
+
var BindingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4411
4484
|
var name = $2;
|
|
4412
4485
|
var b = $5;
|
|
4413
4486
|
var init = $6;
|
|
@@ -4568,7 +4641,7 @@ ${input.slice(result.pos)}
|
|
|
4568
4641
|
children: $0
|
|
4569
4642
|
};
|
|
4570
4643
|
});
|
|
4571
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4644
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4572
4645
|
return {
|
|
4573
4646
|
children: [{
|
|
4574
4647
|
type: "ElisionElement",
|
|
@@ -4641,7 +4714,7 @@ ${input.slice(result.pos)}
|
|
|
4641
4714
|
return result;
|
|
4642
4715
|
}
|
|
4643
4716
|
}
|
|
4644
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4717
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L19, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4645
4718
|
const ref = {
|
|
4646
4719
|
type: "Ref",
|
|
4647
4720
|
base: "ref",
|
|
@@ -4859,7 +4932,7 @@ ${input.slice(result.pos)}
|
|
|
4859
4932
|
}
|
|
4860
4933
|
}
|
|
4861
4934
|
var MatchingProperty$0 = MatchingRestProperty;
|
|
4862
|
-
var MatchingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4935
|
+
var MatchingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4863
4936
|
var name = $2;
|
|
4864
4937
|
var match = $6;
|
|
4865
4938
|
return {
|
|
@@ -5085,7 +5158,7 @@ ${input.slice(result.pos)}
|
|
|
5085
5158
|
}
|
|
5086
5159
|
}
|
|
5087
5160
|
var MatchingElement$0 = MatchingRestElement;
|
|
5088
|
-
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier,
|
|
5161
|
+
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5089
5162
|
var ws = $1;
|
|
5090
5163
|
var name = $2;
|
|
5091
5164
|
var match = $6;
|
|
@@ -5117,7 +5190,7 @@ ${input.slice(result.pos)}
|
|
|
5117
5190
|
children: [ws, binding]
|
|
5118
5191
|
};
|
|
5119
5192
|
});
|
|
5120
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5193
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5121
5194
|
return {
|
|
5122
5195
|
children: [{
|
|
5123
5196
|
type: "ElisionElement",
|
|
@@ -5210,7 +5283,7 @@ ${input.slice(result.pos)}
|
|
|
5210
5283
|
type: "FunctionSignature",
|
|
5211
5284
|
id: wid?.[1],
|
|
5212
5285
|
parameters,
|
|
5213
|
-
returnType: suffix
|
|
5286
|
+
returnType: suffix,
|
|
5214
5287
|
ts: false,
|
|
5215
5288
|
block: null,
|
|
5216
5289
|
children: !parameters.implicit ? $0 : [async, func, star, wid, parameters, w, suffix]
|
|
@@ -5265,19 +5338,15 @@ ${input.slice(result.pos)}
|
|
|
5265
5338
|
};
|
|
5266
5339
|
return {
|
|
5267
5340
|
type: "ArrowFunction",
|
|
5268
|
-
children: [ref2, " => ", prefix, ref2]
|
|
5341
|
+
children: [ref2, " => ", prefix, ref2],
|
|
5342
|
+
ampersandBlock: true
|
|
5269
5343
|
};
|
|
5270
5344
|
}
|
|
5271
5345
|
const { ref } = rhs;
|
|
5272
|
-
if (!prefix) {
|
|
5273
|
-
return {
|
|
5274
|
-
type: "ArrowFunction",
|
|
5275
|
-
children: [ref, " => ", rhs]
|
|
5276
|
-
};
|
|
5277
|
-
}
|
|
5278
5346
|
return {
|
|
5279
5347
|
type: "ArrowFunction",
|
|
5280
|
-
children: [ref, " => ", prefix, rhs]
|
|
5348
|
+
children: [ref, " => ", prefix, rhs],
|
|
5349
|
+
ampersandBlock: true
|
|
5281
5350
|
};
|
|
5282
5351
|
});
|
|
5283
5352
|
function FunctionExpression(state) {
|
|
@@ -5369,7 +5438,7 @@ ${input.slice(result.pos)}
|
|
|
5369
5438
|
type: "FunctionSignature",
|
|
5370
5439
|
id,
|
|
5371
5440
|
parameters,
|
|
5372
|
-
returnType: suffix
|
|
5441
|
+
returnType: suffix,
|
|
5373
5442
|
ts: false,
|
|
5374
5443
|
block: null,
|
|
5375
5444
|
children: [func, w1, id, w2, parameters, suffix]
|
|
@@ -5478,7 +5547,7 @@ ${input.slice(result.pos)}
|
|
|
5478
5547
|
type: "FunctionExpression",
|
|
5479
5548
|
id: void 0,
|
|
5480
5549
|
parameters,
|
|
5481
|
-
returnType: suffix
|
|
5550
|
+
returnType: suffix,
|
|
5482
5551
|
ts: false,
|
|
5483
5552
|
block,
|
|
5484
5553
|
children: [
|
|
@@ -5511,7 +5580,7 @@ ${input.slice(result.pos)}
|
|
|
5511
5580
|
return result;
|
|
5512
5581
|
}
|
|
5513
5582
|
}
|
|
5514
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5583
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5515
5584
|
return { $loc, token: $1 };
|
|
5516
5585
|
});
|
|
5517
5586
|
function Arrow(state) {
|
|
@@ -5575,12 +5644,16 @@ ${input.slice(result.pos)}
|
|
|
5575
5644
|
return result;
|
|
5576
5645
|
}
|
|
5577
5646
|
}
|
|
5578
|
-
var ImplicitNestedBlock$0 = $TS($S(InsertOpenBrace, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5579
|
-
var
|
|
5580
|
-
|
|
5581
|
-
|
|
5647
|
+
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) {
|
|
5648
|
+
var open = $2;
|
|
5649
|
+
if (!$4)
|
|
5650
|
+
return $skip;
|
|
5651
|
+
const [block, ...tail] = $4;
|
|
5652
|
+
return {
|
|
5653
|
+
...block,
|
|
5654
|
+
children: [open, ...block.children, ...tail],
|
|
5582
5655
|
bare: false
|
|
5583
|
-
}
|
|
5656
|
+
};
|
|
5584
5657
|
});
|
|
5585
5658
|
function ImplicitNestedBlock(state) {
|
|
5586
5659
|
let eventData;
|
|
@@ -5745,7 +5818,7 @@ ${input.slice(result.pos)}
|
|
|
5745
5818
|
return result;
|
|
5746
5819
|
}
|
|
5747
5820
|
}
|
|
5748
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5821
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L19, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5749
5822
|
const expressions = [];
|
|
5750
5823
|
return {
|
|
5751
5824
|
type: "BlockStatement",
|
|
@@ -5848,12 +5921,16 @@ ${input.slice(result.pos)}
|
|
|
5848
5921
|
return result;
|
|
5849
5922
|
}
|
|
5850
5923
|
}
|
|
5851
|
-
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5852
|
-
var
|
|
5924
|
+
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5925
|
+
var ws1 = $1;
|
|
5926
|
+
var open = $2;
|
|
5927
|
+
if (!$4)
|
|
5928
|
+
return $skip;
|
|
5929
|
+
const [block, ws2, close] = $4;
|
|
5853
5930
|
return {
|
|
5854
5931
|
type: "BlockStatement",
|
|
5855
5932
|
expressions: block.expressions,
|
|
5856
|
-
children: [
|
|
5933
|
+
children: [ws1, open, ...block.children, ws2, close],
|
|
5857
5934
|
bare: false
|
|
5858
5935
|
};
|
|
5859
5936
|
return block;
|
|
@@ -5968,7 +6045,7 @@ ${input.slice(result.pos)}
|
|
|
5968
6045
|
children: [$1, expressions]
|
|
5969
6046
|
};
|
|
5970
6047
|
});
|
|
5971
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6048
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5972
6049
|
const expressions = [];
|
|
5973
6050
|
return {
|
|
5974
6051
|
type: "BlockStatement",
|
|
@@ -6113,7 +6190,7 @@ ${input.slice(result.pos)}
|
|
|
6113
6190
|
return result;
|
|
6114
6191
|
}
|
|
6115
6192
|
}
|
|
6116
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6193
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6117
6194
|
return { $loc, token: $1 };
|
|
6118
6195
|
});
|
|
6119
6196
|
function NullLiteral(state) {
|
|
@@ -6141,7 +6218,7 @@ ${input.slice(result.pos)}
|
|
|
6141
6218
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6142
6219
|
return value[1];
|
|
6143
6220
|
});
|
|
6144
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6221
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6145
6222
|
return { $loc, token: $1 };
|
|
6146
6223
|
});
|
|
6147
6224
|
function BooleanLiteral(state) {
|
|
@@ -6166,10 +6243,10 @@ ${input.slice(result.pos)}
|
|
|
6166
6243
|
return result;
|
|
6167
6244
|
}
|
|
6168
6245
|
}
|
|
6169
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6246
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6170
6247
|
return { $loc, token: "true" };
|
|
6171
6248
|
});
|
|
6172
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6249
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6173
6250
|
return { $loc, token: "false" };
|
|
6174
6251
|
});
|
|
6175
6252
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6275,7 +6352,7 @@ ${input.slice(result.pos)}
|
|
|
6275
6352
|
return result;
|
|
6276
6353
|
}
|
|
6277
6354
|
}
|
|
6278
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6355
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6279
6356
|
function UpcomingAssignment(state) {
|
|
6280
6357
|
let eventData;
|
|
6281
6358
|
if (state.events) {
|
|
@@ -6541,7 +6618,7 @@ ${input.slice(result.pos)}
|
|
|
6541
6618
|
}
|
|
6542
6619
|
}
|
|
6543
6620
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6544
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6621
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6545
6622
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6546
6623
|
return value[1];
|
|
6547
6624
|
});
|
|
@@ -6968,7 +7045,7 @@ ${input.slice(result.pos)}
|
|
|
6968
7045
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6969
7046
|
return value[1];
|
|
6970
7047
|
});
|
|
6971
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
7048
|
+
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) {
|
|
6972
7049
|
return "";
|
|
6973
7050
|
});
|
|
6974
7051
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6997,7 +7074,7 @@ ${input.slice(result.pos)}
|
|
|
6997
7074
|
}
|
|
6998
7075
|
}
|
|
6999
7076
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
7000
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7077
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
7001
7078
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7002
7079
|
return value[1];
|
|
7003
7080
|
});
|
|
@@ -7167,7 +7244,7 @@ ${input.slice(result.pos)}
|
|
|
7167
7244
|
return result;
|
|
7168
7245
|
}
|
|
7169
7246
|
}
|
|
7170
|
-
var NamedProperty$0 = $TS($S(PropertyName,
|
|
7247
|
+
var NamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7171
7248
|
var name = $1;
|
|
7172
7249
|
var exp = $4;
|
|
7173
7250
|
return {
|
|
@@ -7200,7 +7277,7 @@ ${input.slice(result.pos)}
|
|
|
7200
7277
|
return result;
|
|
7201
7278
|
}
|
|
7202
7279
|
}
|
|
7203
|
-
var ImplicitNamedProperty$0 = $TS($S(PropertyName,
|
|
7280
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7204
7281
|
var name = $1;
|
|
7205
7282
|
var exp = $5;
|
|
7206
7283
|
return {
|
|
@@ -7307,7 +7384,7 @@ ${input.slice(result.pos)}
|
|
|
7307
7384
|
expression
|
|
7308
7385
|
};
|
|
7309
7386
|
});
|
|
7310
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7387
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L17, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7311
7388
|
return {
|
|
7312
7389
|
type: "ComputedPropertyName",
|
|
7313
7390
|
children: $0
|
|
@@ -7475,7 +7552,7 @@ ${input.slice(result.pos)}
|
|
|
7475
7552
|
children: $0,
|
|
7476
7553
|
name,
|
|
7477
7554
|
modifier: $1?.[0]?.token,
|
|
7478
|
-
returnType:
|
|
7555
|
+
returnType: suffix,
|
|
7479
7556
|
parameters
|
|
7480
7557
|
};
|
|
7481
7558
|
});
|
|
@@ -7656,22 +7733,22 @@ ${input.slice(result.pos)}
|
|
|
7656
7733
|
return result;
|
|
7657
7734
|
}
|
|
7658
7735
|
}
|
|
7659
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7660
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7661
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7662
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7663
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7664
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7665
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7666
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7667
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7668
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7669
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7670
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7671
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7672
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7673
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7674
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7736
|
+
var AssignmentOpSymbol$0 = $EXPECT($L34, fail, 'AssignmentOpSymbol "**="');
|
|
7737
|
+
var AssignmentOpSymbol$1 = $EXPECT($L35, fail, 'AssignmentOpSymbol "*="');
|
|
7738
|
+
var AssignmentOpSymbol$2 = $EXPECT($L36, fail, 'AssignmentOpSymbol "/="');
|
|
7739
|
+
var AssignmentOpSymbol$3 = $EXPECT($L37, fail, 'AssignmentOpSymbol "%="');
|
|
7740
|
+
var AssignmentOpSymbol$4 = $EXPECT($L38, fail, 'AssignmentOpSymbol "+="');
|
|
7741
|
+
var AssignmentOpSymbol$5 = $EXPECT($L39, fail, 'AssignmentOpSymbol "-="');
|
|
7742
|
+
var AssignmentOpSymbol$6 = $EXPECT($L40, fail, 'AssignmentOpSymbol "<<="');
|
|
7743
|
+
var AssignmentOpSymbol$7 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>>="');
|
|
7744
|
+
var AssignmentOpSymbol$8 = $EXPECT($L42, fail, 'AssignmentOpSymbol ">>="');
|
|
7745
|
+
var AssignmentOpSymbol$9 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&&="');
|
|
7746
|
+
var AssignmentOpSymbol$10 = $EXPECT($L44, fail, 'AssignmentOpSymbol "&="');
|
|
7747
|
+
var AssignmentOpSymbol$11 = $EXPECT($L45, fail, 'AssignmentOpSymbol "^="');
|
|
7748
|
+
var AssignmentOpSymbol$12 = $EXPECT($L46, fail, 'AssignmentOpSymbol "||="');
|
|
7749
|
+
var AssignmentOpSymbol$13 = $EXPECT($L47, fail, 'AssignmentOpSymbol "|="');
|
|
7750
|
+
var AssignmentOpSymbol$14 = $EXPECT($L48, fail, 'AssignmentOpSymbol "??="');
|
|
7751
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L49, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7675
7752
|
return "??=";
|
|
7676
7753
|
});
|
|
7677
7754
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7702,10 +7779,10 @@ ${input.slice(result.pos)}
|
|
|
7702
7779
|
return result;
|
|
7703
7780
|
}
|
|
7704
7781
|
}
|
|
7705
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7782
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7706
7783
|
return "&&=";
|
|
7707
7784
|
});
|
|
7708
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7785
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L51, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7709
7786
|
return "||=";
|
|
7710
7787
|
});
|
|
7711
7788
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7744,7 +7821,7 @@ ${input.slice(result.pos)}
|
|
|
7744
7821
|
special: true
|
|
7745
7822
|
};
|
|
7746
7823
|
});
|
|
7747
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7824
|
+
var BinaryOp$2 = $TS($S($EXPECT($L52, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7748
7825
|
var id = $4;
|
|
7749
7826
|
if (!module.operators.has(id.name))
|
|
7750
7827
|
return $skip;
|
|
@@ -7776,21 +7853,21 @@ ${input.slice(result.pos)}
|
|
|
7776
7853
|
return result;
|
|
7777
7854
|
}
|
|
7778
7855
|
}
|
|
7779
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7780
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7781
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7782
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7856
|
+
var BinaryOpSymbol$0 = $EXPECT($L53, fail, 'BinaryOpSymbol "**"');
|
|
7857
|
+
var BinaryOpSymbol$1 = $EXPECT($L54, fail, 'BinaryOpSymbol "*"');
|
|
7858
|
+
var BinaryOpSymbol$2 = $EXPECT($L55, fail, 'BinaryOpSymbol "/"');
|
|
7859
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7783
7860
|
return {
|
|
7784
7861
|
call: module.getRef("modulo"),
|
|
7785
7862
|
special: true
|
|
7786
7863
|
};
|
|
7787
7864
|
});
|
|
7788
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7789
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7790
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7791
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7792
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7793
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7865
|
+
var BinaryOpSymbol$4 = $EXPECT($L57, fail, 'BinaryOpSymbol "%"');
|
|
7866
|
+
var BinaryOpSymbol$5 = $EXPECT($L58, fail, 'BinaryOpSymbol "+"');
|
|
7867
|
+
var BinaryOpSymbol$6 = $EXPECT($L17, fail, 'BinaryOpSymbol "-"');
|
|
7868
|
+
var BinaryOpSymbol$7 = $EXPECT($L59, fail, 'BinaryOpSymbol "<="');
|
|
7869
|
+
var BinaryOpSymbol$8 = $EXPECT($L60, fail, 'BinaryOpSymbol ">="');
|
|
7870
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7794
7871
|
return {
|
|
7795
7872
|
$loc,
|
|
7796
7873
|
token: "instanceof",
|
|
@@ -7798,7 +7875,7 @@ ${input.slice(result.pos)}
|
|
|
7798
7875
|
special: true
|
|
7799
7876
|
};
|
|
7800
7877
|
});
|
|
7801
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7878
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L62, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7802
7879
|
return {
|
|
7803
7880
|
$loc,
|
|
7804
7881
|
token: "instanceof",
|
|
@@ -7807,58 +7884,58 @@ ${input.slice(result.pos)}
|
|
|
7807
7884
|
negated: true
|
|
7808
7885
|
};
|
|
7809
7886
|
});
|
|
7810
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7887
|
+
var BinaryOpSymbol$11 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
7811
7888
|
var BinaryOpSymbol$12 = $TR($EXPECT($R7, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7812
7889
|
return "<";
|
|
7813
7890
|
});
|
|
7814
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7815
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7816
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7817
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7818
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7891
|
+
var BinaryOpSymbol$13 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
7892
|
+
var BinaryOpSymbol$14 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
7893
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7894
|
+
var BinaryOpSymbol$16 = $EXPECT($L66, fail, 'BinaryOpSymbol "!=="');
|
|
7895
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L67, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7819
7896
|
if (module.config.coffeeEq)
|
|
7820
7897
|
return "!==";
|
|
7821
7898
|
return $1;
|
|
7822
7899
|
});
|
|
7823
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7900
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7824
7901
|
if (module.config.coffeeIsnt)
|
|
7825
7902
|
return "!==";
|
|
7826
7903
|
return $skip;
|
|
7827
7904
|
});
|
|
7828
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7829
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7905
|
+
var BinaryOpSymbol$19 = $EXPECT($L69, fail, 'BinaryOpSymbol "==="');
|
|
7906
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7830
7907
|
if (module.config.coffeeEq)
|
|
7831
7908
|
return "===";
|
|
7832
7909
|
return $1;
|
|
7833
7910
|
});
|
|
7834
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7911
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7835
7912
|
return "&&";
|
|
7836
7913
|
});
|
|
7837
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7838
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7914
|
+
var BinaryOpSymbol$22 = $EXPECT($L72, fail, 'BinaryOpSymbol "&&"');
|
|
7915
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7839
7916
|
return "in";
|
|
7840
7917
|
});
|
|
7841
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7918
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7842
7919
|
return "||";
|
|
7843
7920
|
});
|
|
7844
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7845
|
-
var BinaryOpSymbol$26 = $TV($C($EXPECT($
|
|
7921
|
+
var BinaryOpSymbol$25 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
7922
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L76, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7846
7923
|
return {
|
|
7847
7924
|
call: module.getRef("xor"),
|
|
7848
7925
|
special: true
|
|
7849
7926
|
};
|
|
7850
7927
|
});
|
|
7851
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
7928
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L78, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7852
7929
|
return {
|
|
7853
7930
|
call: module.getRef("xnor"),
|
|
7854
7931
|
special: true
|
|
7855
7932
|
};
|
|
7856
7933
|
});
|
|
7857
|
-
var BinaryOpSymbol$28 = $EXPECT($
|
|
7934
|
+
var BinaryOpSymbol$28 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
|
|
7858
7935
|
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7859
7936
|
return "??";
|
|
7860
7937
|
});
|
|
7861
|
-
var BinaryOpSymbol$30 = $TS($S($EXPECT($
|
|
7938
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7862
7939
|
return {
|
|
7863
7940
|
$loc,
|
|
7864
7941
|
token: $1,
|
|
@@ -7866,7 +7943,7 @@ ${input.slice(result.pos)}
|
|
|
7866
7943
|
special: true
|
|
7867
7944
|
};
|
|
7868
7945
|
});
|
|
7869
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
7946
|
+
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) {
|
|
7870
7947
|
return {
|
|
7871
7948
|
$loc,
|
|
7872
7949
|
token: "instanceof",
|
|
@@ -7875,7 +7952,7 @@ ${input.slice(result.pos)}
|
|
|
7875
7952
|
negated: true
|
|
7876
7953
|
};
|
|
7877
7954
|
});
|
|
7878
|
-
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($
|
|
7955
|
+
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) {
|
|
7879
7956
|
return {
|
|
7880
7957
|
$loc,
|
|
7881
7958
|
token: "in",
|
|
@@ -7883,7 +7960,7 @@ ${input.slice(result.pos)}
|
|
|
7883
7960
|
negated: true
|
|
7884
7961
|
};
|
|
7885
7962
|
});
|
|
7886
|
-
var BinaryOpSymbol$33 = $TS($S($EXPECT($
|
|
7963
|
+
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) {
|
|
7887
7964
|
return {
|
|
7888
7965
|
method: "includes",
|
|
7889
7966
|
relational: true,
|
|
@@ -7891,7 +7968,7 @@ ${input.slice(result.pos)}
|
|
|
7891
7968
|
special: true
|
|
7892
7969
|
};
|
|
7893
7970
|
});
|
|
7894
|
-
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7971
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7895
7972
|
return {
|
|
7896
7973
|
call: [module.getRef("indexOf"), ".call"],
|
|
7897
7974
|
relational: true,
|
|
@@ -7900,7 +7977,7 @@ ${input.slice(result.pos)}
|
|
|
7900
7977
|
special: true
|
|
7901
7978
|
};
|
|
7902
7979
|
});
|
|
7903
|
-
var BinaryOpSymbol$35 = $TS($S($EXPECT($
|
|
7980
|
+
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) {
|
|
7904
7981
|
return {
|
|
7905
7982
|
method: "includes",
|
|
7906
7983
|
relational: true,
|
|
@@ -7909,7 +7986,7 @@ ${input.slice(result.pos)}
|
|
|
7909
7986
|
negated: true
|
|
7910
7987
|
};
|
|
7911
7988
|
});
|
|
7912
|
-
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7989
|
+
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) {
|
|
7913
7990
|
return {
|
|
7914
7991
|
call: [module.getRef("indexOf"), ".call"],
|
|
7915
7992
|
relational: true,
|
|
@@ -7918,7 +7995,7 @@ ${input.slice(result.pos)}
|
|
|
7918
7995
|
special: true
|
|
7919
7996
|
};
|
|
7920
7997
|
});
|
|
7921
|
-
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($
|
|
7998
|
+
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) {
|
|
7922
7999
|
if (module.config.objectIs) {
|
|
7923
8000
|
return {
|
|
7924
8001
|
call: module.getRef("is"),
|
|
@@ -7930,7 +8007,7 @@ ${input.slice(result.pos)}
|
|
|
7930
8007
|
}
|
|
7931
8008
|
return "!==";
|
|
7932
8009
|
});
|
|
7933
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8010
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7934
8011
|
if (module.config.objectIs) {
|
|
7935
8012
|
return {
|
|
7936
8013
|
call: module.getRef("is"),
|
|
@@ -7941,12 +8018,12 @@ ${input.slice(result.pos)}
|
|
|
7941
8018
|
}
|
|
7942
8019
|
return "===";
|
|
7943
8020
|
});
|
|
7944
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
8021
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7945
8022
|
return $1;
|
|
7946
8023
|
});
|
|
7947
|
-
var BinaryOpSymbol$40 = $EXPECT($
|
|
7948
|
-
var BinaryOpSymbol$41 = $EXPECT($
|
|
7949
|
-
var BinaryOpSymbol$42 = $EXPECT($
|
|
8024
|
+
var BinaryOpSymbol$40 = $EXPECT($L83, fail, 'BinaryOpSymbol "&"');
|
|
8025
|
+
var BinaryOpSymbol$41 = $EXPECT($L16, fail, 'BinaryOpSymbol "^"');
|
|
8026
|
+
var BinaryOpSymbol$42 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
|
|
7950
8027
|
function BinaryOpSymbol(state) {
|
|
7951
8028
|
let eventData;
|
|
7952
8029
|
if (state.events) {
|
|
@@ -7969,8 +8046,8 @@ ${input.slice(result.pos)}
|
|
|
7969
8046
|
return result;
|
|
7970
8047
|
}
|
|
7971
8048
|
}
|
|
7972
|
-
var Xor$0 = $EXPECT($
|
|
7973
|
-
var Xor$1 = $S($EXPECT($
|
|
8049
|
+
var Xor$0 = $EXPECT($L76, fail, 'Xor "^^"');
|
|
8050
|
+
var Xor$1 = $S($EXPECT($L77, fail, 'Xor "xor"'), NonIdContinue);
|
|
7974
8051
|
function Xor(state) {
|
|
7975
8052
|
let eventData;
|
|
7976
8053
|
if (state.events) {
|
|
@@ -7994,7 +8071,7 @@ ${input.slice(result.pos)}
|
|
|
7994
8071
|
}
|
|
7995
8072
|
}
|
|
7996
8073
|
var Xnor$0 = $R$0($EXPECT($R8, fail, "Xnor /!\\^\\^?/"));
|
|
7997
|
-
var Xnor$1 = $EXPECT($
|
|
8074
|
+
var Xnor$1 = $EXPECT($L78, fail, 'Xnor "xnor"');
|
|
7998
8075
|
function Xnor(state) {
|
|
7999
8076
|
let eventData;
|
|
8000
8077
|
if (state.events) {
|
|
@@ -8215,7 +8292,7 @@ ${input.slice(result.pos)}
|
|
|
8215
8292
|
return result;
|
|
8216
8293
|
}
|
|
8217
8294
|
}
|
|
8218
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8295
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8219
8296
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8220
8297
|
});
|
|
8221
8298
|
function EmptyStatement(state) {
|
|
@@ -8294,7 +8371,7 @@ ${input.slice(result.pos)}
|
|
|
8294
8371
|
var w = $3;
|
|
8295
8372
|
return [id, colon, w];
|
|
8296
8373
|
});
|
|
8297
|
-
var Label$1 = $S($EXPECT($
|
|
8374
|
+
var Label$1 = $S($EXPECT($L86, fail, 'Label "$:"'), Whitespace);
|
|
8298
8375
|
function Label(state) {
|
|
8299
8376
|
let eventData;
|
|
8300
8377
|
if (state.events) {
|
|
@@ -9246,7 +9323,7 @@ ${input.slice(result.pos)}
|
|
|
9246
9323
|
return result;
|
|
9247
9324
|
}
|
|
9248
9325
|
}
|
|
9249
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9326
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L87, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9250
9327
|
var own = $1;
|
|
9251
9328
|
var binding = $2;
|
|
9252
9329
|
return {
|
|
@@ -9509,7 +9586,8 @@ ${input.slice(result.pos)}
|
|
|
9509
9586
|
return {
|
|
9510
9587
|
type: "SwitchExpression",
|
|
9511
9588
|
children: ["(()=>{", e.children, "})()"],
|
|
9512
|
-
|
|
9589
|
+
expression: e.expression,
|
|
9590
|
+
caseBlock: e.caseBlock
|
|
9513
9591
|
};
|
|
9514
9592
|
});
|
|
9515
9593
|
function SwitchExpression(state) {
|
|
@@ -9730,8 +9808,8 @@ ${input.slice(result.pos)}
|
|
|
9730
9808
|
return result;
|
|
9731
9809
|
}
|
|
9732
9810
|
}
|
|
9733
|
-
var ImpliedColon$0 = $S(
|
|
9734
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9811
|
+
var ImpliedColon$0 = $S($E(_), Colon);
|
|
9812
|
+
var ImpliedColon$1 = $TV($EXPECT($L19, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9735
9813
|
return { $loc, token: ":" };
|
|
9736
9814
|
});
|
|
9737
9815
|
function ImpliedColon(state) {
|
|
@@ -9984,7 +10062,7 @@ ${input.slice(result.pos)}
|
|
|
9984
10062
|
return result;
|
|
9985
10063
|
}
|
|
9986
10064
|
}
|
|
9987
|
-
var ForbidIndentedApplication$0 = $TV($EXPECT($
|
|
10065
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L19, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9988
10066
|
module.forbidIndentedApplication.push(true);
|
|
9989
10067
|
});
|
|
9990
10068
|
function ForbidIndentedApplication(state) {
|
|
@@ -10009,7 +10087,7 @@ ${input.slice(result.pos)}
|
|
|
10009
10087
|
return result;
|
|
10010
10088
|
}
|
|
10011
10089
|
}
|
|
10012
|
-
var AllowIndentedApplication$0 = $TV($EXPECT($
|
|
10090
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L19, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10013
10091
|
module.forbidIndentedApplication.push(false);
|
|
10014
10092
|
});
|
|
10015
10093
|
function AllowIndentedApplication(state) {
|
|
@@ -10034,7 +10112,7 @@ ${input.slice(result.pos)}
|
|
|
10034
10112
|
return result;
|
|
10035
10113
|
}
|
|
10036
10114
|
}
|
|
10037
|
-
var RestoreIndentedApplication$0 = $TV($EXPECT($
|
|
10115
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L19, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10038
10116
|
module.forbidIndentedApplication.pop();
|
|
10039
10117
|
});
|
|
10040
10118
|
function RestoreIndentedApplication(state) {
|
|
@@ -10059,7 +10137,7 @@ ${input.slice(result.pos)}
|
|
|
10059
10137
|
return result;
|
|
10060
10138
|
}
|
|
10061
10139
|
}
|
|
10062
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
10140
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L19, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10063
10141
|
if (module.config.verbose) {
|
|
10064
10142
|
console.log("forbidIndentedApplication:", module.forbidIndentedApplication);
|
|
10065
10143
|
}
|
|
@@ -10089,7 +10167,7 @@ ${input.slice(result.pos)}
|
|
|
10089
10167
|
return result;
|
|
10090
10168
|
}
|
|
10091
10169
|
}
|
|
10092
|
-
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10170
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10093
10171
|
module.forbidTrailingMemberProperty.push(true);
|
|
10094
10172
|
});
|
|
10095
10173
|
function ForbidTrailingMemberProperty(state) {
|
|
@@ -10114,7 +10192,7 @@ ${input.slice(result.pos)}
|
|
|
10114
10192
|
return result;
|
|
10115
10193
|
}
|
|
10116
10194
|
}
|
|
10117
|
-
var AllowTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10195
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10118
10196
|
module.forbidTrailingMemberProperty.push(false);
|
|
10119
10197
|
});
|
|
10120
10198
|
function AllowTrailingMemberProperty(state) {
|
|
@@ -10139,7 +10217,7 @@ ${input.slice(result.pos)}
|
|
|
10139
10217
|
return result;
|
|
10140
10218
|
}
|
|
10141
10219
|
}
|
|
10142
|
-
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10220
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10143
10221
|
module.forbidTrailingMemberProperty.pop();
|
|
10144
10222
|
});
|
|
10145
10223
|
function RestoreTrailingMemberProperty(state) {
|
|
@@ -10164,7 +10242,7 @@ ${input.slice(result.pos)}
|
|
|
10164
10242
|
return result;
|
|
10165
10243
|
}
|
|
10166
10244
|
}
|
|
10167
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
10245
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L19, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10168
10246
|
if (module.config.verbose) {
|
|
10169
10247
|
console.log("forbidTrailingMemberProperty:", module.forbidTrailingMemberProperty);
|
|
10170
10248
|
}
|
|
@@ -10193,7 +10271,7 @@ ${input.slice(result.pos)}
|
|
|
10193
10271
|
return result;
|
|
10194
10272
|
}
|
|
10195
10273
|
}
|
|
10196
|
-
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10274
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10197
10275
|
module.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10198
10276
|
});
|
|
10199
10277
|
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10218,7 +10296,7 @@ ${input.slice(result.pos)}
|
|
|
10218
10296
|
return result;
|
|
10219
10297
|
}
|
|
10220
10298
|
}
|
|
10221
|
-
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10299
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10222
10300
|
module.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10223
10301
|
});
|
|
10224
10302
|
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10243,7 +10321,7 @@ ${input.slice(result.pos)}
|
|
|
10243
10321
|
return result;
|
|
10244
10322
|
}
|
|
10245
10323
|
}
|
|
10246
|
-
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10324
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10247
10325
|
module.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10248
10326
|
});
|
|
10249
10327
|
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10268,7 +10346,7 @@ ${input.slice(result.pos)}
|
|
|
10268
10346
|
return result;
|
|
10269
10347
|
}
|
|
10270
10348
|
}
|
|
10271
|
-
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($
|
|
10349
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L19, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10272
10350
|
if (module.config.verbose) {
|
|
10273
10351
|
console.log("forbidMultiLineImplicitObjectLiteral:", module.forbidMultiLineImplicitObjectLiteral);
|
|
10274
10352
|
}
|
|
@@ -10381,8 +10459,9 @@ ${input.slice(result.pos)}
|
|
|
10381
10459
|
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
10382
10460
|
return { "type": "DebuggerStatement", "children": value };
|
|
10383
10461
|
});
|
|
10384
|
-
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
10385
|
-
|
|
10462
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L4, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10463
|
+
var expression = value[2];
|
|
10464
|
+
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10386
10465
|
});
|
|
10387
10466
|
var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
|
|
10388
10467
|
return { "type": "ThrowStatement", "children": value };
|
|
@@ -10409,7 +10488,7 @@ ${input.slice(result.pos)}
|
|
|
10409
10488
|
return result;
|
|
10410
10489
|
}
|
|
10411
10490
|
}
|
|
10412
|
-
var Break$0 = $TS($S($EXPECT($
|
|
10491
|
+
var Break$0 = $TS($S($EXPECT($L88, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10413
10492
|
return { $loc, token: $1 };
|
|
10414
10493
|
});
|
|
10415
10494
|
function Break(state) {
|
|
@@ -10434,7 +10513,7 @@ ${input.slice(result.pos)}
|
|
|
10434
10513
|
return result;
|
|
10435
10514
|
}
|
|
10436
10515
|
}
|
|
10437
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
10516
|
+
var Continue$0 = $TS($S($EXPECT($L89, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10438
10517
|
return { $loc, token: $1 };
|
|
10439
10518
|
});
|
|
10440
10519
|
function Continue(state) {
|
|
@@ -10459,7 +10538,7 @@ ${input.slice(result.pos)}
|
|
|
10459
10538
|
return result;
|
|
10460
10539
|
}
|
|
10461
10540
|
}
|
|
10462
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
10541
|
+
var Debugger$0 = $TS($S($EXPECT($L90, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10463
10542
|
return { $loc, token: $1 };
|
|
10464
10543
|
});
|
|
10465
10544
|
function Debugger(state) {
|
|
@@ -10612,7 +10691,7 @@ ${input.slice(result.pos)}
|
|
|
10612
10691
|
return result;
|
|
10613
10692
|
}
|
|
10614
10693
|
}
|
|
10615
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10694
|
+
var ImpliedImport$0 = $TV($EXPECT($L19, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10616
10695
|
return { $loc, token: "import " };
|
|
10617
10696
|
});
|
|
10618
10697
|
function ImpliedImport(state) {
|
|
@@ -10761,7 +10840,7 @@ ${input.slice(result.pos)}
|
|
|
10761
10840
|
return result;
|
|
10762
10841
|
}
|
|
10763
10842
|
}
|
|
10764
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10843
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L91, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10765
10844
|
function ImportAssertion(state) {
|
|
10766
10845
|
let eventData;
|
|
10767
10846
|
if (state.events) {
|
|
@@ -11365,7 +11444,7 @@ ${input.slice(result.pos)}
|
|
|
11365
11444
|
return result;
|
|
11366
11445
|
}
|
|
11367
11446
|
}
|
|
11368
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11447
|
+
var ConstAssignment$0 = $TV($EXPECT($L92, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
11369
11448
|
return { $loc, token: "=" };
|
|
11370
11449
|
});
|
|
11371
11450
|
function ConstAssignment(state) {
|
|
@@ -11390,7 +11469,7 @@ ${input.slice(result.pos)}
|
|
|
11390
11469
|
return result;
|
|
11391
11470
|
}
|
|
11392
11471
|
}
|
|
11393
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11472
|
+
var LetAssignment$0 = $TV($EXPECT($L93, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
11394
11473
|
return { $loc, token: "=" };
|
|
11395
11474
|
});
|
|
11396
11475
|
function LetAssignment(state) {
|
|
@@ -12088,7 +12167,7 @@ ${input.slice(result.pos)}
|
|
|
12088
12167
|
}
|
|
12089
12168
|
}
|
|
12090
12169
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
12091
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
12170
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
12092
12171
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
12093
12172
|
});
|
|
12094
12173
|
function RegularExpressionLiteral(state) {
|
|
@@ -12655,7 +12734,7 @@ ${input.slice(result.pos)}
|
|
|
12655
12734
|
return result;
|
|
12656
12735
|
}
|
|
12657
12736
|
}
|
|
12658
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12737
|
+
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) {
|
|
12659
12738
|
return { $loc, token: $1 };
|
|
12660
12739
|
});
|
|
12661
12740
|
function JSMultiLineComment(state) {
|
|
@@ -12754,7 +12833,7 @@ ${input.slice(result.pos)}
|
|
|
12754
12833
|
return result;
|
|
12755
12834
|
}
|
|
12756
12835
|
}
|
|
12757
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12836
|
+
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) {
|
|
12758
12837
|
return { $loc, token: $1 };
|
|
12759
12838
|
});
|
|
12760
12839
|
function InlineComment(state) {
|
|
@@ -12853,7 +12932,7 @@ ${input.slice(result.pos)}
|
|
|
12853
12932
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12854
12933
|
return { $loc, token: $0 };
|
|
12855
12934
|
});
|
|
12856
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12935
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L96, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12857
12936
|
return "";
|
|
12858
12937
|
});
|
|
12859
12938
|
function NonNewlineWhitespace(state) {
|
|
@@ -13005,7 +13084,7 @@ ${input.slice(result.pos)}
|
|
|
13005
13084
|
}
|
|
13006
13085
|
}
|
|
13007
13086
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
13008
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13087
|
+
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);
|
|
13009
13088
|
var StatementDelimiter$2 = $Y(EOS);
|
|
13010
13089
|
function StatementDelimiter(state) {
|
|
13011
13090
|
let eventData;
|
|
@@ -13080,7 +13159,7 @@ ${input.slice(result.pos)}
|
|
|
13080
13159
|
return result;
|
|
13081
13160
|
}
|
|
13082
13161
|
}
|
|
13083
|
-
var Loc$0 = $TV($EXPECT($
|
|
13162
|
+
var Loc$0 = $TV($EXPECT($L19, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
13084
13163
|
return { $loc, token: "" };
|
|
13085
13164
|
});
|
|
13086
13165
|
function Loc(state) {
|
|
@@ -13105,7 +13184,7 @@ ${input.slice(result.pos)}
|
|
|
13105
13184
|
return result;
|
|
13106
13185
|
}
|
|
13107
13186
|
}
|
|
13108
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13187
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
13109
13188
|
return { $loc, token: $1, ts: true };
|
|
13110
13189
|
});
|
|
13111
13190
|
function Abstract(state) {
|
|
@@ -13130,7 +13209,7 @@ ${input.slice(result.pos)}
|
|
|
13130
13209
|
return result;
|
|
13131
13210
|
}
|
|
13132
13211
|
}
|
|
13133
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
13212
|
+
var Ampersand$0 = $TV($EXPECT($L83, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
13134
13213
|
return { $loc, token: $1 };
|
|
13135
13214
|
});
|
|
13136
13215
|
function Ampersand(state) {
|
|
@@ -13155,7 +13234,7 @@ ${input.slice(result.pos)}
|
|
|
13155
13234
|
return result;
|
|
13156
13235
|
}
|
|
13157
13236
|
}
|
|
13158
|
-
var As$0 = $TS($S($EXPECT($
|
|
13237
|
+
var As$0 = $TS($S($EXPECT($L100, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13159
13238
|
return { $loc, token: $1 };
|
|
13160
13239
|
});
|
|
13161
13240
|
function As(state) {
|
|
@@ -13180,7 +13259,7 @@ ${input.slice(result.pos)}
|
|
|
13180
13259
|
return result;
|
|
13181
13260
|
}
|
|
13182
13261
|
}
|
|
13183
|
-
var At$0 = $TV($EXPECT($
|
|
13262
|
+
var At$0 = $TV($EXPECT($L101, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
13184
13263
|
return { $loc, token: $1 };
|
|
13185
13264
|
});
|
|
13186
13265
|
function At(state) {
|
|
@@ -13205,7 +13284,7 @@ ${input.slice(result.pos)}
|
|
|
13205
13284
|
return result;
|
|
13206
13285
|
}
|
|
13207
13286
|
}
|
|
13208
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13287
|
+
var AtAt$0 = $TV($EXPECT($L102, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
13209
13288
|
return { $loc, token: "@" };
|
|
13210
13289
|
});
|
|
13211
13290
|
function AtAt(state) {
|
|
@@ -13230,7 +13309,7 @@ ${input.slice(result.pos)}
|
|
|
13230
13309
|
return result;
|
|
13231
13310
|
}
|
|
13232
13311
|
}
|
|
13233
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13312
|
+
var Async$0 = $TS($S($EXPECT($L103, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13234
13313
|
return { $loc, token: $1, type: "Async" };
|
|
13235
13314
|
});
|
|
13236
13315
|
function Async(state) {
|
|
@@ -13255,7 +13334,7 @@ ${input.slice(result.pos)}
|
|
|
13255
13334
|
return result;
|
|
13256
13335
|
}
|
|
13257
13336
|
}
|
|
13258
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13337
|
+
var Await$0 = $TS($S($EXPECT($L104, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13259
13338
|
return { $loc, token: $1 };
|
|
13260
13339
|
});
|
|
13261
13340
|
function Await(state) {
|
|
@@ -13280,7 +13359,7 @@ ${input.slice(result.pos)}
|
|
|
13280
13359
|
return result;
|
|
13281
13360
|
}
|
|
13282
13361
|
}
|
|
13283
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13362
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
13284
13363
|
return { $loc, token: $1 };
|
|
13285
13364
|
});
|
|
13286
13365
|
function Backtick(state) {
|
|
@@ -13305,7 +13384,7 @@ ${input.slice(result.pos)}
|
|
|
13305
13384
|
return result;
|
|
13306
13385
|
}
|
|
13307
13386
|
}
|
|
13308
|
-
var By$0 = $TS($S($EXPECT($
|
|
13387
|
+
var By$0 = $TS($S($EXPECT($L105, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13309
13388
|
return { $loc, token: $1 };
|
|
13310
13389
|
});
|
|
13311
13390
|
function By(state) {
|
|
@@ -13330,7 +13409,7 @@ ${input.slice(result.pos)}
|
|
|
13330
13409
|
return result;
|
|
13331
13410
|
}
|
|
13332
13411
|
}
|
|
13333
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13412
|
+
var Case$0 = $TS($S($EXPECT($L106, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13334
13413
|
return { $loc, token: $1 };
|
|
13335
13414
|
});
|
|
13336
13415
|
function Case(state) {
|
|
@@ -13355,7 +13434,7 @@ ${input.slice(result.pos)}
|
|
|
13355
13434
|
return result;
|
|
13356
13435
|
}
|
|
13357
13436
|
}
|
|
13358
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13437
|
+
var Catch$0 = $TS($S($EXPECT($L107, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13359
13438
|
return { $loc, token: $1 };
|
|
13360
13439
|
});
|
|
13361
13440
|
function Catch(state) {
|
|
@@ -13380,7 +13459,7 @@ ${input.slice(result.pos)}
|
|
|
13380
13459
|
return result;
|
|
13381
13460
|
}
|
|
13382
13461
|
}
|
|
13383
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13462
|
+
var Class$0 = $TS($S($EXPECT($L108, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13384
13463
|
return { $loc, token: $1 };
|
|
13385
13464
|
});
|
|
13386
13465
|
function Class(state) {
|
|
@@ -13405,7 +13484,7 @@ ${input.slice(result.pos)}
|
|
|
13405
13484
|
return result;
|
|
13406
13485
|
}
|
|
13407
13486
|
}
|
|
13408
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
13487
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
13409
13488
|
return { $loc, token: $1 };
|
|
13410
13489
|
});
|
|
13411
13490
|
function CloseBrace(state) {
|
|
@@ -13430,7 +13509,7 @@ ${input.slice(result.pos)}
|
|
|
13430
13509
|
return result;
|
|
13431
13510
|
}
|
|
13432
13511
|
}
|
|
13433
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
13512
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
13434
13513
|
return { $loc, token: $1 };
|
|
13435
13514
|
});
|
|
13436
13515
|
function CloseBracket(state) {
|
|
@@ -13455,7 +13534,7 @@ ${input.slice(result.pos)}
|
|
|
13455
13534
|
return result;
|
|
13456
13535
|
}
|
|
13457
13536
|
}
|
|
13458
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
13537
|
+
var CloseParen$0 = $TV($EXPECT($L33, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
13459
13538
|
return { $loc, token: $1 };
|
|
13460
13539
|
});
|
|
13461
13540
|
function CloseParen(state) {
|
|
@@ -13480,7 +13559,7 @@ ${input.slice(result.pos)}
|
|
|
13480
13559
|
return result;
|
|
13481
13560
|
}
|
|
13482
13561
|
}
|
|
13483
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13562
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L109, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
13484
13563
|
return { $loc, token: "${" };
|
|
13485
13564
|
});
|
|
13486
13565
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13505,7 +13584,7 @@ ${input.slice(result.pos)}
|
|
|
13505
13584
|
return result;
|
|
13506
13585
|
}
|
|
13507
13586
|
}
|
|
13508
|
-
var Colon$0 = $TV($EXPECT($
|
|
13587
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
13509
13588
|
return { $loc, token: $1 };
|
|
13510
13589
|
});
|
|
13511
13590
|
function Colon(state) {
|
|
@@ -13530,7 +13609,7 @@ ${input.slice(result.pos)}
|
|
|
13530
13609
|
return result;
|
|
13531
13610
|
}
|
|
13532
13611
|
}
|
|
13533
|
-
var Comma$0 = $TV($EXPECT($
|
|
13612
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
13534
13613
|
return { $loc, token: $1 };
|
|
13535
13614
|
});
|
|
13536
13615
|
function Comma(state) {
|
|
@@ -13555,7 +13634,7 @@ ${input.slice(result.pos)}
|
|
|
13555
13634
|
return result;
|
|
13556
13635
|
}
|
|
13557
13636
|
}
|
|
13558
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13637
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L101, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13559
13638
|
return { $loc, token: "constructor" };
|
|
13560
13639
|
});
|
|
13561
13640
|
function ConstructorShorthand(state) {
|
|
@@ -13580,7 +13659,7 @@ ${input.slice(result.pos)}
|
|
|
13580
13659
|
return result;
|
|
13581
13660
|
}
|
|
13582
13661
|
}
|
|
13583
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13662
|
+
var Declare$0 = $TS($S($EXPECT($L110, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13584
13663
|
return { $loc, token: $1 };
|
|
13585
13664
|
});
|
|
13586
13665
|
function Declare(state) {
|
|
@@ -13605,7 +13684,7 @@ ${input.slice(result.pos)}
|
|
|
13605
13684
|
return result;
|
|
13606
13685
|
}
|
|
13607
13686
|
}
|
|
13608
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13687
|
+
var Default$0 = $TS($S($EXPECT($L111, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13609
13688
|
return { $loc, token: $1 };
|
|
13610
13689
|
});
|
|
13611
13690
|
function Default(state) {
|
|
@@ -13630,7 +13709,7 @@ ${input.slice(result.pos)}
|
|
|
13630
13709
|
return result;
|
|
13631
13710
|
}
|
|
13632
13711
|
}
|
|
13633
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13712
|
+
var Delete$0 = $TS($S($EXPECT($L112, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13634
13713
|
return { $loc, token: $1 };
|
|
13635
13714
|
});
|
|
13636
13715
|
function Delete(state) {
|
|
@@ -13655,7 +13734,7 @@ ${input.slice(result.pos)}
|
|
|
13655
13734
|
return result;
|
|
13656
13735
|
}
|
|
13657
13736
|
}
|
|
13658
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13737
|
+
var Do$0 = $TS($S($EXPECT($L113, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13659
13738
|
return { $loc, token: $1 };
|
|
13660
13739
|
});
|
|
13661
13740
|
function Do(state) {
|
|
@@ -13705,7 +13784,7 @@ ${input.slice(result.pos)}
|
|
|
13705
13784
|
return result;
|
|
13706
13785
|
}
|
|
13707
13786
|
}
|
|
13708
|
-
var DotDot$0 = $
|
|
13787
|
+
var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L4, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
13709
13788
|
return { $loc, token: $1 };
|
|
13710
13789
|
});
|
|
13711
13790
|
function DotDot(state) {
|
|
@@ -13730,7 +13809,7 @@ ${input.slice(result.pos)}
|
|
|
13730
13809
|
return result;
|
|
13731
13810
|
}
|
|
13732
13811
|
}
|
|
13733
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13812
|
+
var DotDotDot$0 = $TV($EXPECT($L115, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13734
13813
|
return { $loc, token: $1 };
|
|
13735
13814
|
});
|
|
13736
13815
|
function DotDotDot(state) {
|
|
@@ -13755,7 +13834,7 @@ ${input.slice(result.pos)}
|
|
|
13755
13834
|
return result;
|
|
13756
13835
|
}
|
|
13757
13836
|
}
|
|
13758
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13837
|
+
var DoubleColon$0 = $TV($EXPECT($L116, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13759
13838
|
return { $loc, token: $1 };
|
|
13760
13839
|
});
|
|
13761
13840
|
function DoubleColon(state) {
|
|
@@ -13780,7 +13859,7 @@ ${input.slice(result.pos)}
|
|
|
13780
13859
|
return result;
|
|
13781
13860
|
}
|
|
13782
13861
|
}
|
|
13783
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13862
|
+
var DoubleQuote$0 = $TV($EXPECT($L117, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13784
13863
|
return { $loc, token: $1 };
|
|
13785
13864
|
});
|
|
13786
13865
|
function DoubleQuote(state) {
|
|
@@ -13805,7 +13884,7 @@ ${input.slice(result.pos)}
|
|
|
13805
13884
|
return result;
|
|
13806
13885
|
}
|
|
13807
13886
|
}
|
|
13808
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13887
|
+
var Else$0 = $TS($S($EXPECT($L118, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13809
13888
|
return { $loc, token: $1 };
|
|
13810
13889
|
});
|
|
13811
13890
|
function Else(state) {
|
|
@@ -13855,7 +13934,7 @@ ${input.slice(result.pos)}
|
|
|
13855
13934
|
return result;
|
|
13856
13935
|
}
|
|
13857
13936
|
}
|
|
13858
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13937
|
+
var Export$0 = $TS($S($EXPECT($L119, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13859
13938
|
return { $loc, token: $1 };
|
|
13860
13939
|
});
|
|
13861
13940
|
function Export(state) {
|
|
@@ -13880,7 +13959,7 @@ ${input.slice(result.pos)}
|
|
|
13880
13959
|
return result;
|
|
13881
13960
|
}
|
|
13882
13961
|
}
|
|
13883
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13962
|
+
var Extends$0 = $TS($S($EXPECT($L120, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13884
13963
|
return { $loc, token: $1 };
|
|
13885
13964
|
});
|
|
13886
13965
|
function Extends(state) {
|
|
@@ -13905,7 +13984,7 @@ ${input.slice(result.pos)}
|
|
|
13905
13984
|
return result;
|
|
13906
13985
|
}
|
|
13907
13986
|
}
|
|
13908
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13987
|
+
var Finally$0 = $TS($S($EXPECT($L121, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13909
13988
|
return { $loc, token: $1 };
|
|
13910
13989
|
});
|
|
13911
13990
|
function Finally(state) {
|
|
@@ -13930,7 +14009,7 @@ ${input.slice(result.pos)}
|
|
|
13930
14009
|
return result;
|
|
13931
14010
|
}
|
|
13932
14011
|
}
|
|
13933
|
-
var For$0 = $TS($S($EXPECT($
|
|
14012
|
+
var For$0 = $TS($S($EXPECT($L122, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13934
14013
|
return { $loc, token: $1 };
|
|
13935
14014
|
});
|
|
13936
14015
|
function For(state) {
|
|
@@ -13955,7 +14034,7 @@ ${input.slice(result.pos)}
|
|
|
13955
14034
|
return result;
|
|
13956
14035
|
}
|
|
13957
14036
|
}
|
|
13958
|
-
var From$0 = $TS($S($EXPECT($
|
|
14037
|
+
var From$0 = $TS($S($EXPECT($L123, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13959
14038
|
return { $loc, token: $1 };
|
|
13960
14039
|
});
|
|
13961
14040
|
function From(state) {
|
|
@@ -13980,7 +14059,7 @@ ${input.slice(result.pos)}
|
|
|
13980
14059
|
return result;
|
|
13981
14060
|
}
|
|
13982
14061
|
}
|
|
13983
|
-
var Function$0 = $TS($S($EXPECT($
|
|
14062
|
+
var Function$0 = $TS($S($EXPECT($L124, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13984
14063
|
return { $loc, token: $1 };
|
|
13985
14064
|
});
|
|
13986
14065
|
function Function(state) {
|
|
@@ -14005,7 +14084,7 @@ ${input.slice(result.pos)}
|
|
|
14005
14084
|
return result;
|
|
14006
14085
|
}
|
|
14007
14086
|
}
|
|
14008
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14087
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L125, fail, 'GetOrSet "get"'), $EXPECT($L126, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14009
14088
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
14010
14089
|
});
|
|
14011
14090
|
function GetOrSet(state) {
|
|
@@ -14030,7 +14109,7 @@ ${input.slice(result.pos)}
|
|
|
14030
14109
|
return result;
|
|
14031
14110
|
}
|
|
14032
14111
|
}
|
|
14033
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14112
|
+
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
14034
14113
|
return { $loc, token: $1 };
|
|
14035
14114
|
});
|
|
14036
14115
|
function If(state) {
|
|
@@ -14080,7 +14159,7 @@ ${input.slice(result.pos)}
|
|
|
14080
14159
|
return result;
|
|
14081
14160
|
}
|
|
14082
14161
|
}
|
|
14083
|
-
var In$0 = $TS($S($EXPECT($
|
|
14162
|
+
var In$0 = $TS($S($EXPECT($L81, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14084
14163
|
return { $loc, token: $1 };
|
|
14085
14164
|
});
|
|
14086
14165
|
function In(state) {
|
|
@@ -14105,7 +14184,7 @@ ${input.slice(result.pos)}
|
|
|
14105
14184
|
return result;
|
|
14106
14185
|
}
|
|
14107
14186
|
}
|
|
14108
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14187
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L128, fail, 'LetOrConst "let"'), $EXPECT($L129, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14109
14188
|
return { $loc, token: $1 };
|
|
14110
14189
|
});
|
|
14111
14190
|
function LetOrConst(state) {
|
|
@@ -14130,7 +14209,7 @@ ${input.slice(result.pos)}
|
|
|
14130
14209
|
return result;
|
|
14131
14210
|
}
|
|
14132
14211
|
}
|
|
14133
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14212
|
+
var Loop$0 = $TS($S($EXPECT($L130, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14134
14213
|
return { $loc, token: "while(true)" };
|
|
14135
14214
|
});
|
|
14136
14215
|
function Loop(state) {
|
|
@@ -14155,7 +14234,7 @@ ${input.slice(result.pos)}
|
|
|
14155
14234
|
return result;
|
|
14156
14235
|
}
|
|
14157
14236
|
}
|
|
14158
|
-
var New$0 = $TS($S($EXPECT($
|
|
14237
|
+
var New$0 = $TS($S($EXPECT($L131, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14159
14238
|
return { $loc, token: $1 };
|
|
14160
14239
|
});
|
|
14161
14240
|
function New(state) {
|
|
@@ -14180,7 +14259,7 @@ ${input.slice(result.pos)}
|
|
|
14180
14259
|
return result;
|
|
14181
14260
|
}
|
|
14182
14261
|
}
|
|
14183
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
14262
|
+
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) {
|
|
14184
14263
|
return { $loc, token: "!" };
|
|
14185
14264
|
});
|
|
14186
14265
|
function Not(state) {
|
|
@@ -14205,7 +14284,7 @@ ${input.slice(result.pos)}
|
|
|
14205
14284
|
return result;
|
|
14206
14285
|
}
|
|
14207
14286
|
}
|
|
14208
|
-
var Of$0 = $TS($S($EXPECT($
|
|
14287
|
+
var Of$0 = $TS($S($EXPECT($L73, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14209
14288
|
return { $loc, token: $1 };
|
|
14210
14289
|
});
|
|
14211
14290
|
function Of(state) {
|
|
@@ -14230,7 +14309,7 @@ ${input.slice(result.pos)}
|
|
|
14230
14309
|
return result;
|
|
14231
14310
|
}
|
|
14232
14311
|
}
|
|
14233
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14312
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L132, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
14234
14313
|
return { $loc, token: $1 };
|
|
14235
14314
|
});
|
|
14236
14315
|
function OpenAngleBracket(state) {
|
|
@@ -14255,7 +14334,7 @@ ${input.slice(result.pos)}
|
|
|
14255
14334
|
return result;
|
|
14256
14335
|
}
|
|
14257
14336
|
}
|
|
14258
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14337
|
+
var OpenBrace$0 = $TV($EXPECT($L133, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
14259
14338
|
return { $loc, token: $1 };
|
|
14260
14339
|
});
|
|
14261
14340
|
function OpenBrace(state) {
|
|
@@ -14280,7 +14359,7 @@ ${input.slice(result.pos)}
|
|
|
14280
14359
|
return result;
|
|
14281
14360
|
}
|
|
14282
14361
|
}
|
|
14283
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14362
|
+
var OpenBracket$0 = $TV($EXPECT($L97, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
14284
14363
|
return { $loc, token: $1 };
|
|
14285
14364
|
});
|
|
14286
14365
|
function OpenBracket(state) {
|
|
@@ -14330,7 +14409,7 @@ ${input.slice(result.pos)}
|
|
|
14330
14409
|
return result;
|
|
14331
14410
|
}
|
|
14332
14411
|
}
|
|
14333
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14412
|
+
var Operator$0 = $TS($S($EXPECT($L134, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14334
14413
|
return { $loc, token: $1 };
|
|
14335
14414
|
});
|
|
14336
14415
|
function Operator(state) {
|
|
@@ -14355,7 +14434,7 @@ ${input.slice(result.pos)}
|
|
|
14355
14434
|
return result;
|
|
14356
14435
|
}
|
|
14357
14436
|
}
|
|
14358
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14437
|
+
var Public$0 = $TS($S($EXPECT($L135, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14359
14438
|
return { $loc, token: $1 };
|
|
14360
14439
|
});
|
|
14361
14440
|
function Public(state) {
|
|
@@ -14380,7 +14459,7 @@ ${input.slice(result.pos)}
|
|
|
14380
14459
|
return result;
|
|
14381
14460
|
}
|
|
14382
14461
|
}
|
|
14383
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14462
|
+
var Private$0 = $TS($S($EXPECT($L136, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14384
14463
|
return { $loc, token: $1 };
|
|
14385
14464
|
});
|
|
14386
14465
|
function Private(state) {
|
|
@@ -14405,7 +14484,7 @@ ${input.slice(result.pos)}
|
|
|
14405
14484
|
return result;
|
|
14406
14485
|
}
|
|
14407
14486
|
}
|
|
14408
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14487
|
+
var Protected$0 = $TS($S($EXPECT($L137, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14409
14488
|
return { $loc, token: $1 };
|
|
14410
14489
|
});
|
|
14411
14490
|
function Protected(state) {
|
|
@@ -14430,13 +14509,13 @@ ${input.slice(result.pos)}
|
|
|
14430
14509
|
return result;
|
|
14431
14510
|
}
|
|
14432
14511
|
}
|
|
14433
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14512
|
+
var Pipe$0 = $TV($EXPECT($L138, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
14434
14513
|
return { $loc, token: $1 };
|
|
14435
14514
|
});
|
|
14436
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14515
|
+
var Pipe$1 = $TV($EXPECT($L139, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
14437
14516
|
return { $loc, token: $1 };
|
|
14438
14517
|
});
|
|
14439
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14518
|
+
var Pipe$2 = $TV($EXPECT($L140, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
14440
14519
|
return { $loc, token: $1 };
|
|
14441
14520
|
});
|
|
14442
14521
|
function Pipe(state) {
|
|
@@ -14486,7 +14565,7 @@ ${input.slice(result.pos)}
|
|
|
14486
14565
|
return result;
|
|
14487
14566
|
}
|
|
14488
14567
|
}
|
|
14489
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14568
|
+
var Readonly$0 = $TS($S($EXPECT($L141, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14490
14569
|
return { $loc, token: $1, ts: true };
|
|
14491
14570
|
});
|
|
14492
14571
|
function Readonly(state) {
|
|
@@ -14511,7 +14590,7 @@ ${input.slice(result.pos)}
|
|
|
14511
14590
|
return result;
|
|
14512
14591
|
}
|
|
14513
14592
|
}
|
|
14514
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14593
|
+
var Return$0 = $TS($S($EXPECT($L142, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14515
14594
|
return { $loc, token: $1 };
|
|
14516
14595
|
});
|
|
14517
14596
|
function Return(state) {
|
|
@@ -14536,7 +14615,7 @@ ${input.slice(result.pos)}
|
|
|
14536
14615
|
return result;
|
|
14537
14616
|
}
|
|
14538
14617
|
}
|
|
14539
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14618
|
+
var Satisfies$0 = $TS($S($EXPECT($L143, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14540
14619
|
return { $loc, token: $1 };
|
|
14541
14620
|
});
|
|
14542
14621
|
function Satisfies(state) {
|
|
@@ -14561,7 +14640,7 @@ ${input.slice(result.pos)}
|
|
|
14561
14640
|
return result;
|
|
14562
14641
|
}
|
|
14563
14642
|
}
|
|
14564
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14643
|
+
var Semicolon$0 = $TV($EXPECT($L85, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
14565
14644
|
return { $loc, token: $1 };
|
|
14566
14645
|
});
|
|
14567
14646
|
function Semicolon(state) {
|
|
@@ -14586,7 +14665,7 @@ ${input.slice(result.pos)}
|
|
|
14586
14665
|
return result;
|
|
14587
14666
|
}
|
|
14588
14667
|
}
|
|
14589
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14668
|
+
var SingleQuote$0 = $TV($EXPECT($L144, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14590
14669
|
return { $loc, token: $1 };
|
|
14591
14670
|
});
|
|
14592
14671
|
function SingleQuote(state) {
|
|
@@ -14611,7 +14690,7 @@ ${input.slice(result.pos)}
|
|
|
14611
14690
|
return result;
|
|
14612
14691
|
}
|
|
14613
14692
|
}
|
|
14614
|
-
var Star$0 = $TV($EXPECT($
|
|
14693
|
+
var Star$0 = $TV($EXPECT($L54, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14615
14694
|
return { $loc, token: $1 };
|
|
14616
14695
|
});
|
|
14617
14696
|
function Star(state) {
|
|
@@ -14636,10 +14715,10 @@ ${input.slice(result.pos)}
|
|
|
14636
14715
|
return result;
|
|
14637
14716
|
}
|
|
14638
14717
|
}
|
|
14639
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14718
|
+
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14640
14719
|
return { $loc, token: $1 };
|
|
14641
14720
|
});
|
|
14642
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14721
|
+
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) {
|
|
14643
14722
|
return { $loc, token: "static " };
|
|
14644
14723
|
});
|
|
14645
14724
|
function Static(state) {
|
|
@@ -14664,7 +14743,7 @@ ${input.slice(result.pos)}
|
|
|
14664
14743
|
return result;
|
|
14665
14744
|
}
|
|
14666
14745
|
}
|
|
14667
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14746
|
+
var SubstitutionStart$0 = $TV($EXPECT($L146, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14668
14747
|
return { $loc, token: $1 };
|
|
14669
14748
|
});
|
|
14670
14749
|
function SubstitutionStart(state) {
|
|
@@ -14689,7 +14768,7 @@ ${input.slice(result.pos)}
|
|
|
14689
14768
|
return result;
|
|
14690
14769
|
}
|
|
14691
14770
|
}
|
|
14692
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14771
|
+
var Switch$0 = $TS($S($EXPECT($L147, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14693
14772
|
return { $loc, token: $1 };
|
|
14694
14773
|
});
|
|
14695
14774
|
function Switch(state) {
|
|
@@ -14714,7 +14793,7 @@ ${input.slice(result.pos)}
|
|
|
14714
14793
|
return result;
|
|
14715
14794
|
}
|
|
14716
14795
|
}
|
|
14717
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14796
|
+
var Target$0 = $TS($S($EXPECT($L148, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14718
14797
|
return { $loc, token: $1 };
|
|
14719
14798
|
});
|
|
14720
14799
|
function Target(state) {
|
|
@@ -14739,7 +14818,7 @@ ${input.slice(result.pos)}
|
|
|
14739
14818
|
return result;
|
|
14740
14819
|
}
|
|
14741
14820
|
}
|
|
14742
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14821
|
+
var Then$0 = $TS($S(__, $EXPECT($L149, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14743
14822
|
return { $loc, token: "" };
|
|
14744
14823
|
});
|
|
14745
14824
|
function Then(state) {
|
|
@@ -14764,7 +14843,7 @@ ${input.slice(result.pos)}
|
|
|
14764
14843
|
return result;
|
|
14765
14844
|
}
|
|
14766
14845
|
}
|
|
14767
|
-
var This$0 = $TS($S($EXPECT($
|
|
14846
|
+
var This$0 = $TS($S($EXPECT($L150, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14768
14847
|
return { $loc, token: $1 };
|
|
14769
14848
|
});
|
|
14770
14849
|
function This(state) {
|
|
@@ -14789,7 +14868,7 @@ ${input.slice(result.pos)}
|
|
|
14789
14868
|
return result;
|
|
14790
14869
|
}
|
|
14791
14870
|
}
|
|
14792
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14871
|
+
var Throw$0 = $TS($S($EXPECT($L151, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14793
14872
|
return { $loc, token: $1 };
|
|
14794
14873
|
});
|
|
14795
14874
|
function Throw(state) {
|
|
@@ -14814,7 +14893,7 @@ ${input.slice(result.pos)}
|
|
|
14814
14893
|
return result;
|
|
14815
14894
|
}
|
|
14816
14895
|
}
|
|
14817
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14896
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L152, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14818
14897
|
return { $loc, token: "`" };
|
|
14819
14898
|
});
|
|
14820
14899
|
function TripleDoubleQuote(state) {
|
|
@@ -14839,7 +14918,7 @@ ${input.slice(result.pos)}
|
|
|
14839
14918
|
return result;
|
|
14840
14919
|
}
|
|
14841
14920
|
}
|
|
14842
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14921
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L153, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14843
14922
|
return { $loc, token: "`" };
|
|
14844
14923
|
});
|
|
14845
14924
|
function TripleSingleQuote(state) {
|
|
@@ -14864,7 +14943,7 @@ ${input.slice(result.pos)}
|
|
|
14864
14943
|
return result;
|
|
14865
14944
|
}
|
|
14866
14945
|
}
|
|
14867
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14946
|
+
var TripleSlash$0 = $TV($EXPECT($L154, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14868
14947
|
return { $loc, token: "/" };
|
|
14869
14948
|
});
|
|
14870
14949
|
function TripleSlash(state) {
|
|
@@ -14889,7 +14968,7 @@ ${input.slice(result.pos)}
|
|
|
14889
14968
|
return result;
|
|
14890
14969
|
}
|
|
14891
14970
|
}
|
|
14892
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14971
|
+
var TripleTick$0 = $TV($EXPECT($L155, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14893
14972
|
return { $loc, token: "`" };
|
|
14894
14973
|
});
|
|
14895
14974
|
function TripleTick(state) {
|
|
@@ -14914,7 +14993,7 @@ ${input.slice(result.pos)}
|
|
|
14914
14993
|
return result;
|
|
14915
14994
|
}
|
|
14916
14995
|
}
|
|
14917
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14996
|
+
var Try$0 = $TS($S($EXPECT($L156, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14918
14997
|
return { $loc, token: $1 };
|
|
14919
14998
|
});
|
|
14920
14999
|
function Try(state) {
|
|
@@ -14939,7 +15018,7 @@ ${input.slice(result.pos)}
|
|
|
14939
15018
|
return result;
|
|
14940
15019
|
}
|
|
14941
15020
|
}
|
|
14942
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
15021
|
+
var Typeof$0 = $TS($S($EXPECT($L157, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14943
15022
|
return { $loc, token: $1 };
|
|
14944
15023
|
});
|
|
14945
15024
|
function Typeof(state) {
|
|
@@ -14964,7 +15043,7 @@ ${input.slice(result.pos)}
|
|
|
14964
15043
|
return result;
|
|
14965
15044
|
}
|
|
14966
15045
|
}
|
|
14967
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
15046
|
+
var Unless$0 = $TS($S($EXPECT($L158, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14968
15047
|
return { $loc, token: $1 };
|
|
14969
15048
|
});
|
|
14970
15049
|
function Unless(state) {
|
|
@@ -14989,7 +15068,7 @@ ${input.slice(result.pos)}
|
|
|
14989
15068
|
return result;
|
|
14990
15069
|
}
|
|
14991
15070
|
}
|
|
14992
|
-
var Until$0 = $TS($S($EXPECT($
|
|
15071
|
+
var Until$0 = $TS($S($EXPECT($L159, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14993
15072
|
return { $loc, token: $1 };
|
|
14994
15073
|
});
|
|
14995
15074
|
function Until(state) {
|
|
@@ -15014,7 +15093,7 @@ ${input.slice(result.pos)}
|
|
|
15014
15093
|
return result;
|
|
15015
15094
|
}
|
|
15016
15095
|
}
|
|
15017
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15096
|
+
var Var$0 = $TS($S($EXPECT($L160, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15018
15097
|
return { $loc, token: $1 };
|
|
15019
15098
|
});
|
|
15020
15099
|
function Var(state) {
|
|
@@ -15039,7 +15118,7 @@ ${input.slice(result.pos)}
|
|
|
15039
15118
|
return result;
|
|
15040
15119
|
}
|
|
15041
15120
|
}
|
|
15042
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15121
|
+
var Void$0 = $TS($S($EXPECT($L161, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15043
15122
|
return { $loc, token: $1 };
|
|
15044
15123
|
});
|
|
15045
15124
|
function Void(state) {
|
|
@@ -15064,7 +15143,7 @@ ${input.slice(result.pos)}
|
|
|
15064
15143
|
return result;
|
|
15065
15144
|
}
|
|
15066
15145
|
}
|
|
15067
|
-
var When$0 = $TS($S($EXPECT($
|
|
15146
|
+
var When$0 = $TS($S($EXPECT($L162, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15068
15147
|
return { $loc, token: "case" };
|
|
15069
15148
|
});
|
|
15070
15149
|
function When(state) {
|
|
@@ -15089,7 +15168,7 @@ ${input.slice(result.pos)}
|
|
|
15089
15168
|
return result;
|
|
15090
15169
|
}
|
|
15091
15170
|
}
|
|
15092
|
-
var While$0 = $TS($S($EXPECT($
|
|
15171
|
+
var While$0 = $TS($S($EXPECT($L163, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15093
15172
|
return { $loc, token: $1 };
|
|
15094
15173
|
});
|
|
15095
15174
|
function While(state) {
|
|
@@ -15114,7 +15193,7 @@ ${input.slice(result.pos)}
|
|
|
15114
15193
|
return result;
|
|
15115
15194
|
}
|
|
15116
15195
|
}
|
|
15117
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15196
|
+
var Yield$0 = $TS($S($EXPECT($L164, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15118
15197
|
return { $loc, token: $1 };
|
|
15119
15198
|
});
|
|
15120
15199
|
function Yield(state) {
|
|
@@ -15259,7 +15338,7 @@ ${input.slice(result.pos)}
|
|
|
15259
15338
|
return result;
|
|
15260
15339
|
}
|
|
15261
15340
|
}
|
|
15262
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15341
|
+
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) {
|
|
15263
15342
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
15264
15343
|
});
|
|
15265
15344
|
function JSXSelfClosingElement(state) {
|
|
@@ -15310,7 +15389,7 @@ ${input.slice(result.pos)}
|
|
|
15310
15389
|
return result;
|
|
15311
15390
|
}
|
|
15312
15391
|
}
|
|
15313
|
-
var PopJSXStack$0 = $TV($EXPECT($
|
|
15392
|
+
var PopJSXStack$0 = $TV($EXPECT($L19, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15314
15393
|
module.JSXTagStack.pop();
|
|
15315
15394
|
});
|
|
15316
15395
|
function PopJSXStack(state) {
|
|
@@ -15335,7 +15414,7 @@ ${input.slice(result.pos)}
|
|
|
15335
15414
|
return result;
|
|
15336
15415
|
}
|
|
15337
15416
|
}
|
|
15338
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
15417
|
+
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
15339
15418
|
function JSXOpeningElement(state) {
|
|
15340
15419
|
let eventData;
|
|
15341
15420
|
if (state.events) {
|
|
@@ -15364,7 +15443,7 @@ ${input.slice(result.pos)}
|
|
|
15364
15443
|
return $skip;
|
|
15365
15444
|
return $0;
|
|
15366
15445
|
});
|
|
15367
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
15446
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L19, fail, 'JSXOptionalClosingElement ""');
|
|
15368
15447
|
function JSXOptionalClosingElement(state) {
|
|
15369
15448
|
let eventData;
|
|
15370
15449
|
if (state.events) {
|
|
@@ -15387,7 +15466,7 @@ ${input.slice(result.pos)}
|
|
|
15387
15466
|
return result;
|
|
15388
15467
|
}
|
|
15389
15468
|
}
|
|
15390
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15469
|
+
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
15391
15470
|
function JSXClosingElement(state) {
|
|
15392
15471
|
let eventData;
|
|
15393
15472
|
if (state.events) {
|
|
@@ -15425,7 +15504,7 @@ ${input.slice(result.pos)}
|
|
|
15425
15504
|
];
|
|
15426
15505
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
15427
15506
|
});
|
|
15428
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15507
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L167, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
15429
15508
|
var children = $3;
|
|
15430
15509
|
$0 = $0.slice(1);
|
|
15431
15510
|
return {
|
|
@@ -15456,7 +15535,7 @@ ${input.slice(result.pos)}
|
|
|
15456
15535
|
return result;
|
|
15457
15536
|
}
|
|
15458
15537
|
}
|
|
15459
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15538
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L167, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
15460
15539
|
module.JSXTagStack.push("");
|
|
15461
15540
|
return $1;
|
|
15462
15541
|
});
|
|
@@ -15487,7 +15566,7 @@ ${input.slice(result.pos)}
|
|
|
15487
15566
|
return $skip;
|
|
15488
15567
|
return $0;
|
|
15489
15568
|
});
|
|
15490
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
15569
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L19, fail, 'JSXOptionalClosingFragment ""');
|
|
15491
15570
|
function JSXOptionalClosingFragment(state) {
|
|
15492
15571
|
let eventData;
|
|
15493
15572
|
if (state.events) {
|
|
@@ -15510,7 +15589,7 @@ ${input.slice(result.pos)}
|
|
|
15510
15589
|
return result;
|
|
15511
15590
|
}
|
|
15512
15591
|
}
|
|
15513
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15592
|
+
var JSXClosingFragment$0 = $EXPECT($L168, fail, 'JSXClosingFragment "</>"');
|
|
15514
15593
|
function JSXClosingFragment(state) {
|
|
15515
15594
|
let eventData;
|
|
15516
15595
|
if (state.events) {
|
|
@@ -16277,7 +16356,7 @@ ${input.slice(result.pos)}
|
|
|
16277
16356
|
}
|
|
16278
16357
|
return $skip;
|
|
16279
16358
|
});
|
|
16280
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
16359
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
16281
16360
|
return { children: [], jsxChildren: [] };
|
|
16282
16361
|
});
|
|
16283
16362
|
function JSXNestedChildren(state) {
|
|
@@ -16406,7 +16485,7 @@ ${input.slice(result.pos)}
|
|
|
16406
16485
|
return result;
|
|
16407
16486
|
}
|
|
16408
16487
|
}
|
|
16409
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16488
|
+
var JSXComment$0 = $TS($S($EXPECT($L169, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L170, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16410
16489
|
return ["{/*", $2, "*/}"];
|
|
16411
16490
|
});
|
|
16412
16491
|
function JSXComment(state) {
|
|
@@ -16704,7 +16783,7 @@ ${input.slice(result.pos)}
|
|
|
16704
16783
|
return result;
|
|
16705
16784
|
}
|
|
16706
16785
|
}
|
|
16707
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16786
|
+
var TypeKeyword$0 = $S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16708
16787
|
function TypeKeyword(state) {
|
|
16709
16788
|
let eventData;
|
|
16710
16789
|
if (state.events) {
|
|
@@ -16727,7 +16806,7 @@ ${input.slice(result.pos)}
|
|
|
16727
16806
|
return result;
|
|
16728
16807
|
}
|
|
16729
16808
|
}
|
|
16730
|
-
var Interface$0 = $S($EXPECT($
|
|
16809
|
+
var Interface$0 = $S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue);
|
|
16731
16810
|
function Interface(state) {
|
|
16732
16811
|
let eventData;
|
|
16733
16812
|
if (state.events) {
|
|
@@ -16750,7 +16829,7 @@ ${input.slice(result.pos)}
|
|
|
16750
16829
|
return result;
|
|
16751
16830
|
}
|
|
16752
16831
|
}
|
|
16753
|
-
var Namespace$0 = $S($EXPECT($
|
|
16832
|
+
var Namespace$0 = $S($EXPECT($L173, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16754
16833
|
function Namespace(state) {
|
|
16755
16834
|
let eventData;
|
|
16756
16835
|
if (state.events) {
|
|
@@ -16998,7 +17077,7 @@ ${input.slice(result.pos)}
|
|
|
16998
17077
|
return result;
|
|
16999
17078
|
}
|
|
17000
17079
|
}
|
|
17001
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
17080
|
+
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)));
|
|
17002
17081
|
function TypeIndexSignature(state) {
|
|
17003
17082
|
let eventData;
|
|
17004
17083
|
if (state.events) {
|
|
@@ -17045,7 +17124,7 @@ ${input.slice(result.pos)}
|
|
|
17045
17124
|
return result;
|
|
17046
17125
|
}
|
|
17047
17126
|
}
|
|
17048
|
-
var TypeSuffix$0 = $T($S($E(QuestionMark),
|
|
17127
|
+
var TypeSuffix$0 = $T($S($E(QuestionMark), $E(_), Colon, Type), function(value) {
|
|
17049
17128
|
return { "type": "TypeSuffix", "ts": true, "children": value };
|
|
17050
17129
|
});
|
|
17051
17130
|
function TypeSuffix(state) {
|
|
@@ -17070,14 +17149,20 @@ ${input.slice(result.pos)}
|
|
|
17070
17149
|
return result;
|
|
17071
17150
|
}
|
|
17072
17151
|
}
|
|
17073
|
-
var ReturnTypeSuffix$0 = $TS($S(
|
|
17074
|
-
|
|
17075
|
-
|
|
17076
|
-
|
|
17077
|
-
|
|
17152
|
+
var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L174, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17153
|
+
var asserts = $3;
|
|
17154
|
+
var t = $4;
|
|
17155
|
+
if (asserts) {
|
|
17156
|
+
t = {
|
|
17157
|
+
type: "AssertsType",
|
|
17158
|
+
t,
|
|
17159
|
+
children: [asserts[0], asserts[1], t]
|
|
17160
|
+
};
|
|
17161
|
+
}
|
|
17078
17162
|
return {
|
|
17079
17163
|
type: "ReturnTypeAnnotation",
|
|
17080
|
-
children,
|
|
17164
|
+
children: [$1, $2, t],
|
|
17165
|
+
t,
|
|
17081
17166
|
ts: true
|
|
17082
17167
|
};
|
|
17083
17168
|
});
|
|
@@ -17103,10 +17188,17 @@ ${input.slice(result.pos)}
|
|
|
17103
17188
|
return result;
|
|
17104
17189
|
}
|
|
17105
17190
|
}
|
|
17106
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
17107
|
-
|
|
17108
|
-
|
|
17109
|
-
|
|
17191
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L82, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
17192
|
+
var lhs = $1;
|
|
17193
|
+
var rhs = $2;
|
|
17194
|
+
if (!rhs)
|
|
17195
|
+
return lhs;
|
|
17196
|
+
return {
|
|
17197
|
+
type: "TypePredicate",
|
|
17198
|
+
lhs,
|
|
17199
|
+
rhs: rhs[3],
|
|
17200
|
+
children: [lhs, ...rhs]
|
|
17201
|
+
};
|
|
17110
17202
|
});
|
|
17111
17203
|
function TypePredicate(state) {
|
|
17112
17204
|
let eventData;
|
|
@@ -17181,6 +17273,8 @@ ${input.slice(result.pos)}
|
|
|
17181
17273
|
}
|
|
17182
17274
|
}
|
|
17183
17275
|
var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
17276
|
+
if (!$1.length && !$3.length)
|
|
17277
|
+
return $2;
|
|
17184
17278
|
return [...$1, $2, ...$3];
|
|
17185
17279
|
});
|
|
17186
17280
|
function TypeUnary(state) {
|
|
@@ -17229,10 +17323,10 @@ ${input.slice(result.pos)}
|
|
|
17229
17323
|
return result;
|
|
17230
17324
|
}
|
|
17231
17325
|
}
|
|
17232
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
17233
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
17234
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
17235
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17326
|
+
var TypeUnaryOp$0 = $S($EXPECT($L175, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17327
|
+
var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17328
|
+
var TypeUnaryOp$2 = $S($EXPECT($L176, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17329
|
+
var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
17236
17330
|
function TypeUnaryOp(state) {
|
|
17237
17331
|
let eventData;
|
|
17238
17332
|
if (state.events) {
|
|
@@ -17283,8 +17377,23 @@ ${input.slice(result.pos)}
|
|
|
17283
17377
|
var TypePrimary$2 = $S($E(_), InlineInterfaceLiteral);
|
|
17284
17378
|
var TypePrimary$3 = $S($E(_), TypeTuple);
|
|
17285
17379
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
17286
|
-
var TypePrimary$5 = $S($E(_), TypeLiteral)
|
|
17287
|
-
|
|
17380
|
+
var TypePrimary$5 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
|
|
17381
|
+
var t = $2;
|
|
17382
|
+
return {
|
|
17383
|
+
type: "LiteralType",
|
|
17384
|
+
t,
|
|
17385
|
+
children: $0
|
|
17386
|
+
};
|
|
17387
|
+
});
|
|
17388
|
+
var TypePrimary$6 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17389
|
+
var args = $4;
|
|
17390
|
+
return {
|
|
17391
|
+
type: "IdentifierType",
|
|
17392
|
+
children: $0,
|
|
17393
|
+
raw: [$2.name, ...$3.map(([dot, id]) => dot.token + id.name)].join(""),
|
|
17394
|
+
args
|
|
17395
|
+
};
|
|
17396
|
+
});
|
|
17288
17397
|
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
17289
17398
|
function TypePrimary(state) {
|
|
17290
17399
|
let eventData;
|
|
@@ -17430,7 +17539,7 @@ ${input.slice(result.pos)}
|
|
|
17430
17539
|
return result;
|
|
17431
17540
|
}
|
|
17432
17541
|
}
|
|
17433
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17542
|
+
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) {
|
|
17434
17543
|
if ($2)
|
|
17435
17544
|
return $0;
|
|
17436
17545
|
return $1;
|
|
@@ -17459,10 +17568,10 @@ ${input.slice(result.pos)}
|
|
|
17459
17568
|
}
|
|
17460
17569
|
var TypeLiteral$0 = TemplateLiteral;
|
|
17461
17570
|
var TypeLiteral$1 = Literal;
|
|
17462
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17463
|
-
return { $loc, token:
|
|
17571
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
17572
|
+
return { type: "VoidType", $loc, token: $1 };
|
|
17464
17573
|
});
|
|
17465
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17574
|
+
var TypeLiteral$3 = $TV($EXPECT($L177, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
17466
17575
|
return { $loc, token: "[]" };
|
|
17467
17576
|
});
|
|
17468
17577
|
function TypeLiteral(state) {
|
|
@@ -17537,7 +17646,7 @@ ${input.slice(result.pos)}
|
|
|
17537
17646
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
17538
17647
|
return value[1];
|
|
17539
17648
|
});
|
|
17540
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17649
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L33, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
17541
17650
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
17542
17651
|
function InlineInterfacePropertyDelimiter(state) {
|
|
17543
17652
|
let eventData;
|
|
@@ -17561,10 +17670,10 @@ ${input.slice(result.pos)}
|
|
|
17561
17670
|
return result;
|
|
17562
17671
|
}
|
|
17563
17672
|
}
|
|
17564
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17673
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L84, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
17565
17674
|
return { $loc, token: "|" };
|
|
17566
17675
|
});
|
|
17567
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17676
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
17568
17677
|
return { $loc, token: "&" };
|
|
17569
17678
|
});
|
|
17570
17679
|
function TypeBinaryOp(state) {
|
|
@@ -17621,7 +17730,7 @@ ${input.slice(result.pos)}
|
|
|
17621
17730
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17622
17731
|
return { $loc, token: "=>" };
|
|
17623
17732
|
});
|
|
17624
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17733
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17625
17734
|
return { $loc, token: "=>" };
|
|
17626
17735
|
});
|
|
17627
17736
|
function TypeArrowFunction(state) {
|
|
@@ -17646,7 +17755,7 @@ ${input.slice(result.pos)}
|
|
|
17646
17755
|
return result;
|
|
17647
17756
|
}
|
|
17648
17757
|
}
|
|
17649
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17758
|
+
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17650
17759
|
return { ts: true, children: $0 };
|
|
17651
17760
|
});
|
|
17652
17761
|
function TypeArguments(state) {
|
|
@@ -17717,7 +17826,7 @@ ${input.slice(result.pos)}
|
|
|
17717
17826
|
return result;
|
|
17718
17827
|
}
|
|
17719
17828
|
}
|
|
17720
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17829
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L132, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17721
17830
|
var parameters = $3;
|
|
17722
17831
|
return {
|
|
17723
17832
|
type: "TypeParameters",
|
|
@@ -17771,7 +17880,7 @@ ${input.slice(result.pos)}
|
|
|
17771
17880
|
return result;
|
|
17772
17881
|
}
|
|
17773
17882
|
}
|
|
17774
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17883
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L120, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17775
17884
|
function TypeConstraint(state) {
|
|
17776
17885
|
let eventData;
|
|
17777
17886
|
if (state.events) {
|
|
@@ -17818,7 +17927,7 @@ ${input.slice(result.pos)}
|
|
|
17818
17927
|
}
|
|
17819
17928
|
}
|
|
17820
17929
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17821
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17930
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17822
17931
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17823
17932
|
return value[1];
|
|
17824
17933
|
});
|
|
@@ -17922,7 +18031,7 @@ ${input.slice(result.pos)}
|
|
|
17922
18031
|
return result;
|
|
17923
18032
|
}
|
|
17924
18033
|
}
|
|
17925
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
18034
|
+
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) {
|
|
17926
18035
|
var options = $3;
|
|
17927
18036
|
return {
|
|
17928
18037
|
type: "CivetPrologue",
|
|
@@ -18083,7 +18192,7 @@ ${input.slice(result.pos)}
|
|
|
18083
18192
|
return result;
|
|
18084
18193
|
}
|
|
18085
18194
|
}
|
|
18086
|
-
var DebugHere$0 = $TV($EXPECT($
|
|
18195
|
+
var DebugHere$0 = $TV($EXPECT($L19, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
18087
18196
|
debugger;
|
|
18088
18197
|
});
|
|
18089
18198
|
function DebugHere(state) {
|
|
@@ -18108,7 +18217,7 @@ ${input.slice(result.pos)}
|
|
|
18108
18217
|
return result;
|
|
18109
18218
|
}
|
|
18110
18219
|
}
|
|
18111
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
18220
|
+
var InsertSemicolon$0 = $TV($EXPECT($L19, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
18112
18221
|
return { $loc, token: ";" };
|
|
18113
18222
|
});
|
|
18114
18223
|
function InsertSemicolon(state) {
|
|
@@ -18133,7 +18242,7 @@ ${input.slice(result.pos)}
|
|
|
18133
18242
|
return result;
|
|
18134
18243
|
}
|
|
18135
18244
|
}
|
|
18136
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
18245
|
+
var InsertOpenParen$0 = $TV($EXPECT($L19, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
18137
18246
|
return { $loc, token: "(" };
|
|
18138
18247
|
});
|
|
18139
18248
|
function InsertOpenParen(state) {
|
|
@@ -18158,7 +18267,7 @@ ${input.slice(result.pos)}
|
|
|
18158
18267
|
return result;
|
|
18159
18268
|
}
|
|
18160
18269
|
}
|
|
18161
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
18270
|
+
var InsertCloseParen$0 = $TV($EXPECT($L19, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
18162
18271
|
return { $loc, token: ")" };
|
|
18163
18272
|
});
|
|
18164
18273
|
function InsertCloseParen(state) {
|
|
@@ -18183,7 +18292,7 @@ ${input.slice(result.pos)}
|
|
|
18183
18292
|
return result;
|
|
18184
18293
|
}
|
|
18185
18294
|
}
|
|
18186
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
18295
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18187
18296
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
18188
18297
|
});
|
|
18189
18298
|
function InsertOpenBrace(state) {
|
|
@@ -18208,7 +18317,7 @@ ${input.slice(result.pos)}
|
|
|
18208
18317
|
return result;
|
|
18209
18318
|
}
|
|
18210
18319
|
}
|
|
18211
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
18320
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18212
18321
|
return { $loc, token: "{" };
|
|
18213
18322
|
});
|
|
18214
18323
|
function InsertInlineOpenBrace(state) {
|
|
@@ -18233,7 +18342,7 @@ ${input.slice(result.pos)}
|
|
|
18233
18342
|
return result;
|
|
18234
18343
|
}
|
|
18235
18344
|
}
|
|
18236
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
18345
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L19, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
18237
18346
|
return { $loc, token: "}" };
|
|
18238
18347
|
});
|
|
18239
18348
|
function InsertCloseBrace(state) {
|
|
@@ -18258,7 +18367,7 @@ ${input.slice(result.pos)}
|
|
|
18258
18367
|
return result;
|
|
18259
18368
|
}
|
|
18260
18369
|
}
|
|
18261
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
18370
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L19, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
18262
18371
|
return { $loc, token: "[" };
|
|
18263
18372
|
});
|
|
18264
18373
|
function InsertOpenBracket(state) {
|
|
@@ -18283,7 +18392,7 @@ ${input.slice(result.pos)}
|
|
|
18283
18392
|
return result;
|
|
18284
18393
|
}
|
|
18285
18394
|
}
|
|
18286
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
18395
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L19, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
18287
18396
|
return { $loc, token: "]" };
|
|
18288
18397
|
});
|
|
18289
18398
|
function InsertCloseBracket(state) {
|
|
@@ -18308,7 +18417,7 @@ ${input.slice(result.pos)}
|
|
|
18308
18417
|
return result;
|
|
18309
18418
|
}
|
|
18310
18419
|
}
|
|
18311
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
18420
|
+
var InsertComma$0 = $TV($EXPECT($L19, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
18312
18421
|
return { $loc, token: "," };
|
|
18313
18422
|
});
|
|
18314
18423
|
function InsertComma(state) {
|
|
@@ -18333,7 +18442,7 @@ ${input.slice(result.pos)}
|
|
|
18333
18442
|
return result;
|
|
18334
18443
|
}
|
|
18335
18444
|
}
|
|
18336
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
18445
|
+
var InsertConst$0 = $TV($EXPECT($L19, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
18337
18446
|
return { $loc, token: "const " };
|
|
18338
18447
|
});
|
|
18339
18448
|
function InsertConst(state) {
|
|
@@ -18358,7 +18467,7 @@ ${input.slice(result.pos)}
|
|
|
18358
18467
|
return result;
|
|
18359
18468
|
}
|
|
18360
18469
|
}
|
|
18361
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
18470
|
+
var InsertLet$0 = $TV($EXPECT($L19, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
18362
18471
|
return { $loc, token: "let " };
|
|
18363
18472
|
});
|
|
18364
18473
|
function InsertLet(state) {
|
|
@@ -18383,7 +18492,7 @@ ${input.slice(result.pos)}
|
|
|
18383
18492
|
return result;
|
|
18384
18493
|
}
|
|
18385
18494
|
}
|
|
18386
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
18495
|
+
var InsertReadonly$0 = $TV($EXPECT($L19, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
18387
18496
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
18388
18497
|
});
|
|
18389
18498
|
function InsertReadonly(state) {
|
|
@@ -18408,7 +18517,7 @@ ${input.slice(result.pos)}
|
|
|
18408
18517
|
return result;
|
|
18409
18518
|
}
|
|
18410
18519
|
}
|
|
18411
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
18520
|
+
var InsertNewline$0 = $TV($EXPECT($L19, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
18412
18521
|
return "\n";
|
|
18413
18522
|
});
|
|
18414
18523
|
function InsertNewline(state) {
|
|
@@ -18433,7 +18542,7 @@ ${input.slice(result.pos)}
|
|
|
18433
18542
|
return result;
|
|
18434
18543
|
}
|
|
18435
18544
|
}
|
|
18436
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
18545
|
+
var InsertIndent$0 = $TV($EXPECT($L19, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
18437
18546
|
return module.currentIndent.token;
|
|
18438
18547
|
});
|
|
18439
18548
|
function InsertIndent(state) {
|
|
@@ -18458,7 +18567,7 @@ ${input.slice(result.pos)}
|
|
|
18458
18567
|
return result;
|
|
18459
18568
|
}
|
|
18460
18569
|
}
|
|
18461
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
18570
|
+
var InsertSpace$0 = $TV($EXPECT($L19, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
18462
18571
|
return { $loc, token: " " };
|
|
18463
18572
|
});
|
|
18464
18573
|
function InsertSpace(state) {
|
|
@@ -18483,7 +18592,7 @@ ${input.slice(result.pos)}
|
|
|
18483
18592
|
return result;
|
|
18484
18593
|
}
|
|
18485
18594
|
}
|
|
18486
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
18595
|
+
var InsertDot$0 = $TV($EXPECT($L19, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
18487
18596
|
return { $loc, token: "." };
|
|
18488
18597
|
});
|
|
18489
18598
|
function InsertDot(state) {
|
|
@@ -18508,7 +18617,7 @@ ${input.slice(result.pos)}
|
|
|
18508
18617
|
return result;
|
|
18509
18618
|
}
|
|
18510
18619
|
}
|
|
18511
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18620
|
+
var InsertBreak$0 = $TV($EXPECT($L19, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
18512
18621
|
return { $loc, token: ";break;" };
|
|
18513
18622
|
});
|
|
18514
18623
|
function InsertBreak(state) {
|
|
@@ -18533,7 +18642,7 @@ ${input.slice(result.pos)}
|
|
|
18533
18642
|
return result;
|
|
18534
18643
|
}
|
|
18535
18644
|
}
|
|
18536
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18645
|
+
var InsertVar$0 = $TV($EXPECT($L19, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
18537
18646
|
return { $loc, token: "var " };
|
|
18538
18647
|
});
|
|
18539
18648
|
function InsertVar(state) {
|
|
@@ -18558,7 +18667,7 @@ ${input.slice(result.pos)}
|
|
|
18558
18667
|
return result;
|
|
18559
18668
|
}
|
|
18560
18669
|
}
|
|
18561
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18670
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18562
18671
|
if (module.config.coffeeBinaryExistential)
|
|
18563
18672
|
return;
|
|
18564
18673
|
return $skip;
|
|
@@ -18585,7 +18694,7 @@ ${input.slice(result.pos)}
|
|
|
18585
18694
|
return result;
|
|
18586
18695
|
}
|
|
18587
18696
|
}
|
|
18588
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18697
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18589
18698
|
if (module.config.coffeeBooleans)
|
|
18590
18699
|
return;
|
|
18591
18700
|
return $skip;
|
|
@@ -18612,7 +18721,7 @@ ${input.slice(result.pos)}
|
|
|
18612
18721
|
return result;
|
|
18613
18722
|
}
|
|
18614
18723
|
}
|
|
18615
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18724
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18616
18725
|
if (module.config.coffeeClasses)
|
|
18617
18726
|
return;
|
|
18618
18727
|
return $skip;
|
|
@@ -18639,7 +18748,7 @@ ${input.slice(result.pos)}
|
|
|
18639
18748
|
return result;
|
|
18640
18749
|
}
|
|
18641
18750
|
}
|
|
18642
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18751
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18643
18752
|
if (module.config.coffeeComment)
|
|
18644
18753
|
return;
|
|
18645
18754
|
return $skip;
|
|
@@ -18666,7 +18775,7 @@ ${input.slice(result.pos)}
|
|
|
18666
18775
|
return result;
|
|
18667
18776
|
}
|
|
18668
18777
|
}
|
|
18669
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18778
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18670
18779
|
if (module.config.coffeeDo)
|
|
18671
18780
|
return;
|
|
18672
18781
|
return $skip;
|
|
@@ -18693,7 +18802,7 @@ ${input.slice(result.pos)}
|
|
|
18693
18802
|
return result;
|
|
18694
18803
|
}
|
|
18695
18804
|
}
|
|
18696
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18805
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18697
18806
|
if (module.config.coffeeForLoops)
|
|
18698
18807
|
return;
|
|
18699
18808
|
return $skip;
|
|
@@ -18720,7 +18829,7 @@ ${input.slice(result.pos)}
|
|
|
18720
18829
|
return result;
|
|
18721
18830
|
}
|
|
18722
18831
|
}
|
|
18723
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18832
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18724
18833
|
if (module.config.coffeeInterpolation)
|
|
18725
18834
|
return;
|
|
18726
18835
|
return $skip;
|
|
@@ -18747,7 +18856,7 @@ ${input.slice(result.pos)}
|
|
|
18747
18856
|
return result;
|
|
18748
18857
|
}
|
|
18749
18858
|
}
|
|
18750
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18859
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18751
18860
|
if (module.config.coffeeIsnt)
|
|
18752
18861
|
return;
|
|
18753
18862
|
return $skip;
|
|
@@ -18774,7 +18883,7 @@ ${input.slice(result.pos)}
|
|
|
18774
18883
|
return result;
|
|
18775
18884
|
}
|
|
18776
18885
|
}
|
|
18777
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18886
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18778
18887
|
if (module.config.coffeeJSX)
|
|
18779
18888
|
return;
|
|
18780
18889
|
return $skip;
|
|
@@ -18801,7 +18910,7 @@ ${input.slice(result.pos)}
|
|
|
18801
18910
|
return result;
|
|
18802
18911
|
}
|
|
18803
18912
|
}
|
|
18804
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18913
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18805
18914
|
if (module.config.coffeeLineContinuation)
|
|
18806
18915
|
return;
|
|
18807
18916
|
return $skip;
|
|
@@ -18828,7 +18937,7 @@ ${input.slice(result.pos)}
|
|
|
18828
18937
|
return result;
|
|
18829
18938
|
}
|
|
18830
18939
|
}
|
|
18831
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18940
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18832
18941
|
if (module.config.coffeeNot)
|
|
18833
18942
|
return;
|
|
18834
18943
|
return $skip;
|
|
@@ -18855,7 +18964,7 @@ ${input.slice(result.pos)}
|
|
|
18855
18964
|
return result;
|
|
18856
18965
|
}
|
|
18857
18966
|
}
|
|
18858
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18967
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18859
18968
|
if (module.config.coffeeOf)
|
|
18860
18969
|
return;
|
|
18861
18970
|
return $skip;
|
|
@@ -18882,7 +18991,7 @@ ${input.slice(result.pos)}
|
|
|
18882
18991
|
return result;
|
|
18883
18992
|
}
|
|
18884
18993
|
}
|
|
18885
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18994
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18886
18995
|
if (module.config.coffeePrototype)
|
|
18887
18996
|
return;
|
|
18888
18997
|
return $skip;
|
|
@@ -18909,7 +19018,7 @@ ${input.slice(result.pos)}
|
|
|
18909
19018
|
return result;
|
|
18910
19019
|
}
|
|
18911
19020
|
}
|
|
18912
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
19021
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L19, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18913
19022
|
if (module.config.objectIs)
|
|
18914
19023
|
return;
|
|
18915
19024
|
return $skip;
|
|
@@ -18936,7 +19045,7 @@ ${input.slice(result.pos)}
|
|
|
18936
19045
|
return result;
|
|
18937
19046
|
}
|
|
18938
19047
|
}
|
|
18939
|
-
var Reset$0 = $TV($EXPECT($
|
|
19048
|
+
var Reset$0 = $TV($EXPECT($L19, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18940
19049
|
module.indentLevels = [{
|
|
18941
19050
|
level: 0,
|
|
18942
19051
|
token: ""
|
|
@@ -19243,7 +19352,7 @@ ${input.slice(result.pos)}
|
|
|
19243
19352
|
return result;
|
|
19244
19353
|
}
|
|
19245
19354
|
}
|
|
19246
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
19355
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L19, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
19247
19356
|
var directives = $2;
|
|
19248
19357
|
directives.forEach((directive) => {
|
|
19249
19358
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19515,6 +19624,9 @@ ${input.slice(result.pos)}
|
|
|
19515
19624
|
else
|
|
19516
19625
|
exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
|
|
19517
19626
|
return;
|
|
19627
|
+
case "PatternMatchingStatement":
|
|
19628
|
+
insertPush(exp.children[0][0], ref);
|
|
19629
|
+
return;
|
|
19518
19630
|
case "SwitchStatement":
|
|
19519
19631
|
insertPush(exp.children[2], ref);
|
|
19520
19632
|
return;
|
|
@@ -19546,6 +19658,12 @@ ${input.slice(result.pos)}
|
|
|
19546
19658
|
return;
|
|
19547
19659
|
}
|
|
19548
19660
|
}
|
|
19661
|
+
function getIndent(statement) {
|
|
19662
|
+
let indent = statement?.[0];
|
|
19663
|
+
if (Array.isArray(indent))
|
|
19664
|
+
indent = indent[indent.length - 1];
|
|
19665
|
+
return indent;
|
|
19666
|
+
}
|
|
19549
19667
|
function insertReturn(node) {
|
|
19550
19668
|
if (!node)
|
|
19551
19669
|
return;
|
|
@@ -19570,9 +19688,7 @@ ${input.slice(result.pos)}
|
|
|
19570
19688
|
const [, exp, semi] = node;
|
|
19571
19689
|
if (semi?.type === "SemicolonDelimiter")
|
|
19572
19690
|
return;
|
|
19573
|
-
let indent = node
|
|
19574
|
-
if (Array.isArray(indent))
|
|
19575
|
-
indent = indent[indent.length - 1];
|
|
19691
|
+
let indent = getIndent(node);
|
|
19576
19692
|
if (!exp)
|
|
19577
19693
|
return;
|
|
19578
19694
|
switch (exp.type) {
|
|
@@ -19598,6 +19714,9 @@ ${input.slice(result.pos)}
|
|
|
19598
19714
|
else
|
|
19599
19715
|
exp.children.push(["\n", indent, wrapWithReturn()]);
|
|
19600
19716
|
return;
|
|
19717
|
+
case "PatternMatchingStatement":
|
|
19718
|
+
insertReturn(exp.children[0][0]);
|
|
19719
|
+
return;
|
|
19601
19720
|
case "SwitchStatement":
|
|
19602
19721
|
insertSwitchReturns(exp);
|
|
19603
19722
|
return;
|
|
@@ -19992,12 +20111,14 @@ ${input.slice(result.pos)}
|
|
|
19992
20111
|
}
|
|
19993
20112
|
return [];
|
|
19994
20113
|
}
|
|
19995
|
-
function gatherRecursive(node, predicate) {
|
|
20114
|
+
function gatherRecursive(node, predicate, skipPredicate) {
|
|
19996
20115
|
if (node == null)
|
|
19997
20116
|
return [];
|
|
19998
20117
|
if (Array.isArray(node)) {
|
|
19999
20118
|
return node.flatMap((n) => gatherRecursive(n, predicate));
|
|
20000
20119
|
}
|
|
20120
|
+
if (skipPredicate?.(node))
|
|
20121
|
+
return [];
|
|
20001
20122
|
if (predicate(node)) {
|
|
20002
20123
|
return [node];
|
|
20003
20124
|
}
|
|
@@ -20015,6 +20136,36 @@ ${input.slice(result.pos)}
|
|
|
20015
20136
|
}
|
|
20016
20137
|
return nodes;
|
|
20017
20138
|
}
|
|
20139
|
+
function isFunction({ type }) {
|
|
20140
|
+
return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition";
|
|
20141
|
+
}
|
|
20142
|
+
function gatherRecursiveWithinFunction(node, predicate) {
|
|
20143
|
+
return gatherRecursive(node, predicate, isFunction);
|
|
20144
|
+
}
|
|
20145
|
+
function addParentPointers(node, parent) {
|
|
20146
|
+
if (node == null)
|
|
20147
|
+
return;
|
|
20148
|
+
if (typeof node !== "object")
|
|
20149
|
+
return;
|
|
20150
|
+
node.parent = parent;
|
|
20151
|
+
if (Array.isArray(node)) {
|
|
20152
|
+
for (const child of node) {
|
|
20153
|
+
addParentPointers(child, node);
|
|
20154
|
+
}
|
|
20155
|
+
} else if (node.children) {
|
|
20156
|
+
for (const child of node.children) {
|
|
20157
|
+
addParentPointers(child, node);
|
|
20158
|
+
}
|
|
20159
|
+
}
|
|
20160
|
+
}
|
|
20161
|
+
function findAncestor(node, predicate, stopPredicate) {
|
|
20162
|
+
node = node.parent;
|
|
20163
|
+
while (node && !stopPredicate?.(node)) {
|
|
20164
|
+
if (predicate(node))
|
|
20165
|
+
return node;
|
|
20166
|
+
node = node.parent;
|
|
20167
|
+
}
|
|
20168
|
+
}
|
|
20018
20169
|
function processParams(f) {
|
|
20019
20170
|
const { type, parameters, block } = f;
|
|
20020
20171
|
if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
|
|
@@ -20060,26 +20211,89 @@ ${input.slice(result.pos)}
|
|
|
20060
20211
|
}
|
|
20061
20212
|
});
|
|
20062
20213
|
}
|
|
20214
|
+
function processReturnValue(func) {
|
|
20215
|
+
const { block } = func;
|
|
20216
|
+
const values = gatherRecursiveWithinFunction(
|
|
20217
|
+
block,
|
|
20218
|
+
({ type }) => type === "ReturnValue"
|
|
20219
|
+
);
|
|
20220
|
+
if (!values.length)
|
|
20221
|
+
return false;
|
|
20222
|
+
const ref = {
|
|
20223
|
+
type: "Ref",
|
|
20224
|
+
base: "ret",
|
|
20225
|
+
id: "ret"
|
|
20226
|
+
};
|
|
20227
|
+
let declared;
|
|
20228
|
+
values.forEach((value) => {
|
|
20229
|
+
value.children = [ref];
|
|
20230
|
+
const ancestor = findAncestor(
|
|
20231
|
+
value,
|
|
20232
|
+
({ type }) => type === "Declaration",
|
|
20233
|
+
isFunction
|
|
20234
|
+
);
|
|
20235
|
+
if (ancestor)
|
|
20236
|
+
declared = true;
|
|
20237
|
+
});
|
|
20238
|
+
if (!declared) {
|
|
20239
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
20240
|
+
if (returnType) {
|
|
20241
|
+
const { t } = returnType;
|
|
20242
|
+
if (t.type === "TypePredicate") {
|
|
20243
|
+
returnType = ": boolean";
|
|
20244
|
+
} else if (t.type === "AssertsType") {
|
|
20245
|
+
returnType = void 0;
|
|
20246
|
+
}
|
|
20247
|
+
}
|
|
20248
|
+
block.expressions.unshift([
|
|
20249
|
+
getIndent(block.expressions[0]),
|
|
20250
|
+
{
|
|
20251
|
+
type: "Declaration",
|
|
20252
|
+
children: ["let ", ref, returnType, ";\n"],
|
|
20253
|
+
names: []
|
|
20254
|
+
}
|
|
20255
|
+
]);
|
|
20256
|
+
}
|
|
20257
|
+
gatherRecursiveWithinFunction(
|
|
20258
|
+
block,
|
|
20259
|
+
(r) => r.type === "ReturnStatement" && !r.expression
|
|
20260
|
+
).forEach((r) => {
|
|
20261
|
+
r.expression = ref;
|
|
20262
|
+
r.children.splice(-1, 1, " ", ref);
|
|
20263
|
+
});
|
|
20264
|
+
if (block.children.at(-2)?.type !== "ReturnStatement") {
|
|
20265
|
+
block.expressions.push([
|
|
20266
|
+
["\n", getIndent(block.expressions.at(-1))],
|
|
20267
|
+
{
|
|
20268
|
+
type: "ReturnStatement",
|
|
20269
|
+
expression: ref,
|
|
20270
|
+
children: ["return ", ref]
|
|
20271
|
+
}
|
|
20272
|
+
]);
|
|
20273
|
+
}
|
|
20274
|
+
return true;
|
|
20275
|
+
}
|
|
20276
|
+
function isVoidType(t) {
|
|
20277
|
+
return t?.type === "LiteralType" && t.t.type === "VoidType";
|
|
20278
|
+
}
|
|
20063
20279
|
function processFunctions(statements) {
|
|
20064
|
-
gatherRecursiveAll(statements, (
|
|
20065
|
-
return n.type === "FunctionExpression" || n.type === "ArrowFunction";
|
|
20066
|
-
}).forEach((f) => {
|
|
20280
|
+
gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
|
|
20067
20281
|
processParams(f);
|
|
20068
|
-
|
|
20069
|
-
|
|
20070
|
-
const isVoid = returnType
|
|
20282
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20283
|
+
const { block, returnType } = f;
|
|
20284
|
+
const isVoid = isVoidType(returnType?.t);
|
|
20071
20285
|
const isBlock = block?.type === "BlockStatement";
|
|
20072
20286
|
if (!isVoid && isBlock) {
|
|
20073
20287
|
insertReturn(block);
|
|
20074
20288
|
}
|
|
20075
20289
|
}
|
|
20076
20290
|
});
|
|
20077
|
-
gatherRecursiveAll(statements, (
|
|
20291
|
+
gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
|
|
20078
20292
|
processParams(f);
|
|
20079
|
-
|
|
20080
|
-
|
|
20293
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20294
|
+
const { signature, block } = f;
|
|
20081
20295
|
const isConstructor = signature.name === "constructor";
|
|
20082
|
-
const isVoid = signature.returnType
|
|
20296
|
+
const isVoid = isVoidType(signature.returnType?.t);
|
|
20083
20297
|
const isSet = signature.modifier === "set";
|
|
20084
20298
|
if (!isConstructor && !isSet && !isVoid) {
|
|
20085
20299
|
insertReturn(block);
|
|
@@ -20430,7 +20644,7 @@ ${input.slice(result.pos)}
|
|
|
20430
20644
|
}
|
|
20431
20645
|
}
|
|
20432
20646
|
function processPatternMatching(statements) {
|
|
20433
|
-
gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
|
|
20647
|
+
gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
|
|
20434
20648
|
const { caseBlock } = s;
|
|
20435
20649
|
const { clauses } = caseBlock;
|
|
20436
20650
|
let errors = false;
|
|
@@ -20509,15 +20723,21 @@ ${input.slice(result.pos)}
|
|
|
20509
20723
|
block.children.push("}");
|
|
20510
20724
|
block.bare = false;
|
|
20511
20725
|
}
|
|
20512
|
-
|
|
20513
|
-
|
|
20726
|
+
if (i < l - 1)
|
|
20727
|
+
next.push("\n", "else ");
|
|
20728
|
+
prev.push(["", {
|
|
20514
20729
|
type: "IfStatement",
|
|
20515
|
-
children: ["if", condition, block,
|
|
20730
|
+
children: ["if", condition, block, next],
|
|
20516
20731
|
then: block,
|
|
20517
|
-
else:
|
|
20518
|
-
});
|
|
20732
|
+
else: next
|
|
20733
|
+
}]);
|
|
20519
20734
|
prev = next;
|
|
20520
20735
|
});
|
|
20736
|
+
if (module.config.implicitReturns && s.type === "SwitchExpression") {
|
|
20737
|
+
insertReturn(root[0]);
|
|
20738
|
+
root.unshift("(()=>{");
|
|
20739
|
+
root.push("})()");
|
|
20740
|
+
}
|
|
20521
20741
|
s.type = "PatternMatchingStatement";
|
|
20522
20742
|
s.children = [root];
|
|
20523
20743
|
});
|
|
@@ -20567,12 +20787,13 @@ ${input.slice(result.pos)}
|
|
|
20567
20787
|
});
|
|
20568
20788
|
}
|
|
20569
20789
|
module.processProgram = function(statements) {
|
|
20790
|
+
addParentPointers(statements);
|
|
20570
20791
|
processPipelineExpressions(statements);
|
|
20571
20792
|
processAssignments(statements);
|
|
20793
|
+
processPatternMatching(statements);
|
|
20572
20794
|
processFunctions(statements);
|
|
20573
20795
|
processSwitchExpressions(statements);
|
|
20574
20796
|
processTryExpressions(statements);
|
|
20575
|
-
processPatternMatching(statements);
|
|
20576
20797
|
gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
|
|
20577
20798
|
checkSpliceRef(statements);
|
|
20578
20799
|
statements.unshift(...module.prelude);
|
|
@@ -20593,18 +20814,7 @@ ${input.slice(result.pos)}
|
|
|
20593
20814
|
return new Set(declarationNames);
|
|
20594
20815
|
}
|
|
20595
20816
|
function populateRefs(statements) {
|
|
20596
|
-
const refNodes =
|
|
20597
|
-
const blockNodes = new Set(gatherNodes(statements, ({ type }) => type === "BlockStatement"));
|
|
20598
|
-
const forNodes = gatherNodes(statements, ({ type }) => type === "ForStatement");
|
|
20599
|
-
forNodes.forEach(({ declaration, block }) => {
|
|
20600
|
-
if (block.type === "BlockStatement") {
|
|
20601
|
-
populateRefs([declaration, ...block.children]);
|
|
20602
|
-
} else {
|
|
20603
|
-
populateRefs([declaration, ...block]);
|
|
20604
|
-
}
|
|
20605
|
-
blockNodes.delete(block);
|
|
20606
|
-
});
|
|
20607
|
-
blockNodes.forEach(({ expressions }) => populateRefs(expressions));
|
|
20817
|
+
const refNodes = gatherRecursive(statements, ({ type }) => type === "Ref");
|
|
20608
20818
|
if (refNodes.length) {
|
|
20609
20819
|
const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
|
|
20610
20820
|
const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
|
|
@@ -20782,6 +20992,15 @@ ${input.slice(result.pos)}
|
|
|
20782
20992
|
module.gatherBindingCode = gatherBindingCode;
|
|
20783
20993
|
module.constructInvocation = function(fn, arg) {
|
|
20784
20994
|
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20995
|
+
if (fn.expr.ampersandBlock) {
|
|
20996
|
+
const [ref, , prefix, rhs] = fn.expr.children;
|
|
20997
|
+
ref.type = "PipedExpression";
|
|
20998
|
+
ref.children = [module.makeLeftHandSideExpression(arg)];
|
|
20999
|
+
return {
|
|
21000
|
+
type: "UnwrappedExpression",
|
|
21001
|
+
children: [module.skipIfOnlyWS(fn.leadingComment), prefix, rhs, module.skipIfOnlyWS(fn.trailingComment)]
|
|
21002
|
+
};
|
|
21003
|
+
}
|
|
20785
21004
|
const lhs = module.makeLeftHandSideExpression(fn.expr);
|
|
20786
21005
|
let comment = module.skipIfOnlyWS(fn.trailingComment);
|
|
20787
21006
|
if (comment)
|
|
@@ -20791,10 +21010,7 @@ ${input.slice(result.pos)}
|
|
|
20791
21010
|
lhs.children.splice(1, 0, comment);
|
|
20792
21011
|
switch (arg.type) {
|
|
20793
21012
|
case "CommaExpression":
|
|
20794
|
-
arg =
|
|
20795
|
-
type: "ParenthesizedExpression",
|
|
20796
|
-
children: ["(", arg, ")"]
|
|
20797
|
-
};
|
|
21013
|
+
arg = module.makeLeftHandSideExpression(arg);
|
|
20798
21014
|
break;
|
|
20799
21015
|
}
|
|
20800
21016
|
return {
|
|
@@ -21010,7 +21226,7 @@ ${input.slice(result.pos)}
|
|
|
21010
21226
|
return result;
|
|
21011
21227
|
}
|
|
21012
21228
|
}
|
|
21013
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
21229
|
+
var PopIndent$0 = $TV($EXPECT($L19, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
21014
21230
|
if (module.config.verbose) {
|
|
21015
21231
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
21016
21232
|
}
|
|
@@ -21149,6 +21365,9 @@ var prune = function(node) {
|
|
|
21149
21365
|
if (node.length === 0) {
|
|
21150
21366
|
return;
|
|
21151
21367
|
}
|
|
21368
|
+
if (node.parent != null) {
|
|
21369
|
+
delete node.parent;
|
|
21370
|
+
}
|
|
21152
21371
|
if (Array.isArray(node)) {
|
|
21153
21372
|
a = node.map(function(n) {
|
|
21154
21373
|
return prune(n);
|