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