@danielx/civet 0.5.69 → 0.5.71
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +781 -500
- package/dist/civet +8 -1
- package/dist/main.js +781 -500
- package/dist/main.mjs +781 -500
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -500,6 +500,8 @@ ${input.slice(result.pos)}
|
|
|
500
500
|
AtThis,
|
|
501
501
|
LeftHandSideExpression,
|
|
502
502
|
CallExpression,
|
|
503
|
+
ReturnValue,
|
|
504
|
+
AfterReturnShorthand,
|
|
503
505
|
CallExpressionRest,
|
|
504
506
|
OptionalShorthand,
|
|
505
507
|
OptionalDot,
|
|
@@ -704,6 +706,9 @@ ${input.slice(result.pos)}
|
|
|
704
706
|
RestoreAll,
|
|
705
707
|
ExpressionStatement,
|
|
706
708
|
KeywordStatement,
|
|
709
|
+
Break,
|
|
710
|
+
Continue,
|
|
711
|
+
Debugger,
|
|
707
712
|
DebuggerExpression,
|
|
708
713
|
ThrowExpression,
|
|
709
714
|
MaybeNestedExpression,
|
|
@@ -982,7 +987,7 @@ ${input.slice(result.pos)}
|
|
|
982
987
|
DirectivePrologue,
|
|
983
988
|
EOS,
|
|
984
989
|
EOL,
|
|
985
|
-
|
|
990
|
+
DebugHere,
|
|
986
991
|
InsertSemicolon,
|
|
987
992
|
InsertOpenParen,
|
|
988
993
|
InsertCloseParen,
|
|
@@ -1039,170 +1044,171 @@ ${input.slice(result.pos)}
|
|
|
1039
1044
|
var $L11 = $L("#");
|
|
1040
1045
|
var $L12 = $L("super");
|
|
1041
1046
|
var $L13 = $L("import");
|
|
1042
|
-
var $L14 = $L("
|
|
1043
|
-
var $L15 = $L("
|
|
1044
|
-
var $L16 = $L("
|
|
1045
|
-
var $L17 = $L("
|
|
1046
|
-
var $L18 = $L("");
|
|
1047
|
-
var $L19 = $L("
|
|
1048
|
-
var $L20 = $L("
|
|
1049
|
-
var $L21 = $L("
|
|
1050
|
-
var $L22 = $L("
|
|
1051
|
-
var $L23 = $L("
|
|
1052
|
-
var $L24 = $L("
|
|
1053
|
-
var $L25 = $L("
|
|
1054
|
-
var $L26 = $L("
|
|
1055
|
-
var $L27 = $L("
|
|
1056
|
-
var $L28 = $L("
|
|
1057
|
-
var $L29 = $L("
|
|
1058
|
-
var $L30 = $L("
|
|
1059
|
-
var $L31 = $L("
|
|
1060
|
-
var $L32 = $L("
|
|
1061
|
-
var $L33 = $L("
|
|
1062
|
-
var $L34 = $L("
|
|
1063
|
-
var $L35 = $L("
|
|
1064
|
-
var $L36 = $L("
|
|
1065
|
-
var $L37 = $L("
|
|
1066
|
-
var $L38 = $L("
|
|
1067
|
-
var $L39 = $L("
|
|
1068
|
-
var $L40 = $L("
|
|
1069
|
-
var $L41 = $L("
|
|
1070
|
-
var $L42 = $L("
|
|
1071
|
-
var $L43 = $L("
|
|
1072
|
-
var $L44 = $L("
|
|
1073
|
-
var $L45 = $L("
|
|
1074
|
-
var $L46 = $L("
|
|
1075
|
-
var $L47 = $L("
|
|
1076
|
-
var $L48 = $L("
|
|
1077
|
-
var $L49 = $L("
|
|
1078
|
-
var $L50 = $L("
|
|
1079
|
-
var $L51 = $L("
|
|
1080
|
-
var $L52 = $L("
|
|
1081
|
-
var $L53 = $L("
|
|
1082
|
-
var $L54 = $L("
|
|
1083
|
-
var $L55 = $L("
|
|
1084
|
-
var $L56 = $L("
|
|
1085
|
-
var $L57 = $L("
|
|
1086
|
-
var $L58 = $L("
|
|
1087
|
-
var $L59 = $L("
|
|
1088
|
-
var $L60 = $L("
|
|
1089
|
-
var $L61 = $L("
|
|
1090
|
-
var $L62 = $L("
|
|
1091
|
-
var $L63 = $L("
|
|
1092
|
-
var $L64 = $L("
|
|
1093
|
-
var $L65 = $L("
|
|
1094
|
-
var $L66 = $L("
|
|
1095
|
-
var $L67 = $L("
|
|
1096
|
-
var $L68 = $L("
|
|
1097
|
-
var $L69 = $L("
|
|
1098
|
-
var $L70 = $L("
|
|
1099
|
-
var $L71 = $L("
|
|
1100
|
-
var $L72 = $L("
|
|
1101
|
-
var $L73 = $L("
|
|
1102
|
-
var $L74 = $L("
|
|
1103
|
-
var $L75 = $L("
|
|
1104
|
-
var $L76 = $L("
|
|
1105
|
-
var $L77 = $L("
|
|
1106
|
-
var $L78 = $L("
|
|
1107
|
-
var $L79 = $L("
|
|
1108
|
-
var $L80 = $L("
|
|
1109
|
-
var $L81 = $L("
|
|
1110
|
-
var $L82 = $L("
|
|
1111
|
-
var $L83 = $L("
|
|
1112
|
-
var $L84 = $L("
|
|
1113
|
-
var $L85 = $L("
|
|
1114
|
-
var $L86 = $L("
|
|
1115
|
-
var $L87 = $L("
|
|
1116
|
-
var $L88 = $L("
|
|
1117
|
-
var $L89 = $L("
|
|
1118
|
-
var $L90 = $L("
|
|
1119
|
-
var $L91 = $L("
|
|
1120
|
-
var $L92 = $L("
|
|
1121
|
-
var $L93 = $L("
|
|
1122
|
-
var $L94 = $L("
|
|
1123
|
-
var $L95 = $L("
|
|
1124
|
-
var $L96 = $L("
|
|
1125
|
-
var $L97 = $L("
|
|
1126
|
-
var $L98 = $L("
|
|
1127
|
-
var $L99 = $L("
|
|
1128
|
-
var $L100 = $L("
|
|
1129
|
-
var $L101 = $L("
|
|
1130
|
-
var $L102 = $L("
|
|
1131
|
-
var $L103 = $L("
|
|
1132
|
-
var $L104 = $L("
|
|
1133
|
-
var $L105 = $L("
|
|
1134
|
-
var $L106 = $L("
|
|
1135
|
-
var $L107 = $L("
|
|
1136
|
-
var $L108 = $L("
|
|
1137
|
-
var $L109 = $L("
|
|
1138
|
-
var $L110 = $L("
|
|
1139
|
-
var $L111 = $L("
|
|
1140
|
-
var $L112 = $L("
|
|
1141
|
-
var $L113 = $L("
|
|
1142
|
-
var $L114 = $L("
|
|
1143
|
-
var $L115 = $L("
|
|
1144
|
-
var $L116 = $L(
|
|
1145
|
-
var $L117 = $L("
|
|
1146
|
-
var $L118 = $L("
|
|
1147
|
-
var $L119 = $L("
|
|
1148
|
-
var $L120 = $L("
|
|
1149
|
-
var $L121 = $L("
|
|
1150
|
-
var $L122 = $L("
|
|
1151
|
-
var $L123 = $L("
|
|
1152
|
-
var $L124 = $L("
|
|
1153
|
-
var $L125 = $L("
|
|
1154
|
-
var $L126 = $L("
|
|
1155
|
-
var $L127 = $L("
|
|
1156
|
-
var $L128 = $L("
|
|
1157
|
-
var $L129 = $L("
|
|
1158
|
-
var $L130 = $L("
|
|
1159
|
-
var $L131 = $L("
|
|
1160
|
-
var $L132 = $L("
|
|
1161
|
-
var $L133 = $L("
|
|
1162
|
-
var $L134 = $L("
|
|
1163
|
-
var $L135 = $L("
|
|
1164
|
-
var $L136 = $L("
|
|
1165
|
-
var $L137 = $L("
|
|
1166
|
-
var $L138 = $L("
|
|
1167
|
-
var $L139 = $L("
|
|
1168
|
-
var $L140 = $L("
|
|
1169
|
-
var $L141 = $L("
|
|
1170
|
-
var $L142 = $L("
|
|
1171
|
-
var $L143 = $L("
|
|
1172
|
-
var $L144 = $L("
|
|
1173
|
-
var $L145 = $L("
|
|
1174
|
-
var $L146 = $L("
|
|
1175
|
-
var $L147 = $L("
|
|
1176
|
-
var $L148 = $L("
|
|
1177
|
-
var $L149 = $L("
|
|
1178
|
-
var $L150 = $L("
|
|
1179
|
-
var $L151 = $L(
|
|
1180
|
-
var $L152 = $L("'
|
|
1181
|
-
var $L153 = $L("
|
|
1182
|
-
var $L154 = $L("
|
|
1183
|
-
var $L155 = $L("
|
|
1184
|
-
var $L156 = $L("
|
|
1185
|
-
var $L157 = $L("
|
|
1186
|
-
var $L158 = $L("
|
|
1187
|
-
var $L159 = $L("
|
|
1188
|
-
var $L160 = $L("
|
|
1189
|
-
var $L161 = $L("
|
|
1190
|
-
var $L162 = $L("
|
|
1191
|
-
var $L163 = $L("
|
|
1192
|
-
var $L164 = $L("
|
|
1193
|
-
var $L165 = $L("
|
|
1194
|
-
var $L166 = $L("
|
|
1195
|
-
var $L167 = $L("
|
|
1196
|
-
var $L168 = $L("
|
|
1197
|
-
var $L169 = $L("
|
|
1198
|
-
var $L170 = $L("
|
|
1199
|
-
var $L171 = $L("
|
|
1200
|
-
var $L172 = $L("
|
|
1201
|
-
var $L173 = $L("
|
|
1202
|
-
var $L174 = $L("
|
|
1203
|
-
var $L175 = $L("
|
|
1204
|
-
var $L176 = $L("
|
|
1205
|
-
var $L177 = $L("
|
|
1047
|
+
var $L14 = $L("return.value");
|
|
1048
|
+
var $L15 = $L("!");
|
|
1049
|
+
var $L16 = $L("^");
|
|
1050
|
+
var $L17 = $L("-");
|
|
1051
|
+
var $L18 = $L("import.meta");
|
|
1052
|
+
var $L19 = $L("");
|
|
1053
|
+
var $L20 = $L(",");
|
|
1054
|
+
var $L21 = $L("->");
|
|
1055
|
+
var $L22 = $L("}");
|
|
1056
|
+
var $L23 = $L("null");
|
|
1057
|
+
var $L24 = $L("true");
|
|
1058
|
+
var $L25 = $L("false");
|
|
1059
|
+
var $L26 = $L("yes");
|
|
1060
|
+
var $L27 = $L("on");
|
|
1061
|
+
var $L28 = $L("no");
|
|
1062
|
+
var $L29 = $L("off");
|
|
1063
|
+
var $L30 = $L(">");
|
|
1064
|
+
var $L31 = $L("]");
|
|
1065
|
+
var $L32 = $L(":");
|
|
1066
|
+
var $L33 = $L(")");
|
|
1067
|
+
var $L34 = $L("**=");
|
|
1068
|
+
var $L35 = $L("*=");
|
|
1069
|
+
var $L36 = $L("/=");
|
|
1070
|
+
var $L37 = $L("%=");
|
|
1071
|
+
var $L38 = $L("+=");
|
|
1072
|
+
var $L39 = $L("-=");
|
|
1073
|
+
var $L40 = $L("<<=");
|
|
1074
|
+
var $L41 = $L(">>>=");
|
|
1075
|
+
var $L42 = $L(">>=");
|
|
1076
|
+
var $L43 = $L("&&=");
|
|
1077
|
+
var $L44 = $L("&=");
|
|
1078
|
+
var $L45 = $L("^=");
|
|
1079
|
+
var $L46 = $L("||=");
|
|
1080
|
+
var $L47 = $L("|=");
|
|
1081
|
+
var $L48 = $L("??=");
|
|
1082
|
+
var $L49 = $L("?=");
|
|
1083
|
+
var $L50 = $L("and=");
|
|
1084
|
+
var $L51 = $L("or=");
|
|
1085
|
+
var $L52 = $L("not");
|
|
1086
|
+
var $L53 = $L("**");
|
|
1087
|
+
var $L54 = $L("*");
|
|
1088
|
+
var $L55 = $L("/");
|
|
1089
|
+
var $L56 = $L("%%");
|
|
1090
|
+
var $L57 = $L("%");
|
|
1091
|
+
var $L58 = $L("+");
|
|
1092
|
+
var $L59 = $L("<=");
|
|
1093
|
+
var $L60 = $L(">=");
|
|
1094
|
+
var $L61 = $L("<?");
|
|
1095
|
+
var $L62 = $L("!<?");
|
|
1096
|
+
var $L63 = $L("<<");
|
|
1097
|
+
var $L64 = $L(">>>");
|
|
1098
|
+
var $L65 = $L(">>");
|
|
1099
|
+
var $L66 = $L("!==");
|
|
1100
|
+
var $L67 = $L("!=");
|
|
1101
|
+
var $L68 = $L("isnt");
|
|
1102
|
+
var $L69 = $L("===");
|
|
1103
|
+
var $L70 = $L("==");
|
|
1104
|
+
var $L71 = $L("and");
|
|
1105
|
+
var $L72 = $L("&&");
|
|
1106
|
+
var $L73 = $L("of");
|
|
1107
|
+
var $L74 = $L("or");
|
|
1108
|
+
var $L75 = $L("||");
|
|
1109
|
+
var $L76 = $L("^^");
|
|
1110
|
+
var $L77 = $L("xor");
|
|
1111
|
+
var $L78 = $L("xnor");
|
|
1112
|
+
var $L79 = $L("??");
|
|
1113
|
+
var $L80 = $L("instanceof");
|
|
1114
|
+
var $L81 = $L("in");
|
|
1115
|
+
var $L82 = $L("is");
|
|
1116
|
+
var $L83 = $L("&");
|
|
1117
|
+
var $L84 = $L("|");
|
|
1118
|
+
var $L85 = $L(";");
|
|
1119
|
+
var $L86 = $L("$:");
|
|
1120
|
+
var $L87 = $L("own");
|
|
1121
|
+
var $L88 = $L("break");
|
|
1122
|
+
var $L89 = $L("continue");
|
|
1123
|
+
var $L90 = $L("debugger");
|
|
1124
|
+
var $L91 = $L("assert");
|
|
1125
|
+
var $L92 = $L(":=");
|
|
1126
|
+
var $L93 = $L(".=");
|
|
1127
|
+
var $L94 = $L("/*");
|
|
1128
|
+
var $L95 = $L("*/");
|
|
1129
|
+
var $L96 = $L("\\");
|
|
1130
|
+
var $L97 = $L("[");
|
|
1131
|
+
var $L98 = $L("`");
|
|
1132
|
+
var $L99 = $L("abstract");
|
|
1133
|
+
var $L100 = $L("as");
|
|
1134
|
+
var $L101 = $L("@");
|
|
1135
|
+
var $L102 = $L("@@");
|
|
1136
|
+
var $L103 = $L("async");
|
|
1137
|
+
var $L104 = $L("await");
|
|
1138
|
+
var $L105 = $L("by");
|
|
1139
|
+
var $L106 = $L("case");
|
|
1140
|
+
var $L107 = $L("catch");
|
|
1141
|
+
var $L108 = $L("class");
|
|
1142
|
+
var $L109 = $L("#{");
|
|
1143
|
+
var $L110 = $L("declare");
|
|
1144
|
+
var $L111 = $L("default");
|
|
1145
|
+
var $L112 = $L("delete");
|
|
1146
|
+
var $L113 = $L("do");
|
|
1147
|
+
var $L114 = $L("..");
|
|
1148
|
+
var $L115 = $L("...");
|
|
1149
|
+
var $L116 = $L("::");
|
|
1150
|
+
var $L117 = $L('"');
|
|
1151
|
+
var $L118 = $L("else");
|
|
1152
|
+
var $L119 = $L("export");
|
|
1153
|
+
var $L120 = $L("extends");
|
|
1154
|
+
var $L121 = $L("finally");
|
|
1155
|
+
var $L122 = $L("for");
|
|
1156
|
+
var $L123 = $L("from");
|
|
1157
|
+
var $L124 = $L("function");
|
|
1158
|
+
var $L125 = $L("get");
|
|
1159
|
+
var $L126 = $L("set");
|
|
1160
|
+
var $L127 = $L("if");
|
|
1161
|
+
var $L128 = $L("let");
|
|
1162
|
+
var $L129 = $L("const");
|
|
1163
|
+
var $L130 = $L("loop");
|
|
1164
|
+
var $L131 = $L("new");
|
|
1165
|
+
var $L132 = $L("<");
|
|
1166
|
+
var $L133 = $L("{");
|
|
1167
|
+
var $L134 = $L("operator");
|
|
1168
|
+
var $L135 = $L("public");
|
|
1169
|
+
var $L136 = $L("private");
|
|
1170
|
+
var $L137 = $L("protected");
|
|
1171
|
+
var $L138 = $L("||>");
|
|
1172
|
+
var $L139 = $L("|>=");
|
|
1173
|
+
var $L140 = $L("|>");
|
|
1174
|
+
var $L141 = $L("readonly");
|
|
1175
|
+
var $L142 = $L("return");
|
|
1176
|
+
var $L143 = $L("satisfies");
|
|
1177
|
+
var $L144 = $L("'");
|
|
1178
|
+
var $L145 = $L("static");
|
|
1179
|
+
var $L146 = $L("${");
|
|
1180
|
+
var $L147 = $L("switch");
|
|
1181
|
+
var $L148 = $L("target");
|
|
1182
|
+
var $L149 = $L("then");
|
|
1183
|
+
var $L150 = $L("this");
|
|
1184
|
+
var $L151 = $L("throw");
|
|
1185
|
+
var $L152 = $L('"""');
|
|
1186
|
+
var $L153 = $L("'''");
|
|
1187
|
+
var $L154 = $L("///");
|
|
1188
|
+
var $L155 = $L("```");
|
|
1189
|
+
var $L156 = $L("try");
|
|
1190
|
+
var $L157 = $L("typeof");
|
|
1191
|
+
var $L158 = $L("unless");
|
|
1192
|
+
var $L159 = $L("until");
|
|
1193
|
+
var $L160 = $L("var");
|
|
1194
|
+
var $L161 = $L("void");
|
|
1195
|
+
var $L162 = $L("when");
|
|
1196
|
+
var $L163 = $L("while");
|
|
1197
|
+
var $L164 = $L("yield");
|
|
1198
|
+
var $L165 = $L("/>");
|
|
1199
|
+
var $L166 = $L("</");
|
|
1200
|
+
var $L167 = $L("<>");
|
|
1201
|
+
var $L168 = $L("</>");
|
|
1202
|
+
var $L169 = $L("<!--");
|
|
1203
|
+
var $L170 = $L("-->");
|
|
1204
|
+
var $L171 = $L("type");
|
|
1205
|
+
var $L172 = $L("interface");
|
|
1206
|
+
var $L173 = $L("namespace");
|
|
1207
|
+
var $L174 = $L("asserts");
|
|
1208
|
+
var $L175 = $L("keyof");
|
|
1209
|
+
var $L176 = $L("infer");
|
|
1210
|
+
var $L177 = $L("[]");
|
|
1211
|
+
var $L178 = $L("civet");
|
|
1206
1212
|
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1207
1213
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1208
1214
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -2372,7 +2378,7 @@ ${input.slice(result.pos)}
|
|
|
2372
2378
|
return {
|
|
2373
2379
|
type: "ArrowFunction",
|
|
2374
2380
|
parameters,
|
|
2375
|
-
returnType: suffix
|
|
2381
|
+
returnType: suffix,
|
|
2376
2382
|
ts: false,
|
|
2377
2383
|
block: expOrBlock,
|
|
2378
2384
|
children: $0
|
|
@@ -3160,7 +3166,7 @@ ${input.slice(result.pos)}
|
|
|
3160
3166
|
return result;
|
|
3161
3167
|
}
|
|
3162
3168
|
}
|
|
3163
|
-
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName,
|
|
3169
|
+
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, $E(_), Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3164
3170
|
var id = $2;
|
|
3165
3171
|
var exp = $6;
|
|
3166
3172
|
switch (exp.type) {
|
|
@@ -3305,7 +3311,8 @@ ${input.slice(result.pos)}
|
|
|
3305
3311
|
children: [$1, ...$2, ...rest.flat()]
|
|
3306
3312
|
});
|
|
3307
3313
|
});
|
|
3308
|
-
var CallExpression$2 =
|
|
3314
|
+
var CallExpression$2 = ReturnValue;
|
|
3315
|
+
var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3309
3316
|
var member = $1;
|
|
3310
3317
|
var trailing = $2;
|
|
3311
3318
|
var rest = $3;
|
|
@@ -3329,17 +3336,69 @@ ${input.slice(result.pos)}
|
|
|
3329
3336
|
}
|
|
3330
3337
|
}
|
|
3331
3338
|
if (state.tokenize) {
|
|
3332
|
-
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
3339
|
+
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state));
|
|
3333
3340
|
if (state.events)
|
|
3334
3341
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3335
3342
|
return result;
|
|
3336
3343
|
} else {
|
|
3337
|
-
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
|
|
3344
|
+
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state);
|
|
3338
3345
|
if (state.events)
|
|
3339
3346
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3340
3347
|
return result;
|
|
3341
3348
|
}
|
|
3342
3349
|
}
|
|
3350
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L14, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
3351
|
+
return { type: "ReturnValue", children: [$1[0]] };
|
|
3352
|
+
});
|
|
3353
|
+
function ReturnValue(state) {
|
|
3354
|
+
let eventData;
|
|
3355
|
+
if (state.events) {
|
|
3356
|
+
const result = state.events.enter?.("ReturnValue", state);
|
|
3357
|
+
if (result) {
|
|
3358
|
+
if (result.cache)
|
|
3359
|
+
return result.cache;
|
|
3360
|
+
eventData = result.data;
|
|
3361
|
+
}
|
|
3362
|
+
}
|
|
3363
|
+
if (state.tokenize) {
|
|
3364
|
+
const result = $TOKEN("ReturnValue", state, ReturnValue$0(state));
|
|
3365
|
+
if (state.events)
|
|
3366
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3367
|
+
return result;
|
|
3368
|
+
} else {
|
|
3369
|
+
const result = ReturnValue$0(state);
|
|
3370
|
+
if (state.events)
|
|
3371
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3372
|
+
return result;
|
|
3373
|
+
}
|
|
3374
|
+
}
|
|
3375
|
+
var AfterReturnShorthand$0 = WAssignmentOp;
|
|
3376
|
+
var AfterReturnShorthand$1 = UpdateExpressionSymbol;
|
|
3377
|
+
var AfterReturnShorthand$2 = TypeSuffix;
|
|
3378
|
+
var AfterReturnShorthand$3 = $S(__, LetAssignment);
|
|
3379
|
+
var AfterReturnShorthand$4 = $S(__, ConstAssignment);
|
|
3380
|
+
function AfterReturnShorthand(state) {
|
|
3381
|
+
let eventData;
|
|
3382
|
+
if (state.events) {
|
|
3383
|
+
const result = state.events.enter?.("AfterReturnShorthand", state);
|
|
3384
|
+
if (result) {
|
|
3385
|
+
if (result.cache)
|
|
3386
|
+
return result.cache;
|
|
3387
|
+
eventData = result.data;
|
|
3388
|
+
}
|
|
3389
|
+
}
|
|
3390
|
+
if (state.tokenize) {
|
|
3391
|
+
const result = $TOKEN("AfterReturnShorthand", state, AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state));
|
|
3392
|
+
if (state.events)
|
|
3393
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3394
|
+
return result;
|
|
3395
|
+
} else {
|
|
3396
|
+
const result = AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state);
|
|
3397
|
+
if (state.events)
|
|
3398
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3399
|
+
return result;
|
|
3400
|
+
}
|
|
3401
|
+
}
|
|
3343
3402
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
3344
3403
|
var CallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
|
|
3345
3404
|
if ($1.type === "StringLiteral") {
|
|
@@ -3426,7 +3485,7 @@ ${input.slice(result.pos)}
|
|
|
3426
3485
|
return result;
|
|
3427
3486
|
}
|
|
3428
3487
|
}
|
|
3429
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
3488
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L15, fail, 'NonNullAssertion "!"'), $N($EXPECT($L16, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3430
3489
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3431
3490
|
});
|
|
3432
3491
|
function NonNullAssertion(state) {
|
|
@@ -3564,7 +3623,7 @@ ${input.slice(result.pos)}
|
|
|
3564
3623
|
]
|
|
3565
3624
|
};
|
|
3566
3625
|
});
|
|
3567
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3626
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L17, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3568
3627
|
var dot = $1;
|
|
3569
3628
|
var neg = $2;
|
|
3570
3629
|
var num = $3;
|
|
@@ -3761,7 +3820,7 @@ ${input.slice(result.pos)}
|
|
|
3761
3820
|
}
|
|
3762
3821
|
}
|
|
3763
3822
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3764
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3823
|
+
var MetaProperty$1 = $TS($S($EXPECT($L18, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3765
3824
|
return { $loc, token: $1 };
|
|
3766
3825
|
});
|
|
3767
3826
|
function MetaProperty(state) {
|
|
@@ -3787,7 +3846,7 @@ ${input.slice(result.pos)}
|
|
|
3787
3846
|
}
|
|
3788
3847
|
}
|
|
3789
3848
|
var Parameters$0 = NonEmptyParameters;
|
|
3790
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3849
|
+
var Parameters$1 = $TV($EXPECT($L19, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3791
3850
|
return {
|
|
3792
3851
|
type: "Parameters",
|
|
3793
3852
|
children: [{ $loc, token: "()" }],
|
|
@@ -4010,6 +4069,9 @@ ${input.slice(result.pos)}
|
|
|
4010
4069
|
};
|
|
4011
4070
|
});
|
|
4012
4071
|
var NWBindingIdentifier$1 = Identifier;
|
|
4072
|
+
var NWBindingIdentifier$2 = $TS($S(ReturnValue), function($skip, $loc, $0, $1) {
|
|
4073
|
+
return { children: [$1], names: [] };
|
|
4074
|
+
});
|
|
4013
4075
|
function NWBindingIdentifier(state) {
|
|
4014
4076
|
let eventData;
|
|
4015
4077
|
if (state.events) {
|
|
@@ -4021,12 +4083,12 @@ ${input.slice(result.pos)}
|
|
|
4021
4083
|
}
|
|
4022
4084
|
}
|
|
4023
4085
|
if (state.tokenize) {
|
|
4024
|
-
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state));
|
|
4086
|
+
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state));
|
|
4025
4087
|
if (state.events)
|
|
4026
4088
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4027
4089
|
return result;
|
|
4028
4090
|
} else {
|
|
4029
|
-
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state);
|
|
4091
|
+
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state);
|
|
4030
4092
|
if (state.events)
|
|
4031
4093
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4032
4094
|
return result;
|
|
@@ -4407,7 +4469,7 @@ ${input.slice(result.pos)}
|
|
|
4407
4469
|
}
|
|
4408
4470
|
}
|
|
4409
4471
|
var BindingProperty$0 = BindingRestProperty;
|
|
4410
|
-
var BindingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4472
|
+
var BindingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4411
4473
|
var name = $2;
|
|
4412
4474
|
var b = $5;
|
|
4413
4475
|
var init = $6;
|
|
@@ -4568,7 +4630,7 @@ ${input.slice(result.pos)}
|
|
|
4568
4630
|
children: $0
|
|
4569
4631
|
};
|
|
4570
4632
|
});
|
|
4571
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4633
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4572
4634
|
return {
|
|
4573
4635
|
children: [{
|
|
4574
4636
|
type: "ElisionElement",
|
|
@@ -4641,7 +4703,7 @@ ${input.slice(result.pos)}
|
|
|
4641
4703
|
return result;
|
|
4642
4704
|
}
|
|
4643
4705
|
}
|
|
4644
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4706
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L19, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4645
4707
|
const ref = {
|
|
4646
4708
|
type: "Ref",
|
|
4647
4709
|
base: "ref",
|
|
@@ -4859,7 +4921,7 @@ ${input.slice(result.pos)}
|
|
|
4859
4921
|
}
|
|
4860
4922
|
}
|
|
4861
4923
|
var MatchingProperty$0 = MatchingRestProperty;
|
|
4862
|
-
var MatchingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4924
|
+
var MatchingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4863
4925
|
var name = $2;
|
|
4864
4926
|
var match = $6;
|
|
4865
4927
|
return {
|
|
@@ -5085,7 +5147,7 @@ ${input.slice(result.pos)}
|
|
|
5085
5147
|
}
|
|
5086
5148
|
}
|
|
5087
5149
|
var MatchingElement$0 = MatchingRestElement;
|
|
5088
|
-
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier,
|
|
5150
|
+
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5089
5151
|
var ws = $1;
|
|
5090
5152
|
var name = $2;
|
|
5091
5153
|
var match = $6;
|
|
@@ -5117,7 +5179,7 @@ ${input.slice(result.pos)}
|
|
|
5117
5179
|
children: [ws, binding]
|
|
5118
5180
|
};
|
|
5119
5181
|
});
|
|
5120
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5182
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5121
5183
|
return {
|
|
5122
5184
|
children: [{
|
|
5123
5185
|
type: "ElisionElement",
|
|
@@ -5210,7 +5272,7 @@ ${input.slice(result.pos)}
|
|
|
5210
5272
|
type: "FunctionSignature",
|
|
5211
5273
|
id: wid?.[1],
|
|
5212
5274
|
parameters,
|
|
5213
|
-
returnType: suffix
|
|
5275
|
+
returnType: suffix,
|
|
5214
5276
|
ts: false,
|
|
5215
5277
|
block: null,
|
|
5216
5278
|
children: !parameters.implicit ? $0 : [async, func, star, wid, parameters, w, suffix]
|
|
@@ -5369,7 +5431,7 @@ ${input.slice(result.pos)}
|
|
|
5369
5431
|
type: "FunctionSignature",
|
|
5370
5432
|
id,
|
|
5371
5433
|
parameters,
|
|
5372
|
-
returnType: suffix
|
|
5434
|
+
returnType: suffix,
|
|
5373
5435
|
ts: false,
|
|
5374
5436
|
block: null,
|
|
5375
5437
|
children: [func, w1, id, w2, parameters, suffix]
|
|
@@ -5478,7 +5540,7 @@ ${input.slice(result.pos)}
|
|
|
5478
5540
|
type: "FunctionExpression",
|
|
5479
5541
|
id: void 0,
|
|
5480
5542
|
parameters,
|
|
5481
|
-
returnType: suffix
|
|
5543
|
+
returnType: suffix,
|
|
5482
5544
|
ts: false,
|
|
5483
5545
|
block,
|
|
5484
5546
|
children: [
|
|
@@ -5511,7 +5573,7 @@ ${input.slice(result.pos)}
|
|
|
5511
5573
|
return result;
|
|
5512
5574
|
}
|
|
5513
5575
|
}
|
|
5514
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5576
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5515
5577
|
return { $loc, token: $1 };
|
|
5516
5578
|
});
|
|
5517
5579
|
function Arrow(state) {
|
|
@@ -5575,12 +5637,16 @@ ${input.slice(result.pos)}
|
|
|
5575
5637
|
return result;
|
|
5576
5638
|
}
|
|
5577
5639
|
}
|
|
5578
|
-
var ImplicitNestedBlock$0 = $TS($S(InsertOpenBrace, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5579
|
-
var
|
|
5580
|
-
|
|
5581
|
-
|
|
5640
|
+
var ImplicitNestedBlock$0 = $TS($S($Y(EOS), InsertOpenBrace, AllowAll, $E($S(NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5641
|
+
var open = $2;
|
|
5642
|
+
if (!$4)
|
|
5643
|
+
return $skip;
|
|
5644
|
+
const [block, ...tail] = $4;
|
|
5645
|
+
return {
|
|
5646
|
+
...block,
|
|
5647
|
+
children: [open, ...block.children, ...tail],
|
|
5582
5648
|
bare: false
|
|
5583
|
-
}
|
|
5649
|
+
};
|
|
5584
5650
|
});
|
|
5585
5651
|
function ImplicitNestedBlock(state) {
|
|
5586
5652
|
let eventData;
|
|
@@ -5745,7 +5811,7 @@ ${input.slice(result.pos)}
|
|
|
5745
5811
|
return result;
|
|
5746
5812
|
}
|
|
5747
5813
|
}
|
|
5748
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5814
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L19, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5749
5815
|
const expressions = [];
|
|
5750
5816
|
return {
|
|
5751
5817
|
type: "BlockStatement",
|
|
@@ -5848,12 +5914,16 @@ ${input.slice(result.pos)}
|
|
|
5848
5914
|
return result;
|
|
5849
5915
|
}
|
|
5850
5916
|
}
|
|
5851
|
-
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5852
|
-
var
|
|
5917
|
+
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5918
|
+
var ws1 = $1;
|
|
5919
|
+
var open = $2;
|
|
5920
|
+
if (!$4)
|
|
5921
|
+
return $skip;
|
|
5922
|
+
const [block, ws2, close] = $4;
|
|
5853
5923
|
return {
|
|
5854
5924
|
type: "BlockStatement",
|
|
5855
5925
|
expressions: block.expressions,
|
|
5856
|
-
children: [
|
|
5926
|
+
children: [ws1, open, ...block.children, ws2, close],
|
|
5857
5927
|
bare: false
|
|
5858
5928
|
};
|
|
5859
5929
|
return block;
|
|
@@ -5968,7 +6038,7 @@ ${input.slice(result.pos)}
|
|
|
5968
6038
|
children: [$1, expressions]
|
|
5969
6039
|
};
|
|
5970
6040
|
});
|
|
5971
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6041
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5972
6042
|
const expressions = [];
|
|
5973
6043
|
return {
|
|
5974
6044
|
type: "BlockStatement",
|
|
@@ -6113,7 +6183,7 @@ ${input.slice(result.pos)}
|
|
|
6113
6183
|
return result;
|
|
6114
6184
|
}
|
|
6115
6185
|
}
|
|
6116
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6186
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6117
6187
|
return { $loc, token: $1 };
|
|
6118
6188
|
});
|
|
6119
6189
|
function NullLiteral(state) {
|
|
@@ -6141,7 +6211,7 @@ ${input.slice(result.pos)}
|
|
|
6141
6211
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6142
6212
|
return value[1];
|
|
6143
6213
|
});
|
|
6144
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6214
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6145
6215
|
return { $loc, token: $1 };
|
|
6146
6216
|
});
|
|
6147
6217
|
function BooleanLiteral(state) {
|
|
@@ -6166,10 +6236,10 @@ ${input.slice(result.pos)}
|
|
|
6166
6236
|
return result;
|
|
6167
6237
|
}
|
|
6168
6238
|
}
|
|
6169
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6239
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6170
6240
|
return { $loc, token: "true" };
|
|
6171
6241
|
});
|
|
6172
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6242
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6173
6243
|
return { $loc, token: "false" };
|
|
6174
6244
|
});
|
|
6175
6245
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6275,7 +6345,7 @@ ${input.slice(result.pos)}
|
|
|
6275
6345
|
return result;
|
|
6276
6346
|
}
|
|
6277
6347
|
}
|
|
6278
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6348
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6279
6349
|
function UpcomingAssignment(state) {
|
|
6280
6350
|
let eventData;
|
|
6281
6351
|
if (state.events) {
|
|
@@ -6541,7 +6611,7 @@ ${input.slice(result.pos)}
|
|
|
6541
6611
|
}
|
|
6542
6612
|
}
|
|
6543
6613
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6544
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6614
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6545
6615
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6546
6616
|
return value[1];
|
|
6547
6617
|
});
|
|
@@ -6968,7 +7038,7 @@ ${input.slice(result.pos)}
|
|
|
6968
7038
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6969
7039
|
return value[1];
|
|
6970
7040
|
});
|
|
6971
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
7041
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L32, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L33, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L31, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L22, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
|
|
6972
7042
|
return "";
|
|
6973
7043
|
});
|
|
6974
7044
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6997,7 +7067,7 @@ ${input.slice(result.pos)}
|
|
|
6997
7067
|
}
|
|
6998
7068
|
}
|
|
6999
7069
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
7000
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7070
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
7001
7071
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7002
7072
|
return value[1];
|
|
7003
7073
|
});
|
|
@@ -7167,7 +7237,7 @@ ${input.slice(result.pos)}
|
|
|
7167
7237
|
return result;
|
|
7168
7238
|
}
|
|
7169
7239
|
}
|
|
7170
|
-
var NamedProperty$0 = $TS($S(PropertyName,
|
|
7240
|
+
var NamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7171
7241
|
var name = $1;
|
|
7172
7242
|
var exp = $4;
|
|
7173
7243
|
return {
|
|
@@ -7200,7 +7270,7 @@ ${input.slice(result.pos)}
|
|
|
7200
7270
|
return result;
|
|
7201
7271
|
}
|
|
7202
7272
|
}
|
|
7203
|
-
var ImplicitNamedProperty$0 = $TS($S(PropertyName,
|
|
7273
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7204
7274
|
var name = $1;
|
|
7205
7275
|
var exp = $5;
|
|
7206
7276
|
return {
|
|
@@ -7307,7 +7377,7 @@ ${input.slice(result.pos)}
|
|
|
7307
7377
|
expression
|
|
7308
7378
|
};
|
|
7309
7379
|
});
|
|
7310
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7380
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L17, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7311
7381
|
return {
|
|
7312
7382
|
type: "ComputedPropertyName",
|
|
7313
7383
|
children: $0
|
|
@@ -7475,7 +7545,7 @@ ${input.slice(result.pos)}
|
|
|
7475
7545
|
children: $0,
|
|
7476
7546
|
name,
|
|
7477
7547
|
modifier: $1?.[0]?.token,
|
|
7478
|
-
returnType:
|
|
7548
|
+
returnType: suffix,
|
|
7479
7549
|
parameters
|
|
7480
7550
|
};
|
|
7481
7551
|
});
|
|
@@ -7656,22 +7726,22 @@ ${input.slice(result.pos)}
|
|
|
7656
7726
|
return result;
|
|
7657
7727
|
}
|
|
7658
7728
|
}
|
|
7659
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7660
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7661
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7662
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7663
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7664
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7665
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7666
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7667
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7668
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7669
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7670
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7671
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7672
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7673
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7674
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7729
|
+
var AssignmentOpSymbol$0 = $EXPECT($L34, fail, 'AssignmentOpSymbol "**="');
|
|
7730
|
+
var AssignmentOpSymbol$1 = $EXPECT($L35, fail, 'AssignmentOpSymbol "*="');
|
|
7731
|
+
var AssignmentOpSymbol$2 = $EXPECT($L36, fail, 'AssignmentOpSymbol "/="');
|
|
7732
|
+
var AssignmentOpSymbol$3 = $EXPECT($L37, fail, 'AssignmentOpSymbol "%="');
|
|
7733
|
+
var AssignmentOpSymbol$4 = $EXPECT($L38, fail, 'AssignmentOpSymbol "+="');
|
|
7734
|
+
var AssignmentOpSymbol$5 = $EXPECT($L39, fail, 'AssignmentOpSymbol "-="');
|
|
7735
|
+
var AssignmentOpSymbol$6 = $EXPECT($L40, fail, 'AssignmentOpSymbol "<<="');
|
|
7736
|
+
var AssignmentOpSymbol$7 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>>="');
|
|
7737
|
+
var AssignmentOpSymbol$8 = $EXPECT($L42, fail, 'AssignmentOpSymbol ">>="');
|
|
7738
|
+
var AssignmentOpSymbol$9 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&&="');
|
|
7739
|
+
var AssignmentOpSymbol$10 = $EXPECT($L44, fail, 'AssignmentOpSymbol "&="');
|
|
7740
|
+
var AssignmentOpSymbol$11 = $EXPECT($L45, fail, 'AssignmentOpSymbol "^="');
|
|
7741
|
+
var AssignmentOpSymbol$12 = $EXPECT($L46, fail, 'AssignmentOpSymbol "||="');
|
|
7742
|
+
var AssignmentOpSymbol$13 = $EXPECT($L47, fail, 'AssignmentOpSymbol "|="');
|
|
7743
|
+
var AssignmentOpSymbol$14 = $EXPECT($L48, fail, 'AssignmentOpSymbol "??="');
|
|
7744
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L49, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7675
7745
|
return "??=";
|
|
7676
7746
|
});
|
|
7677
7747
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7702,10 +7772,10 @@ ${input.slice(result.pos)}
|
|
|
7702
7772
|
return result;
|
|
7703
7773
|
}
|
|
7704
7774
|
}
|
|
7705
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7775
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7706
7776
|
return "&&=";
|
|
7707
7777
|
});
|
|
7708
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7778
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L51, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7709
7779
|
return "||=";
|
|
7710
7780
|
});
|
|
7711
7781
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7744,7 +7814,7 @@ ${input.slice(result.pos)}
|
|
|
7744
7814
|
special: true
|
|
7745
7815
|
};
|
|
7746
7816
|
});
|
|
7747
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7817
|
+
var BinaryOp$2 = $TS($S($EXPECT($L52, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7748
7818
|
var id = $4;
|
|
7749
7819
|
if (!module.operators.has(id.name))
|
|
7750
7820
|
return $skip;
|
|
@@ -7776,21 +7846,21 @@ ${input.slice(result.pos)}
|
|
|
7776
7846
|
return result;
|
|
7777
7847
|
}
|
|
7778
7848
|
}
|
|
7779
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7780
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7781
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7782
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7849
|
+
var BinaryOpSymbol$0 = $EXPECT($L53, fail, 'BinaryOpSymbol "**"');
|
|
7850
|
+
var BinaryOpSymbol$1 = $EXPECT($L54, fail, 'BinaryOpSymbol "*"');
|
|
7851
|
+
var BinaryOpSymbol$2 = $EXPECT($L55, fail, 'BinaryOpSymbol "/"');
|
|
7852
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7783
7853
|
return {
|
|
7784
7854
|
call: module.getRef("modulo"),
|
|
7785
7855
|
special: true
|
|
7786
7856
|
};
|
|
7787
7857
|
});
|
|
7788
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7789
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7790
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7791
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7792
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7793
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7858
|
+
var BinaryOpSymbol$4 = $EXPECT($L57, fail, 'BinaryOpSymbol "%"');
|
|
7859
|
+
var BinaryOpSymbol$5 = $EXPECT($L58, fail, 'BinaryOpSymbol "+"');
|
|
7860
|
+
var BinaryOpSymbol$6 = $EXPECT($L17, fail, 'BinaryOpSymbol "-"');
|
|
7861
|
+
var BinaryOpSymbol$7 = $EXPECT($L59, fail, 'BinaryOpSymbol "<="');
|
|
7862
|
+
var BinaryOpSymbol$8 = $EXPECT($L60, fail, 'BinaryOpSymbol ">="');
|
|
7863
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7794
7864
|
return {
|
|
7795
7865
|
$loc,
|
|
7796
7866
|
token: "instanceof",
|
|
@@ -7798,7 +7868,7 @@ ${input.slice(result.pos)}
|
|
|
7798
7868
|
special: true
|
|
7799
7869
|
};
|
|
7800
7870
|
});
|
|
7801
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7871
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L62, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7802
7872
|
return {
|
|
7803
7873
|
$loc,
|
|
7804
7874
|
token: "instanceof",
|
|
@@ -7807,58 +7877,58 @@ ${input.slice(result.pos)}
|
|
|
7807
7877
|
negated: true
|
|
7808
7878
|
};
|
|
7809
7879
|
});
|
|
7810
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7880
|
+
var BinaryOpSymbol$11 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
7811
7881
|
var BinaryOpSymbol$12 = $TR($EXPECT($R7, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7812
7882
|
return "<";
|
|
7813
7883
|
});
|
|
7814
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7815
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7816
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7817
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7818
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7884
|
+
var BinaryOpSymbol$13 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
7885
|
+
var BinaryOpSymbol$14 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
7886
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7887
|
+
var BinaryOpSymbol$16 = $EXPECT($L66, fail, 'BinaryOpSymbol "!=="');
|
|
7888
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L67, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7819
7889
|
if (module.config.coffeeEq)
|
|
7820
7890
|
return "!==";
|
|
7821
7891
|
return $1;
|
|
7822
7892
|
});
|
|
7823
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7893
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7824
7894
|
if (module.config.coffeeIsnt)
|
|
7825
7895
|
return "!==";
|
|
7826
7896
|
return $skip;
|
|
7827
7897
|
});
|
|
7828
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7829
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7898
|
+
var BinaryOpSymbol$19 = $EXPECT($L69, fail, 'BinaryOpSymbol "==="');
|
|
7899
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7830
7900
|
if (module.config.coffeeEq)
|
|
7831
7901
|
return "===";
|
|
7832
7902
|
return $1;
|
|
7833
7903
|
});
|
|
7834
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7904
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7835
7905
|
return "&&";
|
|
7836
7906
|
});
|
|
7837
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7838
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7907
|
+
var BinaryOpSymbol$22 = $EXPECT($L72, fail, 'BinaryOpSymbol "&&"');
|
|
7908
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7839
7909
|
return "in";
|
|
7840
7910
|
});
|
|
7841
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7911
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7842
7912
|
return "||";
|
|
7843
7913
|
});
|
|
7844
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7845
|
-
var BinaryOpSymbol$26 = $TV($C($EXPECT($
|
|
7914
|
+
var BinaryOpSymbol$25 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
7915
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L76, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7846
7916
|
return {
|
|
7847
7917
|
call: module.getRef("xor"),
|
|
7848
7918
|
special: true
|
|
7849
7919
|
};
|
|
7850
7920
|
});
|
|
7851
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
7921
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L78, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7852
7922
|
return {
|
|
7853
7923
|
call: module.getRef("xnor"),
|
|
7854
7924
|
special: true
|
|
7855
7925
|
};
|
|
7856
7926
|
});
|
|
7857
|
-
var BinaryOpSymbol$28 = $EXPECT($
|
|
7927
|
+
var BinaryOpSymbol$28 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
|
|
7858
7928
|
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7859
7929
|
return "??";
|
|
7860
7930
|
});
|
|
7861
|
-
var BinaryOpSymbol$30 = $TS($S($EXPECT($
|
|
7931
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7862
7932
|
return {
|
|
7863
7933
|
$loc,
|
|
7864
7934
|
token: $1,
|
|
@@ -7866,7 +7936,7 @@ ${input.slice(result.pos)}
|
|
|
7866
7936
|
special: true
|
|
7867
7937
|
};
|
|
7868
7938
|
});
|
|
7869
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
7939
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7870
7940
|
return {
|
|
7871
7941
|
$loc,
|
|
7872
7942
|
token: "instanceof",
|
|
@@ -7875,7 +7945,7 @@ ${input.slice(result.pos)}
|
|
|
7875
7945
|
negated: true
|
|
7876
7946
|
};
|
|
7877
7947
|
});
|
|
7878
|
-
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($
|
|
7948
|
+
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7879
7949
|
return {
|
|
7880
7950
|
$loc,
|
|
7881
7951
|
token: "in",
|
|
@@ -7883,7 +7953,7 @@ ${input.slice(result.pos)}
|
|
|
7883
7953
|
negated: true
|
|
7884
7954
|
};
|
|
7885
7955
|
});
|
|
7886
|
-
var BinaryOpSymbol$33 = $TS($S($EXPECT($
|
|
7956
|
+
var BinaryOpSymbol$33 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7887
7957
|
return {
|
|
7888
7958
|
method: "includes",
|
|
7889
7959
|
relational: true,
|
|
@@ -7891,7 +7961,7 @@ ${input.slice(result.pos)}
|
|
|
7891
7961
|
special: true
|
|
7892
7962
|
};
|
|
7893
7963
|
});
|
|
7894
|
-
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7964
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7895
7965
|
return {
|
|
7896
7966
|
call: [module.getRef("indexOf"), ".call"],
|
|
7897
7967
|
relational: true,
|
|
@@ -7900,7 +7970,7 @@ ${input.slice(result.pos)}
|
|
|
7900
7970
|
special: true
|
|
7901
7971
|
};
|
|
7902
7972
|
});
|
|
7903
|
-
var BinaryOpSymbol$35 = $TS($S($EXPECT($
|
|
7973
|
+
var BinaryOpSymbol$35 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
7904
7974
|
return {
|
|
7905
7975
|
method: "includes",
|
|
7906
7976
|
relational: true,
|
|
@@ -7909,7 +7979,7 @@ ${input.slice(result.pos)}
|
|
|
7909
7979
|
negated: true
|
|
7910
7980
|
};
|
|
7911
7981
|
});
|
|
7912
|
-
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7982
|
+
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7913
7983
|
return {
|
|
7914
7984
|
call: [module.getRef("indexOf"), ".call"],
|
|
7915
7985
|
relational: true,
|
|
@@ -7918,7 +7988,7 @@ ${input.slice(result.pos)}
|
|
|
7918
7988
|
special: true
|
|
7919
7989
|
};
|
|
7920
7990
|
});
|
|
7921
|
-
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($
|
|
7991
|
+
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L52, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7922
7992
|
if (module.config.objectIs) {
|
|
7923
7993
|
return {
|
|
7924
7994
|
call: module.getRef("is"),
|
|
@@ -7930,7 +8000,7 @@ ${input.slice(result.pos)}
|
|
|
7930
8000
|
}
|
|
7931
8001
|
return "!==";
|
|
7932
8002
|
});
|
|
7933
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8003
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7934
8004
|
if (module.config.objectIs) {
|
|
7935
8005
|
return {
|
|
7936
8006
|
call: module.getRef("is"),
|
|
@@ -7941,12 +8011,12 @@ ${input.slice(result.pos)}
|
|
|
7941
8011
|
}
|
|
7942
8012
|
return "===";
|
|
7943
8013
|
});
|
|
7944
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
8014
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7945
8015
|
return $1;
|
|
7946
8016
|
});
|
|
7947
|
-
var BinaryOpSymbol$40 = $EXPECT($
|
|
7948
|
-
var BinaryOpSymbol$41 = $EXPECT($
|
|
7949
|
-
var BinaryOpSymbol$42 = $EXPECT($
|
|
8017
|
+
var BinaryOpSymbol$40 = $EXPECT($L83, fail, 'BinaryOpSymbol "&"');
|
|
8018
|
+
var BinaryOpSymbol$41 = $EXPECT($L16, fail, 'BinaryOpSymbol "^"');
|
|
8019
|
+
var BinaryOpSymbol$42 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
|
|
7950
8020
|
function BinaryOpSymbol(state) {
|
|
7951
8021
|
let eventData;
|
|
7952
8022
|
if (state.events) {
|
|
@@ -7969,8 +8039,8 @@ ${input.slice(result.pos)}
|
|
|
7969
8039
|
return result;
|
|
7970
8040
|
}
|
|
7971
8041
|
}
|
|
7972
|
-
var Xor$0 = $EXPECT($
|
|
7973
|
-
var Xor$1 = $S($EXPECT($
|
|
8042
|
+
var Xor$0 = $EXPECT($L76, fail, 'Xor "^^"');
|
|
8043
|
+
var Xor$1 = $S($EXPECT($L77, fail, 'Xor "xor"'), NonIdContinue);
|
|
7974
8044
|
function Xor(state) {
|
|
7975
8045
|
let eventData;
|
|
7976
8046
|
if (state.events) {
|
|
@@ -7994,7 +8064,7 @@ ${input.slice(result.pos)}
|
|
|
7994
8064
|
}
|
|
7995
8065
|
}
|
|
7996
8066
|
var Xnor$0 = $R$0($EXPECT($R8, fail, "Xnor /!\\^\\^?/"));
|
|
7997
|
-
var Xnor$1 = $EXPECT($
|
|
8067
|
+
var Xnor$1 = $EXPECT($L78, fail, 'Xnor "xnor"');
|
|
7998
8068
|
function Xnor(state) {
|
|
7999
8069
|
let eventData;
|
|
8000
8070
|
if (state.events) {
|
|
@@ -8215,7 +8285,7 @@ ${input.slice(result.pos)}
|
|
|
8215
8285
|
return result;
|
|
8216
8286
|
}
|
|
8217
8287
|
}
|
|
8218
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8288
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8219
8289
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8220
8290
|
});
|
|
8221
8291
|
function EmptyStatement(state) {
|
|
@@ -8294,7 +8364,7 @@ ${input.slice(result.pos)}
|
|
|
8294
8364
|
var w = $3;
|
|
8295
8365
|
return [id, colon, w];
|
|
8296
8366
|
});
|
|
8297
|
-
var Label$1 = $S($EXPECT($
|
|
8367
|
+
var Label$1 = $S($EXPECT($L86, fail, 'Label "$:"'), Whitespace);
|
|
8298
8368
|
function Label(state) {
|
|
8299
8369
|
let eventData;
|
|
8300
8370
|
if (state.events) {
|
|
@@ -9246,7 +9316,7 @@ ${input.slice(result.pos)}
|
|
|
9246
9316
|
return result;
|
|
9247
9317
|
}
|
|
9248
9318
|
}
|
|
9249
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9319
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L87, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9250
9320
|
var own = $1;
|
|
9251
9321
|
var binding = $2;
|
|
9252
9322
|
return {
|
|
@@ -9730,8 +9800,8 @@ ${input.slice(result.pos)}
|
|
|
9730
9800
|
return result;
|
|
9731
9801
|
}
|
|
9732
9802
|
}
|
|
9733
|
-
var ImpliedColon$0 = $S(
|
|
9734
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9803
|
+
var ImpliedColon$0 = $S($E(_), Colon);
|
|
9804
|
+
var ImpliedColon$1 = $TV($EXPECT($L19, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9735
9805
|
return { $loc, token: ":" };
|
|
9736
9806
|
});
|
|
9737
9807
|
function ImpliedColon(state) {
|
|
@@ -9984,7 +10054,7 @@ ${input.slice(result.pos)}
|
|
|
9984
10054
|
return result;
|
|
9985
10055
|
}
|
|
9986
10056
|
}
|
|
9987
|
-
var ForbidIndentedApplication$0 = $TV($EXPECT($
|
|
10057
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L19, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9988
10058
|
module.forbidIndentedApplication.push(true);
|
|
9989
10059
|
});
|
|
9990
10060
|
function ForbidIndentedApplication(state) {
|
|
@@ -10009,7 +10079,7 @@ ${input.slice(result.pos)}
|
|
|
10009
10079
|
return result;
|
|
10010
10080
|
}
|
|
10011
10081
|
}
|
|
10012
|
-
var AllowIndentedApplication$0 = $TV($EXPECT($
|
|
10082
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L19, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10013
10083
|
module.forbidIndentedApplication.push(false);
|
|
10014
10084
|
});
|
|
10015
10085
|
function AllowIndentedApplication(state) {
|
|
@@ -10034,7 +10104,7 @@ ${input.slice(result.pos)}
|
|
|
10034
10104
|
return result;
|
|
10035
10105
|
}
|
|
10036
10106
|
}
|
|
10037
|
-
var RestoreIndentedApplication$0 = $TV($EXPECT($
|
|
10107
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L19, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10038
10108
|
module.forbidIndentedApplication.pop();
|
|
10039
10109
|
});
|
|
10040
10110
|
function RestoreIndentedApplication(state) {
|
|
@@ -10059,7 +10129,7 @@ ${input.slice(result.pos)}
|
|
|
10059
10129
|
return result;
|
|
10060
10130
|
}
|
|
10061
10131
|
}
|
|
10062
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
10132
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L19, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10063
10133
|
if (module.config.verbose) {
|
|
10064
10134
|
console.log("forbidIndentedApplication:", module.forbidIndentedApplication);
|
|
10065
10135
|
}
|
|
@@ -10089,7 +10159,7 @@ ${input.slice(result.pos)}
|
|
|
10089
10159
|
return result;
|
|
10090
10160
|
}
|
|
10091
10161
|
}
|
|
10092
|
-
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10162
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10093
10163
|
module.forbidTrailingMemberProperty.push(true);
|
|
10094
10164
|
});
|
|
10095
10165
|
function ForbidTrailingMemberProperty(state) {
|
|
@@ -10114,7 +10184,7 @@ ${input.slice(result.pos)}
|
|
|
10114
10184
|
return result;
|
|
10115
10185
|
}
|
|
10116
10186
|
}
|
|
10117
|
-
var AllowTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10187
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10118
10188
|
module.forbidTrailingMemberProperty.push(false);
|
|
10119
10189
|
});
|
|
10120
10190
|
function AllowTrailingMemberProperty(state) {
|
|
@@ -10139,7 +10209,7 @@ ${input.slice(result.pos)}
|
|
|
10139
10209
|
return result;
|
|
10140
10210
|
}
|
|
10141
10211
|
}
|
|
10142
|
-
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10212
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10143
10213
|
module.forbidTrailingMemberProperty.pop();
|
|
10144
10214
|
});
|
|
10145
10215
|
function RestoreTrailingMemberProperty(state) {
|
|
@@ -10164,7 +10234,7 @@ ${input.slice(result.pos)}
|
|
|
10164
10234
|
return result;
|
|
10165
10235
|
}
|
|
10166
10236
|
}
|
|
10167
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
10237
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L19, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10168
10238
|
if (module.config.verbose) {
|
|
10169
10239
|
console.log("forbidTrailingMemberProperty:", module.forbidTrailingMemberProperty);
|
|
10170
10240
|
}
|
|
@@ -10193,7 +10263,7 @@ ${input.slice(result.pos)}
|
|
|
10193
10263
|
return result;
|
|
10194
10264
|
}
|
|
10195
10265
|
}
|
|
10196
|
-
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10266
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10197
10267
|
module.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10198
10268
|
});
|
|
10199
10269
|
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10218,7 +10288,7 @@ ${input.slice(result.pos)}
|
|
|
10218
10288
|
return result;
|
|
10219
10289
|
}
|
|
10220
10290
|
}
|
|
10221
|
-
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10291
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10222
10292
|
module.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10223
10293
|
});
|
|
10224
10294
|
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10243,7 +10313,7 @@ ${input.slice(result.pos)}
|
|
|
10243
10313
|
return result;
|
|
10244
10314
|
}
|
|
10245
10315
|
}
|
|
10246
|
-
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10316
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10247
10317
|
module.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10248
10318
|
});
|
|
10249
10319
|
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10268,7 +10338,7 @@ ${input.slice(result.pos)}
|
|
|
10268
10338
|
return result;
|
|
10269
10339
|
}
|
|
10270
10340
|
}
|
|
10271
|
-
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($
|
|
10341
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L19, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10272
10342
|
if (module.config.verbose) {
|
|
10273
10343
|
console.log("forbidMultiLineImplicitObjectLiteral:", module.forbidMultiLineImplicitObjectLiteral);
|
|
10274
10344
|
}
|
|
@@ -10366,17 +10436,24 @@ ${input.slice(result.pos)}
|
|
|
10366
10436
|
return result;
|
|
10367
10437
|
}
|
|
10368
10438
|
}
|
|
10369
|
-
var KeywordStatement$0 = $
|
|
10370
|
-
return {
|
|
10439
|
+
var KeywordStatement$0 = $TS($S(Break, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10440
|
+
return {
|
|
10441
|
+
type: "BreakStatement",
|
|
10442
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10443
|
+
};
|
|
10371
10444
|
});
|
|
10372
|
-
var KeywordStatement$1 = $
|
|
10373
|
-
return {
|
|
10445
|
+
var KeywordStatement$1 = $TS($S(Continue, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10446
|
+
return {
|
|
10447
|
+
type: "ContinueStatement",
|
|
10448
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10449
|
+
};
|
|
10374
10450
|
});
|
|
10375
|
-
var KeywordStatement$2 = $T($S(
|
|
10451
|
+
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
10376
10452
|
return { "type": "DebuggerStatement", "children": value };
|
|
10377
10453
|
});
|
|
10378
|
-
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
10379
|
-
|
|
10454
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L4, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10455
|
+
var expression = value[2];
|
|
10456
|
+
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10380
10457
|
});
|
|
10381
10458
|
var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
|
|
10382
10459
|
return { "type": "ThrowStatement", "children": value };
|
|
@@ -10403,7 +10480,82 @@ ${input.slice(result.pos)}
|
|
|
10403
10480
|
return result;
|
|
10404
10481
|
}
|
|
10405
10482
|
}
|
|
10406
|
-
var
|
|
10483
|
+
var Break$0 = $TS($S($EXPECT($L88, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10484
|
+
return { $loc, token: $1 };
|
|
10485
|
+
});
|
|
10486
|
+
function Break(state) {
|
|
10487
|
+
let eventData;
|
|
10488
|
+
if (state.events) {
|
|
10489
|
+
const result = state.events.enter?.("Break", state);
|
|
10490
|
+
if (result) {
|
|
10491
|
+
if (result.cache)
|
|
10492
|
+
return result.cache;
|
|
10493
|
+
eventData = result.data;
|
|
10494
|
+
}
|
|
10495
|
+
}
|
|
10496
|
+
if (state.tokenize) {
|
|
10497
|
+
const result = $TOKEN("Break", state, Break$0(state));
|
|
10498
|
+
if (state.events)
|
|
10499
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10500
|
+
return result;
|
|
10501
|
+
} else {
|
|
10502
|
+
const result = Break$0(state);
|
|
10503
|
+
if (state.events)
|
|
10504
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10505
|
+
return result;
|
|
10506
|
+
}
|
|
10507
|
+
}
|
|
10508
|
+
var Continue$0 = $TS($S($EXPECT($L89, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10509
|
+
return { $loc, token: $1 };
|
|
10510
|
+
});
|
|
10511
|
+
function Continue(state) {
|
|
10512
|
+
let eventData;
|
|
10513
|
+
if (state.events) {
|
|
10514
|
+
const result = state.events.enter?.("Continue", state);
|
|
10515
|
+
if (result) {
|
|
10516
|
+
if (result.cache)
|
|
10517
|
+
return result.cache;
|
|
10518
|
+
eventData = result.data;
|
|
10519
|
+
}
|
|
10520
|
+
}
|
|
10521
|
+
if (state.tokenize) {
|
|
10522
|
+
const result = $TOKEN("Continue", state, Continue$0(state));
|
|
10523
|
+
if (state.events)
|
|
10524
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10525
|
+
return result;
|
|
10526
|
+
} else {
|
|
10527
|
+
const result = Continue$0(state);
|
|
10528
|
+
if (state.events)
|
|
10529
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10530
|
+
return result;
|
|
10531
|
+
}
|
|
10532
|
+
}
|
|
10533
|
+
var Debugger$0 = $TS($S($EXPECT($L90, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10534
|
+
return { $loc, token: $1 };
|
|
10535
|
+
});
|
|
10536
|
+
function Debugger(state) {
|
|
10537
|
+
let eventData;
|
|
10538
|
+
if (state.events) {
|
|
10539
|
+
const result = state.events.enter?.("Debugger", state);
|
|
10540
|
+
if (result) {
|
|
10541
|
+
if (result.cache)
|
|
10542
|
+
return result.cache;
|
|
10543
|
+
eventData = result.data;
|
|
10544
|
+
}
|
|
10545
|
+
}
|
|
10546
|
+
if (state.tokenize) {
|
|
10547
|
+
const result = $TOKEN("Debugger", state, Debugger$0(state));
|
|
10548
|
+
if (state.events)
|
|
10549
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10550
|
+
return result;
|
|
10551
|
+
} else {
|
|
10552
|
+
const result = Debugger$0(state);
|
|
10553
|
+
if (state.events)
|
|
10554
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10555
|
+
return result;
|
|
10556
|
+
}
|
|
10557
|
+
}
|
|
10558
|
+
var DebuggerExpression$0 = $TS($S(Debugger), function($skip, $loc, $0, $1) {
|
|
10407
10559
|
return {
|
|
10408
10560
|
type: "DebuggerExpression",
|
|
10409
10561
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10531,7 +10683,7 @@ ${input.slice(result.pos)}
|
|
|
10531
10683
|
return result;
|
|
10532
10684
|
}
|
|
10533
10685
|
}
|
|
10534
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10686
|
+
var ImpliedImport$0 = $TV($EXPECT($L19, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10535
10687
|
return { $loc, token: "import " };
|
|
10536
10688
|
});
|
|
10537
10689
|
function ImpliedImport(state) {
|
|
@@ -10680,7 +10832,7 @@ ${input.slice(result.pos)}
|
|
|
10680
10832
|
return result;
|
|
10681
10833
|
}
|
|
10682
10834
|
}
|
|
10683
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10835
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L91, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10684
10836
|
function ImportAssertion(state) {
|
|
10685
10837
|
let eventData;
|
|
10686
10838
|
if (state.events) {
|
|
@@ -11284,7 +11436,7 @@ ${input.slice(result.pos)}
|
|
|
11284
11436
|
return result;
|
|
11285
11437
|
}
|
|
11286
11438
|
}
|
|
11287
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11439
|
+
var ConstAssignment$0 = $TV($EXPECT($L92, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
11288
11440
|
return { $loc, token: "=" };
|
|
11289
11441
|
});
|
|
11290
11442
|
function ConstAssignment(state) {
|
|
@@ -11309,7 +11461,7 @@ ${input.slice(result.pos)}
|
|
|
11309
11461
|
return result;
|
|
11310
11462
|
}
|
|
11311
11463
|
}
|
|
11312
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11464
|
+
var LetAssignment$0 = $TV($EXPECT($L93, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
11313
11465
|
return { $loc, token: "=" };
|
|
11314
11466
|
});
|
|
11315
11467
|
function LetAssignment(state) {
|
|
@@ -12007,7 +12159,7 @@ ${input.slice(result.pos)}
|
|
|
12007
12159
|
}
|
|
12008
12160
|
}
|
|
12009
12161
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
12010
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
12162
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
12011
12163
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
12012
12164
|
});
|
|
12013
12165
|
function RegularExpressionLiteral(state) {
|
|
@@ -12574,7 +12726,7 @@ ${input.slice(result.pos)}
|
|
|
12574
12726
|
return result;
|
|
12575
12727
|
}
|
|
12576
12728
|
}
|
|
12577
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12729
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L94, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L95, fail, 'JSMultiLineComment "*/"')), $EXPECT($R42, fail, "JSMultiLineComment /./"))), $EXPECT($L95, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12578
12730
|
return { $loc, token: $1 };
|
|
12579
12731
|
});
|
|
12580
12732
|
function JSMultiLineComment(state) {
|
|
@@ -12673,7 +12825,7 @@ ${input.slice(result.pos)}
|
|
|
12673
12825
|
return result;
|
|
12674
12826
|
}
|
|
12675
12827
|
}
|
|
12676
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12828
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L94, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L95, fail, 'InlineComment "*/"')), $EXPECT($R46, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L95, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12677
12829
|
return { $loc, token: $1 };
|
|
12678
12830
|
});
|
|
12679
12831
|
function InlineComment(state) {
|
|
@@ -12772,7 +12924,7 @@ ${input.slice(result.pos)}
|
|
|
12772
12924
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12773
12925
|
return { $loc, token: $0 };
|
|
12774
12926
|
});
|
|
12775
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12927
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L96, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12776
12928
|
return "";
|
|
12777
12929
|
});
|
|
12778
12930
|
function NonNewlineWhitespace(state) {
|
|
@@ -12924,7 +13076,7 @@ ${input.slice(result.pos)}
|
|
|
12924
13076
|
}
|
|
12925
13077
|
}
|
|
12926
13078
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12927
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13079
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L97, fail, 'StatementDelimiter "["'), $EXPECT($L98, fail, 'StatementDelimiter "`"'), $EXPECT($L58, fail, 'StatementDelimiter "+"'), $EXPECT($L17, fail, 'StatementDelimiter "-"'), $EXPECT($L54, fail, 'StatementDelimiter "*"'), $EXPECT($L55, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
12928
13080
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12929
13081
|
function StatementDelimiter(state) {
|
|
12930
13082
|
let eventData;
|
|
@@ -12999,7 +13151,7 @@ ${input.slice(result.pos)}
|
|
|
12999
13151
|
return result;
|
|
13000
13152
|
}
|
|
13001
13153
|
}
|
|
13002
|
-
var Loc$0 = $TV($EXPECT($
|
|
13154
|
+
var Loc$0 = $TV($EXPECT($L19, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
13003
13155
|
return { $loc, token: "" };
|
|
13004
13156
|
});
|
|
13005
13157
|
function Loc(state) {
|
|
@@ -13024,7 +13176,7 @@ ${input.slice(result.pos)}
|
|
|
13024
13176
|
return result;
|
|
13025
13177
|
}
|
|
13026
13178
|
}
|
|
13027
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13179
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
13028
13180
|
return { $loc, token: $1, ts: true };
|
|
13029
13181
|
});
|
|
13030
13182
|
function Abstract(state) {
|
|
@@ -13049,7 +13201,7 @@ ${input.slice(result.pos)}
|
|
|
13049
13201
|
return result;
|
|
13050
13202
|
}
|
|
13051
13203
|
}
|
|
13052
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
13204
|
+
var Ampersand$0 = $TV($EXPECT($L83, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
13053
13205
|
return { $loc, token: $1 };
|
|
13054
13206
|
});
|
|
13055
13207
|
function Ampersand(state) {
|
|
@@ -13074,7 +13226,7 @@ ${input.slice(result.pos)}
|
|
|
13074
13226
|
return result;
|
|
13075
13227
|
}
|
|
13076
13228
|
}
|
|
13077
|
-
var As$0 = $TS($S($EXPECT($
|
|
13229
|
+
var As$0 = $TS($S($EXPECT($L100, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13078
13230
|
return { $loc, token: $1 };
|
|
13079
13231
|
});
|
|
13080
13232
|
function As(state) {
|
|
@@ -13099,7 +13251,7 @@ ${input.slice(result.pos)}
|
|
|
13099
13251
|
return result;
|
|
13100
13252
|
}
|
|
13101
13253
|
}
|
|
13102
|
-
var At$0 = $TV($EXPECT($
|
|
13254
|
+
var At$0 = $TV($EXPECT($L101, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
13103
13255
|
return { $loc, token: $1 };
|
|
13104
13256
|
});
|
|
13105
13257
|
function At(state) {
|
|
@@ -13124,7 +13276,7 @@ ${input.slice(result.pos)}
|
|
|
13124
13276
|
return result;
|
|
13125
13277
|
}
|
|
13126
13278
|
}
|
|
13127
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13279
|
+
var AtAt$0 = $TV($EXPECT($L102, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
13128
13280
|
return { $loc, token: "@" };
|
|
13129
13281
|
});
|
|
13130
13282
|
function AtAt(state) {
|
|
@@ -13149,7 +13301,7 @@ ${input.slice(result.pos)}
|
|
|
13149
13301
|
return result;
|
|
13150
13302
|
}
|
|
13151
13303
|
}
|
|
13152
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13304
|
+
var Async$0 = $TS($S($EXPECT($L103, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13153
13305
|
return { $loc, token: $1, type: "Async" };
|
|
13154
13306
|
});
|
|
13155
13307
|
function Async(state) {
|
|
@@ -13174,7 +13326,7 @@ ${input.slice(result.pos)}
|
|
|
13174
13326
|
return result;
|
|
13175
13327
|
}
|
|
13176
13328
|
}
|
|
13177
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13329
|
+
var Await$0 = $TS($S($EXPECT($L104, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13178
13330
|
return { $loc, token: $1 };
|
|
13179
13331
|
});
|
|
13180
13332
|
function Await(state) {
|
|
@@ -13199,7 +13351,7 @@ ${input.slice(result.pos)}
|
|
|
13199
13351
|
return result;
|
|
13200
13352
|
}
|
|
13201
13353
|
}
|
|
13202
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13354
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
13203
13355
|
return { $loc, token: $1 };
|
|
13204
13356
|
});
|
|
13205
13357
|
function Backtick(state) {
|
|
@@ -13224,7 +13376,7 @@ ${input.slice(result.pos)}
|
|
|
13224
13376
|
return result;
|
|
13225
13377
|
}
|
|
13226
13378
|
}
|
|
13227
|
-
var By$0 = $TS($S($EXPECT($
|
|
13379
|
+
var By$0 = $TS($S($EXPECT($L105, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13228
13380
|
return { $loc, token: $1 };
|
|
13229
13381
|
});
|
|
13230
13382
|
function By(state) {
|
|
@@ -13249,7 +13401,7 @@ ${input.slice(result.pos)}
|
|
|
13249
13401
|
return result;
|
|
13250
13402
|
}
|
|
13251
13403
|
}
|
|
13252
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13404
|
+
var Case$0 = $TS($S($EXPECT($L106, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13253
13405
|
return { $loc, token: $1 };
|
|
13254
13406
|
});
|
|
13255
13407
|
function Case(state) {
|
|
@@ -13274,7 +13426,7 @@ ${input.slice(result.pos)}
|
|
|
13274
13426
|
return result;
|
|
13275
13427
|
}
|
|
13276
13428
|
}
|
|
13277
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13429
|
+
var Catch$0 = $TS($S($EXPECT($L107, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13278
13430
|
return { $loc, token: $1 };
|
|
13279
13431
|
});
|
|
13280
13432
|
function Catch(state) {
|
|
@@ -13299,7 +13451,7 @@ ${input.slice(result.pos)}
|
|
|
13299
13451
|
return result;
|
|
13300
13452
|
}
|
|
13301
13453
|
}
|
|
13302
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13454
|
+
var Class$0 = $TS($S($EXPECT($L108, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13303
13455
|
return { $loc, token: $1 };
|
|
13304
13456
|
});
|
|
13305
13457
|
function Class(state) {
|
|
@@ -13324,7 +13476,7 @@ ${input.slice(result.pos)}
|
|
|
13324
13476
|
return result;
|
|
13325
13477
|
}
|
|
13326
13478
|
}
|
|
13327
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
13479
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
13328
13480
|
return { $loc, token: $1 };
|
|
13329
13481
|
});
|
|
13330
13482
|
function CloseBrace(state) {
|
|
@@ -13349,7 +13501,7 @@ ${input.slice(result.pos)}
|
|
|
13349
13501
|
return result;
|
|
13350
13502
|
}
|
|
13351
13503
|
}
|
|
13352
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
13504
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
13353
13505
|
return { $loc, token: $1 };
|
|
13354
13506
|
});
|
|
13355
13507
|
function CloseBracket(state) {
|
|
@@ -13374,7 +13526,7 @@ ${input.slice(result.pos)}
|
|
|
13374
13526
|
return result;
|
|
13375
13527
|
}
|
|
13376
13528
|
}
|
|
13377
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
13529
|
+
var CloseParen$0 = $TV($EXPECT($L33, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
13378
13530
|
return { $loc, token: $1 };
|
|
13379
13531
|
});
|
|
13380
13532
|
function CloseParen(state) {
|
|
@@ -13399,7 +13551,7 @@ ${input.slice(result.pos)}
|
|
|
13399
13551
|
return result;
|
|
13400
13552
|
}
|
|
13401
13553
|
}
|
|
13402
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13554
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L109, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
13403
13555
|
return { $loc, token: "${" };
|
|
13404
13556
|
});
|
|
13405
13557
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13424,7 +13576,7 @@ ${input.slice(result.pos)}
|
|
|
13424
13576
|
return result;
|
|
13425
13577
|
}
|
|
13426
13578
|
}
|
|
13427
|
-
var Colon$0 = $TV($EXPECT($
|
|
13579
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
13428
13580
|
return { $loc, token: $1 };
|
|
13429
13581
|
});
|
|
13430
13582
|
function Colon(state) {
|
|
@@ -13449,7 +13601,7 @@ ${input.slice(result.pos)}
|
|
|
13449
13601
|
return result;
|
|
13450
13602
|
}
|
|
13451
13603
|
}
|
|
13452
|
-
var Comma$0 = $TV($EXPECT($
|
|
13604
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
13453
13605
|
return { $loc, token: $1 };
|
|
13454
13606
|
});
|
|
13455
13607
|
function Comma(state) {
|
|
@@ -13474,7 +13626,7 @@ ${input.slice(result.pos)}
|
|
|
13474
13626
|
return result;
|
|
13475
13627
|
}
|
|
13476
13628
|
}
|
|
13477
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13629
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L101, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13478
13630
|
return { $loc, token: "constructor" };
|
|
13479
13631
|
});
|
|
13480
13632
|
function ConstructorShorthand(state) {
|
|
@@ -13499,7 +13651,7 @@ ${input.slice(result.pos)}
|
|
|
13499
13651
|
return result;
|
|
13500
13652
|
}
|
|
13501
13653
|
}
|
|
13502
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13654
|
+
var Declare$0 = $TS($S($EXPECT($L110, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13503
13655
|
return { $loc, token: $1 };
|
|
13504
13656
|
});
|
|
13505
13657
|
function Declare(state) {
|
|
@@ -13524,7 +13676,7 @@ ${input.slice(result.pos)}
|
|
|
13524
13676
|
return result;
|
|
13525
13677
|
}
|
|
13526
13678
|
}
|
|
13527
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13679
|
+
var Default$0 = $TS($S($EXPECT($L111, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13528
13680
|
return { $loc, token: $1 };
|
|
13529
13681
|
});
|
|
13530
13682
|
function Default(state) {
|
|
@@ -13549,7 +13701,7 @@ ${input.slice(result.pos)}
|
|
|
13549
13701
|
return result;
|
|
13550
13702
|
}
|
|
13551
13703
|
}
|
|
13552
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13704
|
+
var Delete$0 = $TS($S($EXPECT($L112, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13553
13705
|
return { $loc, token: $1 };
|
|
13554
13706
|
});
|
|
13555
13707
|
function Delete(state) {
|
|
@@ -13574,7 +13726,7 @@ ${input.slice(result.pos)}
|
|
|
13574
13726
|
return result;
|
|
13575
13727
|
}
|
|
13576
13728
|
}
|
|
13577
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13729
|
+
var Do$0 = $TS($S($EXPECT($L113, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13578
13730
|
return { $loc, token: $1 };
|
|
13579
13731
|
});
|
|
13580
13732
|
function Do(state) {
|
|
@@ -13624,7 +13776,7 @@ ${input.slice(result.pos)}
|
|
|
13624
13776
|
return result;
|
|
13625
13777
|
}
|
|
13626
13778
|
}
|
|
13627
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13779
|
+
var DotDot$0 = $TV($EXPECT($L114, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13628
13780
|
return { $loc, token: $1 };
|
|
13629
13781
|
});
|
|
13630
13782
|
function DotDot(state) {
|
|
@@ -13649,7 +13801,7 @@ ${input.slice(result.pos)}
|
|
|
13649
13801
|
return result;
|
|
13650
13802
|
}
|
|
13651
13803
|
}
|
|
13652
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13804
|
+
var DotDotDot$0 = $TV($EXPECT($L115, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13653
13805
|
return { $loc, token: $1 };
|
|
13654
13806
|
});
|
|
13655
13807
|
function DotDotDot(state) {
|
|
@@ -13674,7 +13826,7 @@ ${input.slice(result.pos)}
|
|
|
13674
13826
|
return result;
|
|
13675
13827
|
}
|
|
13676
13828
|
}
|
|
13677
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13829
|
+
var DoubleColon$0 = $TV($EXPECT($L116, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13678
13830
|
return { $loc, token: $1 };
|
|
13679
13831
|
});
|
|
13680
13832
|
function DoubleColon(state) {
|
|
@@ -13699,7 +13851,7 @@ ${input.slice(result.pos)}
|
|
|
13699
13851
|
return result;
|
|
13700
13852
|
}
|
|
13701
13853
|
}
|
|
13702
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13854
|
+
var DoubleQuote$0 = $TV($EXPECT($L117, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13703
13855
|
return { $loc, token: $1 };
|
|
13704
13856
|
});
|
|
13705
13857
|
function DoubleQuote(state) {
|
|
@@ -13724,7 +13876,7 @@ ${input.slice(result.pos)}
|
|
|
13724
13876
|
return result;
|
|
13725
13877
|
}
|
|
13726
13878
|
}
|
|
13727
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13879
|
+
var Else$0 = $TS($S($EXPECT($L118, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13728
13880
|
return { $loc, token: $1 };
|
|
13729
13881
|
});
|
|
13730
13882
|
function Else(state) {
|
|
@@ -13774,7 +13926,7 @@ ${input.slice(result.pos)}
|
|
|
13774
13926
|
return result;
|
|
13775
13927
|
}
|
|
13776
13928
|
}
|
|
13777
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13929
|
+
var Export$0 = $TS($S($EXPECT($L119, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13778
13930
|
return { $loc, token: $1 };
|
|
13779
13931
|
});
|
|
13780
13932
|
function Export(state) {
|
|
@@ -13799,7 +13951,7 @@ ${input.slice(result.pos)}
|
|
|
13799
13951
|
return result;
|
|
13800
13952
|
}
|
|
13801
13953
|
}
|
|
13802
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13954
|
+
var Extends$0 = $TS($S($EXPECT($L120, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13803
13955
|
return { $loc, token: $1 };
|
|
13804
13956
|
});
|
|
13805
13957
|
function Extends(state) {
|
|
@@ -13824,7 +13976,7 @@ ${input.slice(result.pos)}
|
|
|
13824
13976
|
return result;
|
|
13825
13977
|
}
|
|
13826
13978
|
}
|
|
13827
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13979
|
+
var Finally$0 = $TS($S($EXPECT($L121, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13828
13980
|
return { $loc, token: $1 };
|
|
13829
13981
|
});
|
|
13830
13982
|
function Finally(state) {
|
|
@@ -13849,7 +14001,7 @@ ${input.slice(result.pos)}
|
|
|
13849
14001
|
return result;
|
|
13850
14002
|
}
|
|
13851
14003
|
}
|
|
13852
|
-
var For$0 = $TS($S($EXPECT($
|
|
14004
|
+
var For$0 = $TS($S($EXPECT($L122, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13853
14005
|
return { $loc, token: $1 };
|
|
13854
14006
|
});
|
|
13855
14007
|
function For(state) {
|
|
@@ -13874,7 +14026,7 @@ ${input.slice(result.pos)}
|
|
|
13874
14026
|
return result;
|
|
13875
14027
|
}
|
|
13876
14028
|
}
|
|
13877
|
-
var From$0 = $TS($S($EXPECT($
|
|
14029
|
+
var From$0 = $TS($S($EXPECT($L123, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13878
14030
|
return { $loc, token: $1 };
|
|
13879
14031
|
});
|
|
13880
14032
|
function From(state) {
|
|
@@ -13899,7 +14051,7 @@ ${input.slice(result.pos)}
|
|
|
13899
14051
|
return result;
|
|
13900
14052
|
}
|
|
13901
14053
|
}
|
|
13902
|
-
var Function$0 = $TS($S($EXPECT($
|
|
14054
|
+
var Function$0 = $TS($S($EXPECT($L124, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13903
14055
|
return { $loc, token: $1 };
|
|
13904
14056
|
});
|
|
13905
14057
|
function Function(state) {
|
|
@@ -13924,7 +14076,7 @@ ${input.slice(result.pos)}
|
|
|
13924
14076
|
return result;
|
|
13925
14077
|
}
|
|
13926
14078
|
}
|
|
13927
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14079
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L125, fail, 'GetOrSet "get"'), $EXPECT($L126, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13928
14080
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13929
14081
|
});
|
|
13930
14082
|
function GetOrSet(state) {
|
|
@@ -13949,7 +14101,7 @@ ${input.slice(result.pos)}
|
|
|
13949
14101
|
return result;
|
|
13950
14102
|
}
|
|
13951
14103
|
}
|
|
13952
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14104
|
+
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13953
14105
|
return { $loc, token: $1 };
|
|
13954
14106
|
});
|
|
13955
14107
|
function If(state) {
|
|
@@ -13999,7 +14151,7 @@ ${input.slice(result.pos)}
|
|
|
13999
14151
|
return result;
|
|
14000
14152
|
}
|
|
14001
14153
|
}
|
|
14002
|
-
var In$0 = $TS($S($EXPECT($
|
|
14154
|
+
var In$0 = $TS($S($EXPECT($L81, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14003
14155
|
return { $loc, token: $1 };
|
|
14004
14156
|
});
|
|
14005
14157
|
function In(state) {
|
|
@@ -14024,7 +14176,7 @@ ${input.slice(result.pos)}
|
|
|
14024
14176
|
return result;
|
|
14025
14177
|
}
|
|
14026
14178
|
}
|
|
14027
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14179
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L128, fail, 'LetOrConst "let"'), $EXPECT($L129, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14028
14180
|
return { $loc, token: $1 };
|
|
14029
14181
|
});
|
|
14030
14182
|
function LetOrConst(state) {
|
|
@@ -14049,7 +14201,7 @@ ${input.slice(result.pos)}
|
|
|
14049
14201
|
return result;
|
|
14050
14202
|
}
|
|
14051
14203
|
}
|
|
14052
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14204
|
+
var Loop$0 = $TS($S($EXPECT($L130, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14053
14205
|
return { $loc, token: "while(true)" };
|
|
14054
14206
|
});
|
|
14055
14207
|
function Loop(state) {
|
|
@@ -14074,7 +14226,7 @@ ${input.slice(result.pos)}
|
|
|
14074
14226
|
return result;
|
|
14075
14227
|
}
|
|
14076
14228
|
}
|
|
14077
|
-
var New$0 = $TS($S($EXPECT($
|
|
14229
|
+
var New$0 = $TS($S($EXPECT($L131, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14078
14230
|
return { $loc, token: $1 };
|
|
14079
14231
|
});
|
|
14080
14232
|
function New(state) {
|
|
@@ -14099,7 +14251,7 @@ ${input.slice(result.pos)}
|
|
|
14099
14251
|
return result;
|
|
14100
14252
|
}
|
|
14101
14253
|
}
|
|
14102
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
14254
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L52, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L8, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14103
14255
|
return { $loc, token: "!" };
|
|
14104
14256
|
});
|
|
14105
14257
|
function Not(state) {
|
|
@@ -14124,7 +14276,7 @@ ${input.slice(result.pos)}
|
|
|
14124
14276
|
return result;
|
|
14125
14277
|
}
|
|
14126
14278
|
}
|
|
14127
|
-
var Of$0 = $TS($S($EXPECT($
|
|
14279
|
+
var Of$0 = $TS($S($EXPECT($L73, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14128
14280
|
return { $loc, token: $1 };
|
|
14129
14281
|
});
|
|
14130
14282
|
function Of(state) {
|
|
@@ -14149,7 +14301,7 @@ ${input.slice(result.pos)}
|
|
|
14149
14301
|
return result;
|
|
14150
14302
|
}
|
|
14151
14303
|
}
|
|
14152
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14304
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L132, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
14153
14305
|
return { $loc, token: $1 };
|
|
14154
14306
|
});
|
|
14155
14307
|
function OpenAngleBracket(state) {
|
|
@@ -14174,7 +14326,7 @@ ${input.slice(result.pos)}
|
|
|
14174
14326
|
return result;
|
|
14175
14327
|
}
|
|
14176
14328
|
}
|
|
14177
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14329
|
+
var OpenBrace$0 = $TV($EXPECT($L133, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
14178
14330
|
return { $loc, token: $1 };
|
|
14179
14331
|
});
|
|
14180
14332
|
function OpenBrace(state) {
|
|
@@ -14199,7 +14351,7 @@ ${input.slice(result.pos)}
|
|
|
14199
14351
|
return result;
|
|
14200
14352
|
}
|
|
14201
14353
|
}
|
|
14202
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14354
|
+
var OpenBracket$0 = $TV($EXPECT($L97, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
14203
14355
|
return { $loc, token: $1 };
|
|
14204
14356
|
});
|
|
14205
14357
|
function OpenBracket(state) {
|
|
@@ -14249,7 +14401,7 @@ ${input.slice(result.pos)}
|
|
|
14249
14401
|
return result;
|
|
14250
14402
|
}
|
|
14251
14403
|
}
|
|
14252
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14404
|
+
var Operator$0 = $TS($S($EXPECT($L134, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14253
14405
|
return { $loc, token: $1 };
|
|
14254
14406
|
});
|
|
14255
14407
|
function Operator(state) {
|
|
@@ -14274,7 +14426,7 @@ ${input.slice(result.pos)}
|
|
|
14274
14426
|
return result;
|
|
14275
14427
|
}
|
|
14276
14428
|
}
|
|
14277
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14429
|
+
var Public$0 = $TS($S($EXPECT($L135, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14278
14430
|
return { $loc, token: $1 };
|
|
14279
14431
|
});
|
|
14280
14432
|
function Public(state) {
|
|
@@ -14299,7 +14451,7 @@ ${input.slice(result.pos)}
|
|
|
14299
14451
|
return result;
|
|
14300
14452
|
}
|
|
14301
14453
|
}
|
|
14302
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14454
|
+
var Private$0 = $TS($S($EXPECT($L136, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14303
14455
|
return { $loc, token: $1 };
|
|
14304
14456
|
});
|
|
14305
14457
|
function Private(state) {
|
|
@@ -14324,7 +14476,7 @@ ${input.slice(result.pos)}
|
|
|
14324
14476
|
return result;
|
|
14325
14477
|
}
|
|
14326
14478
|
}
|
|
14327
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14479
|
+
var Protected$0 = $TS($S($EXPECT($L137, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14328
14480
|
return { $loc, token: $1 };
|
|
14329
14481
|
});
|
|
14330
14482
|
function Protected(state) {
|
|
@@ -14349,13 +14501,13 @@ ${input.slice(result.pos)}
|
|
|
14349
14501
|
return result;
|
|
14350
14502
|
}
|
|
14351
14503
|
}
|
|
14352
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14504
|
+
var Pipe$0 = $TV($EXPECT($L138, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
14353
14505
|
return { $loc, token: $1 };
|
|
14354
14506
|
});
|
|
14355
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14507
|
+
var Pipe$1 = $TV($EXPECT($L139, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
14356
14508
|
return { $loc, token: $1 };
|
|
14357
14509
|
});
|
|
14358
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14510
|
+
var Pipe$2 = $TV($EXPECT($L140, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
14359
14511
|
return { $loc, token: $1 };
|
|
14360
14512
|
});
|
|
14361
14513
|
function Pipe(state) {
|
|
@@ -14405,7 +14557,7 @@ ${input.slice(result.pos)}
|
|
|
14405
14557
|
return result;
|
|
14406
14558
|
}
|
|
14407
14559
|
}
|
|
14408
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14560
|
+
var Readonly$0 = $TS($S($EXPECT($L141, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14409
14561
|
return { $loc, token: $1, ts: true };
|
|
14410
14562
|
});
|
|
14411
14563
|
function Readonly(state) {
|
|
@@ -14430,7 +14582,7 @@ ${input.slice(result.pos)}
|
|
|
14430
14582
|
return result;
|
|
14431
14583
|
}
|
|
14432
14584
|
}
|
|
14433
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14585
|
+
var Return$0 = $TS($S($EXPECT($L142, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14434
14586
|
return { $loc, token: $1 };
|
|
14435
14587
|
});
|
|
14436
14588
|
function Return(state) {
|
|
@@ -14455,7 +14607,7 @@ ${input.slice(result.pos)}
|
|
|
14455
14607
|
return result;
|
|
14456
14608
|
}
|
|
14457
14609
|
}
|
|
14458
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14610
|
+
var Satisfies$0 = $TS($S($EXPECT($L143, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14459
14611
|
return { $loc, token: $1 };
|
|
14460
14612
|
});
|
|
14461
14613
|
function Satisfies(state) {
|
|
@@ -14480,7 +14632,7 @@ ${input.slice(result.pos)}
|
|
|
14480
14632
|
return result;
|
|
14481
14633
|
}
|
|
14482
14634
|
}
|
|
14483
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14635
|
+
var Semicolon$0 = $TV($EXPECT($L85, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
14484
14636
|
return { $loc, token: $1 };
|
|
14485
14637
|
});
|
|
14486
14638
|
function Semicolon(state) {
|
|
@@ -14505,7 +14657,7 @@ ${input.slice(result.pos)}
|
|
|
14505
14657
|
return result;
|
|
14506
14658
|
}
|
|
14507
14659
|
}
|
|
14508
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14660
|
+
var SingleQuote$0 = $TV($EXPECT($L144, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14509
14661
|
return { $loc, token: $1 };
|
|
14510
14662
|
});
|
|
14511
14663
|
function SingleQuote(state) {
|
|
@@ -14530,7 +14682,7 @@ ${input.slice(result.pos)}
|
|
|
14530
14682
|
return result;
|
|
14531
14683
|
}
|
|
14532
14684
|
}
|
|
14533
|
-
var Star$0 = $TV($EXPECT($
|
|
14685
|
+
var Star$0 = $TV($EXPECT($L54, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14534
14686
|
return { $loc, token: $1 };
|
|
14535
14687
|
});
|
|
14536
14688
|
function Star(state) {
|
|
@@ -14555,10 +14707,10 @@ ${input.slice(result.pos)}
|
|
|
14555
14707
|
return result;
|
|
14556
14708
|
}
|
|
14557
14709
|
}
|
|
14558
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14710
|
+
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14559
14711
|
return { $loc, token: $1 };
|
|
14560
14712
|
});
|
|
14561
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14713
|
+
var Static$1 = $TS($S($EXPECT($L101, fail, 'Static "@"'), $N($C($EXPECT($L2, fail, 'Static "("'), $EXPECT($L101, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
14562
14714
|
return { $loc, token: "static " };
|
|
14563
14715
|
});
|
|
14564
14716
|
function Static(state) {
|
|
@@ -14583,7 +14735,7 @@ ${input.slice(result.pos)}
|
|
|
14583
14735
|
return result;
|
|
14584
14736
|
}
|
|
14585
14737
|
}
|
|
14586
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14738
|
+
var SubstitutionStart$0 = $TV($EXPECT($L146, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14587
14739
|
return { $loc, token: $1 };
|
|
14588
14740
|
});
|
|
14589
14741
|
function SubstitutionStart(state) {
|
|
@@ -14608,7 +14760,7 @@ ${input.slice(result.pos)}
|
|
|
14608
14760
|
return result;
|
|
14609
14761
|
}
|
|
14610
14762
|
}
|
|
14611
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14763
|
+
var Switch$0 = $TS($S($EXPECT($L147, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14612
14764
|
return { $loc, token: $1 };
|
|
14613
14765
|
});
|
|
14614
14766
|
function Switch(state) {
|
|
@@ -14633,7 +14785,7 @@ ${input.slice(result.pos)}
|
|
|
14633
14785
|
return result;
|
|
14634
14786
|
}
|
|
14635
14787
|
}
|
|
14636
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14788
|
+
var Target$0 = $TS($S($EXPECT($L148, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14637
14789
|
return { $loc, token: $1 };
|
|
14638
14790
|
});
|
|
14639
14791
|
function Target(state) {
|
|
@@ -14658,7 +14810,7 @@ ${input.slice(result.pos)}
|
|
|
14658
14810
|
return result;
|
|
14659
14811
|
}
|
|
14660
14812
|
}
|
|
14661
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14813
|
+
var Then$0 = $TS($S(__, $EXPECT($L149, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14662
14814
|
return { $loc, token: "" };
|
|
14663
14815
|
});
|
|
14664
14816
|
function Then(state) {
|
|
@@ -14683,7 +14835,7 @@ ${input.slice(result.pos)}
|
|
|
14683
14835
|
return result;
|
|
14684
14836
|
}
|
|
14685
14837
|
}
|
|
14686
|
-
var This$0 = $TS($S($EXPECT($
|
|
14838
|
+
var This$0 = $TS($S($EXPECT($L150, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14687
14839
|
return { $loc, token: $1 };
|
|
14688
14840
|
});
|
|
14689
14841
|
function This(state) {
|
|
@@ -14708,7 +14860,7 @@ ${input.slice(result.pos)}
|
|
|
14708
14860
|
return result;
|
|
14709
14861
|
}
|
|
14710
14862
|
}
|
|
14711
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14863
|
+
var Throw$0 = $TS($S($EXPECT($L151, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14712
14864
|
return { $loc, token: $1 };
|
|
14713
14865
|
});
|
|
14714
14866
|
function Throw(state) {
|
|
@@ -14733,7 +14885,7 @@ ${input.slice(result.pos)}
|
|
|
14733
14885
|
return result;
|
|
14734
14886
|
}
|
|
14735
14887
|
}
|
|
14736
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14888
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L152, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14737
14889
|
return { $loc, token: "`" };
|
|
14738
14890
|
});
|
|
14739
14891
|
function TripleDoubleQuote(state) {
|
|
@@ -14758,7 +14910,7 @@ ${input.slice(result.pos)}
|
|
|
14758
14910
|
return result;
|
|
14759
14911
|
}
|
|
14760
14912
|
}
|
|
14761
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14913
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L153, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14762
14914
|
return { $loc, token: "`" };
|
|
14763
14915
|
});
|
|
14764
14916
|
function TripleSingleQuote(state) {
|
|
@@ -14783,7 +14935,7 @@ ${input.slice(result.pos)}
|
|
|
14783
14935
|
return result;
|
|
14784
14936
|
}
|
|
14785
14937
|
}
|
|
14786
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14938
|
+
var TripleSlash$0 = $TV($EXPECT($L154, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14787
14939
|
return { $loc, token: "/" };
|
|
14788
14940
|
});
|
|
14789
14941
|
function TripleSlash(state) {
|
|
@@ -14808,7 +14960,7 @@ ${input.slice(result.pos)}
|
|
|
14808
14960
|
return result;
|
|
14809
14961
|
}
|
|
14810
14962
|
}
|
|
14811
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14963
|
+
var TripleTick$0 = $TV($EXPECT($L155, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14812
14964
|
return { $loc, token: "`" };
|
|
14813
14965
|
});
|
|
14814
14966
|
function TripleTick(state) {
|
|
@@ -14833,7 +14985,7 @@ ${input.slice(result.pos)}
|
|
|
14833
14985
|
return result;
|
|
14834
14986
|
}
|
|
14835
14987
|
}
|
|
14836
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14988
|
+
var Try$0 = $TS($S($EXPECT($L156, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14837
14989
|
return { $loc, token: $1 };
|
|
14838
14990
|
});
|
|
14839
14991
|
function Try(state) {
|
|
@@ -14858,7 +15010,7 @@ ${input.slice(result.pos)}
|
|
|
14858
15010
|
return result;
|
|
14859
15011
|
}
|
|
14860
15012
|
}
|
|
14861
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
15013
|
+
var Typeof$0 = $TS($S($EXPECT($L157, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14862
15014
|
return { $loc, token: $1 };
|
|
14863
15015
|
});
|
|
14864
15016
|
function Typeof(state) {
|
|
@@ -14883,7 +15035,7 @@ ${input.slice(result.pos)}
|
|
|
14883
15035
|
return result;
|
|
14884
15036
|
}
|
|
14885
15037
|
}
|
|
14886
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
15038
|
+
var Unless$0 = $TS($S($EXPECT($L158, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14887
15039
|
return { $loc, token: $1 };
|
|
14888
15040
|
});
|
|
14889
15041
|
function Unless(state) {
|
|
@@ -14908,7 +15060,7 @@ ${input.slice(result.pos)}
|
|
|
14908
15060
|
return result;
|
|
14909
15061
|
}
|
|
14910
15062
|
}
|
|
14911
|
-
var Until$0 = $TS($S($EXPECT($
|
|
15063
|
+
var Until$0 = $TS($S($EXPECT($L159, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14912
15064
|
return { $loc, token: $1 };
|
|
14913
15065
|
});
|
|
14914
15066
|
function Until(state) {
|
|
@@ -14933,7 +15085,7 @@ ${input.slice(result.pos)}
|
|
|
14933
15085
|
return result;
|
|
14934
15086
|
}
|
|
14935
15087
|
}
|
|
14936
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15088
|
+
var Var$0 = $TS($S($EXPECT($L160, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14937
15089
|
return { $loc, token: $1 };
|
|
14938
15090
|
});
|
|
14939
15091
|
function Var(state) {
|
|
@@ -14958,7 +15110,7 @@ ${input.slice(result.pos)}
|
|
|
14958
15110
|
return result;
|
|
14959
15111
|
}
|
|
14960
15112
|
}
|
|
14961
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15113
|
+
var Void$0 = $TS($S($EXPECT($L161, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14962
15114
|
return { $loc, token: $1 };
|
|
14963
15115
|
});
|
|
14964
15116
|
function Void(state) {
|
|
@@ -14983,7 +15135,7 @@ ${input.slice(result.pos)}
|
|
|
14983
15135
|
return result;
|
|
14984
15136
|
}
|
|
14985
15137
|
}
|
|
14986
|
-
var When$0 = $TS($S($EXPECT($
|
|
15138
|
+
var When$0 = $TS($S($EXPECT($L162, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14987
15139
|
return { $loc, token: "case" };
|
|
14988
15140
|
});
|
|
14989
15141
|
function When(state) {
|
|
@@ -15008,7 +15160,7 @@ ${input.slice(result.pos)}
|
|
|
15008
15160
|
return result;
|
|
15009
15161
|
}
|
|
15010
15162
|
}
|
|
15011
|
-
var While$0 = $TS($S($EXPECT($
|
|
15163
|
+
var While$0 = $TS($S($EXPECT($L163, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15012
15164
|
return { $loc, token: $1 };
|
|
15013
15165
|
});
|
|
15014
15166
|
function While(state) {
|
|
@@ -15033,7 +15185,7 @@ ${input.slice(result.pos)}
|
|
|
15033
15185
|
return result;
|
|
15034
15186
|
}
|
|
15035
15187
|
}
|
|
15036
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15188
|
+
var Yield$0 = $TS($S($EXPECT($L164, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15037
15189
|
return { $loc, token: $1 };
|
|
15038
15190
|
});
|
|
15039
15191
|
function Yield(state) {
|
|
@@ -15178,7 +15330,7 @@ ${input.slice(result.pos)}
|
|
|
15178
15330
|
return result;
|
|
15179
15331
|
}
|
|
15180
15332
|
}
|
|
15181
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15333
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L132, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L165, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
15182
15334
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
15183
15335
|
});
|
|
15184
15336
|
function JSXSelfClosingElement(state) {
|
|
@@ -15229,7 +15381,7 @@ ${input.slice(result.pos)}
|
|
|
15229
15381
|
return result;
|
|
15230
15382
|
}
|
|
15231
15383
|
}
|
|
15232
|
-
var PopJSXStack$0 = $TV($EXPECT($
|
|
15384
|
+
var PopJSXStack$0 = $TV($EXPECT($L19, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15233
15385
|
module.JSXTagStack.pop();
|
|
15234
15386
|
});
|
|
15235
15387
|
function PopJSXStack(state) {
|
|
@@ -15254,7 +15406,7 @@ ${input.slice(result.pos)}
|
|
|
15254
15406
|
return result;
|
|
15255
15407
|
}
|
|
15256
15408
|
}
|
|
15257
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
15409
|
+
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
15258
15410
|
function JSXOpeningElement(state) {
|
|
15259
15411
|
let eventData;
|
|
15260
15412
|
if (state.events) {
|
|
@@ -15283,7 +15435,7 @@ ${input.slice(result.pos)}
|
|
|
15283
15435
|
return $skip;
|
|
15284
15436
|
return $0;
|
|
15285
15437
|
});
|
|
15286
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
15438
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L19, fail, 'JSXOptionalClosingElement ""');
|
|
15287
15439
|
function JSXOptionalClosingElement(state) {
|
|
15288
15440
|
let eventData;
|
|
15289
15441
|
if (state.events) {
|
|
@@ -15306,7 +15458,7 @@ ${input.slice(result.pos)}
|
|
|
15306
15458
|
return result;
|
|
15307
15459
|
}
|
|
15308
15460
|
}
|
|
15309
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15461
|
+
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
15310
15462
|
function JSXClosingElement(state) {
|
|
15311
15463
|
let eventData;
|
|
15312
15464
|
if (state.events) {
|
|
@@ -15344,7 +15496,7 @@ ${input.slice(result.pos)}
|
|
|
15344
15496
|
];
|
|
15345
15497
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
15346
15498
|
});
|
|
15347
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15499
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L167, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
15348
15500
|
var children = $3;
|
|
15349
15501
|
$0 = $0.slice(1);
|
|
15350
15502
|
return {
|
|
@@ -15375,7 +15527,7 @@ ${input.slice(result.pos)}
|
|
|
15375
15527
|
return result;
|
|
15376
15528
|
}
|
|
15377
15529
|
}
|
|
15378
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15530
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L167, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
15379
15531
|
module.JSXTagStack.push("");
|
|
15380
15532
|
return $1;
|
|
15381
15533
|
});
|
|
@@ -15406,7 +15558,7 @@ ${input.slice(result.pos)}
|
|
|
15406
15558
|
return $skip;
|
|
15407
15559
|
return $0;
|
|
15408
15560
|
});
|
|
15409
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
15561
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L19, fail, 'JSXOptionalClosingFragment ""');
|
|
15410
15562
|
function JSXOptionalClosingFragment(state) {
|
|
15411
15563
|
let eventData;
|
|
15412
15564
|
if (state.events) {
|
|
@@ -15429,7 +15581,7 @@ ${input.slice(result.pos)}
|
|
|
15429
15581
|
return result;
|
|
15430
15582
|
}
|
|
15431
15583
|
}
|
|
15432
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15584
|
+
var JSXClosingFragment$0 = $EXPECT($L168, fail, 'JSXClosingFragment "</>"');
|
|
15433
15585
|
function JSXClosingFragment(state) {
|
|
15434
15586
|
let eventData;
|
|
15435
15587
|
if (state.events) {
|
|
@@ -16196,7 +16348,7 @@ ${input.slice(result.pos)}
|
|
|
16196
16348
|
}
|
|
16197
16349
|
return $skip;
|
|
16198
16350
|
});
|
|
16199
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
16351
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
16200
16352
|
return { children: [], jsxChildren: [] };
|
|
16201
16353
|
});
|
|
16202
16354
|
function JSXNestedChildren(state) {
|
|
@@ -16325,7 +16477,7 @@ ${input.slice(result.pos)}
|
|
|
16325
16477
|
return result;
|
|
16326
16478
|
}
|
|
16327
16479
|
}
|
|
16328
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16480
|
+
var JSXComment$0 = $TS($S($EXPECT($L169, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L170, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16329
16481
|
return ["{/*", $2, "*/}"];
|
|
16330
16482
|
});
|
|
16331
16483
|
function JSXComment(state) {
|
|
@@ -16623,7 +16775,7 @@ ${input.slice(result.pos)}
|
|
|
16623
16775
|
return result;
|
|
16624
16776
|
}
|
|
16625
16777
|
}
|
|
16626
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16778
|
+
var TypeKeyword$0 = $S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16627
16779
|
function TypeKeyword(state) {
|
|
16628
16780
|
let eventData;
|
|
16629
16781
|
if (state.events) {
|
|
@@ -16646,7 +16798,7 @@ ${input.slice(result.pos)}
|
|
|
16646
16798
|
return result;
|
|
16647
16799
|
}
|
|
16648
16800
|
}
|
|
16649
|
-
var Interface$0 = $S($EXPECT($
|
|
16801
|
+
var Interface$0 = $S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue);
|
|
16650
16802
|
function Interface(state) {
|
|
16651
16803
|
let eventData;
|
|
16652
16804
|
if (state.events) {
|
|
@@ -16669,7 +16821,7 @@ ${input.slice(result.pos)}
|
|
|
16669
16821
|
return result;
|
|
16670
16822
|
}
|
|
16671
16823
|
}
|
|
16672
|
-
var Namespace$0 = $S($EXPECT($
|
|
16824
|
+
var Namespace$0 = $S($EXPECT($L173, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16673
16825
|
function Namespace(state) {
|
|
16674
16826
|
let eventData;
|
|
16675
16827
|
if (state.events) {
|
|
@@ -16917,7 +17069,7 @@ ${input.slice(result.pos)}
|
|
|
16917
17069
|
return result;
|
|
16918
17070
|
}
|
|
16919
17071
|
}
|
|
16920
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
17072
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L141, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R58, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
16921
17073
|
function TypeIndexSignature(state) {
|
|
16922
17074
|
let eventData;
|
|
16923
17075
|
if (state.events) {
|
|
@@ -16964,7 +17116,7 @@ ${input.slice(result.pos)}
|
|
|
16964
17116
|
return result;
|
|
16965
17117
|
}
|
|
16966
17118
|
}
|
|
16967
|
-
var TypeSuffix$0 = $T($S($E(QuestionMark),
|
|
17119
|
+
var TypeSuffix$0 = $T($S($E(QuestionMark), $E(_), Colon, Type), function(value) {
|
|
16968
17120
|
return { "type": "TypeSuffix", "ts": true, "children": value };
|
|
16969
17121
|
});
|
|
16970
17122
|
function TypeSuffix(state) {
|
|
@@ -16989,14 +17141,20 @@ ${input.slice(result.pos)}
|
|
|
16989
17141
|
return result;
|
|
16990
17142
|
}
|
|
16991
17143
|
}
|
|
16992
|
-
var ReturnTypeSuffix$0 = $TS($S(
|
|
16993
|
-
|
|
16994
|
-
|
|
16995
|
-
|
|
16996
|
-
|
|
17144
|
+
var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L174, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17145
|
+
var asserts = $3;
|
|
17146
|
+
var t = $4;
|
|
17147
|
+
if (asserts) {
|
|
17148
|
+
t = {
|
|
17149
|
+
type: "AssertsType",
|
|
17150
|
+
t,
|
|
17151
|
+
children: [asserts[0], asserts[1], t]
|
|
17152
|
+
};
|
|
17153
|
+
}
|
|
16997
17154
|
return {
|
|
16998
17155
|
type: "ReturnTypeAnnotation",
|
|
16999
|
-
children,
|
|
17156
|
+
children: [$1, $2, t],
|
|
17157
|
+
t,
|
|
17000
17158
|
ts: true
|
|
17001
17159
|
};
|
|
17002
17160
|
});
|
|
@@ -17022,10 +17180,17 @@ ${input.slice(result.pos)}
|
|
|
17022
17180
|
return result;
|
|
17023
17181
|
}
|
|
17024
17182
|
}
|
|
17025
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
17026
|
-
|
|
17027
|
-
|
|
17028
|
-
|
|
17183
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L82, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
17184
|
+
var lhs = $1;
|
|
17185
|
+
var rhs = $2;
|
|
17186
|
+
if (!rhs)
|
|
17187
|
+
return lhs;
|
|
17188
|
+
return {
|
|
17189
|
+
type: "TypePredicate",
|
|
17190
|
+
lhs,
|
|
17191
|
+
rhs: rhs[3],
|
|
17192
|
+
children: [lhs, ...rhs]
|
|
17193
|
+
};
|
|
17029
17194
|
});
|
|
17030
17195
|
function TypePredicate(state) {
|
|
17031
17196
|
let eventData;
|
|
@@ -17100,6 +17265,8 @@ ${input.slice(result.pos)}
|
|
|
17100
17265
|
}
|
|
17101
17266
|
}
|
|
17102
17267
|
var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
17268
|
+
if (!$1.length && !$3.length)
|
|
17269
|
+
return $2;
|
|
17103
17270
|
return [...$1, $2, ...$3];
|
|
17104
17271
|
});
|
|
17105
17272
|
function TypeUnary(state) {
|
|
@@ -17148,10 +17315,10 @@ ${input.slice(result.pos)}
|
|
|
17148
17315
|
return result;
|
|
17149
17316
|
}
|
|
17150
17317
|
}
|
|
17151
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
17152
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
17153
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
17154
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17318
|
+
var TypeUnaryOp$0 = $S($EXPECT($L175, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17319
|
+
var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17320
|
+
var TypeUnaryOp$2 = $S($EXPECT($L176, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17321
|
+
var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
17155
17322
|
function TypeUnaryOp(state) {
|
|
17156
17323
|
let eventData;
|
|
17157
17324
|
if (state.events) {
|
|
@@ -17202,8 +17369,23 @@ ${input.slice(result.pos)}
|
|
|
17202
17369
|
var TypePrimary$2 = $S($E(_), InlineInterfaceLiteral);
|
|
17203
17370
|
var TypePrimary$3 = $S($E(_), TypeTuple);
|
|
17204
17371
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
17205
|
-
var TypePrimary$5 = $S($E(_), TypeLiteral)
|
|
17206
|
-
|
|
17372
|
+
var TypePrimary$5 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
|
|
17373
|
+
var t = $2;
|
|
17374
|
+
return {
|
|
17375
|
+
type: "LiteralType",
|
|
17376
|
+
t,
|
|
17377
|
+
children: $0
|
|
17378
|
+
};
|
|
17379
|
+
});
|
|
17380
|
+
var TypePrimary$6 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17381
|
+
var args = $4;
|
|
17382
|
+
return {
|
|
17383
|
+
type: "IdentifierType",
|
|
17384
|
+
children: $0,
|
|
17385
|
+
raw: [$2.name, ...$3.map(([dot, id]) => dot.token + id.name)].join(""),
|
|
17386
|
+
args
|
|
17387
|
+
};
|
|
17388
|
+
});
|
|
17207
17389
|
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
17208
17390
|
function TypePrimary(state) {
|
|
17209
17391
|
let eventData;
|
|
@@ -17349,7 +17531,7 @@ ${input.slice(result.pos)}
|
|
|
17349
17531
|
return result;
|
|
17350
17532
|
}
|
|
17351
17533
|
}
|
|
17352
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17534
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L120, fail, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
17353
17535
|
if ($2)
|
|
17354
17536
|
return $0;
|
|
17355
17537
|
return $1;
|
|
@@ -17378,10 +17560,10 @@ ${input.slice(result.pos)}
|
|
|
17378
17560
|
}
|
|
17379
17561
|
var TypeLiteral$0 = TemplateLiteral;
|
|
17380
17562
|
var TypeLiteral$1 = Literal;
|
|
17381
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17382
|
-
return { $loc, token:
|
|
17563
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
17564
|
+
return { type: "VoidType", $loc, token: $1 };
|
|
17383
17565
|
});
|
|
17384
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17566
|
+
var TypeLiteral$3 = $TV($EXPECT($L177, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
17385
17567
|
return { $loc, token: "[]" };
|
|
17386
17568
|
});
|
|
17387
17569
|
function TypeLiteral(state) {
|
|
@@ -17456,7 +17638,7 @@ ${input.slice(result.pos)}
|
|
|
17456
17638
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
17457
17639
|
return value[1];
|
|
17458
17640
|
});
|
|
17459
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17641
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L33, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
17460
17642
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
17461
17643
|
function InlineInterfacePropertyDelimiter(state) {
|
|
17462
17644
|
let eventData;
|
|
@@ -17480,10 +17662,10 @@ ${input.slice(result.pos)}
|
|
|
17480
17662
|
return result;
|
|
17481
17663
|
}
|
|
17482
17664
|
}
|
|
17483
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17665
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L84, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
17484
17666
|
return { $loc, token: "|" };
|
|
17485
17667
|
});
|
|
17486
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17668
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
17487
17669
|
return { $loc, token: "&" };
|
|
17488
17670
|
});
|
|
17489
17671
|
function TypeBinaryOp(state) {
|
|
@@ -17540,7 +17722,7 @@ ${input.slice(result.pos)}
|
|
|
17540
17722
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17541
17723
|
return { $loc, token: "=>" };
|
|
17542
17724
|
});
|
|
17543
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17725
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17544
17726
|
return { $loc, token: "=>" };
|
|
17545
17727
|
});
|
|
17546
17728
|
function TypeArrowFunction(state) {
|
|
@@ -17565,7 +17747,7 @@ ${input.slice(result.pos)}
|
|
|
17565
17747
|
return result;
|
|
17566
17748
|
}
|
|
17567
17749
|
}
|
|
17568
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17750
|
+
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17569
17751
|
return { ts: true, children: $0 };
|
|
17570
17752
|
});
|
|
17571
17753
|
function TypeArguments(state) {
|
|
@@ -17636,7 +17818,7 @@ ${input.slice(result.pos)}
|
|
|
17636
17818
|
return result;
|
|
17637
17819
|
}
|
|
17638
17820
|
}
|
|
17639
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17821
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L132, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17640
17822
|
var parameters = $3;
|
|
17641
17823
|
return {
|
|
17642
17824
|
type: "TypeParameters",
|
|
@@ -17690,7 +17872,7 @@ ${input.slice(result.pos)}
|
|
|
17690
17872
|
return result;
|
|
17691
17873
|
}
|
|
17692
17874
|
}
|
|
17693
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17875
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L120, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17694
17876
|
function TypeConstraint(state) {
|
|
17695
17877
|
let eventData;
|
|
17696
17878
|
if (state.events) {
|
|
@@ -17737,7 +17919,7 @@ ${input.slice(result.pos)}
|
|
|
17737
17919
|
}
|
|
17738
17920
|
}
|
|
17739
17921
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17740
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17922
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17741
17923
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17742
17924
|
return value[1];
|
|
17743
17925
|
});
|
|
@@ -17841,7 +18023,7 @@ ${input.slice(result.pos)}
|
|
|
17841
18023
|
return result;
|
|
17842
18024
|
}
|
|
17843
18025
|
}
|
|
17844
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
18026
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L178, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R61, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17845
18027
|
var options = $3;
|
|
17846
18028
|
return {
|
|
17847
18029
|
type: "CivetPrologue",
|
|
@@ -18002,13 +18184,13 @@ ${input.slice(result.pos)}
|
|
|
18002
18184
|
return result;
|
|
18003
18185
|
}
|
|
18004
18186
|
}
|
|
18005
|
-
var
|
|
18187
|
+
var DebugHere$0 = $TV($EXPECT($L19, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
18006
18188
|
debugger;
|
|
18007
18189
|
});
|
|
18008
|
-
function
|
|
18190
|
+
function DebugHere(state) {
|
|
18009
18191
|
let eventData;
|
|
18010
18192
|
if (state.events) {
|
|
18011
|
-
const result = state.events.enter?.("
|
|
18193
|
+
const result = state.events.enter?.("DebugHere", state);
|
|
18012
18194
|
if (result) {
|
|
18013
18195
|
if (result.cache)
|
|
18014
18196
|
return result.cache;
|
|
@@ -18016,18 +18198,18 @@ ${input.slice(result.pos)}
|
|
|
18016
18198
|
}
|
|
18017
18199
|
}
|
|
18018
18200
|
if (state.tokenize) {
|
|
18019
|
-
const result = $TOKEN("
|
|
18201
|
+
const result = $TOKEN("DebugHere", state, DebugHere$0(state));
|
|
18020
18202
|
if (state.events)
|
|
18021
|
-
state.events.exit?.("
|
|
18203
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
18022
18204
|
return result;
|
|
18023
18205
|
} else {
|
|
18024
|
-
const result =
|
|
18206
|
+
const result = DebugHere$0(state);
|
|
18025
18207
|
if (state.events)
|
|
18026
|
-
state.events.exit?.("
|
|
18208
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
18027
18209
|
return result;
|
|
18028
18210
|
}
|
|
18029
18211
|
}
|
|
18030
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
18212
|
+
var InsertSemicolon$0 = $TV($EXPECT($L19, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
18031
18213
|
return { $loc, token: ";" };
|
|
18032
18214
|
});
|
|
18033
18215
|
function InsertSemicolon(state) {
|
|
@@ -18052,7 +18234,7 @@ ${input.slice(result.pos)}
|
|
|
18052
18234
|
return result;
|
|
18053
18235
|
}
|
|
18054
18236
|
}
|
|
18055
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
18237
|
+
var InsertOpenParen$0 = $TV($EXPECT($L19, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
18056
18238
|
return { $loc, token: "(" };
|
|
18057
18239
|
});
|
|
18058
18240
|
function InsertOpenParen(state) {
|
|
@@ -18077,7 +18259,7 @@ ${input.slice(result.pos)}
|
|
|
18077
18259
|
return result;
|
|
18078
18260
|
}
|
|
18079
18261
|
}
|
|
18080
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
18262
|
+
var InsertCloseParen$0 = $TV($EXPECT($L19, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
18081
18263
|
return { $loc, token: ")" };
|
|
18082
18264
|
});
|
|
18083
18265
|
function InsertCloseParen(state) {
|
|
@@ -18102,7 +18284,7 @@ ${input.slice(result.pos)}
|
|
|
18102
18284
|
return result;
|
|
18103
18285
|
}
|
|
18104
18286
|
}
|
|
18105
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
18287
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18106
18288
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
18107
18289
|
});
|
|
18108
18290
|
function InsertOpenBrace(state) {
|
|
@@ -18127,7 +18309,7 @@ ${input.slice(result.pos)}
|
|
|
18127
18309
|
return result;
|
|
18128
18310
|
}
|
|
18129
18311
|
}
|
|
18130
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
18312
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18131
18313
|
return { $loc, token: "{" };
|
|
18132
18314
|
});
|
|
18133
18315
|
function InsertInlineOpenBrace(state) {
|
|
@@ -18152,7 +18334,7 @@ ${input.slice(result.pos)}
|
|
|
18152
18334
|
return result;
|
|
18153
18335
|
}
|
|
18154
18336
|
}
|
|
18155
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
18337
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L19, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
18156
18338
|
return { $loc, token: "}" };
|
|
18157
18339
|
});
|
|
18158
18340
|
function InsertCloseBrace(state) {
|
|
@@ -18177,7 +18359,7 @@ ${input.slice(result.pos)}
|
|
|
18177
18359
|
return result;
|
|
18178
18360
|
}
|
|
18179
18361
|
}
|
|
18180
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
18362
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L19, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
18181
18363
|
return { $loc, token: "[" };
|
|
18182
18364
|
});
|
|
18183
18365
|
function InsertOpenBracket(state) {
|
|
@@ -18202,7 +18384,7 @@ ${input.slice(result.pos)}
|
|
|
18202
18384
|
return result;
|
|
18203
18385
|
}
|
|
18204
18386
|
}
|
|
18205
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
18387
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L19, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
18206
18388
|
return { $loc, token: "]" };
|
|
18207
18389
|
});
|
|
18208
18390
|
function InsertCloseBracket(state) {
|
|
@@ -18227,7 +18409,7 @@ ${input.slice(result.pos)}
|
|
|
18227
18409
|
return result;
|
|
18228
18410
|
}
|
|
18229
18411
|
}
|
|
18230
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
18412
|
+
var InsertComma$0 = $TV($EXPECT($L19, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
18231
18413
|
return { $loc, token: "," };
|
|
18232
18414
|
});
|
|
18233
18415
|
function InsertComma(state) {
|
|
@@ -18252,7 +18434,7 @@ ${input.slice(result.pos)}
|
|
|
18252
18434
|
return result;
|
|
18253
18435
|
}
|
|
18254
18436
|
}
|
|
18255
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
18437
|
+
var InsertConst$0 = $TV($EXPECT($L19, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
18256
18438
|
return { $loc, token: "const " };
|
|
18257
18439
|
});
|
|
18258
18440
|
function InsertConst(state) {
|
|
@@ -18277,7 +18459,7 @@ ${input.slice(result.pos)}
|
|
|
18277
18459
|
return result;
|
|
18278
18460
|
}
|
|
18279
18461
|
}
|
|
18280
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
18462
|
+
var InsertLet$0 = $TV($EXPECT($L19, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
18281
18463
|
return { $loc, token: "let " };
|
|
18282
18464
|
});
|
|
18283
18465
|
function InsertLet(state) {
|
|
@@ -18302,7 +18484,7 @@ ${input.slice(result.pos)}
|
|
|
18302
18484
|
return result;
|
|
18303
18485
|
}
|
|
18304
18486
|
}
|
|
18305
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
18487
|
+
var InsertReadonly$0 = $TV($EXPECT($L19, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
18306
18488
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
18307
18489
|
});
|
|
18308
18490
|
function InsertReadonly(state) {
|
|
@@ -18327,7 +18509,7 @@ ${input.slice(result.pos)}
|
|
|
18327
18509
|
return result;
|
|
18328
18510
|
}
|
|
18329
18511
|
}
|
|
18330
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
18512
|
+
var InsertNewline$0 = $TV($EXPECT($L19, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
18331
18513
|
return "\n";
|
|
18332
18514
|
});
|
|
18333
18515
|
function InsertNewline(state) {
|
|
@@ -18352,7 +18534,7 @@ ${input.slice(result.pos)}
|
|
|
18352
18534
|
return result;
|
|
18353
18535
|
}
|
|
18354
18536
|
}
|
|
18355
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
18537
|
+
var InsertIndent$0 = $TV($EXPECT($L19, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
18356
18538
|
return module.currentIndent.token;
|
|
18357
18539
|
});
|
|
18358
18540
|
function InsertIndent(state) {
|
|
@@ -18377,7 +18559,7 @@ ${input.slice(result.pos)}
|
|
|
18377
18559
|
return result;
|
|
18378
18560
|
}
|
|
18379
18561
|
}
|
|
18380
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
18562
|
+
var InsertSpace$0 = $TV($EXPECT($L19, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
18381
18563
|
return { $loc, token: " " };
|
|
18382
18564
|
});
|
|
18383
18565
|
function InsertSpace(state) {
|
|
@@ -18402,7 +18584,7 @@ ${input.slice(result.pos)}
|
|
|
18402
18584
|
return result;
|
|
18403
18585
|
}
|
|
18404
18586
|
}
|
|
18405
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
18587
|
+
var InsertDot$0 = $TV($EXPECT($L19, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
18406
18588
|
return { $loc, token: "." };
|
|
18407
18589
|
});
|
|
18408
18590
|
function InsertDot(state) {
|
|
@@ -18427,7 +18609,7 @@ ${input.slice(result.pos)}
|
|
|
18427
18609
|
return result;
|
|
18428
18610
|
}
|
|
18429
18611
|
}
|
|
18430
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18612
|
+
var InsertBreak$0 = $TV($EXPECT($L19, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
18431
18613
|
return { $loc, token: ";break;" };
|
|
18432
18614
|
});
|
|
18433
18615
|
function InsertBreak(state) {
|
|
@@ -18452,7 +18634,7 @@ ${input.slice(result.pos)}
|
|
|
18452
18634
|
return result;
|
|
18453
18635
|
}
|
|
18454
18636
|
}
|
|
18455
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18637
|
+
var InsertVar$0 = $TV($EXPECT($L19, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
18456
18638
|
return { $loc, token: "var " };
|
|
18457
18639
|
});
|
|
18458
18640
|
function InsertVar(state) {
|
|
@@ -18477,7 +18659,7 @@ ${input.slice(result.pos)}
|
|
|
18477
18659
|
return result;
|
|
18478
18660
|
}
|
|
18479
18661
|
}
|
|
18480
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18662
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18481
18663
|
if (module.config.coffeeBinaryExistential)
|
|
18482
18664
|
return;
|
|
18483
18665
|
return $skip;
|
|
@@ -18504,7 +18686,7 @@ ${input.slice(result.pos)}
|
|
|
18504
18686
|
return result;
|
|
18505
18687
|
}
|
|
18506
18688
|
}
|
|
18507
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18689
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18508
18690
|
if (module.config.coffeeBooleans)
|
|
18509
18691
|
return;
|
|
18510
18692
|
return $skip;
|
|
@@ -18531,7 +18713,7 @@ ${input.slice(result.pos)}
|
|
|
18531
18713
|
return result;
|
|
18532
18714
|
}
|
|
18533
18715
|
}
|
|
18534
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18716
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18535
18717
|
if (module.config.coffeeClasses)
|
|
18536
18718
|
return;
|
|
18537
18719
|
return $skip;
|
|
@@ -18558,7 +18740,7 @@ ${input.slice(result.pos)}
|
|
|
18558
18740
|
return result;
|
|
18559
18741
|
}
|
|
18560
18742
|
}
|
|
18561
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18743
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18562
18744
|
if (module.config.coffeeComment)
|
|
18563
18745
|
return;
|
|
18564
18746
|
return $skip;
|
|
@@ -18585,7 +18767,7 @@ ${input.slice(result.pos)}
|
|
|
18585
18767
|
return result;
|
|
18586
18768
|
}
|
|
18587
18769
|
}
|
|
18588
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18770
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18589
18771
|
if (module.config.coffeeDo)
|
|
18590
18772
|
return;
|
|
18591
18773
|
return $skip;
|
|
@@ -18612,7 +18794,7 @@ ${input.slice(result.pos)}
|
|
|
18612
18794
|
return result;
|
|
18613
18795
|
}
|
|
18614
18796
|
}
|
|
18615
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18797
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18616
18798
|
if (module.config.coffeeForLoops)
|
|
18617
18799
|
return;
|
|
18618
18800
|
return $skip;
|
|
@@ -18639,7 +18821,7 @@ ${input.slice(result.pos)}
|
|
|
18639
18821
|
return result;
|
|
18640
18822
|
}
|
|
18641
18823
|
}
|
|
18642
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18824
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18643
18825
|
if (module.config.coffeeInterpolation)
|
|
18644
18826
|
return;
|
|
18645
18827
|
return $skip;
|
|
@@ -18666,7 +18848,7 @@ ${input.slice(result.pos)}
|
|
|
18666
18848
|
return result;
|
|
18667
18849
|
}
|
|
18668
18850
|
}
|
|
18669
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18851
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18670
18852
|
if (module.config.coffeeIsnt)
|
|
18671
18853
|
return;
|
|
18672
18854
|
return $skip;
|
|
@@ -18693,7 +18875,7 @@ ${input.slice(result.pos)}
|
|
|
18693
18875
|
return result;
|
|
18694
18876
|
}
|
|
18695
18877
|
}
|
|
18696
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18878
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18697
18879
|
if (module.config.coffeeJSX)
|
|
18698
18880
|
return;
|
|
18699
18881
|
return $skip;
|
|
@@ -18720,7 +18902,7 @@ ${input.slice(result.pos)}
|
|
|
18720
18902
|
return result;
|
|
18721
18903
|
}
|
|
18722
18904
|
}
|
|
18723
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18905
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18724
18906
|
if (module.config.coffeeLineContinuation)
|
|
18725
18907
|
return;
|
|
18726
18908
|
return $skip;
|
|
@@ -18747,7 +18929,7 @@ ${input.slice(result.pos)}
|
|
|
18747
18929
|
return result;
|
|
18748
18930
|
}
|
|
18749
18931
|
}
|
|
18750
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18932
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18751
18933
|
if (module.config.coffeeNot)
|
|
18752
18934
|
return;
|
|
18753
18935
|
return $skip;
|
|
@@ -18774,7 +18956,7 @@ ${input.slice(result.pos)}
|
|
|
18774
18956
|
return result;
|
|
18775
18957
|
}
|
|
18776
18958
|
}
|
|
18777
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18959
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18778
18960
|
if (module.config.coffeeOf)
|
|
18779
18961
|
return;
|
|
18780
18962
|
return $skip;
|
|
@@ -18801,7 +18983,7 @@ ${input.slice(result.pos)}
|
|
|
18801
18983
|
return result;
|
|
18802
18984
|
}
|
|
18803
18985
|
}
|
|
18804
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18986
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18805
18987
|
if (module.config.coffeePrototype)
|
|
18806
18988
|
return;
|
|
18807
18989
|
return $skip;
|
|
@@ -18828,7 +19010,7 @@ ${input.slice(result.pos)}
|
|
|
18828
19010
|
return result;
|
|
18829
19011
|
}
|
|
18830
19012
|
}
|
|
18831
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
19013
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L19, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18832
19014
|
if (module.config.objectIs)
|
|
18833
19015
|
return;
|
|
18834
19016
|
return $skip;
|
|
@@ -18855,7 +19037,7 @@ ${input.slice(result.pos)}
|
|
|
18855
19037
|
return result;
|
|
18856
19038
|
}
|
|
18857
19039
|
}
|
|
18858
|
-
var Reset$0 = $TV($EXPECT($
|
|
19040
|
+
var Reset$0 = $TV($EXPECT($L19, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18859
19041
|
module.indentLevels = [{
|
|
18860
19042
|
level: 0,
|
|
18861
19043
|
token: ""
|
|
@@ -19162,7 +19344,7 @@ ${input.slice(result.pos)}
|
|
|
19162
19344
|
return result;
|
|
19163
19345
|
}
|
|
19164
19346
|
}
|
|
19165
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
19347
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L19, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
19166
19348
|
var directives = $2;
|
|
19167
19349
|
directives.forEach((directive) => {
|
|
19168
19350
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19465,6 +19647,12 @@ ${input.slice(result.pos)}
|
|
|
19465
19647
|
return;
|
|
19466
19648
|
}
|
|
19467
19649
|
}
|
|
19650
|
+
function getIndent(statement) {
|
|
19651
|
+
let indent = statement?.[0];
|
|
19652
|
+
if (Array.isArray(indent))
|
|
19653
|
+
indent = indent[indent.length - 1];
|
|
19654
|
+
return indent;
|
|
19655
|
+
}
|
|
19468
19656
|
function insertReturn(node) {
|
|
19469
19657
|
if (!node)
|
|
19470
19658
|
return;
|
|
@@ -19489,9 +19677,7 @@ ${input.slice(result.pos)}
|
|
|
19489
19677
|
const [, exp, semi] = node;
|
|
19490
19678
|
if (semi?.type === "SemicolonDelimiter")
|
|
19491
19679
|
return;
|
|
19492
|
-
let indent = node
|
|
19493
|
-
if (Array.isArray(indent))
|
|
19494
|
-
indent = indent[indent.length - 1];
|
|
19680
|
+
let indent = getIndent(node);
|
|
19495
19681
|
if (!exp)
|
|
19496
19682
|
return;
|
|
19497
19683
|
switch (exp.type) {
|
|
@@ -19880,7 +20066,12 @@ ${input.slice(result.pos)}
|
|
|
19880
20066
|
names
|
|
19881
20067
|
};
|
|
19882
20068
|
}
|
|
19883
|
-
|
|
20069
|
+
return {
|
|
20070
|
+
children: [{
|
|
20071
|
+
type: "Error",
|
|
20072
|
+
message: "Multiple rest properties in object pattern"
|
|
20073
|
+
}, props2]
|
|
20074
|
+
};
|
|
19884
20075
|
};
|
|
19885
20076
|
function gatherNodes(node, predicate) {
|
|
19886
20077
|
if (node == null)
|
|
@@ -19906,12 +20097,14 @@ ${input.slice(result.pos)}
|
|
|
19906
20097
|
}
|
|
19907
20098
|
return [];
|
|
19908
20099
|
}
|
|
19909
|
-
function gatherRecursive(node, predicate) {
|
|
20100
|
+
function gatherRecursive(node, predicate, skipPredicate) {
|
|
19910
20101
|
if (node == null)
|
|
19911
20102
|
return [];
|
|
19912
20103
|
if (Array.isArray(node)) {
|
|
19913
20104
|
return node.flatMap((n) => gatherRecursive(n, predicate));
|
|
19914
20105
|
}
|
|
20106
|
+
if (skipPredicate?.(node))
|
|
20107
|
+
return [];
|
|
19915
20108
|
if (predicate(node)) {
|
|
19916
20109
|
return [node];
|
|
19917
20110
|
}
|
|
@@ -19929,6 +20122,36 @@ ${input.slice(result.pos)}
|
|
|
19929
20122
|
}
|
|
19930
20123
|
return nodes;
|
|
19931
20124
|
}
|
|
20125
|
+
function isFunction({ type }) {
|
|
20126
|
+
return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition";
|
|
20127
|
+
}
|
|
20128
|
+
function gatherRecursiveWithinFunction(node, predicate) {
|
|
20129
|
+
return gatherRecursive(node, predicate, isFunction);
|
|
20130
|
+
}
|
|
20131
|
+
function addParentPointers(node, parent) {
|
|
20132
|
+
if (node == null)
|
|
20133
|
+
return;
|
|
20134
|
+
if (typeof node !== "object")
|
|
20135
|
+
return;
|
|
20136
|
+
node.parent = parent;
|
|
20137
|
+
if (Array.isArray(node)) {
|
|
20138
|
+
for (const child of node) {
|
|
20139
|
+
addParentPointers(child, node);
|
|
20140
|
+
}
|
|
20141
|
+
} else if (node.children) {
|
|
20142
|
+
for (const child of node.children) {
|
|
20143
|
+
addParentPointers(child, node);
|
|
20144
|
+
}
|
|
20145
|
+
}
|
|
20146
|
+
}
|
|
20147
|
+
function findAncestor(node, predicate, stopPredicate) {
|
|
20148
|
+
node = node.parent;
|
|
20149
|
+
while (node && !stopPredicate?.(node)) {
|
|
20150
|
+
if (predicate(node))
|
|
20151
|
+
return node;
|
|
20152
|
+
node = node.parent;
|
|
20153
|
+
}
|
|
20154
|
+
}
|
|
19932
20155
|
function processParams(f) {
|
|
19933
20156
|
const { type, parameters, block } = f;
|
|
19934
20157
|
if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
|
|
@@ -19974,26 +20197,89 @@ ${input.slice(result.pos)}
|
|
|
19974
20197
|
}
|
|
19975
20198
|
});
|
|
19976
20199
|
}
|
|
20200
|
+
function processReturnValue(func) {
|
|
20201
|
+
const { block } = func;
|
|
20202
|
+
const values = gatherRecursiveWithinFunction(
|
|
20203
|
+
block,
|
|
20204
|
+
({ type }) => type === "ReturnValue"
|
|
20205
|
+
);
|
|
20206
|
+
if (!values.length)
|
|
20207
|
+
return false;
|
|
20208
|
+
const ref = {
|
|
20209
|
+
type: "Ref",
|
|
20210
|
+
base: "ret",
|
|
20211
|
+
id: "ret"
|
|
20212
|
+
};
|
|
20213
|
+
let declared;
|
|
20214
|
+
values.forEach((value) => {
|
|
20215
|
+
value.children = [ref];
|
|
20216
|
+
const ancestor = findAncestor(
|
|
20217
|
+
value,
|
|
20218
|
+
({ type }) => type === "Declaration",
|
|
20219
|
+
isFunction
|
|
20220
|
+
);
|
|
20221
|
+
if (ancestor)
|
|
20222
|
+
declared = true;
|
|
20223
|
+
});
|
|
20224
|
+
if (!declared) {
|
|
20225
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
20226
|
+
if (returnType) {
|
|
20227
|
+
const { t } = returnType;
|
|
20228
|
+
if (t.type === "TypePredicate") {
|
|
20229
|
+
returnType = ": boolean";
|
|
20230
|
+
} else if (t.type === "AssertsType") {
|
|
20231
|
+
returnType = void 0;
|
|
20232
|
+
}
|
|
20233
|
+
}
|
|
20234
|
+
block.expressions.unshift([
|
|
20235
|
+
getIndent(block.expressions[0]),
|
|
20236
|
+
{
|
|
20237
|
+
type: "Declaration",
|
|
20238
|
+
children: ["let ", ref, returnType, ";\n"],
|
|
20239
|
+
names: []
|
|
20240
|
+
}
|
|
20241
|
+
]);
|
|
20242
|
+
}
|
|
20243
|
+
gatherRecursiveWithinFunction(
|
|
20244
|
+
block,
|
|
20245
|
+
(r) => r.type === "ReturnStatement" && !r.expression
|
|
20246
|
+
).forEach((r) => {
|
|
20247
|
+
r.expression = ref;
|
|
20248
|
+
r.children.splice(-1, 1, " ", ref);
|
|
20249
|
+
});
|
|
20250
|
+
if (block.children.at(-2)?.type !== "ReturnStatement") {
|
|
20251
|
+
block.expressions.push([
|
|
20252
|
+
["\n", getIndent(block.expressions.at(-1))],
|
|
20253
|
+
{
|
|
20254
|
+
type: "ReturnStatement",
|
|
20255
|
+
expression: ref,
|
|
20256
|
+
children: ["return ", ref]
|
|
20257
|
+
}
|
|
20258
|
+
]);
|
|
20259
|
+
}
|
|
20260
|
+
return true;
|
|
20261
|
+
}
|
|
20262
|
+
function isVoidType(t) {
|
|
20263
|
+
return t?.type === "LiteralType" && t.t.type === "VoidType";
|
|
20264
|
+
}
|
|
19977
20265
|
function processFunctions(statements) {
|
|
19978
|
-
gatherRecursiveAll(statements, (
|
|
19979
|
-
return n.type === "FunctionExpression" || n.type === "ArrowFunction";
|
|
19980
|
-
}).forEach((f) => {
|
|
20266
|
+
gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
|
|
19981
20267
|
processParams(f);
|
|
19982
|
-
|
|
19983
|
-
|
|
19984
|
-
const isVoid = returnType
|
|
20268
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20269
|
+
const { block, returnType } = f;
|
|
20270
|
+
const isVoid = isVoidType(returnType?.t);
|
|
19985
20271
|
const isBlock = block?.type === "BlockStatement";
|
|
19986
20272
|
if (!isVoid && isBlock) {
|
|
19987
20273
|
insertReturn(block);
|
|
19988
20274
|
}
|
|
19989
20275
|
}
|
|
19990
20276
|
});
|
|
19991
|
-
gatherRecursiveAll(statements, (
|
|
20277
|
+
gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
|
|
19992
20278
|
processParams(f);
|
|
19993
|
-
|
|
19994
|
-
|
|
20279
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20280
|
+
const { signature, block } = f;
|
|
19995
20281
|
const isConstructor = signature.name === "constructor";
|
|
19996
|
-
const isVoid = signature.returnType
|
|
20282
|
+
const isVoid = isVoidType(signature.returnType?.t);
|
|
19997
20283
|
const isSet = signature.modifier === "set";
|
|
19998
20284
|
if (!isConstructor && !isSet && !isVoid) {
|
|
19999
20285
|
insertReturn(block);
|
|
@@ -20481,6 +20767,7 @@ ${input.slice(result.pos)}
|
|
|
20481
20767
|
});
|
|
20482
20768
|
}
|
|
20483
20769
|
module.processProgram = function(statements) {
|
|
20770
|
+
addParentPointers(statements);
|
|
20484
20771
|
processPipelineExpressions(statements);
|
|
20485
20772
|
processAssignments(statements);
|
|
20486
20773
|
processFunctions(statements);
|
|
@@ -20507,18 +20794,7 @@ ${input.slice(result.pos)}
|
|
|
20507
20794
|
return new Set(declarationNames);
|
|
20508
20795
|
}
|
|
20509
20796
|
function populateRefs(statements) {
|
|
20510
|
-
const refNodes =
|
|
20511
|
-
const blockNodes = new Set(gatherNodes(statements, ({ type }) => type === "BlockStatement"));
|
|
20512
|
-
const forNodes = gatherNodes(statements, ({ type }) => type === "ForStatement");
|
|
20513
|
-
forNodes.forEach(({ declaration, block }) => {
|
|
20514
|
-
if (block.type === "BlockStatement") {
|
|
20515
|
-
populateRefs([declaration, ...block.children]);
|
|
20516
|
-
} else {
|
|
20517
|
-
populateRefs([declaration, ...block]);
|
|
20518
|
-
}
|
|
20519
|
-
blockNodes.delete(block);
|
|
20520
|
-
});
|
|
20521
|
-
blockNodes.forEach(({ expressions }) => populateRefs(expressions));
|
|
20797
|
+
const refNodes = gatherRecursive(statements, ({ type }) => type === "Ref");
|
|
20522
20798
|
if (refNodes.length) {
|
|
20523
20799
|
const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
|
|
20524
20800
|
const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
|
|
@@ -20924,7 +21200,7 @@ ${input.slice(result.pos)}
|
|
|
20924
21200
|
return result;
|
|
20925
21201
|
}
|
|
20926
21202
|
}
|
|
20927
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
21203
|
+
var PopIndent$0 = $TV($EXPECT($L19, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
20928
21204
|
if (module.config.verbose) {
|
|
20929
21205
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
20930
21206
|
}
|
|
@@ -21072,6 +21348,9 @@ ${input.slice(result.pos)}
|
|
|
21072
21348
|
if (node.length === 0) {
|
|
21073
21349
|
return;
|
|
21074
21350
|
}
|
|
21351
|
+
if (node.parent != null) {
|
|
21352
|
+
delete node.parent;
|
|
21353
|
+
}
|
|
21075
21354
|
if (Array.isArray(node)) {
|
|
21076
21355
|
a = node.map(function(n) {
|
|
21077
21356
|
return prune(n);
|
|
@@ -21462,7 +21741,9 @@ ${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode2(JSON.stri
|
|
|
21462
21741
|
}
|
|
21463
21742
|
result = generate_default(ast, options);
|
|
21464
21743
|
if ((ref = options.errors) != null ? ref.length : void 0) {
|
|
21465
|
-
throw new Error(`Parse errors: ${options.errors.
|
|
21744
|
+
throw new Error(`Parse errors: ${options.errors.map(function(e) {
|
|
21745
|
+
return e.message;
|
|
21746
|
+
}).join("\n")} `);
|
|
21466
21747
|
}
|
|
21467
21748
|
return result;
|
|
21468
21749
|
};
|