@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.js
CHANGED
|
@@ -499,6 +499,8 @@ ${input.slice(result.pos)}
|
|
|
499
499
|
AtThis,
|
|
500
500
|
LeftHandSideExpression,
|
|
501
501
|
CallExpression,
|
|
502
|
+
ReturnValue,
|
|
503
|
+
AfterReturnShorthand,
|
|
502
504
|
CallExpressionRest,
|
|
503
505
|
OptionalShorthand,
|
|
504
506
|
OptionalDot,
|
|
@@ -1041,170 +1043,171 @@ ${input.slice(result.pos)}
|
|
|
1041
1043
|
var $L11 = $L("#");
|
|
1042
1044
|
var $L12 = $L("super");
|
|
1043
1045
|
var $L13 = $L("import");
|
|
1044
|
-
var $L14 = $L("
|
|
1045
|
-
var $L15 = $L("
|
|
1046
|
-
var $L16 = $L("
|
|
1047
|
-
var $L17 = $L("
|
|
1048
|
-
var $L18 = $L("");
|
|
1049
|
-
var $L19 = $L("
|
|
1050
|
-
var $L20 = $L("
|
|
1051
|
-
var $L21 = $L("
|
|
1052
|
-
var $L22 = $L("
|
|
1053
|
-
var $L23 = $L("
|
|
1054
|
-
var $L24 = $L("
|
|
1055
|
-
var $L25 = $L("
|
|
1056
|
-
var $L26 = $L("
|
|
1057
|
-
var $L27 = $L("
|
|
1058
|
-
var $L28 = $L("
|
|
1059
|
-
var $L29 = $L("
|
|
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("
|
|
1081
|
-
var $L51 = $L("
|
|
1082
|
-
var $L52 = $L("
|
|
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("
|
|
1099
|
-
var $L69 = $L("
|
|
1100
|
-
var $L70 = $L("
|
|
1101
|
-
var $L71 = $L("
|
|
1102
|
-
var $L72 = $L("
|
|
1103
|
-
var $L73 = $L("
|
|
1104
|
-
var $L74 = $L("
|
|
1105
|
-
var $L75 = $L("
|
|
1106
|
-
var $L76 = $L("
|
|
1107
|
-
var $L77 = $L("
|
|
1108
|
-
var $L78 = $L("
|
|
1109
|
-
var $L79 = $L("
|
|
1110
|
-
var $L80 = $L("
|
|
1111
|
-
var $L81 = $L("
|
|
1112
|
-
var $L82 = $L("
|
|
1113
|
-
var $L83 = $L("
|
|
1114
|
-
var $L84 = $L("
|
|
1115
|
-
var $L85 = $L("
|
|
1116
|
-
var $L86 = $L("
|
|
1117
|
-
var $L87 = $L("
|
|
1118
|
-
var $L88 = $L("
|
|
1119
|
-
var $L89 = $L("
|
|
1120
|
-
var $L90 = $L("
|
|
1121
|
-
var $L91 = $L("
|
|
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("
|
|
1130
|
-
var $L100 = $L("
|
|
1131
|
-
var $L101 = $L("
|
|
1132
|
-
var $L102 = $L("
|
|
1133
|
-
var $L103 = $L("
|
|
1134
|
-
var $L104 = $L("
|
|
1135
|
-
var $L105 = $L("
|
|
1136
|
-
var $L106 = $L("
|
|
1137
|
-
var $L107 = $L("
|
|
1138
|
-
var $L108 = $L("
|
|
1139
|
-
var $L109 = $L("
|
|
1140
|
-
var $L110 = $L("
|
|
1141
|
-
var $L111 = $L("
|
|
1142
|
-
var $L112 = $L("
|
|
1143
|
-
var $L113 = $L("
|
|
1144
|
-
var $L114 = $L("
|
|
1145
|
-
var $L115 = $L("
|
|
1146
|
-
var $L116 = $L(
|
|
1147
|
-
var $L117 = $L("
|
|
1148
|
-
var $L118 = $L("
|
|
1149
|
-
var $L119 = $L("
|
|
1150
|
-
var $L120 = $L("
|
|
1151
|
-
var $L121 = $L("
|
|
1152
|
-
var $L122 = $L("
|
|
1153
|
-
var $L123 = $L("
|
|
1154
|
-
var $L124 = $L("
|
|
1155
|
-
var $L125 = $L("
|
|
1156
|
-
var $L126 = $L("
|
|
1157
|
-
var $L127 = $L("
|
|
1158
|
-
var $L128 = $L("
|
|
1159
|
-
var $L129 = $L("
|
|
1160
|
-
var $L130 = $L("
|
|
1161
|
-
var $L131 = $L("
|
|
1162
|
-
var $L132 = $L("
|
|
1163
|
-
var $L133 = $L("
|
|
1164
|
-
var $L134 = $L("
|
|
1165
|
-
var $L135 = $L("
|
|
1166
|
-
var $L136 = $L("
|
|
1167
|
-
var $L137 = $L("
|
|
1168
|
-
var $L138 = $L("
|
|
1169
|
-
var $L139 = $L("
|
|
1170
|
-
var $L140 = $L("
|
|
1171
|
-
var $L141 = $L("
|
|
1172
|
-
var $L142 = $L("
|
|
1173
|
-
var $L143 = $L("
|
|
1174
|
-
var $L144 = $L("
|
|
1175
|
-
var $L145 = $L("
|
|
1176
|
-
var $L146 = $L("
|
|
1177
|
-
var $L147 = $L("
|
|
1178
|
-
var $L148 = $L("
|
|
1179
|
-
var $L149 = $L("
|
|
1180
|
-
var $L150 = $L("
|
|
1181
|
-
var $L151 = $L(
|
|
1182
|
-
var $L152 = $L("'
|
|
1183
|
-
var $L153 = $L("
|
|
1184
|
-
var $L154 = $L("
|
|
1185
|
-
var $L155 = $L("
|
|
1186
|
-
var $L156 = $L("
|
|
1187
|
-
var $L157 = $L("
|
|
1188
|
-
var $L158 = $L("
|
|
1189
|
-
var $L159 = $L("
|
|
1190
|
-
var $L160 = $L("
|
|
1191
|
-
var $L161 = $L("
|
|
1192
|
-
var $L162 = $L("
|
|
1193
|
-
var $L163 = $L("
|
|
1194
|
-
var $L164 = $L("
|
|
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("
|
|
1202
|
-
var $L172 = $L("
|
|
1203
|
-
var $L173 = $L("
|
|
1204
|
-
var $L174 = $L("
|
|
1205
|
-
var $L175 = $L("
|
|
1206
|
-
var $L176 = $L("
|
|
1207
|
-
var $L177 = $L("
|
|
1046
|
+
var $L14 = $L("return.value");
|
|
1047
|
+
var $L15 = $L("!");
|
|
1048
|
+
var $L16 = $L("^");
|
|
1049
|
+
var $L17 = $L("-");
|
|
1050
|
+
var $L18 = $L("import.meta");
|
|
1051
|
+
var $L19 = $L("");
|
|
1052
|
+
var $L20 = $L(",");
|
|
1053
|
+
var $L21 = $L("->");
|
|
1054
|
+
var $L22 = $L("}");
|
|
1055
|
+
var $L23 = $L("null");
|
|
1056
|
+
var $L24 = $L("true");
|
|
1057
|
+
var $L25 = $L("false");
|
|
1058
|
+
var $L26 = $L("yes");
|
|
1059
|
+
var $L27 = $L("on");
|
|
1060
|
+
var $L28 = $L("no");
|
|
1061
|
+
var $L29 = $L("off");
|
|
1062
|
+
var $L30 = $L(">");
|
|
1063
|
+
var $L31 = $L("]");
|
|
1064
|
+
var $L32 = $L(":");
|
|
1065
|
+
var $L33 = $L(")");
|
|
1066
|
+
var $L34 = $L("**=");
|
|
1067
|
+
var $L35 = $L("*=");
|
|
1068
|
+
var $L36 = $L("/=");
|
|
1069
|
+
var $L37 = $L("%=");
|
|
1070
|
+
var $L38 = $L("+=");
|
|
1071
|
+
var $L39 = $L("-=");
|
|
1072
|
+
var $L40 = $L("<<=");
|
|
1073
|
+
var $L41 = $L(">>>=");
|
|
1074
|
+
var $L42 = $L(">>=");
|
|
1075
|
+
var $L43 = $L("&&=");
|
|
1076
|
+
var $L44 = $L("&=");
|
|
1077
|
+
var $L45 = $L("^=");
|
|
1078
|
+
var $L46 = $L("||=");
|
|
1079
|
+
var $L47 = $L("|=");
|
|
1080
|
+
var $L48 = $L("??=");
|
|
1081
|
+
var $L49 = $L("?=");
|
|
1082
|
+
var $L50 = $L("and=");
|
|
1083
|
+
var $L51 = $L("or=");
|
|
1084
|
+
var $L52 = $L("not");
|
|
1085
|
+
var $L53 = $L("**");
|
|
1086
|
+
var $L54 = $L("*");
|
|
1087
|
+
var $L55 = $L("/");
|
|
1088
|
+
var $L56 = $L("%%");
|
|
1089
|
+
var $L57 = $L("%");
|
|
1090
|
+
var $L58 = $L("+");
|
|
1091
|
+
var $L59 = $L("<=");
|
|
1092
|
+
var $L60 = $L(">=");
|
|
1093
|
+
var $L61 = $L("<?");
|
|
1094
|
+
var $L62 = $L("!<?");
|
|
1095
|
+
var $L63 = $L("<<");
|
|
1096
|
+
var $L64 = $L(">>>");
|
|
1097
|
+
var $L65 = $L(">>");
|
|
1098
|
+
var $L66 = $L("!==");
|
|
1099
|
+
var $L67 = $L("!=");
|
|
1100
|
+
var $L68 = $L("isnt");
|
|
1101
|
+
var $L69 = $L("===");
|
|
1102
|
+
var $L70 = $L("==");
|
|
1103
|
+
var $L71 = $L("and");
|
|
1104
|
+
var $L72 = $L("&&");
|
|
1105
|
+
var $L73 = $L("of");
|
|
1106
|
+
var $L74 = $L("or");
|
|
1107
|
+
var $L75 = $L("||");
|
|
1108
|
+
var $L76 = $L("^^");
|
|
1109
|
+
var $L77 = $L("xor");
|
|
1110
|
+
var $L78 = $L("xnor");
|
|
1111
|
+
var $L79 = $L("??");
|
|
1112
|
+
var $L80 = $L("instanceof");
|
|
1113
|
+
var $L81 = $L("in");
|
|
1114
|
+
var $L82 = $L("is");
|
|
1115
|
+
var $L83 = $L("&");
|
|
1116
|
+
var $L84 = $L("|");
|
|
1117
|
+
var $L85 = $L(";");
|
|
1118
|
+
var $L86 = $L("$:");
|
|
1119
|
+
var $L87 = $L("own");
|
|
1120
|
+
var $L88 = $L("break");
|
|
1121
|
+
var $L89 = $L("continue");
|
|
1122
|
+
var $L90 = $L("debugger");
|
|
1123
|
+
var $L91 = $L("assert");
|
|
1124
|
+
var $L92 = $L(":=");
|
|
1125
|
+
var $L93 = $L(".=");
|
|
1126
|
+
var $L94 = $L("/*");
|
|
1127
|
+
var $L95 = $L("*/");
|
|
1128
|
+
var $L96 = $L("\\");
|
|
1129
|
+
var $L97 = $L("[");
|
|
1130
|
+
var $L98 = $L("`");
|
|
1131
|
+
var $L99 = $L("abstract");
|
|
1132
|
+
var $L100 = $L("as");
|
|
1133
|
+
var $L101 = $L("@");
|
|
1134
|
+
var $L102 = $L("@@");
|
|
1135
|
+
var $L103 = $L("async");
|
|
1136
|
+
var $L104 = $L("await");
|
|
1137
|
+
var $L105 = $L("by");
|
|
1138
|
+
var $L106 = $L("case");
|
|
1139
|
+
var $L107 = $L("catch");
|
|
1140
|
+
var $L108 = $L("class");
|
|
1141
|
+
var $L109 = $L("#{");
|
|
1142
|
+
var $L110 = $L("declare");
|
|
1143
|
+
var $L111 = $L("default");
|
|
1144
|
+
var $L112 = $L("delete");
|
|
1145
|
+
var $L113 = $L("do");
|
|
1146
|
+
var $L114 = $L("..");
|
|
1147
|
+
var $L115 = $L("...");
|
|
1148
|
+
var $L116 = $L("::");
|
|
1149
|
+
var $L117 = $L('"');
|
|
1150
|
+
var $L118 = $L("else");
|
|
1151
|
+
var $L119 = $L("export");
|
|
1152
|
+
var $L120 = $L("extends");
|
|
1153
|
+
var $L121 = $L("finally");
|
|
1154
|
+
var $L122 = $L("for");
|
|
1155
|
+
var $L123 = $L("from");
|
|
1156
|
+
var $L124 = $L("function");
|
|
1157
|
+
var $L125 = $L("get");
|
|
1158
|
+
var $L126 = $L("set");
|
|
1159
|
+
var $L127 = $L("if");
|
|
1160
|
+
var $L128 = $L("let");
|
|
1161
|
+
var $L129 = $L("const");
|
|
1162
|
+
var $L130 = $L("loop");
|
|
1163
|
+
var $L131 = $L("new");
|
|
1164
|
+
var $L132 = $L("<");
|
|
1165
|
+
var $L133 = $L("{");
|
|
1166
|
+
var $L134 = $L("operator");
|
|
1167
|
+
var $L135 = $L("public");
|
|
1168
|
+
var $L136 = $L("private");
|
|
1169
|
+
var $L137 = $L("protected");
|
|
1170
|
+
var $L138 = $L("||>");
|
|
1171
|
+
var $L139 = $L("|>=");
|
|
1172
|
+
var $L140 = $L("|>");
|
|
1173
|
+
var $L141 = $L("readonly");
|
|
1174
|
+
var $L142 = $L("return");
|
|
1175
|
+
var $L143 = $L("satisfies");
|
|
1176
|
+
var $L144 = $L("'");
|
|
1177
|
+
var $L145 = $L("static");
|
|
1178
|
+
var $L146 = $L("${");
|
|
1179
|
+
var $L147 = $L("switch");
|
|
1180
|
+
var $L148 = $L("target");
|
|
1181
|
+
var $L149 = $L("then");
|
|
1182
|
+
var $L150 = $L("this");
|
|
1183
|
+
var $L151 = $L("throw");
|
|
1184
|
+
var $L152 = $L('"""');
|
|
1185
|
+
var $L153 = $L("'''");
|
|
1186
|
+
var $L154 = $L("///");
|
|
1187
|
+
var $L155 = $L("```");
|
|
1188
|
+
var $L156 = $L("try");
|
|
1189
|
+
var $L157 = $L("typeof");
|
|
1190
|
+
var $L158 = $L("unless");
|
|
1191
|
+
var $L159 = $L("until");
|
|
1192
|
+
var $L160 = $L("var");
|
|
1193
|
+
var $L161 = $L("void");
|
|
1194
|
+
var $L162 = $L("when");
|
|
1195
|
+
var $L163 = $L("while");
|
|
1196
|
+
var $L164 = $L("yield");
|
|
1197
|
+
var $L165 = $L("/>");
|
|
1198
|
+
var $L166 = $L("</");
|
|
1199
|
+
var $L167 = $L("<>");
|
|
1200
|
+
var $L168 = $L("</>");
|
|
1201
|
+
var $L169 = $L("<!--");
|
|
1202
|
+
var $L170 = $L("-->");
|
|
1203
|
+
var $L171 = $L("type");
|
|
1204
|
+
var $L172 = $L("interface");
|
|
1205
|
+
var $L173 = $L("namespace");
|
|
1206
|
+
var $L174 = $L("asserts");
|
|
1207
|
+
var $L175 = $L("keyof");
|
|
1208
|
+
var $L176 = $L("infer");
|
|
1209
|
+
var $L177 = $L("[]");
|
|
1210
|
+
var $L178 = $L("civet");
|
|
1208
1211
|
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1209
1212
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1210
1213
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -2374,7 +2377,7 @@ ${input.slice(result.pos)}
|
|
|
2374
2377
|
return {
|
|
2375
2378
|
type: "ArrowFunction",
|
|
2376
2379
|
parameters,
|
|
2377
|
-
returnType: suffix
|
|
2380
|
+
returnType: suffix,
|
|
2378
2381
|
ts: false,
|
|
2379
2382
|
block: expOrBlock,
|
|
2380
2383
|
children: $0
|
|
@@ -3162,7 +3165,7 @@ ${input.slice(result.pos)}
|
|
|
3162
3165
|
return result;
|
|
3163
3166
|
}
|
|
3164
3167
|
}
|
|
3165
|
-
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName,
|
|
3168
|
+
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, $E(_), Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3166
3169
|
var id = $2;
|
|
3167
3170
|
var exp = $6;
|
|
3168
3171
|
switch (exp.type) {
|
|
@@ -3307,7 +3310,8 @@ ${input.slice(result.pos)}
|
|
|
3307
3310
|
children: [$1, ...$2, ...rest.flat()]
|
|
3308
3311
|
});
|
|
3309
3312
|
});
|
|
3310
|
-
var CallExpression$2 =
|
|
3313
|
+
var CallExpression$2 = ReturnValue;
|
|
3314
|
+
var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3311
3315
|
var member = $1;
|
|
3312
3316
|
var trailing = $2;
|
|
3313
3317
|
var rest = $3;
|
|
@@ -3331,17 +3335,69 @@ ${input.slice(result.pos)}
|
|
|
3331
3335
|
}
|
|
3332
3336
|
}
|
|
3333
3337
|
if (state.tokenize) {
|
|
3334
|
-
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
3338
|
+
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state));
|
|
3335
3339
|
if (state.events)
|
|
3336
3340
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3337
3341
|
return result;
|
|
3338
3342
|
} else {
|
|
3339
|
-
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
|
|
3343
|
+
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state);
|
|
3340
3344
|
if (state.events)
|
|
3341
3345
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3342
3346
|
return result;
|
|
3343
3347
|
}
|
|
3344
3348
|
}
|
|
3349
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L14, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
3350
|
+
return { type: "ReturnValue", children: [$1[0]] };
|
|
3351
|
+
});
|
|
3352
|
+
function ReturnValue(state) {
|
|
3353
|
+
let eventData;
|
|
3354
|
+
if (state.events) {
|
|
3355
|
+
const result = state.events.enter?.("ReturnValue", state);
|
|
3356
|
+
if (result) {
|
|
3357
|
+
if (result.cache)
|
|
3358
|
+
return result.cache;
|
|
3359
|
+
eventData = result.data;
|
|
3360
|
+
}
|
|
3361
|
+
}
|
|
3362
|
+
if (state.tokenize) {
|
|
3363
|
+
const result = $TOKEN("ReturnValue", state, ReturnValue$0(state));
|
|
3364
|
+
if (state.events)
|
|
3365
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3366
|
+
return result;
|
|
3367
|
+
} else {
|
|
3368
|
+
const result = ReturnValue$0(state);
|
|
3369
|
+
if (state.events)
|
|
3370
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3371
|
+
return result;
|
|
3372
|
+
}
|
|
3373
|
+
}
|
|
3374
|
+
var AfterReturnShorthand$0 = WAssignmentOp;
|
|
3375
|
+
var AfterReturnShorthand$1 = UpdateExpressionSymbol;
|
|
3376
|
+
var AfterReturnShorthand$2 = TypeSuffix;
|
|
3377
|
+
var AfterReturnShorthand$3 = $S(__, LetAssignment);
|
|
3378
|
+
var AfterReturnShorthand$4 = $S(__, ConstAssignment);
|
|
3379
|
+
function AfterReturnShorthand(state) {
|
|
3380
|
+
let eventData;
|
|
3381
|
+
if (state.events) {
|
|
3382
|
+
const result = state.events.enter?.("AfterReturnShorthand", state);
|
|
3383
|
+
if (result) {
|
|
3384
|
+
if (result.cache)
|
|
3385
|
+
return result.cache;
|
|
3386
|
+
eventData = result.data;
|
|
3387
|
+
}
|
|
3388
|
+
}
|
|
3389
|
+
if (state.tokenize) {
|
|
3390
|
+
const result = $TOKEN("AfterReturnShorthand", state, AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state));
|
|
3391
|
+
if (state.events)
|
|
3392
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3393
|
+
return result;
|
|
3394
|
+
} else {
|
|
3395
|
+
const result = AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state);
|
|
3396
|
+
if (state.events)
|
|
3397
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3398
|
+
return result;
|
|
3399
|
+
}
|
|
3400
|
+
}
|
|
3345
3401
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
3346
3402
|
var CallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
|
|
3347
3403
|
if ($1.type === "StringLiteral") {
|
|
@@ -3428,7 +3484,7 @@ ${input.slice(result.pos)}
|
|
|
3428
3484
|
return result;
|
|
3429
3485
|
}
|
|
3430
3486
|
}
|
|
3431
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
3487
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L15, fail, 'NonNullAssertion "!"'), $N($EXPECT($L16, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3432
3488
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3433
3489
|
});
|
|
3434
3490
|
function NonNullAssertion(state) {
|
|
@@ -3566,7 +3622,7 @@ ${input.slice(result.pos)}
|
|
|
3566
3622
|
]
|
|
3567
3623
|
};
|
|
3568
3624
|
});
|
|
3569
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3625
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L17, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3570
3626
|
var dot = $1;
|
|
3571
3627
|
var neg = $2;
|
|
3572
3628
|
var num = $3;
|
|
@@ -3643,6 +3699,20 @@ ${input.slice(result.pos)}
|
|
|
3643
3699
|
children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
|
|
3644
3700
|
};
|
|
3645
3701
|
});
|
|
3702
|
+
var SliceParameters$2 = $TS($S(Loc, __, $C(DotDot, DotDotDot), $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3703
|
+
var l = $1;
|
|
3704
|
+
var ws = $2;
|
|
3705
|
+
const start = {
|
|
3706
|
+
$loc: l.$loc,
|
|
3707
|
+
token: "0"
|
|
3708
|
+
};
|
|
3709
|
+
return {
|
|
3710
|
+
type: "SliceParameters",
|
|
3711
|
+
start,
|
|
3712
|
+
end: void 0,
|
|
3713
|
+
children: [start, ws]
|
|
3714
|
+
};
|
|
3715
|
+
});
|
|
3646
3716
|
function SliceParameters(state) {
|
|
3647
3717
|
let eventData;
|
|
3648
3718
|
if (state.events) {
|
|
@@ -3654,12 +3724,12 @@ ${input.slice(result.pos)}
|
|
|
3654
3724
|
}
|
|
3655
3725
|
}
|
|
3656
3726
|
if (state.tokenize) {
|
|
3657
|
-
const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
|
|
3727
|
+
const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state));
|
|
3658
3728
|
if (state.events)
|
|
3659
3729
|
state.events.exit?.("SliceParameters", state, result, eventData);
|
|
3660
3730
|
return result;
|
|
3661
3731
|
} else {
|
|
3662
|
-
const result = SliceParameters$0(state) || SliceParameters$1(state);
|
|
3732
|
+
const result = SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state);
|
|
3663
3733
|
if (state.events)
|
|
3664
3734
|
state.events.exit?.("SliceParameters", state, result, eventData);
|
|
3665
3735
|
return result;
|
|
@@ -3763,7 +3833,7 @@ ${input.slice(result.pos)}
|
|
|
3763
3833
|
}
|
|
3764
3834
|
}
|
|
3765
3835
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3766
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3836
|
+
var MetaProperty$1 = $TS($S($EXPECT($L18, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3767
3837
|
return { $loc, token: $1 };
|
|
3768
3838
|
});
|
|
3769
3839
|
function MetaProperty(state) {
|
|
@@ -3789,7 +3859,7 @@ ${input.slice(result.pos)}
|
|
|
3789
3859
|
}
|
|
3790
3860
|
}
|
|
3791
3861
|
var Parameters$0 = NonEmptyParameters;
|
|
3792
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3862
|
+
var Parameters$1 = $TV($EXPECT($L19, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3793
3863
|
return {
|
|
3794
3864
|
type: "Parameters",
|
|
3795
3865
|
children: [{ $loc, token: "()" }],
|
|
@@ -4012,6 +4082,9 @@ ${input.slice(result.pos)}
|
|
|
4012
4082
|
};
|
|
4013
4083
|
});
|
|
4014
4084
|
var NWBindingIdentifier$1 = Identifier;
|
|
4085
|
+
var NWBindingIdentifier$2 = $TS($S(ReturnValue), function($skip, $loc, $0, $1) {
|
|
4086
|
+
return { children: [$1], names: [] };
|
|
4087
|
+
});
|
|
4015
4088
|
function NWBindingIdentifier(state) {
|
|
4016
4089
|
let eventData;
|
|
4017
4090
|
if (state.events) {
|
|
@@ -4023,12 +4096,12 @@ ${input.slice(result.pos)}
|
|
|
4023
4096
|
}
|
|
4024
4097
|
}
|
|
4025
4098
|
if (state.tokenize) {
|
|
4026
|
-
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state));
|
|
4099
|
+
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state));
|
|
4027
4100
|
if (state.events)
|
|
4028
4101
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4029
4102
|
return result;
|
|
4030
4103
|
} else {
|
|
4031
|
-
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state);
|
|
4104
|
+
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state);
|
|
4032
4105
|
if (state.events)
|
|
4033
4106
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4034
4107
|
return result;
|
|
@@ -4409,7 +4482,7 @@ ${input.slice(result.pos)}
|
|
|
4409
4482
|
}
|
|
4410
4483
|
}
|
|
4411
4484
|
var BindingProperty$0 = BindingRestProperty;
|
|
4412
|
-
var BindingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4485
|
+
var BindingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4413
4486
|
var name = $2;
|
|
4414
4487
|
var b = $5;
|
|
4415
4488
|
var init = $6;
|
|
@@ -4570,7 +4643,7 @@ ${input.slice(result.pos)}
|
|
|
4570
4643
|
children: $0
|
|
4571
4644
|
};
|
|
4572
4645
|
});
|
|
4573
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4646
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4574
4647
|
return {
|
|
4575
4648
|
children: [{
|
|
4576
4649
|
type: "ElisionElement",
|
|
@@ -4643,7 +4716,7 @@ ${input.slice(result.pos)}
|
|
|
4643
4716
|
return result;
|
|
4644
4717
|
}
|
|
4645
4718
|
}
|
|
4646
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4719
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L19, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4647
4720
|
const ref = {
|
|
4648
4721
|
type: "Ref",
|
|
4649
4722
|
base: "ref",
|
|
@@ -4861,7 +4934,7 @@ ${input.slice(result.pos)}
|
|
|
4861
4934
|
}
|
|
4862
4935
|
}
|
|
4863
4936
|
var MatchingProperty$0 = MatchingRestProperty;
|
|
4864
|
-
var MatchingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4937
|
+
var MatchingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4865
4938
|
var name = $2;
|
|
4866
4939
|
var match = $6;
|
|
4867
4940
|
return {
|
|
@@ -5087,7 +5160,7 @@ ${input.slice(result.pos)}
|
|
|
5087
5160
|
}
|
|
5088
5161
|
}
|
|
5089
5162
|
var MatchingElement$0 = MatchingRestElement;
|
|
5090
|
-
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier,
|
|
5163
|
+
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5091
5164
|
var ws = $1;
|
|
5092
5165
|
var name = $2;
|
|
5093
5166
|
var match = $6;
|
|
@@ -5119,7 +5192,7 @@ ${input.slice(result.pos)}
|
|
|
5119
5192
|
children: [ws, binding]
|
|
5120
5193
|
};
|
|
5121
5194
|
});
|
|
5122
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5195
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5123
5196
|
return {
|
|
5124
5197
|
children: [{
|
|
5125
5198
|
type: "ElisionElement",
|
|
@@ -5212,7 +5285,7 @@ ${input.slice(result.pos)}
|
|
|
5212
5285
|
type: "FunctionSignature",
|
|
5213
5286
|
id: wid?.[1],
|
|
5214
5287
|
parameters,
|
|
5215
|
-
returnType: suffix
|
|
5288
|
+
returnType: suffix,
|
|
5216
5289
|
ts: false,
|
|
5217
5290
|
block: null,
|
|
5218
5291
|
children: !parameters.implicit ? $0 : [async, func, star, wid, parameters, w, suffix]
|
|
@@ -5267,19 +5340,15 @@ ${input.slice(result.pos)}
|
|
|
5267
5340
|
};
|
|
5268
5341
|
return {
|
|
5269
5342
|
type: "ArrowFunction",
|
|
5270
|
-
children: [ref2, " => ", prefix, ref2]
|
|
5343
|
+
children: [ref2, " => ", prefix, ref2],
|
|
5344
|
+
ampersandBlock: true
|
|
5271
5345
|
};
|
|
5272
5346
|
}
|
|
5273
5347
|
const { ref } = rhs;
|
|
5274
|
-
if (!prefix) {
|
|
5275
|
-
return {
|
|
5276
|
-
type: "ArrowFunction",
|
|
5277
|
-
children: [ref, " => ", rhs]
|
|
5278
|
-
};
|
|
5279
|
-
}
|
|
5280
5348
|
return {
|
|
5281
5349
|
type: "ArrowFunction",
|
|
5282
|
-
children: [ref, " => ", prefix, rhs]
|
|
5350
|
+
children: [ref, " => ", prefix, rhs],
|
|
5351
|
+
ampersandBlock: true
|
|
5283
5352
|
};
|
|
5284
5353
|
});
|
|
5285
5354
|
function FunctionExpression(state) {
|
|
@@ -5371,7 +5440,7 @@ ${input.slice(result.pos)}
|
|
|
5371
5440
|
type: "FunctionSignature",
|
|
5372
5441
|
id,
|
|
5373
5442
|
parameters,
|
|
5374
|
-
returnType: suffix
|
|
5443
|
+
returnType: suffix,
|
|
5375
5444
|
ts: false,
|
|
5376
5445
|
block: null,
|
|
5377
5446
|
children: [func, w1, id, w2, parameters, suffix]
|
|
@@ -5480,7 +5549,7 @@ ${input.slice(result.pos)}
|
|
|
5480
5549
|
type: "FunctionExpression",
|
|
5481
5550
|
id: void 0,
|
|
5482
5551
|
parameters,
|
|
5483
|
-
returnType: suffix
|
|
5552
|
+
returnType: suffix,
|
|
5484
5553
|
ts: false,
|
|
5485
5554
|
block,
|
|
5486
5555
|
children: [
|
|
@@ -5513,7 +5582,7 @@ ${input.slice(result.pos)}
|
|
|
5513
5582
|
return result;
|
|
5514
5583
|
}
|
|
5515
5584
|
}
|
|
5516
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5585
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5517
5586
|
return { $loc, token: $1 };
|
|
5518
5587
|
});
|
|
5519
5588
|
function Arrow(state) {
|
|
@@ -5577,12 +5646,16 @@ ${input.slice(result.pos)}
|
|
|
5577
5646
|
return result;
|
|
5578
5647
|
}
|
|
5579
5648
|
}
|
|
5580
|
-
var ImplicitNestedBlock$0 = $TS($S(InsertOpenBrace, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5581
|
-
var
|
|
5582
|
-
|
|
5583
|
-
|
|
5649
|
+
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) {
|
|
5650
|
+
var open = $2;
|
|
5651
|
+
if (!$4)
|
|
5652
|
+
return $skip;
|
|
5653
|
+
const [block, ...tail] = $4;
|
|
5654
|
+
return {
|
|
5655
|
+
...block,
|
|
5656
|
+
children: [open, ...block.children, ...tail],
|
|
5584
5657
|
bare: false
|
|
5585
|
-
}
|
|
5658
|
+
};
|
|
5586
5659
|
});
|
|
5587
5660
|
function ImplicitNestedBlock(state) {
|
|
5588
5661
|
let eventData;
|
|
@@ -5747,7 +5820,7 @@ ${input.slice(result.pos)}
|
|
|
5747
5820
|
return result;
|
|
5748
5821
|
}
|
|
5749
5822
|
}
|
|
5750
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5823
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L19, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5751
5824
|
const expressions = [];
|
|
5752
5825
|
return {
|
|
5753
5826
|
type: "BlockStatement",
|
|
@@ -5850,12 +5923,16 @@ ${input.slice(result.pos)}
|
|
|
5850
5923
|
return result;
|
|
5851
5924
|
}
|
|
5852
5925
|
}
|
|
5853
|
-
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5854
|
-
var
|
|
5926
|
+
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5927
|
+
var ws1 = $1;
|
|
5928
|
+
var open = $2;
|
|
5929
|
+
if (!$4)
|
|
5930
|
+
return $skip;
|
|
5931
|
+
const [block, ws2, close] = $4;
|
|
5855
5932
|
return {
|
|
5856
5933
|
type: "BlockStatement",
|
|
5857
5934
|
expressions: block.expressions,
|
|
5858
|
-
children: [
|
|
5935
|
+
children: [ws1, open, ...block.children, ws2, close],
|
|
5859
5936
|
bare: false
|
|
5860
5937
|
};
|
|
5861
5938
|
return block;
|
|
@@ -5970,7 +6047,7 @@ ${input.slice(result.pos)}
|
|
|
5970
6047
|
children: [$1, expressions]
|
|
5971
6048
|
};
|
|
5972
6049
|
});
|
|
5973
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6050
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5974
6051
|
const expressions = [];
|
|
5975
6052
|
return {
|
|
5976
6053
|
type: "BlockStatement",
|
|
@@ -6115,7 +6192,7 @@ ${input.slice(result.pos)}
|
|
|
6115
6192
|
return result;
|
|
6116
6193
|
}
|
|
6117
6194
|
}
|
|
6118
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6195
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6119
6196
|
return { $loc, token: $1 };
|
|
6120
6197
|
});
|
|
6121
6198
|
function NullLiteral(state) {
|
|
@@ -6143,7 +6220,7 @@ ${input.slice(result.pos)}
|
|
|
6143
6220
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6144
6221
|
return value[1];
|
|
6145
6222
|
});
|
|
6146
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6223
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6147
6224
|
return { $loc, token: $1 };
|
|
6148
6225
|
});
|
|
6149
6226
|
function BooleanLiteral(state) {
|
|
@@ -6168,10 +6245,10 @@ ${input.slice(result.pos)}
|
|
|
6168
6245
|
return result;
|
|
6169
6246
|
}
|
|
6170
6247
|
}
|
|
6171
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6248
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6172
6249
|
return { $loc, token: "true" };
|
|
6173
6250
|
});
|
|
6174
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6251
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6175
6252
|
return { $loc, token: "false" };
|
|
6176
6253
|
});
|
|
6177
6254
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6277,7 +6354,7 @@ ${input.slice(result.pos)}
|
|
|
6277
6354
|
return result;
|
|
6278
6355
|
}
|
|
6279
6356
|
}
|
|
6280
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6357
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6281
6358
|
function UpcomingAssignment(state) {
|
|
6282
6359
|
let eventData;
|
|
6283
6360
|
if (state.events) {
|
|
@@ -6543,7 +6620,7 @@ ${input.slice(result.pos)}
|
|
|
6543
6620
|
}
|
|
6544
6621
|
}
|
|
6545
6622
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6546
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6623
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6547
6624
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6548
6625
|
return value[1];
|
|
6549
6626
|
});
|
|
@@ -6970,7 +7047,7 @@ ${input.slice(result.pos)}
|
|
|
6970
7047
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6971
7048
|
return value[1];
|
|
6972
7049
|
});
|
|
6973
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
7050
|
+
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) {
|
|
6974
7051
|
return "";
|
|
6975
7052
|
});
|
|
6976
7053
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6999,7 +7076,7 @@ ${input.slice(result.pos)}
|
|
|
6999
7076
|
}
|
|
7000
7077
|
}
|
|
7001
7078
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
7002
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7079
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
7003
7080
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7004
7081
|
return value[1];
|
|
7005
7082
|
});
|
|
@@ -7169,7 +7246,7 @@ ${input.slice(result.pos)}
|
|
|
7169
7246
|
return result;
|
|
7170
7247
|
}
|
|
7171
7248
|
}
|
|
7172
|
-
var NamedProperty$0 = $TS($S(PropertyName,
|
|
7249
|
+
var NamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7173
7250
|
var name = $1;
|
|
7174
7251
|
var exp = $4;
|
|
7175
7252
|
return {
|
|
@@ -7202,7 +7279,7 @@ ${input.slice(result.pos)}
|
|
|
7202
7279
|
return result;
|
|
7203
7280
|
}
|
|
7204
7281
|
}
|
|
7205
|
-
var ImplicitNamedProperty$0 = $TS($S(PropertyName,
|
|
7282
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7206
7283
|
var name = $1;
|
|
7207
7284
|
var exp = $5;
|
|
7208
7285
|
return {
|
|
@@ -7309,7 +7386,7 @@ ${input.slice(result.pos)}
|
|
|
7309
7386
|
expression
|
|
7310
7387
|
};
|
|
7311
7388
|
});
|
|
7312
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7389
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L17, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7313
7390
|
return {
|
|
7314
7391
|
type: "ComputedPropertyName",
|
|
7315
7392
|
children: $0
|
|
@@ -7477,7 +7554,7 @@ ${input.slice(result.pos)}
|
|
|
7477
7554
|
children: $0,
|
|
7478
7555
|
name,
|
|
7479
7556
|
modifier: $1?.[0]?.token,
|
|
7480
|
-
returnType:
|
|
7557
|
+
returnType: suffix,
|
|
7481
7558
|
parameters
|
|
7482
7559
|
};
|
|
7483
7560
|
});
|
|
@@ -7658,22 +7735,22 @@ ${input.slice(result.pos)}
|
|
|
7658
7735
|
return result;
|
|
7659
7736
|
}
|
|
7660
7737
|
}
|
|
7661
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7662
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7663
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7664
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7665
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7666
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7667
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7668
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7669
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7670
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7671
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7672
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7673
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7674
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7675
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7676
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7738
|
+
var AssignmentOpSymbol$0 = $EXPECT($L34, fail, 'AssignmentOpSymbol "**="');
|
|
7739
|
+
var AssignmentOpSymbol$1 = $EXPECT($L35, fail, 'AssignmentOpSymbol "*="');
|
|
7740
|
+
var AssignmentOpSymbol$2 = $EXPECT($L36, fail, 'AssignmentOpSymbol "/="');
|
|
7741
|
+
var AssignmentOpSymbol$3 = $EXPECT($L37, fail, 'AssignmentOpSymbol "%="');
|
|
7742
|
+
var AssignmentOpSymbol$4 = $EXPECT($L38, fail, 'AssignmentOpSymbol "+="');
|
|
7743
|
+
var AssignmentOpSymbol$5 = $EXPECT($L39, fail, 'AssignmentOpSymbol "-="');
|
|
7744
|
+
var AssignmentOpSymbol$6 = $EXPECT($L40, fail, 'AssignmentOpSymbol "<<="');
|
|
7745
|
+
var AssignmentOpSymbol$7 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>>="');
|
|
7746
|
+
var AssignmentOpSymbol$8 = $EXPECT($L42, fail, 'AssignmentOpSymbol ">>="');
|
|
7747
|
+
var AssignmentOpSymbol$9 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&&="');
|
|
7748
|
+
var AssignmentOpSymbol$10 = $EXPECT($L44, fail, 'AssignmentOpSymbol "&="');
|
|
7749
|
+
var AssignmentOpSymbol$11 = $EXPECT($L45, fail, 'AssignmentOpSymbol "^="');
|
|
7750
|
+
var AssignmentOpSymbol$12 = $EXPECT($L46, fail, 'AssignmentOpSymbol "||="');
|
|
7751
|
+
var AssignmentOpSymbol$13 = $EXPECT($L47, fail, 'AssignmentOpSymbol "|="');
|
|
7752
|
+
var AssignmentOpSymbol$14 = $EXPECT($L48, fail, 'AssignmentOpSymbol "??="');
|
|
7753
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L49, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7677
7754
|
return "??=";
|
|
7678
7755
|
});
|
|
7679
7756
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7704,10 +7781,10 @@ ${input.slice(result.pos)}
|
|
|
7704
7781
|
return result;
|
|
7705
7782
|
}
|
|
7706
7783
|
}
|
|
7707
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7784
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7708
7785
|
return "&&=";
|
|
7709
7786
|
});
|
|
7710
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7787
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L51, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7711
7788
|
return "||=";
|
|
7712
7789
|
});
|
|
7713
7790
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7746,7 +7823,7 @@ ${input.slice(result.pos)}
|
|
|
7746
7823
|
special: true
|
|
7747
7824
|
};
|
|
7748
7825
|
});
|
|
7749
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7826
|
+
var BinaryOp$2 = $TS($S($EXPECT($L52, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7750
7827
|
var id = $4;
|
|
7751
7828
|
if (!module2.operators.has(id.name))
|
|
7752
7829
|
return $skip;
|
|
@@ -7778,21 +7855,21 @@ ${input.slice(result.pos)}
|
|
|
7778
7855
|
return result;
|
|
7779
7856
|
}
|
|
7780
7857
|
}
|
|
7781
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7782
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7783
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7784
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7858
|
+
var BinaryOpSymbol$0 = $EXPECT($L53, fail, 'BinaryOpSymbol "**"');
|
|
7859
|
+
var BinaryOpSymbol$1 = $EXPECT($L54, fail, 'BinaryOpSymbol "*"');
|
|
7860
|
+
var BinaryOpSymbol$2 = $EXPECT($L55, fail, 'BinaryOpSymbol "/"');
|
|
7861
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7785
7862
|
return {
|
|
7786
7863
|
call: module2.getRef("modulo"),
|
|
7787
7864
|
special: true
|
|
7788
7865
|
};
|
|
7789
7866
|
});
|
|
7790
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7791
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7792
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7793
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7794
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7795
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7867
|
+
var BinaryOpSymbol$4 = $EXPECT($L57, fail, 'BinaryOpSymbol "%"');
|
|
7868
|
+
var BinaryOpSymbol$5 = $EXPECT($L58, fail, 'BinaryOpSymbol "+"');
|
|
7869
|
+
var BinaryOpSymbol$6 = $EXPECT($L17, fail, 'BinaryOpSymbol "-"');
|
|
7870
|
+
var BinaryOpSymbol$7 = $EXPECT($L59, fail, 'BinaryOpSymbol "<="');
|
|
7871
|
+
var BinaryOpSymbol$8 = $EXPECT($L60, fail, 'BinaryOpSymbol ">="');
|
|
7872
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7796
7873
|
return {
|
|
7797
7874
|
$loc,
|
|
7798
7875
|
token: "instanceof",
|
|
@@ -7800,7 +7877,7 @@ ${input.slice(result.pos)}
|
|
|
7800
7877
|
special: true
|
|
7801
7878
|
};
|
|
7802
7879
|
});
|
|
7803
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7880
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L62, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7804
7881
|
return {
|
|
7805
7882
|
$loc,
|
|
7806
7883
|
token: "instanceof",
|
|
@@ -7809,58 +7886,58 @@ ${input.slice(result.pos)}
|
|
|
7809
7886
|
negated: true
|
|
7810
7887
|
};
|
|
7811
7888
|
});
|
|
7812
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7889
|
+
var BinaryOpSymbol$11 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
7813
7890
|
var BinaryOpSymbol$12 = $TR($EXPECT($R7, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7814
7891
|
return "<";
|
|
7815
7892
|
});
|
|
7816
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7817
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7818
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7819
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7820
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7893
|
+
var BinaryOpSymbol$13 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
7894
|
+
var BinaryOpSymbol$14 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
7895
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7896
|
+
var BinaryOpSymbol$16 = $EXPECT($L66, fail, 'BinaryOpSymbol "!=="');
|
|
7897
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L67, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7821
7898
|
if (module2.config.coffeeEq)
|
|
7822
7899
|
return "!==";
|
|
7823
7900
|
return $1;
|
|
7824
7901
|
});
|
|
7825
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7902
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7826
7903
|
if (module2.config.coffeeIsnt)
|
|
7827
7904
|
return "!==";
|
|
7828
7905
|
return $skip;
|
|
7829
7906
|
});
|
|
7830
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7831
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7907
|
+
var BinaryOpSymbol$19 = $EXPECT($L69, fail, 'BinaryOpSymbol "==="');
|
|
7908
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7832
7909
|
if (module2.config.coffeeEq)
|
|
7833
7910
|
return "===";
|
|
7834
7911
|
return $1;
|
|
7835
7912
|
});
|
|
7836
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7913
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7837
7914
|
return "&&";
|
|
7838
7915
|
});
|
|
7839
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7840
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7916
|
+
var BinaryOpSymbol$22 = $EXPECT($L72, fail, 'BinaryOpSymbol "&&"');
|
|
7917
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7841
7918
|
return "in";
|
|
7842
7919
|
});
|
|
7843
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7920
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7844
7921
|
return "||";
|
|
7845
7922
|
});
|
|
7846
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7847
|
-
var BinaryOpSymbol$26 = $TV($C($EXPECT($
|
|
7923
|
+
var BinaryOpSymbol$25 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
7924
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L76, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7848
7925
|
return {
|
|
7849
7926
|
call: module2.getRef("xor"),
|
|
7850
7927
|
special: true
|
|
7851
7928
|
};
|
|
7852
7929
|
});
|
|
7853
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
7930
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L78, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7854
7931
|
return {
|
|
7855
7932
|
call: module2.getRef("xnor"),
|
|
7856
7933
|
special: true
|
|
7857
7934
|
};
|
|
7858
7935
|
});
|
|
7859
|
-
var BinaryOpSymbol$28 = $EXPECT($
|
|
7936
|
+
var BinaryOpSymbol$28 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
|
|
7860
7937
|
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7861
7938
|
return "??";
|
|
7862
7939
|
});
|
|
7863
|
-
var BinaryOpSymbol$30 = $TS($S($EXPECT($
|
|
7940
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7864
7941
|
return {
|
|
7865
7942
|
$loc,
|
|
7866
7943
|
token: $1,
|
|
@@ -7868,7 +7945,7 @@ ${input.slice(result.pos)}
|
|
|
7868
7945
|
special: true
|
|
7869
7946
|
};
|
|
7870
7947
|
});
|
|
7871
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
7948
|
+
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) {
|
|
7872
7949
|
return {
|
|
7873
7950
|
$loc,
|
|
7874
7951
|
token: "instanceof",
|
|
@@ -7877,7 +7954,7 @@ ${input.slice(result.pos)}
|
|
|
7877
7954
|
negated: true
|
|
7878
7955
|
};
|
|
7879
7956
|
});
|
|
7880
|
-
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($
|
|
7957
|
+
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) {
|
|
7881
7958
|
return {
|
|
7882
7959
|
$loc,
|
|
7883
7960
|
token: "in",
|
|
@@ -7885,7 +7962,7 @@ ${input.slice(result.pos)}
|
|
|
7885
7962
|
negated: true
|
|
7886
7963
|
};
|
|
7887
7964
|
});
|
|
7888
|
-
var BinaryOpSymbol$33 = $TS($S($EXPECT($
|
|
7965
|
+
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) {
|
|
7889
7966
|
return {
|
|
7890
7967
|
method: "includes",
|
|
7891
7968
|
relational: true,
|
|
@@ -7893,7 +7970,7 @@ ${input.slice(result.pos)}
|
|
|
7893
7970
|
special: true
|
|
7894
7971
|
};
|
|
7895
7972
|
});
|
|
7896
|
-
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7973
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7897
7974
|
return {
|
|
7898
7975
|
call: [module2.getRef("indexOf"), ".call"],
|
|
7899
7976
|
relational: true,
|
|
@@ -7902,7 +7979,7 @@ ${input.slice(result.pos)}
|
|
|
7902
7979
|
special: true
|
|
7903
7980
|
};
|
|
7904
7981
|
});
|
|
7905
|
-
var BinaryOpSymbol$35 = $TS($S($EXPECT($
|
|
7982
|
+
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) {
|
|
7906
7983
|
return {
|
|
7907
7984
|
method: "includes",
|
|
7908
7985
|
relational: true,
|
|
@@ -7911,7 +7988,7 @@ ${input.slice(result.pos)}
|
|
|
7911
7988
|
negated: true
|
|
7912
7989
|
};
|
|
7913
7990
|
});
|
|
7914
|
-
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7991
|
+
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) {
|
|
7915
7992
|
return {
|
|
7916
7993
|
call: [module2.getRef("indexOf"), ".call"],
|
|
7917
7994
|
relational: true,
|
|
@@ -7920,7 +7997,7 @@ ${input.slice(result.pos)}
|
|
|
7920
7997
|
special: true
|
|
7921
7998
|
};
|
|
7922
7999
|
});
|
|
7923
|
-
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($
|
|
8000
|
+
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) {
|
|
7924
8001
|
if (module2.config.objectIs) {
|
|
7925
8002
|
return {
|
|
7926
8003
|
call: module2.getRef("is"),
|
|
@@ -7932,7 +8009,7 @@ ${input.slice(result.pos)}
|
|
|
7932
8009
|
}
|
|
7933
8010
|
return "!==";
|
|
7934
8011
|
});
|
|
7935
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8012
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7936
8013
|
if (module2.config.objectIs) {
|
|
7937
8014
|
return {
|
|
7938
8015
|
call: module2.getRef("is"),
|
|
@@ -7943,12 +8020,12 @@ ${input.slice(result.pos)}
|
|
|
7943
8020
|
}
|
|
7944
8021
|
return "===";
|
|
7945
8022
|
});
|
|
7946
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
8023
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7947
8024
|
return $1;
|
|
7948
8025
|
});
|
|
7949
|
-
var BinaryOpSymbol$40 = $EXPECT($
|
|
7950
|
-
var BinaryOpSymbol$41 = $EXPECT($
|
|
7951
|
-
var BinaryOpSymbol$42 = $EXPECT($
|
|
8026
|
+
var BinaryOpSymbol$40 = $EXPECT($L83, fail, 'BinaryOpSymbol "&"');
|
|
8027
|
+
var BinaryOpSymbol$41 = $EXPECT($L16, fail, 'BinaryOpSymbol "^"');
|
|
8028
|
+
var BinaryOpSymbol$42 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
|
|
7952
8029
|
function BinaryOpSymbol(state) {
|
|
7953
8030
|
let eventData;
|
|
7954
8031
|
if (state.events) {
|
|
@@ -7971,8 +8048,8 @@ ${input.slice(result.pos)}
|
|
|
7971
8048
|
return result;
|
|
7972
8049
|
}
|
|
7973
8050
|
}
|
|
7974
|
-
var Xor$0 = $EXPECT($
|
|
7975
|
-
var Xor$1 = $S($EXPECT($
|
|
8051
|
+
var Xor$0 = $EXPECT($L76, fail, 'Xor "^^"');
|
|
8052
|
+
var Xor$1 = $S($EXPECT($L77, fail, 'Xor "xor"'), NonIdContinue);
|
|
7976
8053
|
function Xor(state) {
|
|
7977
8054
|
let eventData;
|
|
7978
8055
|
if (state.events) {
|
|
@@ -7996,7 +8073,7 @@ ${input.slice(result.pos)}
|
|
|
7996
8073
|
}
|
|
7997
8074
|
}
|
|
7998
8075
|
var Xnor$0 = $R$0($EXPECT($R8, fail, "Xnor /!\\^\\^?/"));
|
|
7999
|
-
var Xnor$1 = $EXPECT($
|
|
8076
|
+
var Xnor$1 = $EXPECT($L78, fail, 'Xnor "xnor"');
|
|
8000
8077
|
function Xnor(state) {
|
|
8001
8078
|
let eventData;
|
|
8002
8079
|
if (state.events) {
|
|
@@ -8217,7 +8294,7 @@ ${input.slice(result.pos)}
|
|
|
8217
8294
|
return result;
|
|
8218
8295
|
}
|
|
8219
8296
|
}
|
|
8220
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8297
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8221
8298
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8222
8299
|
});
|
|
8223
8300
|
function EmptyStatement(state) {
|
|
@@ -8296,7 +8373,7 @@ ${input.slice(result.pos)}
|
|
|
8296
8373
|
var w = $3;
|
|
8297
8374
|
return [id, colon, w];
|
|
8298
8375
|
});
|
|
8299
|
-
var Label$1 = $S($EXPECT($
|
|
8376
|
+
var Label$1 = $S($EXPECT($L86, fail, 'Label "$:"'), Whitespace);
|
|
8300
8377
|
function Label(state) {
|
|
8301
8378
|
let eventData;
|
|
8302
8379
|
if (state.events) {
|
|
@@ -9248,7 +9325,7 @@ ${input.slice(result.pos)}
|
|
|
9248
9325
|
return result;
|
|
9249
9326
|
}
|
|
9250
9327
|
}
|
|
9251
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9328
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L87, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9252
9329
|
var own = $1;
|
|
9253
9330
|
var binding = $2;
|
|
9254
9331
|
return {
|
|
@@ -9511,7 +9588,8 @@ ${input.slice(result.pos)}
|
|
|
9511
9588
|
return {
|
|
9512
9589
|
type: "SwitchExpression",
|
|
9513
9590
|
children: ["(()=>{", e.children, "})()"],
|
|
9514
|
-
|
|
9591
|
+
expression: e.expression,
|
|
9592
|
+
caseBlock: e.caseBlock
|
|
9515
9593
|
};
|
|
9516
9594
|
});
|
|
9517
9595
|
function SwitchExpression(state) {
|
|
@@ -9732,8 +9810,8 @@ ${input.slice(result.pos)}
|
|
|
9732
9810
|
return result;
|
|
9733
9811
|
}
|
|
9734
9812
|
}
|
|
9735
|
-
var ImpliedColon$0 = $S(
|
|
9736
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9813
|
+
var ImpliedColon$0 = $S($E(_), Colon);
|
|
9814
|
+
var ImpliedColon$1 = $TV($EXPECT($L19, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9737
9815
|
return { $loc, token: ":" };
|
|
9738
9816
|
});
|
|
9739
9817
|
function ImpliedColon(state) {
|
|
@@ -9986,7 +10064,7 @@ ${input.slice(result.pos)}
|
|
|
9986
10064
|
return result;
|
|
9987
10065
|
}
|
|
9988
10066
|
}
|
|
9989
|
-
var ForbidIndentedApplication$0 = $TV($EXPECT($
|
|
10067
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L19, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9990
10068
|
module2.forbidIndentedApplication.push(true);
|
|
9991
10069
|
});
|
|
9992
10070
|
function ForbidIndentedApplication(state) {
|
|
@@ -10011,7 +10089,7 @@ ${input.slice(result.pos)}
|
|
|
10011
10089
|
return result;
|
|
10012
10090
|
}
|
|
10013
10091
|
}
|
|
10014
|
-
var AllowIndentedApplication$0 = $TV($EXPECT($
|
|
10092
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L19, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10015
10093
|
module2.forbidIndentedApplication.push(false);
|
|
10016
10094
|
});
|
|
10017
10095
|
function AllowIndentedApplication(state) {
|
|
@@ -10036,7 +10114,7 @@ ${input.slice(result.pos)}
|
|
|
10036
10114
|
return result;
|
|
10037
10115
|
}
|
|
10038
10116
|
}
|
|
10039
|
-
var RestoreIndentedApplication$0 = $TV($EXPECT($
|
|
10117
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L19, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10040
10118
|
module2.forbidIndentedApplication.pop();
|
|
10041
10119
|
});
|
|
10042
10120
|
function RestoreIndentedApplication(state) {
|
|
@@ -10061,7 +10139,7 @@ ${input.slice(result.pos)}
|
|
|
10061
10139
|
return result;
|
|
10062
10140
|
}
|
|
10063
10141
|
}
|
|
10064
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
10142
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L19, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10065
10143
|
if (module2.config.verbose) {
|
|
10066
10144
|
console.log("forbidIndentedApplication:", module2.forbidIndentedApplication);
|
|
10067
10145
|
}
|
|
@@ -10091,7 +10169,7 @@ ${input.slice(result.pos)}
|
|
|
10091
10169
|
return result;
|
|
10092
10170
|
}
|
|
10093
10171
|
}
|
|
10094
|
-
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10172
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10095
10173
|
module2.forbidTrailingMemberProperty.push(true);
|
|
10096
10174
|
});
|
|
10097
10175
|
function ForbidTrailingMemberProperty(state) {
|
|
@@ -10116,7 +10194,7 @@ ${input.slice(result.pos)}
|
|
|
10116
10194
|
return result;
|
|
10117
10195
|
}
|
|
10118
10196
|
}
|
|
10119
|
-
var AllowTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10197
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10120
10198
|
module2.forbidTrailingMemberProperty.push(false);
|
|
10121
10199
|
});
|
|
10122
10200
|
function AllowTrailingMemberProperty(state) {
|
|
@@ -10141,7 +10219,7 @@ ${input.slice(result.pos)}
|
|
|
10141
10219
|
return result;
|
|
10142
10220
|
}
|
|
10143
10221
|
}
|
|
10144
|
-
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10222
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10145
10223
|
module2.forbidTrailingMemberProperty.pop();
|
|
10146
10224
|
});
|
|
10147
10225
|
function RestoreTrailingMemberProperty(state) {
|
|
@@ -10166,7 +10244,7 @@ ${input.slice(result.pos)}
|
|
|
10166
10244
|
return result;
|
|
10167
10245
|
}
|
|
10168
10246
|
}
|
|
10169
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
10247
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L19, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10170
10248
|
if (module2.config.verbose) {
|
|
10171
10249
|
console.log("forbidTrailingMemberProperty:", module2.forbidTrailingMemberProperty);
|
|
10172
10250
|
}
|
|
@@ -10195,7 +10273,7 @@ ${input.slice(result.pos)}
|
|
|
10195
10273
|
return result;
|
|
10196
10274
|
}
|
|
10197
10275
|
}
|
|
10198
|
-
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10276
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10199
10277
|
module2.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10200
10278
|
});
|
|
10201
10279
|
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10220,7 +10298,7 @@ ${input.slice(result.pos)}
|
|
|
10220
10298
|
return result;
|
|
10221
10299
|
}
|
|
10222
10300
|
}
|
|
10223
|
-
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10301
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10224
10302
|
module2.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10225
10303
|
});
|
|
10226
10304
|
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10245,7 +10323,7 @@ ${input.slice(result.pos)}
|
|
|
10245
10323
|
return result;
|
|
10246
10324
|
}
|
|
10247
10325
|
}
|
|
10248
|
-
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10326
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10249
10327
|
module2.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10250
10328
|
});
|
|
10251
10329
|
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10270,7 +10348,7 @@ ${input.slice(result.pos)}
|
|
|
10270
10348
|
return result;
|
|
10271
10349
|
}
|
|
10272
10350
|
}
|
|
10273
|
-
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($
|
|
10351
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L19, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10274
10352
|
if (module2.config.verbose) {
|
|
10275
10353
|
console.log("forbidMultiLineImplicitObjectLiteral:", module2.forbidMultiLineImplicitObjectLiteral);
|
|
10276
10354
|
}
|
|
@@ -10383,8 +10461,9 @@ ${input.slice(result.pos)}
|
|
|
10383
10461
|
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
10384
10462
|
return { "type": "DebuggerStatement", "children": value };
|
|
10385
10463
|
});
|
|
10386
|
-
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
10387
|
-
|
|
10464
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L4, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10465
|
+
var expression = value[2];
|
|
10466
|
+
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10388
10467
|
});
|
|
10389
10468
|
var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
|
|
10390
10469
|
return { "type": "ThrowStatement", "children": value };
|
|
@@ -10411,7 +10490,7 @@ ${input.slice(result.pos)}
|
|
|
10411
10490
|
return result;
|
|
10412
10491
|
}
|
|
10413
10492
|
}
|
|
10414
|
-
var Break$0 = $TS($S($EXPECT($
|
|
10493
|
+
var Break$0 = $TS($S($EXPECT($L88, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10415
10494
|
return { $loc, token: $1 };
|
|
10416
10495
|
});
|
|
10417
10496
|
function Break(state) {
|
|
@@ -10436,7 +10515,7 @@ ${input.slice(result.pos)}
|
|
|
10436
10515
|
return result;
|
|
10437
10516
|
}
|
|
10438
10517
|
}
|
|
10439
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
10518
|
+
var Continue$0 = $TS($S($EXPECT($L89, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10440
10519
|
return { $loc, token: $1 };
|
|
10441
10520
|
});
|
|
10442
10521
|
function Continue(state) {
|
|
@@ -10461,7 +10540,7 @@ ${input.slice(result.pos)}
|
|
|
10461
10540
|
return result;
|
|
10462
10541
|
}
|
|
10463
10542
|
}
|
|
10464
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
10543
|
+
var Debugger$0 = $TS($S($EXPECT($L90, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10465
10544
|
return { $loc, token: $1 };
|
|
10466
10545
|
});
|
|
10467
10546
|
function Debugger(state) {
|
|
@@ -10614,7 +10693,7 @@ ${input.slice(result.pos)}
|
|
|
10614
10693
|
return result;
|
|
10615
10694
|
}
|
|
10616
10695
|
}
|
|
10617
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10696
|
+
var ImpliedImport$0 = $TV($EXPECT($L19, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10618
10697
|
return { $loc, token: "import " };
|
|
10619
10698
|
});
|
|
10620
10699
|
function ImpliedImport(state) {
|
|
@@ -10763,7 +10842,7 @@ ${input.slice(result.pos)}
|
|
|
10763
10842
|
return result;
|
|
10764
10843
|
}
|
|
10765
10844
|
}
|
|
10766
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10845
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L91, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10767
10846
|
function ImportAssertion(state) {
|
|
10768
10847
|
let eventData;
|
|
10769
10848
|
if (state.events) {
|
|
@@ -11367,7 +11446,7 @@ ${input.slice(result.pos)}
|
|
|
11367
11446
|
return result;
|
|
11368
11447
|
}
|
|
11369
11448
|
}
|
|
11370
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11449
|
+
var ConstAssignment$0 = $TV($EXPECT($L92, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
11371
11450
|
return { $loc, token: "=" };
|
|
11372
11451
|
});
|
|
11373
11452
|
function ConstAssignment(state) {
|
|
@@ -11392,7 +11471,7 @@ ${input.slice(result.pos)}
|
|
|
11392
11471
|
return result;
|
|
11393
11472
|
}
|
|
11394
11473
|
}
|
|
11395
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11474
|
+
var LetAssignment$0 = $TV($EXPECT($L93, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
11396
11475
|
return { $loc, token: "=" };
|
|
11397
11476
|
});
|
|
11398
11477
|
function LetAssignment(state) {
|
|
@@ -12090,7 +12169,7 @@ ${input.slice(result.pos)}
|
|
|
12090
12169
|
}
|
|
12091
12170
|
}
|
|
12092
12171
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
12093
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
12172
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
12094
12173
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
12095
12174
|
});
|
|
12096
12175
|
function RegularExpressionLiteral(state) {
|
|
@@ -12657,7 +12736,7 @@ ${input.slice(result.pos)}
|
|
|
12657
12736
|
return result;
|
|
12658
12737
|
}
|
|
12659
12738
|
}
|
|
12660
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12739
|
+
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) {
|
|
12661
12740
|
return { $loc, token: $1 };
|
|
12662
12741
|
});
|
|
12663
12742
|
function JSMultiLineComment(state) {
|
|
@@ -12756,7 +12835,7 @@ ${input.slice(result.pos)}
|
|
|
12756
12835
|
return result;
|
|
12757
12836
|
}
|
|
12758
12837
|
}
|
|
12759
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12838
|
+
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) {
|
|
12760
12839
|
return { $loc, token: $1 };
|
|
12761
12840
|
});
|
|
12762
12841
|
function InlineComment(state) {
|
|
@@ -12855,7 +12934,7 @@ ${input.slice(result.pos)}
|
|
|
12855
12934
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12856
12935
|
return { $loc, token: $0 };
|
|
12857
12936
|
});
|
|
12858
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12937
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L96, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12859
12938
|
return "";
|
|
12860
12939
|
});
|
|
12861
12940
|
function NonNewlineWhitespace(state) {
|
|
@@ -13007,7 +13086,7 @@ ${input.slice(result.pos)}
|
|
|
13007
13086
|
}
|
|
13008
13087
|
}
|
|
13009
13088
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
13010
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13089
|
+
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);
|
|
13011
13090
|
var StatementDelimiter$2 = $Y(EOS);
|
|
13012
13091
|
function StatementDelimiter(state) {
|
|
13013
13092
|
let eventData;
|
|
@@ -13082,7 +13161,7 @@ ${input.slice(result.pos)}
|
|
|
13082
13161
|
return result;
|
|
13083
13162
|
}
|
|
13084
13163
|
}
|
|
13085
|
-
var Loc$0 = $TV($EXPECT($
|
|
13164
|
+
var Loc$0 = $TV($EXPECT($L19, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
13086
13165
|
return { $loc, token: "" };
|
|
13087
13166
|
});
|
|
13088
13167
|
function Loc(state) {
|
|
@@ -13107,7 +13186,7 @@ ${input.slice(result.pos)}
|
|
|
13107
13186
|
return result;
|
|
13108
13187
|
}
|
|
13109
13188
|
}
|
|
13110
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13189
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
13111
13190
|
return { $loc, token: $1, ts: true };
|
|
13112
13191
|
});
|
|
13113
13192
|
function Abstract(state) {
|
|
@@ -13132,7 +13211,7 @@ ${input.slice(result.pos)}
|
|
|
13132
13211
|
return result;
|
|
13133
13212
|
}
|
|
13134
13213
|
}
|
|
13135
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
13214
|
+
var Ampersand$0 = $TV($EXPECT($L83, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
13136
13215
|
return { $loc, token: $1 };
|
|
13137
13216
|
});
|
|
13138
13217
|
function Ampersand(state) {
|
|
@@ -13157,7 +13236,7 @@ ${input.slice(result.pos)}
|
|
|
13157
13236
|
return result;
|
|
13158
13237
|
}
|
|
13159
13238
|
}
|
|
13160
|
-
var As$0 = $TS($S($EXPECT($
|
|
13239
|
+
var As$0 = $TS($S($EXPECT($L100, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13161
13240
|
return { $loc, token: $1 };
|
|
13162
13241
|
});
|
|
13163
13242
|
function As(state) {
|
|
@@ -13182,7 +13261,7 @@ ${input.slice(result.pos)}
|
|
|
13182
13261
|
return result;
|
|
13183
13262
|
}
|
|
13184
13263
|
}
|
|
13185
|
-
var At$0 = $TV($EXPECT($
|
|
13264
|
+
var At$0 = $TV($EXPECT($L101, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
13186
13265
|
return { $loc, token: $1 };
|
|
13187
13266
|
});
|
|
13188
13267
|
function At(state) {
|
|
@@ -13207,7 +13286,7 @@ ${input.slice(result.pos)}
|
|
|
13207
13286
|
return result;
|
|
13208
13287
|
}
|
|
13209
13288
|
}
|
|
13210
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13289
|
+
var AtAt$0 = $TV($EXPECT($L102, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
13211
13290
|
return { $loc, token: "@" };
|
|
13212
13291
|
});
|
|
13213
13292
|
function AtAt(state) {
|
|
@@ -13232,7 +13311,7 @@ ${input.slice(result.pos)}
|
|
|
13232
13311
|
return result;
|
|
13233
13312
|
}
|
|
13234
13313
|
}
|
|
13235
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13314
|
+
var Async$0 = $TS($S($EXPECT($L103, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13236
13315
|
return { $loc, token: $1, type: "Async" };
|
|
13237
13316
|
});
|
|
13238
13317
|
function Async(state) {
|
|
@@ -13257,7 +13336,7 @@ ${input.slice(result.pos)}
|
|
|
13257
13336
|
return result;
|
|
13258
13337
|
}
|
|
13259
13338
|
}
|
|
13260
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13339
|
+
var Await$0 = $TS($S($EXPECT($L104, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13261
13340
|
return { $loc, token: $1 };
|
|
13262
13341
|
});
|
|
13263
13342
|
function Await(state) {
|
|
@@ -13282,7 +13361,7 @@ ${input.slice(result.pos)}
|
|
|
13282
13361
|
return result;
|
|
13283
13362
|
}
|
|
13284
13363
|
}
|
|
13285
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13364
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
13286
13365
|
return { $loc, token: $1 };
|
|
13287
13366
|
});
|
|
13288
13367
|
function Backtick(state) {
|
|
@@ -13307,7 +13386,7 @@ ${input.slice(result.pos)}
|
|
|
13307
13386
|
return result;
|
|
13308
13387
|
}
|
|
13309
13388
|
}
|
|
13310
|
-
var By$0 = $TS($S($EXPECT($
|
|
13389
|
+
var By$0 = $TS($S($EXPECT($L105, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13311
13390
|
return { $loc, token: $1 };
|
|
13312
13391
|
});
|
|
13313
13392
|
function By(state) {
|
|
@@ -13332,7 +13411,7 @@ ${input.slice(result.pos)}
|
|
|
13332
13411
|
return result;
|
|
13333
13412
|
}
|
|
13334
13413
|
}
|
|
13335
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13414
|
+
var Case$0 = $TS($S($EXPECT($L106, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13336
13415
|
return { $loc, token: $1 };
|
|
13337
13416
|
});
|
|
13338
13417
|
function Case(state) {
|
|
@@ -13357,7 +13436,7 @@ ${input.slice(result.pos)}
|
|
|
13357
13436
|
return result;
|
|
13358
13437
|
}
|
|
13359
13438
|
}
|
|
13360
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13439
|
+
var Catch$0 = $TS($S($EXPECT($L107, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13361
13440
|
return { $loc, token: $1 };
|
|
13362
13441
|
});
|
|
13363
13442
|
function Catch(state) {
|
|
@@ -13382,7 +13461,7 @@ ${input.slice(result.pos)}
|
|
|
13382
13461
|
return result;
|
|
13383
13462
|
}
|
|
13384
13463
|
}
|
|
13385
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13464
|
+
var Class$0 = $TS($S($EXPECT($L108, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13386
13465
|
return { $loc, token: $1 };
|
|
13387
13466
|
});
|
|
13388
13467
|
function Class(state) {
|
|
@@ -13407,7 +13486,7 @@ ${input.slice(result.pos)}
|
|
|
13407
13486
|
return result;
|
|
13408
13487
|
}
|
|
13409
13488
|
}
|
|
13410
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
13489
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
13411
13490
|
return { $loc, token: $1 };
|
|
13412
13491
|
});
|
|
13413
13492
|
function CloseBrace(state) {
|
|
@@ -13432,7 +13511,7 @@ ${input.slice(result.pos)}
|
|
|
13432
13511
|
return result;
|
|
13433
13512
|
}
|
|
13434
13513
|
}
|
|
13435
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
13514
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
13436
13515
|
return { $loc, token: $1 };
|
|
13437
13516
|
});
|
|
13438
13517
|
function CloseBracket(state) {
|
|
@@ -13457,7 +13536,7 @@ ${input.slice(result.pos)}
|
|
|
13457
13536
|
return result;
|
|
13458
13537
|
}
|
|
13459
13538
|
}
|
|
13460
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
13539
|
+
var CloseParen$0 = $TV($EXPECT($L33, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
13461
13540
|
return { $loc, token: $1 };
|
|
13462
13541
|
});
|
|
13463
13542
|
function CloseParen(state) {
|
|
@@ -13482,7 +13561,7 @@ ${input.slice(result.pos)}
|
|
|
13482
13561
|
return result;
|
|
13483
13562
|
}
|
|
13484
13563
|
}
|
|
13485
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13564
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L109, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
13486
13565
|
return { $loc, token: "${" };
|
|
13487
13566
|
});
|
|
13488
13567
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13507,7 +13586,7 @@ ${input.slice(result.pos)}
|
|
|
13507
13586
|
return result;
|
|
13508
13587
|
}
|
|
13509
13588
|
}
|
|
13510
|
-
var Colon$0 = $TV($EXPECT($
|
|
13589
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
13511
13590
|
return { $loc, token: $1 };
|
|
13512
13591
|
});
|
|
13513
13592
|
function Colon(state) {
|
|
@@ -13532,7 +13611,7 @@ ${input.slice(result.pos)}
|
|
|
13532
13611
|
return result;
|
|
13533
13612
|
}
|
|
13534
13613
|
}
|
|
13535
|
-
var Comma$0 = $TV($EXPECT($
|
|
13614
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
13536
13615
|
return { $loc, token: $1 };
|
|
13537
13616
|
});
|
|
13538
13617
|
function Comma(state) {
|
|
@@ -13557,7 +13636,7 @@ ${input.slice(result.pos)}
|
|
|
13557
13636
|
return result;
|
|
13558
13637
|
}
|
|
13559
13638
|
}
|
|
13560
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13639
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L101, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13561
13640
|
return { $loc, token: "constructor" };
|
|
13562
13641
|
});
|
|
13563
13642
|
function ConstructorShorthand(state) {
|
|
@@ -13582,7 +13661,7 @@ ${input.slice(result.pos)}
|
|
|
13582
13661
|
return result;
|
|
13583
13662
|
}
|
|
13584
13663
|
}
|
|
13585
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13664
|
+
var Declare$0 = $TS($S($EXPECT($L110, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13586
13665
|
return { $loc, token: $1 };
|
|
13587
13666
|
});
|
|
13588
13667
|
function Declare(state) {
|
|
@@ -13607,7 +13686,7 @@ ${input.slice(result.pos)}
|
|
|
13607
13686
|
return result;
|
|
13608
13687
|
}
|
|
13609
13688
|
}
|
|
13610
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13689
|
+
var Default$0 = $TS($S($EXPECT($L111, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13611
13690
|
return { $loc, token: $1 };
|
|
13612
13691
|
});
|
|
13613
13692
|
function Default(state) {
|
|
@@ -13632,7 +13711,7 @@ ${input.slice(result.pos)}
|
|
|
13632
13711
|
return result;
|
|
13633
13712
|
}
|
|
13634
13713
|
}
|
|
13635
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13714
|
+
var Delete$0 = $TS($S($EXPECT($L112, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13636
13715
|
return { $loc, token: $1 };
|
|
13637
13716
|
});
|
|
13638
13717
|
function Delete(state) {
|
|
@@ -13657,7 +13736,7 @@ ${input.slice(result.pos)}
|
|
|
13657
13736
|
return result;
|
|
13658
13737
|
}
|
|
13659
13738
|
}
|
|
13660
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13739
|
+
var Do$0 = $TS($S($EXPECT($L113, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13661
13740
|
return { $loc, token: $1 };
|
|
13662
13741
|
});
|
|
13663
13742
|
function Do(state) {
|
|
@@ -13707,7 +13786,7 @@ ${input.slice(result.pos)}
|
|
|
13707
13786
|
return result;
|
|
13708
13787
|
}
|
|
13709
13788
|
}
|
|
13710
|
-
var DotDot$0 = $
|
|
13789
|
+
var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L4, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
13711
13790
|
return { $loc, token: $1 };
|
|
13712
13791
|
});
|
|
13713
13792
|
function DotDot(state) {
|
|
@@ -13732,7 +13811,7 @@ ${input.slice(result.pos)}
|
|
|
13732
13811
|
return result;
|
|
13733
13812
|
}
|
|
13734
13813
|
}
|
|
13735
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13814
|
+
var DotDotDot$0 = $TV($EXPECT($L115, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13736
13815
|
return { $loc, token: $1 };
|
|
13737
13816
|
});
|
|
13738
13817
|
function DotDotDot(state) {
|
|
@@ -13757,7 +13836,7 @@ ${input.slice(result.pos)}
|
|
|
13757
13836
|
return result;
|
|
13758
13837
|
}
|
|
13759
13838
|
}
|
|
13760
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13839
|
+
var DoubleColon$0 = $TV($EXPECT($L116, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13761
13840
|
return { $loc, token: $1 };
|
|
13762
13841
|
});
|
|
13763
13842
|
function DoubleColon(state) {
|
|
@@ -13782,7 +13861,7 @@ ${input.slice(result.pos)}
|
|
|
13782
13861
|
return result;
|
|
13783
13862
|
}
|
|
13784
13863
|
}
|
|
13785
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13864
|
+
var DoubleQuote$0 = $TV($EXPECT($L117, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13786
13865
|
return { $loc, token: $1 };
|
|
13787
13866
|
});
|
|
13788
13867
|
function DoubleQuote(state) {
|
|
@@ -13807,7 +13886,7 @@ ${input.slice(result.pos)}
|
|
|
13807
13886
|
return result;
|
|
13808
13887
|
}
|
|
13809
13888
|
}
|
|
13810
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13889
|
+
var Else$0 = $TS($S($EXPECT($L118, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13811
13890
|
return { $loc, token: $1 };
|
|
13812
13891
|
});
|
|
13813
13892
|
function Else(state) {
|
|
@@ -13857,7 +13936,7 @@ ${input.slice(result.pos)}
|
|
|
13857
13936
|
return result;
|
|
13858
13937
|
}
|
|
13859
13938
|
}
|
|
13860
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13939
|
+
var Export$0 = $TS($S($EXPECT($L119, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13861
13940
|
return { $loc, token: $1 };
|
|
13862
13941
|
});
|
|
13863
13942
|
function Export(state) {
|
|
@@ -13882,7 +13961,7 @@ ${input.slice(result.pos)}
|
|
|
13882
13961
|
return result;
|
|
13883
13962
|
}
|
|
13884
13963
|
}
|
|
13885
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13964
|
+
var Extends$0 = $TS($S($EXPECT($L120, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13886
13965
|
return { $loc, token: $1 };
|
|
13887
13966
|
});
|
|
13888
13967
|
function Extends(state) {
|
|
@@ -13907,7 +13986,7 @@ ${input.slice(result.pos)}
|
|
|
13907
13986
|
return result;
|
|
13908
13987
|
}
|
|
13909
13988
|
}
|
|
13910
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13989
|
+
var Finally$0 = $TS($S($EXPECT($L121, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13911
13990
|
return { $loc, token: $1 };
|
|
13912
13991
|
});
|
|
13913
13992
|
function Finally(state) {
|
|
@@ -13932,7 +14011,7 @@ ${input.slice(result.pos)}
|
|
|
13932
14011
|
return result;
|
|
13933
14012
|
}
|
|
13934
14013
|
}
|
|
13935
|
-
var For$0 = $TS($S($EXPECT($
|
|
14014
|
+
var For$0 = $TS($S($EXPECT($L122, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13936
14015
|
return { $loc, token: $1 };
|
|
13937
14016
|
});
|
|
13938
14017
|
function For(state) {
|
|
@@ -13957,7 +14036,7 @@ ${input.slice(result.pos)}
|
|
|
13957
14036
|
return result;
|
|
13958
14037
|
}
|
|
13959
14038
|
}
|
|
13960
|
-
var From$0 = $TS($S($EXPECT($
|
|
14039
|
+
var From$0 = $TS($S($EXPECT($L123, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13961
14040
|
return { $loc, token: $1 };
|
|
13962
14041
|
});
|
|
13963
14042
|
function From(state) {
|
|
@@ -13982,7 +14061,7 @@ ${input.slice(result.pos)}
|
|
|
13982
14061
|
return result;
|
|
13983
14062
|
}
|
|
13984
14063
|
}
|
|
13985
|
-
var Function$0 = $TS($S($EXPECT($
|
|
14064
|
+
var Function$0 = $TS($S($EXPECT($L124, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13986
14065
|
return { $loc, token: $1 };
|
|
13987
14066
|
});
|
|
13988
14067
|
function Function(state) {
|
|
@@ -14007,7 +14086,7 @@ ${input.slice(result.pos)}
|
|
|
14007
14086
|
return result;
|
|
14008
14087
|
}
|
|
14009
14088
|
}
|
|
14010
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14089
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L125, fail, 'GetOrSet "get"'), $EXPECT($L126, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14011
14090
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
14012
14091
|
});
|
|
14013
14092
|
function GetOrSet(state) {
|
|
@@ -14032,7 +14111,7 @@ ${input.slice(result.pos)}
|
|
|
14032
14111
|
return result;
|
|
14033
14112
|
}
|
|
14034
14113
|
}
|
|
14035
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14114
|
+
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
14036
14115
|
return { $loc, token: $1 };
|
|
14037
14116
|
});
|
|
14038
14117
|
function If(state) {
|
|
@@ -14082,7 +14161,7 @@ ${input.slice(result.pos)}
|
|
|
14082
14161
|
return result;
|
|
14083
14162
|
}
|
|
14084
14163
|
}
|
|
14085
|
-
var In$0 = $TS($S($EXPECT($
|
|
14164
|
+
var In$0 = $TS($S($EXPECT($L81, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14086
14165
|
return { $loc, token: $1 };
|
|
14087
14166
|
});
|
|
14088
14167
|
function In(state) {
|
|
@@ -14107,7 +14186,7 @@ ${input.slice(result.pos)}
|
|
|
14107
14186
|
return result;
|
|
14108
14187
|
}
|
|
14109
14188
|
}
|
|
14110
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14189
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L128, fail, 'LetOrConst "let"'), $EXPECT($L129, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14111
14190
|
return { $loc, token: $1 };
|
|
14112
14191
|
});
|
|
14113
14192
|
function LetOrConst(state) {
|
|
@@ -14132,7 +14211,7 @@ ${input.slice(result.pos)}
|
|
|
14132
14211
|
return result;
|
|
14133
14212
|
}
|
|
14134
14213
|
}
|
|
14135
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14214
|
+
var Loop$0 = $TS($S($EXPECT($L130, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14136
14215
|
return { $loc, token: "while(true)" };
|
|
14137
14216
|
});
|
|
14138
14217
|
function Loop(state) {
|
|
@@ -14157,7 +14236,7 @@ ${input.slice(result.pos)}
|
|
|
14157
14236
|
return result;
|
|
14158
14237
|
}
|
|
14159
14238
|
}
|
|
14160
|
-
var New$0 = $TS($S($EXPECT($
|
|
14239
|
+
var New$0 = $TS($S($EXPECT($L131, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14161
14240
|
return { $loc, token: $1 };
|
|
14162
14241
|
});
|
|
14163
14242
|
function New(state) {
|
|
@@ -14182,7 +14261,7 @@ ${input.slice(result.pos)}
|
|
|
14182
14261
|
return result;
|
|
14183
14262
|
}
|
|
14184
14263
|
}
|
|
14185
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
14264
|
+
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) {
|
|
14186
14265
|
return { $loc, token: "!" };
|
|
14187
14266
|
});
|
|
14188
14267
|
function Not(state) {
|
|
@@ -14207,7 +14286,7 @@ ${input.slice(result.pos)}
|
|
|
14207
14286
|
return result;
|
|
14208
14287
|
}
|
|
14209
14288
|
}
|
|
14210
|
-
var Of$0 = $TS($S($EXPECT($
|
|
14289
|
+
var Of$0 = $TS($S($EXPECT($L73, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14211
14290
|
return { $loc, token: $1 };
|
|
14212
14291
|
});
|
|
14213
14292
|
function Of(state) {
|
|
@@ -14232,7 +14311,7 @@ ${input.slice(result.pos)}
|
|
|
14232
14311
|
return result;
|
|
14233
14312
|
}
|
|
14234
14313
|
}
|
|
14235
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14314
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L132, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
14236
14315
|
return { $loc, token: $1 };
|
|
14237
14316
|
});
|
|
14238
14317
|
function OpenAngleBracket(state) {
|
|
@@ -14257,7 +14336,7 @@ ${input.slice(result.pos)}
|
|
|
14257
14336
|
return result;
|
|
14258
14337
|
}
|
|
14259
14338
|
}
|
|
14260
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14339
|
+
var OpenBrace$0 = $TV($EXPECT($L133, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
14261
14340
|
return { $loc, token: $1 };
|
|
14262
14341
|
});
|
|
14263
14342
|
function OpenBrace(state) {
|
|
@@ -14282,7 +14361,7 @@ ${input.slice(result.pos)}
|
|
|
14282
14361
|
return result;
|
|
14283
14362
|
}
|
|
14284
14363
|
}
|
|
14285
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14364
|
+
var OpenBracket$0 = $TV($EXPECT($L97, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
14286
14365
|
return { $loc, token: $1 };
|
|
14287
14366
|
});
|
|
14288
14367
|
function OpenBracket(state) {
|
|
@@ -14332,7 +14411,7 @@ ${input.slice(result.pos)}
|
|
|
14332
14411
|
return result;
|
|
14333
14412
|
}
|
|
14334
14413
|
}
|
|
14335
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14414
|
+
var Operator$0 = $TS($S($EXPECT($L134, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14336
14415
|
return { $loc, token: $1 };
|
|
14337
14416
|
});
|
|
14338
14417
|
function Operator(state) {
|
|
@@ -14357,7 +14436,7 @@ ${input.slice(result.pos)}
|
|
|
14357
14436
|
return result;
|
|
14358
14437
|
}
|
|
14359
14438
|
}
|
|
14360
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14439
|
+
var Public$0 = $TS($S($EXPECT($L135, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14361
14440
|
return { $loc, token: $1 };
|
|
14362
14441
|
});
|
|
14363
14442
|
function Public(state) {
|
|
@@ -14382,7 +14461,7 @@ ${input.slice(result.pos)}
|
|
|
14382
14461
|
return result;
|
|
14383
14462
|
}
|
|
14384
14463
|
}
|
|
14385
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14464
|
+
var Private$0 = $TS($S($EXPECT($L136, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14386
14465
|
return { $loc, token: $1 };
|
|
14387
14466
|
});
|
|
14388
14467
|
function Private(state) {
|
|
@@ -14407,7 +14486,7 @@ ${input.slice(result.pos)}
|
|
|
14407
14486
|
return result;
|
|
14408
14487
|
}
|
|
14409
14488
|
}
|
|
14410
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14489
|
+
var Protected$0 = $TS($S($EXPECT($L137, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14411
14490
|
return { $loc, token: $1 };
|
|
14412
14491
|
});
|
|
14413
14492
|
function Protected(state) {
|
|
@@ -14432,13 +14511,13 @@ ${input.slice(result.pos)}
|
|
|
14432
14511
|
return result;
|
|
14433
14512
|
}
|
|
14434
14513
|
}
|
|
14435
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14514
|
+
var Pipe$0 = $TV($EXPECT($L138, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
14436
14515
|
return { $loc, token: $1 };
|
|
14437
14516
|
});
|
|
14438
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14517
|
+
var Pipe$1 = $TV($EXPECT($L139, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
14439
14518
|
return { $loc, token: $1 };
|
|
14440
14519
|
});
|
|
14441
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14520
|
+
var Pipe$2 = $TV($EXPECT($L140, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
14442
14521
|
return { $loc, token: $1 };
|
|
14443
14522
|
});
|
|
14444
14523
|
function Pipe(state) {
|
|
@@ -14488,7 +14567,7 @@ ${input.slice(result.pos)}
|
|
|
14488
14567
|
return result;
|
|
14489
14568
|
}
|
|
14490
14569
|
}
|
|
14491
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14570
|
+
var Readonly$0 = $TS($S($EXPECT($L141, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14492
14571
|
return { $loc, token: $1, ts: true };
|
|
14493
14572
|
});
|
|
14494
14573
|
function Readonly(state) {
|
|
@@ -14513,7 +14592,7 @@ ${input.slice(result.pos)}
|
|
|
14513
14592
|
return result;
|
|
14514
14593
|
}
|
|
14515
14594
|
}
|
|
14516
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14595
|
+
var Return$0 = $TS($S($EXPECT($L142, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14517
14596
|
return { $loc, token: $1 };
|
|
14518
14597
|
});
|
|
14519
14598
|
function Return(state) {
|
|
@@ -14538,7 +14617,7 @@ ${input.slice(result.pos)}
|
|
|
14538
14617
|
return result;
|
|
14539
14618
|
}
|
|
14540
14619
|
}
|
|
14541
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14620
|
+
var Satisfies$0 = $TS($S($EXPECT($L143, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14542
14621
|
return { $loc, token: $1 };
|
|
14543
14622
|
});
|
|
14544
14623
|
function Satisfies(state) {
|
|
@@ -14563,7 +14642,7 @@ ${input.slice(result.pos)}
|
|
|
14563
14642
|
return result;
|
|
14564
14643
|
}
|
|
14565
14644
|
}
|
|
14566
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14645
|
+
var Semicolon$0 = $TV($EXPECT($L85, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
14567
14646
|
return { $loc, token: $1 };
|
|
14568
14647
|
});
|
|
14569
14648
|
function Semicolon(state) {
|
|
@@ -14588,7 +14667,7 @@ ${input.slice(result.pos)}
|
|
|
14588
14667
|
return result;
|
|
14589
14668
|
}
|
|
14590
14669
|
}
|
|
14591
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14670
|
+
var SingleQuote$0 = $TV($EXPECT($L144, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14592
14671
|
return { $loc, token: $1 };
|
|
14593
14672
|
});
|
|
14594
14673
|
function SingleQuote(state) {
|
|
@@ -14613,7 +14692,7 @@ ${input.slice(result.pos)}
|
|
|
14613
14692
|
return result;
|
|
14614
14693
|
}
|
|
14615
14694
|
}
|
|
14616
|
-
var Star$0 = $TV($EXPECT($
|
|
14695
|
+
var Star$0 = $TV($EXPECT($L54, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14617
14696
|
return { $loc, token: $1 };
|
|
14618
14697
|
});
|
|
14619
14698
|
function Star(state) {
|
|
@@ -14638,10 +14717,10 @@ ${input.slice(result.pos)}
|
|
|
14638
14717
|
return result;
|
|
14639
14718
|
}
|
|
14640
14719
|
}
|
|
14641
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14720
|
+
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14642
14721
|
return { $loc, token: $1 };
|
|
14643
14722
|
});
|
|
14644
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14723
|
+
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) {
|
|
14645
14724
|
return { $loc, token: "static " };
|
|
14646
14725
|
});
|
|
14647
14726
|
function Static(state) {
|
|
@@ -14666,7 +14745,7 @@ ${input.slice(result.pos)}
|
|
|
14666
14745
|
return result;
|
|
14667
14746
|
}
|
|
14668
14747
|
}
|
|
14669
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14748
|
+
var SubstitutionStart$0 = $TV($EXPECT($L146, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14670
14749
|
return { $loc, token: $1 };
|
|
14671
14750
|
});
|
|
14672
14751
|
function SubstitutionStart(state) {
|
|
@@ -14691,7 +14770,7 @@ ${input.slice(result.pos)}
|
|
|
14691
14770
|
return result;
|
|
14692
14771
|
}
|
|
14693
14772
|
}
|
|
14694
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14773
|
+
var Switch$0 = $TS($S($EXPECT($L147, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14695
14774
|
return { $loc, token: $1 };
|
|
14696
14775
|
});
|
|
14697
14776
|
function Switch(state) {
|
|
@@ -14716,7 +14795,7 @@ ${input.slice(result.pos)}
|
|
|
14716
14795
|
return result;
|
|
14717
14796
|
}
|
|
14718
14797
|
}
|
|
14719
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14798
|
+
var Target$0 = $TS($S($EXPECT($L148, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14720
14799
|
return { $loc, token: $1 };
|
|
14721
14800
|
});
|
|
14722
14801
|
function Target(state) {
|
|
@@ -14741,7 +14820,7 @@ ${input.slice(result.pos)}
|
|
|
14741
14820
|
return result;
|
|
14742
14821
|
}
|
|
14743
14822
|
}
|
|
14744
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14823
|
+
var Then$0 = $TS($S(__, $EXPECT($L149, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14745
14824
|
return { $loc, token: "" };
|
|
14746
14825
|
});
|
|
14747
14826
|
function Then(state) {
|
|
@@ -14766,7 +14845,7 @@ ${input.slice(result.pos)}
|
|
|
14766
14845
|
return result;
|
|
14767
14846
|
}
|
|
14768
14847
|
}
|
|
14769
|
-
var This$0 = $TS($S($EXPECT($
|
|
14848
|
+
var This$0 = $TS($S($EXPECT($L150, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14770
14849
|
return { $loc, token: $1 };
|
|
14771
14850
|
});
|
|
14772
14851
|
function This(state) {
|
|
@@ -14791,7 +14870,7 @@ ${input.slice(result.pos)}
|
|
|
14791
14870
|
return result;
|
|
14792
14871
|
}
|
|
14793
14872
|
}
|
|
14794
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14873
|
+
var Throw$0 = $TS($S($EXPECT($L151, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14795
14874
|
return { $loc, token: $1 };
|
|
14796
14875
|
});
|
|
14797
14876
|
function Throw(state) {
|
|
@@ -14816,7 +14895,7 @@ ${input.slice(result.pos)}
|
|
|
14816
14895
|
return result;
|
|
14817
14896
|
}
|
|
14818
14897
|
}
|
|
14819
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14898
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L152, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14820
14899
|
return { $loc, token: "`" };
|
|
14821
14900
|
});
|
|
14822
14901
|
function TripleDoubleQuote(state) {
|
|
@@ -14841,7 +14920,7 @@ ${input.slice(result.pos)}
|
|
|
14841
14920
|
return result;
|
|
14842
14921
|
}
|
|
14843
14922
|
}
|
|
14844
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14923
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L153, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14845
14924
|
return { $loc, token: "`" };
|
|
14846
14925
|
});
|
|
14847
14926
|
function TripleSingleQuote(state) {
|
|
@@ -14866,7 +14945,7 @@ ${input.slice(result.pos)}
|
|
|
14866
14945
|
return result;
|
|
14867
14946
|
}
|
|
14868
14947
|
}
|
|
14869
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14948
|
+
var TripleSlash$0 = $TV($EXPECT($L154, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14870
14949
|
return { $loc, token: "/" };
|
|
14871
14950
|
});
|
|
14872
14951
|
function TripleSlash(state) {
|
|
@@ -14891,7 +14970,7 @@ ${input.slice(result.pos)}
|
|
|
14891
14970
|
return result;
|
|
14892
14971
|
}
|
|
14893
14972
|
}
|
|
14894
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14973
|
+
var TripleTick$0 = $TV($EXPECT($L155, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14895
14974
|
return { $loc, token: "`" };
|
|
14896
14975
|
});
|
|
14897
14976
|
function TripleTick(state) {
|
|
@@ -14916,7 +14995,7 @@ ${input.slice(result.pos)}
|
|
|
14916
14995
|
return result;
|
|
14917
14996
|
}
|
|
14918
14997
|
}
|
|
14919
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14998
|
+
var Try$0 = $TS($S($EXPECT($L156, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14920
14999
|
return { $loc, token: $1 };
|
|
14921
15000
|
});
|
|
14922
15001
|
function Try(state) {
|
|
@@ -14941,7 +15020,7 @@ ${input.slice(result.pos)}
|
|
|
14941
15020
|
return result;
|
|
14942
15021
|
}
|
|
14943
15022
|
}
|
|
14944
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
15023
|
+
var Typeof$0 = $TS($S($EXPECT($L157, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14945
15024
|
return { $loc, token: $1 };
|
|
14946
15025
|
});
|
|
14947
15026
|
function Typeof(state) {
|
|
@@ -14966,7 +15045,7 @@ ${input.slice(result.pos)}
|
|
|
14966
15045
|
return result;
|
|
14967
15046
|
}
|
|
14968
15047
|
}
|
|
14969
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
15048
|
+
var Unless$0 = $TS($S($EXPECT($L158, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14970
15049
|
return { $loc, token: $1 };
|
|
14971
15050
|
});
|
|
14972
15051
|
function Unless(state) {
|
|
@@ -14991,7 +15070,7 @@ ${input.slice(result.pos)}
|
|
|
14991
15070
|
return result;
|
|
14992
15071
|
}
|
|
14993
15072
|
}
|
|
14994
|
-
var Until$0 = $TS($S($EXPECT($
|
|
15073
|
+
var Until$0 = $TS($S($EXPECT($L159, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14995
15074
|
return { $loc, token: $1 };
|
|
14996
15075
|
});
|
|
14997
15076
|
function Until(state) {
|
|
@@ -15016,7 +15095,7 @@ ${input.slice(result.pos)}
|
|
|
15016
15095
|
return result;
|
|
15017
15096
|
}
|
|
15018
15097
|
}
|
|
15019
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15098
|
+
var Var$0 = $TS($S($EXPECT($L160, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15020
15099
|
return { $loc, token: $1 };
|
|
15021
15100
|
});
|
|
15022
15101
|
function Var(state) {
|
|
@@ -15041,7 +15120,7 @@ ${input.slice(result.pos)}
|
|
|
15041
15120
|
return result;
|
|
15042
15121
|
}
|
|
15043
15122
|
}
|
|
15044
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15123
|
+
var Void$0 = $TS($S($EXPECT($L161, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15045
15124
|
return { $loc, token: $1 };
|
|
15046
15125
|
});
|
|
15047
15126
|
function Void(state) {
|
|
@@ -15066,7 +15145,7 @@ ${input.slice(result.pos)}
|
|
|
15066
15145
|
return result;
|
|
15067
15146
|
}
|
|
15068
15147
|
}
|
|
15069
|
-
var When$0 = $TS($S($EXPECT($
|
|
15148
|
+
var When$0 = $TS($S($EXPECT($L162, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15070
15149
|
return { $loc, token: "case" };
|
|
15071
15150
|
});
|
|
15072
15151
|
function When(state) {
|
|
@@ -15091,7 +15170,7 @@ ${input.slice(result.pos)}
|
|
|
15091
15170
|
return result;
|
|
15092
15171
|
}
|
|
15093
15172
|
}
|
|
15094
|
-
var While$0 = $TS($S($EXPECT($
|
|
15173
|
+
var While$0 = $TS($S($EXPECT($L163, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15095
15174
|
return { $loc, token: $1 };
|
|
15096
15175
|
});
|
|
15097
15176
|
function While(state) {
|
|
@@ -15116,7 +15195,7 @@ ${input.slice(result.pos)}
|
|
|
15116
15195
|
return result;
|
|
15117
15196
|
}
|
|
15118
15197
|
}
|
|
15119
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15198
|
+
var Yield$0 = $TS($S($EXPECT($L164, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15120
15199
|
return { $loc, token: $1 };
|
|
15121
15200
|
});
|
|
15122
15201
|
function Yield(state) {
|
|
@@ -15261,7 +15340,7 @@ ${input.slice(result.pos)}
|
|
|
15261
15340
|
return result;
|
|
15262
15341
|
}
|
|
15263
15342
|
}
|
|
15264
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15343
|
+
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) {
|
|
15265
15344
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
15266
15345
|
});
|
|
15267
15346
|
function JSXSelfClosingElement(state) {
|
|
@@ -15312,7 +15391,7 @@ ${input.slice(result.pos)}
|
|
|
15312
15391
|
return result;
|
|
15313
15392
|
}
|
|
15314
15393
|
}
|
|
15315
|
-
var PopJSXStack$0 = $TV($EXPECT($
|
|
15394
|
+
var PopJSXStack$0 = $TV($EXPECT($L19, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15316
15395
|
module2.JSXTagStack.pop();
|
|
15317
15396
|
});
|
|
15318
15397
|
function PopJSXStack(state) {
|
|
@@ -15337,7 +15416,7 @@ ${input.slice(result.pos)}
|
|
|
15337
15416
|
return result;
|
|
15338
15417
|
}
|
|
15339
15418
|
}
|
|
15340
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
15419
|
+
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
15341
15420
|
function JSXOpeningElement(state) {
|
|
15342
15421
|
let eventData;
|
|
15343
15422
|
if (state.events) {
|
|
@@ -15366,7 +15445,7 @@ ${input.slice(result.pos)}
|
|
|
15366
15445
|
return $skip;
|
|
15367
15446
|
return $0;
|
|
15368
15447
|
});
|
|
15369
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
15448
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L19, fail, 'JSXOptionalClosingElement ""');
|
|
15370
15449
|
function JSXOptionalClosingElement(state) {
|
|
15371
15450
|
let eventData;
|
|
15372
15451
|
if (state.events) {
|
|
@@ -15389,7 +15468,7 @@ ${input.slice(result.pos)}
|
|
|
15389
15468
|
return result;
|
|
15390
15469
|
}
|
|
15391
15470
|
}
|
|
15392
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15471
|
+
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
15393
15472
|
function JSXClosingElement(state) {
|
|
15394
15473
|
let eventData;
|
|
15395
15474
|
if (state.events) {
|
|
@@ -15427,7 +15506,7 @@ ${input.slice(result.pos)}
|
|
|
15427
15506
|
];
|
|
15428
15507
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
15429
15508
|
});
|
|
15430
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15509
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L167, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
15431
15510
|
var children = $3;
|
|
15432
15511
|
$0 = $0.slice(1);
|
|
15433
15512
|
return {
|
|
@@ -15458,7 +15537,7 @@ ${input.slice(result.pos)}
|
|
|
15458
15537
|
return result;
|
|
15459
15538
|
}
|
|
15460
15539
|
}
|
|
15461
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15540
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L167, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
15462
15541
|
module2.JSXTagStack.push("");
|
|
15463
15542
|
return $1;
|
|
15464
15543
|
});
|
|
@@ -15489,7 +15568,7 @@ ${input.slice(result.pos)}
|
|
|
15489
15568
|
return $skip;
|
|
15490
15569
|
return $0;
|
|
15491
15570
|
});
|
|
15492
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
15571
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L19, fail, 'JSXOptionalClosingFragment ""');
|
|
15493
15572
|
function JSXOptionalClosingFragment(state) {
|
|
15494
15573
|
let eventData;
|
|
15495
15574
|
if (state.events) {
|
|
@@ -15512,7 +15591,7 @@ ${input.slice(result.pos)}
|
|
|
15512
15591
|
return result;
|
|
15513
15592
|
}
|
|
15514
15593
|
}
|
|
15515
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15594
|
+
var JSXClosingFragment$0 = $EXPECT($L168, fail, 'JSXClosingFragment "</>"');
|
|
15516
15595
|
function JSXClosingFragment(state) {
|
|
15517
15596
|
let eventData;
|
|
15518
15597
|
if (state.events) {
|
|
@@ -16279,7 +16358,7 @@ ${input.slice(result.pos)}
|
|
|
16279
16358
|
}
|
|
16280
16359
|
return $skip;
|
|
16281
16360
|
});
|
|
16282
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
16361
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
16283
16362
|
return { children: [], jsxChildren: [] };
|
|
16284
16363
|
});
|
|
16285
16364
|
function JSXNestedChildren(state) {
|
|
@@ -16408,7 +16487,7 @@ ${input.slice(result.pos)}
|
|
|
16408
16487
|
return result;
|
|
16409
16488
|
}
|
|
16410
16489
|
}
|
|
16411
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16490
|
+
var JSXComment$0 = $TS($S($EXPECT($L169, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L170, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16412
16491
|
return ["{/*", $2, "*/}"];
|
|
16413
16492
|
});
|
|
16414
16493
|
function JSXComment(state) {
|
|
@@ -16706,7 +16785,7 @@ ${input.slice(result.pos)}
|
|
|
16706
16785
|
return result;
|
|
16707
16786
|
}
|
|
16708
16787
|
}
|
|
16709
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16788
|
+
var TypeKeyword$0 = $S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16710
16789
|
function TypeKeyword(state) {
|
|
16711
16790
|
let eventData;
|
|
16712
16791
|
if (state.events) {
|
|
@@ -16729,7 +16808,7 @@ ${input.slice(result.pos)}
|
|
|
16729
16808
|
return result;
|
|
16730
16809
|
}
|
|
16731
16810
|
}
|
|
16732
|
-
var Interface$0 = $S($EXPECT($
|
|
16811
|
+
var Interface$0 = $S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue);
|
|
16733
16812
|
function Interface(state) {
|
|
16734
16813
|
let eventData;
|
|
16735
16814
|
if (state.events) {
|
|
@@ -16752,7 +16831,7 @@ ${input.slice(result.pos)}
|
|
|
16752
16831
|
return result;
|
|
16753
16832
|
}
|
|
16754
16833
|
}
|
|
16755
|
-
var Namespace$0 = $S($EXPECT($
|
|
16834
|
+
var Namespace$0 = $S($EXPECT($L173, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16756
16835
|
function Namespace(state) {
|
|
16757
16836
|
let eventData;
|
|
16758
16837
|
if (state.events) {
|
|
@@ -17000,7 +17079,7 @@ ${input.slice(result.pos)}
|
|
|
17000
17079
|
return result;
|
|
17001
17080
|
}
|
|
17002
17081
|
}
|
|
17003
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
17082
|
+
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)));
|
|
17004
17083
|
function TypeIndexSignature(state) {
|
|
17005
17084
|
let eventData;
|
|
17006
17085
|
if (state.events) {
|
|
@@ -17047,7 +17126,7 @@ ${input.slice(result.pos)}
|
|
|
17047
17126
|
return result;
|
|
17048
17127
|
}
|
|
17049
17128
|
}
|
|
17050
|
-
var TypeSuffix$0 = $T($S($E(QuestionMark),
|
|
17129
|
+
var TypeSuffix$0 = $T($S($E(QuestionMark), $E(_), Colon, Type), function(value) {
|
|
17051
17130
|
return { "type": "TypeSuffix", "ts": true, "children": value };
|
|
17052
17131
|
});
|
|
17053
17132
|
function TypeSuffix(state) {
|
|
@@ -17072,14 +17151,20 @@ ${input.slice(result.pos)}
|
|
|
17072
17151
|
return result;
|
|
17073
17152
|
}
|
|
17074
17153
|
}
|
|
17075
|
-
var ReturnTypeSuffix$0 = $TS($S(
|
|
17076
|
-
|
|
17077
|
-
|
|
17078
|
-
|
|
17079
|
-
|
|
17154
|
+
var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L174, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17155
|
+
var asserts = $3;
|
|
17156
|
+
var t = $4;
|
|
17157
|
+
if (asserts) {
|
|
17158
|
+
t = {
|
|
17159
|
+
type: "AssertsType",
|
|
17160
|
+
t,
|
|
17161
|
+
children: [asserts[0], asserts[1], t]
|
|
17162
|
+
};
|
|
17163
|
+
}
|
|
17080
17164
|
return {
|
|
17081
17165
|
type: "ReturnTypeAnnotation",
|
|
17082
|
-
children,
|
|
17166
|
+
children: [$1, $2, t],
|
|
17167
|
+
t,
|
|
17083
17168
|
ts: true
|
|
17084
17169
|
};
|
|
17085
17170
|
});
|
|
@@ -17105,10 +17190,17 @@ ${input.slice(result.pos)}
|
|
|
17105
17190
|
return result;
|
|
17106
17191
|
}
|
|
17107
17192
|
}
|
|
17108
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
17109
|
-
|
|
17110
|
-
|
|
17111
|
-
|
|
17193
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L82, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
17194
|
+
var lhs = $1;
|
|
17195
|
+
var rhs = $2;
|
|
17196
|
+
if (!rhs)
|
|
17197
|
+
return lhs;
|
|
17198
|
+
return {
|
|
17199
|
+
type: "TypePredicate",
|
|
17200
|
+
lhs,
|
|
17201
|
+
rhs: rhs[3],
|
|
17202
|
+
children: [lhs, ...rhs]
|
|
17203
|
+
};
|
|
17112
17204
|
});
|
|
17113
17205
|
function TypePredicate(state) {
|
|
17114
17206
|
let eventData;
|
|
@@ -17183,6 +17275,8 @@ ${input.slice(result.pos)}
|
|
|
17183
17275
|
}
|
|
17184
17276
|
}
|
|
17185
17277
|
var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
17278
|
+
if (!$1.length && !$3.length)
|
|
17279
|
+
return $2;
|
|
17186
17280
|
return [...$1, $2, ...$3];
|
|
17187
17281
|
});
|
|
17188
17282
|
function TypeUnary(state) {
|
|
@@ -17231,10 +17325,10 @@ ${input.slice(result.pos)}
|
|
|
17231
17325
|
return result;
|
|
17232
17326
|
}
|
|
17233
17327
|
}
|
|
17234
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
17235
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
17236
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
17237
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17328
|
+
var TypeUnaryOp$0 = $S($EXPECT($L175, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17329
|
+
var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17330
|
+
var TypeUnaryOp$2 = $S($EXPECT($L176, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17331
|
+
var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
17238
17332
|
function TypeUnaryOp(state) {
|
|
17239
17333
|
let eventData;
|
|
17240
17334
|
if (state.events) {
|
|
@@ -17285,8 +17379,23 @@ ${input.slice(result.pos)}
|
|
|
17285
17379
|
var TypePrimary$2 = $S($E(_), InlineInterfaceLiteral);
|
|
17286
17380
|
var TypePrimary$3 = $S($E(_), TypeTuple);
|
|
17287
17381
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
17288
|
-
var TypePrimary$5 = $S($E(_), TypeLiteral)
|
|
17289
|
-
|
|
17382
|
+
var TypePrimary$5 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
|
|
17383
|
+
var t = $2;
|
|
17384
|
+
return {
|
|
17385
|
+
type: "LiteralType",
|
|
17386
|
+
t,
|
|
17387
|
+
children: $0
|
|
17388
|
+
};
|
|
17389
|
+
});
|
|
17390
|
+
var TypePrimary$6 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17391
|
+
var args = $4;
|
|
17392
|
+
return {
|
|
17393
|
+
type: "IdentifierType",
|
|
17394
|
+
children: $0,
|
|
17395
|
+
raw: [$2.name, ...$3.map(([dot, id]) => dot.token + id.name)].join(""),
|
|
17396
|
+
args
|
|
17397
|
+
};
|
|
17398
|
+
});
|
|
17290
17399
|
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
17291
17400
|
function TypePrimary(state) {
|
|
17292
17401
|
let eventData;
|
|
@@ -17432,7 +17541,7 @@ ${input.slice(result.pos)}
|
|
|
17432
17541
|
return result;
|
|
17433
17542
|
}
|
|
17434
17543
|
}
|
|
17435
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17544
|
+
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) {
|
|
17436
17545
|
if ($2)
|
|
17437
17546
|
return $0;
|
|
17438
17547
|
return $1;
|
|
@@ -17461,10 +17570,10 @@ ${input.slice(result.pos)}
|
|
|
17461
17570
|
}
|
|
17462
17571
|
var TypeLiteral$0 = TemplateLiteral;
|
|
17463
17572
|
var TypeLiteral$1 = Literal;
|
|
17464
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17465
|
-
return { $loc, token:
|
|
17573
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
17574
|
+
return { type: "VoidType", $loc, token: $1 };
|
|
17466
17575
|
});
|
|
17467
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17576
|
+
var TypeLiteral$3 = $TV($EXPECT($L177, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
17468
17577
|
return { $loc, token: "[]" };
|
|
17469
17578
|
});
|
|
17470
17579
|
function TypeLiteral(state) {
|
|
@@ -17539,7 +17648,7 @@ ${input.slice(result.pos)}
|
|
|
17539
17648
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
17540
17649
|
return value[1];
|
|
17541
17650
|
});
|
|
17542
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17651
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L33, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
17543
17652
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
17544
17653
|
function InlineInterfacePropertyDelimiter(state) {
|
|
17545
17654
|
let eventData;
|
|
@@ -17563,10 +17672,10 @@ ${input.slice(result.pos)}
|
|
|
17563
17672
|
return result;
|
|
17564
17673
|
}
|
|
17565
17674
|
}
|
|
17566
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17675
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L84, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
17567
17676
|
return { $loc, token: "|" };
|
|
17568
17677
|
});
|
|
17569
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17678
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
17570
17679
|
return { $loc, token: "&" };
|
|
17571
17680
|
});
|
|
17572
17681
|
function TypeBinaryOp(state) {
|
|
@@ -17623,7 +17732,7 @@ ${input.slice(result.pos)}
|
|
|
17623
17732
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17624
17733
|
return { $loc, token: "=>" };
|
|
17625
17734
|
});
|
|
17626
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17735
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17627
17736
|
return { $loc, token: "=>" };
|
|
17628
17737
|
});
|
|
17629
17738
|
function TypeArrowFunction(state) {
|
|
@@ -17648,7 +17757,7 @@ ${input.slice(result.pos)}
|
|
|
17648
17757
|
return result;
|
|
17649
17758
|
}
|
|
17650
17759
|
}
|
|
17651
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17760
|
+
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17652
17761
|
return { ts: true, children: $0 };
|
|
17653
17762
|
});
|
|
17654
17763
|
function TypeArguments(state) {
|
|
@@ -17719,7 +17828,7 @@ ${input.slice(result.pos)}
|
|
|
17719
17828
|
return result;
|
|
17720
17829
|
}
|
|
17721
17830
|
}
|
|
17722
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17831
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L132, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17723
17832
|
var parameters = $3;
|
|
17724
17833
|
return {
|
|
17725
17834
|
type: "TypeParameters",
|
|
@@ -17773,7 +17882,7 @@ ${input.slice(result.pos)}
|
|
|
17773
17882
|
return result;
|
|
17774
17883
|
}
|
|
17775
17884
|
}
|
|
17776
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17885
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L120, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17777
17886
|
function TypeConstraint(state) {
|
|
17778
17887
|
let eventData;
|
|
17779
17888
|
if (state.events) {
|
|
@@ -17820,7 +17929,7 @@ ${input.slice(result.pos)}
|
|
|
17820
17929
|
}
|
|
17821
17930
|
}
|
|
17822
17931
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17823
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17932
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17824
17933
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17825
17934
|
return value[1];
|
|
17826
17935
|
});
|
|
@@ -17924,7 +18033,7 @@ ${input.slice(result.pos)}
|
|
|
17924
18033
|
return result;
|
|
17925
18034
|
}
|
|
17926
18035
|
}
|
|
17927
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
18036
|
+
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) {
|
|
17928
18037
|
var options = $3;
|
|
17929
18038
|
return {
|
|
17930
18039
|
type: "CivetPrologue",
|
|
@@ -18085,7 +18194,7 @@ ${input.slice(result.pos)}
|
|
|
18085
18194
|
return result;
|
|
18086
18195
|
}
|
|
18087
18196
|
}
|
|
18088
|
-
var DebugHere$0 = $TV($EXPECT($
|
|
18197
|
+
var DebugHere$0 = $TV($EXPECT($L19, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
18089
18198
|
debugger;
|
|
18090
18199
|
});
|
|
18091
18200
|
function DebugHere(state) {
|
|
@@ -18110,7 +18219,7 @@ ${input.slice(result.pos)}
|
|
|
18110
18219
|
return result;
|
|
18111
18220
|
}
|
|
18112
18221
|
}
|
|
18113
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
18222
|
+
var InsertSemicolon$0 = $TV($EXPECT($L19, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
18114
18223
|
return { $loc, token: ";" };
|
|
18115
18224
|
});
|
|
18116
18225
|
function InsertSemicolon(state) {
|
|
@@ -18135,7 +18244,7 @@ ${input.slice(result.pos)}
|
|
|
18135
18244
|
return result;
|
|
18136
18245
|
}
|
|
18137
18246
|
}
|
|
18138
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
18247
|
+
var InsertOpenParen$0 = $TV($EXPECT($L19, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
18139
18248
|
return { $loc, token: "(" };
|
|
18140
18249
|
});
|
|
18141
18250
|
function InsertOpenParen(state) {
|
|
@@ -18160,7 +18269,7 @@ ${input.slice(result.pos)}
|
|
|
18160
18269
|
return result;
|
|
18161
18270
|
}
|
|
18162
18271
|
}
|
|
18163
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
18272
|
+
var InsertCloseParen$0 = $TV($EXPECT($L19, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
18164
18273
|
return { $loc, token: ")" };
|
|
18165
18274
|
});
|
|
18166
18275
|
function InsertCloseParen(state) {
|
|
@@ -18185,7 +18294,7 @@ ${input.slice(result.pos)}
|
|
|
18185
18294
|
return result;
|
|
18186
18295
|
}
|
|
18187
18296
|
}
|
|
18188
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
18297
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18189
18298
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
18190
18299
|
});
|
|
18191
18300
|
function InsertOpenBrace(state) {
|
|
@@ -18210,7 +18319,7 @@ ${input.slice(result.pos)}
|
|
|
18210
18319
|
return result;
|
|
18211
18320
|
}
|
|
18212
18321
|
}
|
|
18213
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
18322
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18214
18323
|
return { $loc, token: "{" };
|
|
18215
18324
|
});
|
|
18216
18325
|
function InsertInlineOpenBrace(state) {
|
|
@@ -18235,7 +18344,7 @@ ${input.slice(result.pos)}
|
|
|
18235
18344
|
return result;
|
|
18236
18345
|
}
|
|
18237
18346
|
}
|
|
18238
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
18347
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L19, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
18239
18348
|
return { $loc, token: "}" };
|
|
18240
18349
|
});
|
|
18241
18350
|
function InsertCloseBrace(state) {
|
|
@@ -18260,7 +18369,7 @@ ${input.slice(result.pos)}
|
|
|
18260
18369
|
return result;
|
|
18261
18370
|
}
|
|
18262
18371
|
}
|
|
18263
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
18372
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L19, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
18264
18373
|
return { $loc, token: "[" };
|
|
18265
18374
|
});
|
|
18266
18375
|
function InsertOpenBracket(state) {
|
|
@@ -18285,7 +18394,7 @@ ${input.slice(result.pos)}
|
|
|
18285
18394
|
return result;
|
|
18286
18395
|
}
|
|
18287
18396
|
}
|
|
18288
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
18397
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L19, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
18289
18398
|
return { $loc, token: "]" };
|
|
18290
18399
|
});
|
|
18291
18400
|
function InsertCloseBracket(state) {
|
|
@@ -18310,7 +18419,7 @@ ${input.slice(result.pos)}
|
|
|
18310
18419
|
return result;
|
|
18311
18420
|
}
|
|
18312
18421
|
}
|
|
18313
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
18422
|
+
var InsertComma$0 = $TV($EXPECT($L19, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
18314
18423
|
return { $loc, token: "," };
|
|
18315
18424
|
});
|
|
18316
18425
|
function InsertComma(state) {
|
|
@@ -18335,7 +18444,7 @@ ${input.slice(result.pos)}
|
|
|
18335
18444
|
return result;
|
|
18336
18445
|
}
|
|
18337
18446
|
}
|
|
18338
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
18447
|
+
var InsertConst$0 = $TV($EXPECT($L19, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
18339
18448
|
return { $loc, token: "const " };
|
|
18340
18449
|
});
|
|
18341
18450
|
function InsertConst(state) {
|
|
@@ -18360,7 +18469,7 @@ ${input.slice(result.pos)}
|
|
|
18360
18469
|
return result;
|
|
18361
18470
|
}
|
|
18362
18471
|
}
|
|
18363
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
18472
|
+
var InsertLet$0 = $TV($EXPECT($L19, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
18364
18473
|
return { $loc, token: "let " };
|
|
18365
18474
|
});
|
|
18366
18475
|
function InsertLet(state) {
|
|
@@ -18385,7 +18494,7 @@ ${input.slice(result.pos)}
|
|
|
18385
18494
|
return result;
|
|
18386
18495
|
}
|
|
18387
18496
|
}
|
|
18388
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
18497
|
+
var InsertReadonly$0 = $TV($EXPECT($L19, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
18389
18498
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
18390
18499
|
});
|
|
18391
18500
|
function InsertReadonly(state) {
|
|
@@ -18410,7 +18519,7 @@ ${input.slice(result.pos)}
|
|
|
18410
18519
|
return result;
|
|
18411
18520
|
}
|
|
18412
18521
|
}
|
|
18413
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
18522
|
+
var InsertNewline$0 = $TV($EXPECT($L19, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
18414
18523
|
return "\n";
|
|
18415
18524
|
});
|
|
18416
18525
|
function InsertNewline(state) {
|
|
@@ -18435,7 +18544,7 @@ ${input.slice(result.pos)}
|
|
|
18435
18544
|
return result;
|
|
18436
18545
|
}
|
|
18437
18546
|
}
|
|
18438
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
18547
|
+
var InsertIndent$0 = $TV($EXPECT($L19, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
18439
18548
|
return module2.currentIndent.token;
|
|
18440
18549
|
});
|
|
18441
18550
|
function InsertIndent(state) {
|
|
@@ -18460,7 +18569,7 @@ ${input.slice(result.pos)}
|
|
|
18460
18569
|
return result;
|
|
18461
18570
|
}
|
|
18462
18571
|
}
|
|
18463
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
18572
|
+
var InsertSpace$0 = $TV($EXPECT($L19, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
18464
18573
|
return { $loc, token: " " };
|
|
18465
18574
|
});
|
|
18466
18575
|
function InsertSpace(state) {
|
|
@@ -18485,7 +18594,7 @@ ${input.slice(result.pos)}
|
|
|
18485
18594
|
return result;
|
|
18486
18595
|
}
|
|
18487
18596
|
}
|
|
18488
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
18597
|
+
var InsertDot$0 = $TV($EXPECT($L19, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
18489
18598
|
return { $loc, token: "." };
|
|
18490
18599
|
});
|
|
18491
18600
|
function InsertDot(state) {
|
|
@@ -18510,7 +18619,7 @@ ${input.slice(result.pos)}
|
|
|
18510
18619
|
return result;
|
|
18511
18620
|
}
|
|
18512
18621
|
}
|
|
18513
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18622
|
+
var InsertBreak$0 = $TV($EXPECT($L19, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
18514
18623
|
return { $loc, token: ";break;" };
|
|
18515
18624
|
});
|
|
18516
18625
|
function InsertBreak(state) {
|
|
@@ -18535,7 +18644,7 @@ ${input.slice(result.pos)}
|
|
|
18535
18644
|
return result;
|
|
18536
18645
|
}
|
|
18537
18646
|
}
|
|
18538
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18647
|
+
var InsertVar$0 = $TV($EXPECT($L19, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
18539
18648
|
return { $loc, token: "var " };
|
|
18540
18649
|
});
|
|
18541
18650
|
function InsertVar(state) {
|
|
@@ -18560,7 +18669,7 @@ ${input.slice(result.pos)}
|
|
|
18560
18669
|
return result;
|
|
18561
18670
|
}
|
|
18562
18671
|
}
|
|
18563
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18672
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18564
18673
|
if (module2.config.coffeeBinaryExistential)
|
|
18565
18674
|
return;
|
|
18566
18675
|
return $skip;
|
|
@@ -18587,7 +18696,7 @@ ${input.slice(result.pos)}
|
|
|
18587
18696
|
return result;
|
|
18588
18697
|
}
|
|
18589
18698
|
}
|
|
18590
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18699
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18591
18700
|
if (module2.config.coffeeBooleans)
|
|
18592
18701
|
return;
|
|
18593
18702
|
return $skip;
|
|
@@ -18614,7 +18723,7 @@ ${input.slice(result.pos)}
|
|
|
18614
18723
|
return result;
|
|
18615
18724
|
}
|
|
18616
18725
|
}
|
|
18617
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18726
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18618
18727
|
if (module2.config.coffeeClasses)
|
|
18619
18728
|
return;
|
|
18620
18729
|
return $skip;
|
|
@@ -18641,7 +18750,7 @@ ${input.slice(result.pos)}
|
|
|
18641
18750
|
return result;
|
|
18642
18751
|
}
|
|
18643
18752
|
}
|
|
18644
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18753
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18645
18754
|
if (module2.config.coffeeComment)
|
|
18646
18755
|
return;
|
|
18647
18756
|
return $skip;
|
|
@@ -18668,7 +18777,7 @@ ${input.slice(result.pos)}
|
|
|
18668
18777
|
return result;
|
|
18669
18778
|
}
|
|
18670
18779
|
}
|
|
18671
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18780
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18672
18781
|
if (module2.config.coffeeDo)
|
|
18673
18782
|
return;
|
|
18674
18783
|
return $skip;
|
|
@@ -18695,7 +18804,7 @@ ${input.slice(result.pos)}
|
|
|
18695
18804
|
return result;
|
|
18696
18805
|
}
|
|
18697
18806
|
}
|
|
18698
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18807
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18699
18808
|
if (module2.config.coffeeForLoops)
|
|
18700
18809
|
return;
|
|
18701
18810
|
return $skip;
|
|
@@ -18722,7 +18831,7 @@ ${input.slice(result.pos)}
|
|
|
18722
18831
|
return result;
|
|
18723
18832
|
}
|
|
18724
18833
|
}
|
|
18725
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18834
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18726
18835
|
if (module2.config.coffeeInterpolation)
|
|
18727
18836
|
return;
|
|
18728
18837
|
return $skip;
|
|
@@ -18749,7 +18858,7 @@ ${input.slice(result.pos)}
|
|
|
18749
18858
|
return result;
|
|
18750
18859
|
}
|
|
18751
18860
|
}
|
|
18752
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18861
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18753
18862
|
if (module2.config.coffeeIsnt)
|
|
18754
18863
|
return;
|
|
18755
18864
|
return $skip;
|
|
@@ -18776,7 +18885,7 @@ ${input.slice(result.pos)}
|
|
|
18776
18885
|
return result;
|
|
18777
18886
|
}
|
|
18778
18887
|
}
|
|
18779
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18888
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18780
18889
|
if (module2.config.coffeeJSX)
|
|
18781
18890
|
return;
|
|
18782
18891
|
return $skip;
|
|
@@ -18803,7 +18912,7 @@ ${input.slice(result.pos)}
|
|
|
18803
18912
|
return result;
|
|
18804
18913
|
}
|
|
18805
18914
|
}
|
|
18806
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18915
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18807
18916
|
if (module2.config.coffeeLineContinuation)
|
|
18808
18917
|
return;
|
|
18809
18918
|
return $skip;
|
|
@@ -18830,7 +18939,7 @@ ${input.slice(result.pos)}
|
|
|
18830
18939
|
return result;
|
|
18831
18940
|
}
|
|
18832
18941
|
}
|
|
18833
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18942
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18834
18943
|
if (module2.config.coffeeNot)
|
|
18835
18944
|
return;
|
|
18836
18945
|
return $skip;
|
|
@@ -18857,7 +18966,7 @@ ${input.slice(result.pos)}
|
|
|
18857
18966
|
return result;
|
|
18858
18967
|
}
|
|
18859
18968
|
}
|
|
18860
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18969
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18861
18970
|
if (module2.config.coffeeOf)
|
|
18862
18971
|
return;
|
|
18863
18972
|
return $skip;
|
|
@@ -18884,7 +18993,7 @@ ${input.slice(result.pos)}
|
|
|
18884
18993
|
return result;
|
|
18885
18994
|
}
|
|
18886
18995
|
}
|
|
18887
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18996
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18888
18997
|
if (module2.config.coffeePrototype)
|
|
18889
18998
|
return;
|
|
18890
18999
|
return $skip;
|
|
@@ -18911,7 +19020,7 @@ ${input.slice(result.pos)}
|
|
|
18911
19020
|
return result;
|
|
18912
19021
|
}
|
|
18913
19022
|
}
|
|
18914
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
19023
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L19, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18915
19024
|
if (module2.config.objectIs)
|
|
18916
19025
|
return;
|
|
18917
19026
|
return $skip;
|
|
@@ -18938,7 +19047,7 @@ ${input.slice(result.pos)}
|
|
|
18938
19047
|
return result;
|
|
18939
19048
|
}
|
|
18940
19049
|
}
|
|
18941
|
-
var Reset$0 = $TV($EXPECT($
|
|
19050
|
+
var Reset$0 = $TV($EXPECT($L19, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18942
19051
|
module2.indentLevels = [{
|
|
18943
19052
|
level: 0,
|
|
18944
19053
|
token: ""
|
|
@@ -19245,7 +19354,7 @@ ${input.slice(result.pos)}
|
|
|
19245
19354
|
return result;
|
|
19246
19355
|
}
|
|
19247
19356
|
}
|
|
19248
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
19357
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L19, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
19249
19358
|
var directives = $2;
|
|
19250
19359
|
directives.forEach((directive) => {
|
|
19251
19360
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19517,6 +19626,9 @@ ${input.slice(result.pos)}
|
|
|
19517
19626
|
else
|
|
19518
19627
|
exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
|
|
19519
19628
|
return;
|
|
19629
|
+
case "PatternMatchingStatement":
|
|
19630
|
+
insertPush(exp.children[0][0], ref);
|
|
19631
|
+
return;
|
|
19520
19632
|
case "SwitchStatement":
|
|
19521
19633
|
insertPush(exp.children[2], ref);
|
|
19522
19634
|
return;
|
|
@@ -19548,6 +19660,12 @@ ${input.slice(result.pos)}
|
|
|
19548
19660
|
return;
|
|
19549
19661
|
}
|
|
19550
19662
|
}
|
|
19663
|
+
function getIndent(statement) {
|
|
19664
|
+
let indent = statement?.[0];
|
|
19665
|
+
if (Array.isArray(indent))
|
|
19666
|
+
indent = indent[indent.length - 1];
|
|
19667
|
+
return indent;
|
|
19668
|
+
}
|
|
19551
19669
|
function insertReturn(node) {
|
|
19552
19670
|
if (!node)
|
|
19553
19671
|
return;
|
|
@@ -19572,9 +19690,7 @@ ${input.slice(result.pos)}
|
|
|
19572
19690
|
const [, exp, semi] = node;
|
|
19573
19691
|
if (semi?.type === "SemicolonDelimiter")
|
|
19574
19692
|
return;
|
|
19575
|
-
let indent = node
|
|
19576
|
-
if (Array.isArray(indent))
|
|
19577
|
-
indent = indent[indent.length - 1];
|
|
19693
|
+
let indent = getIndent(node);
|
|
19578
19694
|
if (!exp)
|
|
19579
19695
|
return;
|
|
19580
19696
|
switch (exp.type) {
|
|
@@ -19600,6 +19716,9 @@ ${input.slice(result.pos)}
|
|
|
19600
19716
|
else
|
|
19601
19717
|
exp.children.push(["\n", indent, wrapWithReturn()]);
|
|
19602
19718
|
return;
|
|
19719
|
+
case "PatternMatchingStatement":
|
|
19720
|
+
insertReturn(exp.children[0][0]);
|
|
19721
|
+
return;
|
|
19603
19722
|
case "SwitchStatement":
|
|
19604
19723
|
insertSwitchReturns(exp);
|
|
19605
19724
|
return;
|
|
@@ -19994,12 +20113,14 @@ ${input.slice(result.pos)}
|
|
|
19994
20113
|
}
|
|
19995
20114
|
return [];
|
|
19996
20115
|
}
|
|
19997
|
-
function gatherRecursive(node, predicate) {
|
|
20116
|
+
function gatherRecursive(node, predicate, skipPredicate) {
|
|
19998
20117
|
if (node == null)
|
|
19999
20118
|
return [];
|
|
20000
20119
|
if (Array.isArray(node)) {
|
|
20001
20120
|
return node.flatMap((n) => gatherRecursive(n, predicate));
|
|
20002
20121
|
}
|
|
20122
|
+
if (skipPredicate?.(node))
|
|
20123
|
+
return [];
|
|
20003
20124
|
if (predicate(node)) {
|
|
20004
20125
|
return [node];
|
|
20005
20126
|
}
|
|
@@ -20017,6 +20138,36 @@ ${input.slice(result.pos)}
|
|
|
20017
20138
|
}
|
|
20018
20139
|
return nodes;
|
|
20019
20140
|
}
|
|
20141
|
+
function isFunction({ type }) {
|
|
20142
|
+
return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition";
|
|
20143
|
+
}
|
|
20144
|
+
function gatherRecursiveWithinFunction(node, predicate) {
|
|
20145
|
+
return gatherRecursive(node, predicate, isFunction);
|
|
20146
|
+
}
|
|
20147
|
+
function addParentPointers(node, parent) {
|
|
20148
|
+
if (node == null)
|
|
20149
|
+
return;
|
|
20150
|
+
if (typeof node !== "object")
|
|
20151
|
+
return;
|
|
20152
|
+
node.parent = parent;
|
|
20153
|
+
if (Array.isArray(node)) {
|
|
20154
|
+
for (const child of node) {
|
|
20155
|
+
addParentPointers(child, node);
|
|
20156
|
+
}
|
|
20157
|
+
} else if (node.children) {
|
|
20158
|
+
for (const child of node.children) {
|
|
20159
|
+
addParentPointers(child, node);
|
|
20160
|
+
}
|
|
20161
|
+
}
|
|
20162
|
+
}
|
|
20163
|
+
function findAncestor(node, predicate, stopPredicate) {
|
|
20164
|
+
node = node.parent;
|
|
20165
|
+
while (node && !stopPredicate?.(node)) {
|
|
20166
|
+
if (predicate(node))
|
|
20167
|
+
return node;
|
|
20168
|
+
node = node.parent;
|
|
20169
|
+
}
|
|
20170
|
+
}
|
|
20020
20171
|
function processParams(f) {
|
|
20021
20172
|
const { type, parameters, block } = f;
|
|
20022
20173
|
if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
|
|
@@ -20062,26 +20213,89 @@ ${input.slice(result.pos)}
|
|
|
20062
20213
|
}
|
|
20063
20214
|
});
|
|
20064
20215
|
}
|
|
20216
|
+
function processReturnValue(func) {
|
|
20217
|
+
const { block } = func;
|
|
20218
|
+
const values = gatherRecursiveWithinFunction(
|
|
20219
|
+
block,
|
|
20220
|
+
({ type }) => type === "ReturnValue"
|
|
20221
|
+
);
|
|
20222
|
+
if (!values.length)
|
|
20223
|
+
return false;
|
|
20224
|
+
const ref = {
|
|
20225
|
+
type: "Ref",
|
|
20226
|
+
base: "ret",
|
|
20227
|
+
id: "ret"
|
|
20228
|
+
};
|
|
20229
|
+
let declared;
|
|
20230
|
+
values.forEach((value) => {
|
|
20231
|
+
value.children = [ref];
|
|
20232
|
+
const ancestor = findAncestor(
|
|
20233
|
+
value,
|
|
20234
|
+
({ type }) => type === "Declaration",
|
|
20235
|
+
isFunction
|
|
20236
|
+
);
|
|
20237
|
+
if (ancestor)
|
|
20238
|
+
declared = true;
|
|
20239
|
+
});
|
|
20240
|
+
if (!declared) {
|
|
20241
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
20242
|
+
if (returnType) {
|
|
20243
|
+
const { t } = returnType;
|
|
20244
|
+
if (t.type === "TypePredicate") {
|
|
20245
|
+
returnType = ": boolean";
|
|
20246
|
+
} else if (t.type === "AssertsType") {
|
|
20247
|
+
returnType = void 0;
|
|
20248
|
+
}
|
|
20249
|
+
}
|
|
20250
|
+
block.expressions.unshift([
|
|
20251
|
+
getIndent(block.expressions[0]),
|
|
20252
|
+
{
|
|
20253
|
+
type: "Declaration",
|
|
20254
|
+
children: ["let ", ref, returnType, ";\n"],
|
|
20255
|
+
names: []
|
|
20256
|
+
}
|
|
20257
|
+
]);
|
|
20258
|
+
}
|
|
20259
|
+
gatherRecursiveWithinFunction(
|
|
20260
|
+
block,
|
|
20261
|
+
(r) => r.type === "ReturnStatement" && !r.expression
|
|
20262
|
+
).forEach((r) => {
|
|
20263
|
+
r.expression = ref;
|
|
20264
|
+
r.children.splice(-1, 1, " ", ref);
|
|
20265
|
+
});
|
|
20266
|
+
if (block.children.at(-2)?.type !== "ReturnStatement") {
|
|
20267
|
+
block.expressions.push([
|
|
20268
|
+
["\n", getIndent(block.expressions.at(-1))],
|
|
20269
|
+
{
|
|
20270
|
+
type: "ReturnStatement",
|
|
20271
|
+
expression: ref,
|
|
20272
|
+
children: ["return ", ref]
|
|
20273
|
+
}
|
|
20274
|
+
]);
|
|
20275
|
+
}
|
|
20276
|
+
return true;
|
|
20277
|
+
}
|
|
20278
|
+
function isVoidType(t) {
|
|
20279
|
+
return t?.type === "LiteralType" && t.t.type === "VoidType";
|
|
20280
|
+
}
|
|
20065
20281
|
function processFunctions(statements) {
|
|
20066
|
-
gatherRecursiveAll(statements, (
|
|
20067
|
-
return n.type === "FunctionExpression" || n.type === "ArrowFunction";
|
|
20068
|
-
}).forEach((f) => {
|
|
20282
|
+
gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
|
|
20069
20283
|
processParams(f);
|
|
20070
|
-
|
|
20071
|
-
|
|
20072
|
-
const isVoid = returnType
|
|
20284
|
+
if (!processReturnValue(f) && module2.config.implicitReturns) {
|
|
20285
|
+
const { block, returnType } = f;
|
|
20286
|
+
const isVoid = isVoidType(returnType?.t);
|
|
20073
20287
|
const isBlock = block?.type === "BlockStatement";
|
|
20074
20288
|
if (!isVoid && isBlock) {
|
|
20075
20289
|
insertReturn(block);
|
|
20076
20290
|
}
|
|
20077
20291
|
}
|
|
20078
20292
|
});
|
|
20079
|
-
gatherRecursiveAll(statements, (
|
|
20293
|
+
gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
|
|
20080
20294
|
processParams(f);
|
|
20081
|
-
|
|
20082
|
-
|
|
20295
|
+
if (!processReturnValue(f) && module2.config.implicitReturns) {
|
|
20296
|
+
const { signature, block } = f;
|
|
20083
20297
|
const isConstructor = signature.name === "constructor";
|
|
20084
|
-
const isVoid = signature.returnType
|
|
20298
|
+
const isVoid = isVoidType(signature.returnType?.t);
|
|
20085
20299
|
const isSet = signature.modifier === "set";
|
|
20086
20300
|
if (!isConstructor && !isSet && !isVoid) {
|
|
20087
20301
|
insertReturn(block);
|
|
@@ -20432,7 +20646,7 @@ ${input.slice(result.pos)}
|
|
|
20432
20646
|
}
|
|
20433
20647
|
}
|
|
20434
20648
|
function processPatternMatching(statements) {
|
|
20435
|
-
gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
|
|
20649
|
+
gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
|
|
20436
20650
|
const { caseBlock } = s;
|
|
20437
20651
|
const { clauses } = caseBlock;
|
|
20438
20652
|
let errors = false;
|
|
@@ -20511,15 +20725,21 @@ ${input.slice(result.pos)}
|
|
|
20511
20725
|
block.children.push("}");
|
|
20512
20726
|
block.bare = false;
|
|
20513
20727
|
}
|
|
20514
|
-
|
|
20515
|
-
|
|
20728
|
+
if (i < l - 1)
|
|
20729
|
+
next.push("\n", "else ");
|
|
20730
|
+
prev.push(["", {
|
|
20516
20731
|
type: "IfStatement",
|
|
20517
|
-
children: ["if", condition, block,
|
|
20732
|
+
children: ["if", condition, block, next],
|
|
20518
20733
|
then: block,
|
|
20519
|
-
else:
|
|
20520
|
-
});
|
|
20734
|
+
else: next
|
|
20735
|
+
}]);
|
|
20521
20736
|
prev = next;
|
|
20522
20737
|
});
|
|
20738
|
+
if (module2.config.implicitReturns && s.type === "SwitchExpression") {
|
|
20739
|
+
insertReturn(root[0]);
|
|
20740
|
+
root.unshift("(()=>{");
|
|
20741
|
+
root.push("})()");
|
|
20742
|
+
}
|
|
20523
20743
|
s.type = "PatternMatchingStatement";
|
|
20524
20744
|
s.children = [root];
|
|
20525
20745
|
});
|
|
@@ -20569,12 +20789,13 @@ ${input.slice(result.pos)}
|
|
|
20569
20789
|
});
|
|
20570
20790
|
}
|
|
20571
20791
|
module2.processProgram = function(statements) {
|
|
20792
|
+
addParentPointers(statements);
|
|
20572
20793
|
processPipelineExpressions(statements);
|
|
20573
20794
|
processAssignments(statements);
|
|
20795
|
+
processPatternMatching(statements);
|
|
20574
20796
|
processFunctions(statements);
|
|
20575
20797
|
processSwitchExpressions(statements);
|
|
20576
20798
|
processTryExpressions(statements);
|
|
20577
|
-
processPatternMatching(statements);
|
|
20578
20799
|
gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
|
|
20579
20800
|
checkSpliceRef(statements);
|
|
20580
20801
|
statements.unshift(...module2.prelude);
|
|
@@ -20595,18 +20816,7 @@ ${input.slice(result.pos)}
|
|
|
20595
20816
|
return new Set(declarationNames);
|
|
20596
20817
|
}
|
|
20597
20818
|
function populateRefs(statements) {
|
|
20598
|
-
const refNodes =
|
|
20599
|
-
const blockNodes = new Set(gatherNodes(statements, ({ type }) => type === "BlockStatement"));
|
|
20600
|
-
const forNodes = gatherNodes(statements, ({ type }) => type === "ForStatement");
|
|
20601
|
-
forNodes.forEach(({ declaration, block }) => {
|
|
20602
|
-
if (block.type === "BlockStatement") {
|
|
20603
|
-
populateRefs([declaration, ...block.children]);
|
|
20604
|
-
} else {
|
|
20605
|
-
populateRefs([declaration, ...block]);
|
|
20606
|
-
}
|
|
20607
|
-
blockNodes.delete(block);
|
|
20608
|
-
});
|
|
20609
|
-
blockNodes.forEach(({ expressions }) => populateRefs(expressions));
|
|
20819
|
+
const refNodes = gatherRecursive(statements, ({ type }) => type === "Ref");
|
|
20610
20820
|
if (refNodes.length) {
|
|
20611
20821
|
const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
|
|
20612
20822
|
const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
|
|
@@ -20784,6 +20994,15 @@ ${input.slice(result.pos)}
|
|
|
20784
20994
|
module2.gatherBindingCode = gatherBindingCode;
|
|
20785
20995
|
module2.constructInvocation = function(fn, arg) {
|
|
20786
20996
|
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20997
|
+
if (fn.expr.ampersandBlock) {
|
|
20998
|
+
const [ref, , prefix, rhs] = fn.expr.children;
|
|
20999
|
+
ref.type = "PipedExpression";
|
|
21000
|
+
ref.children = [module2.makeLeftHandSideExpression(arg)];
|
|
21001
|
+
return {
|
|
21002
|
+
type: "UnwrappedExpression",
|
|
21003
|
+
children: [module2.skipIfOnlyWS(fn.leadingComment), prefix, rhs, module2.skipIfOnlyWS(fn.trailingComment)]
|
|
21004
|
+
};
|
|
21005
|
+
}
|
|
20787
21006
|
const lhs = module2.makeLeftHandSideExpression(fn.expr);
|
|
20788
21007
|
let comment = module2.skipIfOnlyWS(fn.trailingComment);
|
|
20789
21008
|
if (comment)
|
|
@@ -20793,10 +21012,7 @@ ${input.slice(result.pos)}
|
|
|
20793
21012
|
lhs.children.splice(1, 0, comment);
|
|
20794
21013
|
switch (arg.type) {
|
|
20795
21014
|
case "CommaExpression":
|
|
20796
|
-
arg =
|
|
20797
|
-
type: "ParenthesizedExpression",
|
|
20798
|
-
children: ["(", arg, ")"]
|
|
20799
|
-
};
|
|
21015
|
+
arg = module2.makeLeftHandSideExpression(arg);
|
|
20800
21016
|
break;
|
|
20801
21017
|
}
|
|
20802
21018
|
return {
|
|
@@ -21012,7 +21228,7 @@ ${input.slice(result.pos)}
|
|
|
21012
21228
|
return result;
|
|
21013
21229
|
}
|
|
21014
21230
|
}
|
|
21015
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
21231
|
+
var PopIndent$0 = $TV($EXPECT($L19, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
21016
21232
|
if (module2.config.verbose) {
|
|
21017
21233
|
console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
|
|
21018
21234
|
}
|
|
@@ -21161,6 +21377,9 @@ var prune = function(node) {
|
|
|
21161
21377
|
if (node.length === 0) {
|
|
21162
21378
|
return;
|
|
21163
21379
|
}
|
|
21380
|
+
if (node.parent != null) {
|
|
21381
|
+
delete node.parent;
|
|
21382
|
+
}
|
|
21164
21383
|
if (Array.isArray(node)) {
|
|
21165
21384
|
a = node.map(function(n) {
|
|
21166
21385
|
return prune(n);
|