@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.mjs
CHANGED
|
@@ -497,6 +497,8 @@ ${input.slice(result.pos)}
|
|
|
497
497
|
AtThis,
|
|
498
498
|
LeftHandSideExpression,
|
|
499
499
|
CallExpression,
|
|
500
|
+
ReturnValue,
|
|
501
|
+
AfterReturnShorthand,
|
|
500
502
|
CallExpressionRest,
|
|
501
503
|
OptionalShorthand,
|
|
502
504
|
OptionalDot,
|
|
@@ -701,6 +703,9 @@ ${input.slice(result.pos)}
|
|
|
701
703
|
RestoreAll,
|
|
702
704
|
ExpressionStatement,
|
|
703
705
|
KeywordStatement,
|
|
706
|
+
Break,
|
|
707
|
+
Continue,
|
|
708
|
+
Debugger,
|
|
704
709
|
DebuggerExpression,
|
|
705
710
|
ThrowExpression,
|
|
706
711
|
MaybeNestedExpression,
|
|
@@ -979,7 +984,7 @@ ${input.slice(result.pos)}
|
|
|
979
984
|
DirectivePrologue,
|
|
980
985
|
EOS,
|
|
981
986
|
EOL,
|
|
982
|
-
|
|
987
|
+
DebugHere,
|
|
983
988
|
InsertSemicolon,
|
|
984
989
|
InsertOpenParen,
|
|
985
990
|
InsertCloseParen,
|
|
@@ -1036,170 +1041,171 @@ ${input.slice(result.pos)}
|
|
|
1036
1041
|
var $L11 = $L("#");
|
|
1037
1042
|
var $L12 = $L("super");
|
|
1038
1043
|
var $L13 = $L("import");
|
|
1039
|
-
var $L14 = $L("
|
|
1040
|
-
var $L15 = $L("
|
|
1041
|
-
var $L16 = $L("
|
|
1042
|
-
var $L17 = $L("
|
|
1043
|
-
var $L18 = $L("");
|
|
1044
|
-
var $L19 = $L("
|
|
1045
|
-
var $L20 = $L("
|
|
1046
|
-
var $L21 = $L("
|
|
1047
|
-
var $L22 = $L("
|
|
1048
|
-
var $L23 = $L("
|
|
1049
|
-
var $L24 = $L("
|
|
1050
|
-
var $L25 = $L("
|
|
1051
|
-
var $L26 = $L("
|
|
1052
|
-
var $L27 = $L("
|
|
1053
|
-
var $L28 = $L("
|
|
1054
|
-
var $L29 = $L("
|
|
1055
|
-
var $L30 = $L("
|
|
1056
|
-
var $L31 = $L("
|
|
1057
|
-
var $L32 = $L("
|
|
1058
|
-
var $L33 = $L("
|
|
1059
|
-
var $L34 = $L("
|
|
1060
|
-
var $L35 = $L("
|
|
1061
|
-
var $L36 = $L("
|
|
1062
|
-
var $L37 = $L("
|
|
1063
|
-
var $L38 = $L("
|
|
1064
|
-
var $L39 = $L("
|
|
1065
|
-
var $L40 = $L("
|
|
1066
|
-
var $L41 = $L("
|
|
1067
|
-
var $L42 = $L("
|
|
1068
|
-
var $L43 = $L("
|
|
1069
|
-
var $L44 = $L("
|
|
1070
|
-
var $L45 = $L("
|
|
1071
|
-
var $L46 = $L("
|
|
1072
|
-
var $L47 = $L("
|
|
1073
|
-
var $L48 = $L("
|
|
1074
|
-
var $L49 = $L("
|
|
1075
|
-
var $L50 = $L("
|
|
1076
|
-
var $L51 = $L("
|
|
1077
|
-
var $L52 = $L("
|
|
1078
|
-
var $L53 = $L("
|
|
1079
|
-
var $L54 = $L("
|
|
1080
|
-
var $L55 = $L("
|
|
1081
|
-
var $L56 = $L("
|
|
1082
|
-
var $L57 = $L("
|
|
1083
|
-
var $L58 = $L("
|
|
1084
|
-
var $L59 = $L("
|
|
1085
|
-
var $L60 = $L("
|
|
1086
|
-
var $L61 = $L("
|
|
1087
|
-
var $L62 = $L("
|
|
1088
|
-
var $L63 = $L("
|
|
1089
|
-
var $L64 = $L("
|
|
1090
|
-
var $L65 = $L("
|
|
1091
|
-
var $L66 = $L("
|
|
1092
|
-
var $L67 = $L("
|
|
1093
|
-
var $L68 = $L("
|
|
1094
|
-
var $L69 = $L("
|
|
1095
|
-
var $L70 = $L("
|
|
1096
|
-
var $L71 = $L("
|
|
1097
|
-
var $L72 = $L("
|
|
1098
|
-
var $L73 = $L("
|
|
1099
|
-
var $L74 = $L("
|
|
1100
|
-
var $L75 = $L("
|
|
1101
|
-
var $L76 = $L("
|
|
1102
|
-
var $L77 = $L("
|
|
1103
|
-
var $L78 = $L("
|
|
1104
|
-
var $L79 = $L("
|
|
1105
|
-
var $L80 = $L("
|
|
1106
|
-
var $L81 = $L("
|
|
1107
|
-
var $L82 = $L("
|
|
1108
|
-
var $L83 = $L("
|
|
1109
|
-
var $L84 = $L("
|
|
1110
|
-
var $L85 = $L("
|
|
1111
|
-
var $L86 = $L("
|
|
1112
|
-
var $L87 = $L("
|
|
1113
|
-
var $L88 = $L("
|
|
1114
|
-
var $L89 = $L("
|
|
1115
|
-
var $L90 = $L("
|
|
1116
|
-
var $L91 = $L("
|
|
1117
|
-
var $L92 = $L("
|
|
1118
|
-
var $L93 = $L("
|
|
1119
|
-
var $L94 = $L("
|
|
1120
|
-
var $L95 = $L("
|
|
1121
|
-
var $L96 = $L("
|
|
1122
|
-
var $L97 = $L("
|
|
1123
|
-
var $L98 = $L("
|
|
1124
|
-
var $L99 = $L("
|
|
1125
|
-
var $L100 = $L("
|
|
1126
|
-
var $L101 = $L("
|
|
1127
|
-
var $L102 = $L("
|
|
1128
|
-
var $L103 = $L("
|
|
1129
|
-
var $L104 = $L("
|
|
1130
|
-
var $L105 = $L("
|
|
1131
|
-
var $L106 = $L("
|
|
1132
|
-
var $L107 = $L("
|
|
1133
|
-
var $L108 = $L("
|
|
1134
|
-
var $L109 = $L("
|
|
1135
|
-
var $L110 = $L("
|
|
1136
|
-
var $L111 = $L("
|
|
1137
|
-
var $L112 = $L("
|
|
1138
|
-
var $L113 = $L("
|
|
1139
|
-
var $L114 = $L("
|
|
1140
|
-
var $L115 = $L("
|
|
1141
|
-
var $L116 = $L(
|
|
1142
|
-
var $L117 = $L("
|
|
1143
|
-
var $L118 = $L("
|
|
1144
|
-
var $L119 = $L("
|
|
1145
|
-
var $L120 = $L("
|
|
1146
|
-
var $L121 = $L("
|
|
1147
|
-
var $L122 = $L("
|
|
1148
|
-
var $L123 = $L("
|
|
1149
|
-
var $L124 = $L("
|
|
1150
|
-
var $L125 = $L("
|
|
1151
|
-
var $L126 = $L("
|
|
1152
|
-
var $L127 = $L("
|
|
1153
|
-
var $L128 = $L("
|
|
1154
|
-
var $L129 = $L("
|
|
1155
|
-
var $L130 = $L("
|
|
1156
|
-
var $L131 = $L("
|
|
1157
|
-
var $L132 = $L("
|
|
1158
|
-
var $L133 = $L("
|
|
1159
|
-
var $L134 = $L("
|
|
1160
|
-
var $L135 = $L("
|
|
1161
|
-
var $L136 = $L("
|
|
1162
|
-
var $L137 = $L("
|
|
1163
|
-
var $L138 = $L("
|
|
1164
|
-
var $L139 = $L("
|
|
1165
|
-
var $L140 = $L("
|
|
1166
|
-
var $L141 = $L("
|
|
1167
|
-
var $L142 = $L("
|
|
1168
|
-
var $L143 = $L("
|
|
1169
|
-
var $L144 = $L("
|
|
1170
|
-
var $L145 = $L("
|
|
1171
|
-
var $L146 = $L("
|
|
1172
|
-
var $L147 = $L("
|
|
1173
|
-
var $L148 = $L("
|
|
1174
|
-
var $L149 = $L("
|
|
1175
|
-
var $L150 = $L("
|
|
1176
|
-
var $L151 = $L(
|
|
1177
|
-
var $L152 = $L("'
|
|
1178
|
-
var $L153 = $L("
|
|
1179
|
-
var $L154 = $L("
|
|
1180
|
-
var $L155 = $L("
|
|
1181
|
-
var $L156 = $L("
|
|
1182
|
-
var $L157 = $L("
|
|
1183
|
-
var $L158 = $L("
|
|
1184
|
-
var $L159 = $L("
|
|
1185
|
-
var $L160 = $L("
|
|
1186
|
-
var $L161 = $L("
|
|
1187
|
-
var $L162 = $L("
|
|
1188
|
-
var $L163 = $L("
|
|
1189
|
-
var $L164 = $L("
|
|
1190
|
-
var $L165 = $L("
|
|
1191
|
-
var $L166 = $L("
|
|
1192
|
-
var $L167 = $L("
|
|
1193
|
-
var $L168 = $L("
|
|
1194
|
-
var $L169 = $L("
|
|
1195
|
-
var $L170 = $L("
|
|
1196
|
-
var $L171 = $L("
|
|
1197
|
-
var $L172 = $L("
|
|
1198
|
-
var $L173 = $L("
|
|
1199
|
-
var $L174 = $L("
|
|
1200
|
-
var $L175 = $L("
|
|
1201
|
-
var $L176 = $L("
|
|
1202
|
-
var $L177 = $L("
|
|
1044
|
+
var $L14 = $L("return.value");
|
|
1045
|
+
var $L15 = $L("!");
|
|
1046
|
+
var $L16 = $L("^");
|
|
1047
|
+
var $L17 = $L("-");
|
|
1048
|
+
var $L18 = $L("import.meta");
|
|
1049
|
+
var $L19 = $L("");
|
|
1050
|
+
var $L20 = $L(",");
|
|
1051
|
+
var $L21 = $L("->");
|
|
1052
|
+
var $L22 = $L("}");
|
|
1053
|
+
var $L23 = $L("null");
|
|
1054
|
+
var $L24 = $L("true");
|
|
1055
|
+
var $L25 = $L("false");
|
|
1056
|
+
var $L26 = $L("yes");
|
|
1057
|
+
var $L27 = $L("on");
|
|
1058
|
+
var $L28 = $L("no");
|
|
1059
|
+
var $L29 = $L("off");
|
|
1060
|
+
var $L30 = $L(">");
|
|
1061
|
+
var $L31 = $L("]");
|
|
1062
|
+
var $L32 = $L(":");
|
|
1063
|
+
var $L33 = $L(")");
|
|
1064
|
+
var $L34 = $L("**=");
|
|
1065
|
+
var $L35 = $L("*=");
|
|
1066
|
+
var $L36 = $L("/=");
|
|
1067
|
+
var $L37 = $L("%=");
|
|
1068
|
+
var $L38 = $L("+=");
|
|
1069
|
+
var $L39 = $L("-=");
|
|
1070
|
+
var $L40 = $L("<<=");
|
|
1071
|
+
var $L41 = $L(">>>=");
|
|
1072
|
+
var $L42 = $L(">>=");
|
|
1073
|
+
var $L43 = $L("&&=");
|
|
1074
|
+
var $L44 = $L("&=");
|
|
1075
|
+
var $L45 = $L("^=");
|
|
1076
|
+
var $L46 = $L("||=");
|
|
1077
|
+
var $L47 = $L("|=");
|
|
1078
|
+
var $L48 = $L("??=");
|
|
1079
|
+
var $L49 = $L("?=");
|
|
1080
|
+
var $L50 = $L("and=");
|
|
1081
|
+
var $L51 = $L("or=");
|
|
1082
|
+
var $L52 = $L("not");
|
|
1083
|
+
var $L53 = $L("**");
|
|
1084
|
+
var $L54 = $L("*");
|
|
1085
|
+
var $L55 = $L("/");
|
|
1086
|
+
var $L56 = $L("%%");
|
|
1087
|
+
var $L57 = $L("%");
|
|
1088
|
+
var $L58 = $L("+");
|
|
1089
|
+
var $L59 = $L("<=");
|
|
1090
|
+
var $L60 = $L(">=");
|
|
1091
|
+
var $L61 = $L("<?");
|
|
1092
|
+
var $L62 = $L("!<?");
|
|
1093
|
+
var $L63 = $L("<<");
|
|
1094
|
+
var $L64 = $L(">>>");
|
|
1095
|
+
var $L65 = $L(">>");
|
|
1096
|
+
var $L66 = $L("!==");
|
|
1097
|
+
var $L67 = $L("!=");
|
|
1098
|
+
var $L68 = $L("isnt");
|
|
1099
|
+
var $L69 = $L("===");
|
|
1100
|
+
var $L70 = $L("==");
|
|
1101
|
+
var $L71 = $L("and");
|
|
1102
|
+
var $L72 = $L("&&");
|
|
1103
|
+
var $L73 = $L("of");
|
|
1104
|
+
var $L74 = $L("or");
|
|
1105
|
+
var $L75 = $L("||");
|
|
1106
|
+
var $L76 = $L("^^");
|
|
1107
|
+
var $L77 = $L("xor");
|
|
1108
|
+
var $L78 = $L("xnor");
|
|
1109
|
+
var $L79 = $L("??");
|
|
1110
|
+
var $L80 = $L("instanceof");
|
|
1111
|
+
var $L81 = $L("in");
|
|
1112
|
+
var $L82 = $L("is");
|
|
1113
|
+
var $L83 = $L("&");
|
|
1114
|
+
var $L84 = $L("|");
|
|
1115
|
+
var $L85 = $L(";");
|
|
1116
|
+
var $L86 = $L("$:");
|
|
1117
|
+
var $L87 = $L("own");
|
|
1118
|
+
var $L88 = $L("break");
|
|
1119
|
+
var $L89 = $L("continue");
|
|
1120
|
+
var $L90 = $L("debugger");
|
|
1121
|
+
var $L91 = $L("assert");
|
|
1122
|
+
var $L92 = $L(":=");
|
|
1123
|
+
var $L93 = $L(".=");
|
|
1124
|
+
var $L94 = $L("/*");
|
|
1125
|
+
var $L95 = $L("*/");
|
|
1126
|
+
var $L96 = $L("\\");
|
|
1127
|
+
var $L97 = $L("[");
|
|
1128
|
+
var $L98 = $L("`");
|
|
1129
|
+
var $L99 = $L("abstract");
|
|
1130
|
+
var $L100 = $L("as");
|
|
1131
|
+
var $L101 = $L("@");
|
|
1132
|
+
var $L102 = $L("@@");
|
|
1133
|
+
var $L103 = $L("async");
|
|
1134
|
+
var $L104 = $L("await");
|
|
1135
|
+
var $L105 = $L("by");
|
|
1136
|
+
var $L106 = $L("case");
|
|
1137
|
+
var $L107 = $L("catch");
|
|
1138
|
+
var $L108 = $L("class");
|
|
1139
|
+
var $L109 = $L("#{");
|
|
1140
|
+
var $L110 = $L("declare");
|
|
1141
|
+
var $L111 = $L("default");
|
|
1142
|
+
var $L112 = $L("delete");
|
|
1143
|
+
var $L113 = $L("do");
|
|
1144
|
+
var $L114 = $L("..");
|
|
1145
|
+
var $L115 = $L("...");
|
|
1146
|
+
var $L116 = $L("::");
|
|
1147
|
+
var $L117 = $L('"');
|
|
1148
|
+
var $L118 = $L("else");
|
|
1149
|
+
var $L119 = $L("export");
|
|
1150
|
+
var $L120 = $L("extends");
|
|
1151
|
+
var $L121 = $L("finally");
|
|
1152
|
+
var $L122 = $L("for");
|
|
1153
|
+
var $L123 = $L("from");
|
|
1154
|
+
var $L124 = $L("function");
|
|
1155
|
+
var $L125 = $L("get");
|
|
1156
|
+
var $L126 = $L("set");
|
|
1157
|
+
var $L127 = $L("if");
|
|
1158
|
+
var $L128 = $L("let");
|
|
1159
|
+
var $L129 = $L("const");
|
|
1160
|
+
var $L130 = $L("loop");
|
|
1161
|
+
var $L131 = $L("new");
|
|
1162
|
+
var $L132 = $L("<");
|
|
1163
|
+
var $L133 = $L("{");
|
|
1164
|
+
var $L134 = $L("operator");
|
|
1165
|
+
var $L135 = $L("public");
|
|
1166
|
+
var $L136 = $L("private");
|
|
1167
|
+
var $L137 = $L("protected");
|
|
1168
|
+
var $L138 = $L("||>");
|
|
1169
|
+
var $L139 = $L("|>=");
|
|
1170
|
+
var $L140 = $L("|>");
|
|
1171
|
+
var $L141 = $L("readonly");
|
|
1172
|
+
var $L142 = $L("return");
|
|
1173
|
+
var $L143 = $L("satisfies");
|
|
1174
|
+
var $L144 = $L("'");
|
|
1175
|
+
var $L145 = $L("static");
|
|
1176
|
+
var $L146 = $L("${");
|
|
1177
|
+
var $L147 = $L("switch");
|
|
1178
|
+
var $L148 = $L("target");
|
|
1179
|
+
var $L149 = $L("then");
|
|
1180
|
+
var $L150 = $L("this");
|
|
1181
|
+
var $L151 = $L("throw");
|
|
1182
|
+
var $L152 = $L('"""');
|
|
1183
|
+
var $L153 = $L("'''");
|
|
1184
|
+
var $L154 = $L("///");
|
|
1185
|
+
var $L155 = $L("```");
|
|
1186
|
+
var $L156 = $L("try");
|
|
1187
|
+
var $L157 = $L("typeof");
|
|
1188
|
+
var $L158 = $L("unless");
|
|
1189
|
+
var $L159 = $L("until");
|
|
1190
|
+
var $L160 = $L("var");
|
|
1191
|
+
var $L161 = $L("void");
|
|
1192
|
+
var $L162 = $L("when");
|
|
1193
|
+
var $L163 = $L("while");
|
|
1194
|
+
var $L164 = $L("yield");
|
|
1195
|
+
var $L165 = $L("/>");
|
|
1196
|
+
var $L166 = $L("</");
|
|
1197
|
+
var $L167 = $L("<>");
|
|
1198
|
+
var $L168 = $L("</>");
|
|
1199
|
+
var $L169 = $L("<!--");
|
|
1200
|
+
var $L170 = $L("-->");
|
|
1201
|
+
var $L171 = $L("type");
|
|
1202
|
+
var $L172 = $L("interface");
|
|
1203
|
+
var $L173 = $L("namespace");
|
|
1204
|
+
var $L174 = $L("asserts");
|
|
1205
|
+
var $L175 = $L("keyof");
|
|
1206
|
+
var $L176 = $L("infer");
|
|
1207
|
+
var $L177 = $L("[]");
|
|
1208
|
+
var $L178 = $L("civet");
|
|
1203
1209
|
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1204
1210
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1205
1211
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -2369,7 +2375,7 @@ ${input.slice(result.pos)}
|
|
|
2369
2375
|
return {
|
|
2370
2376
|
type: "ArrowFunction",
|
|
2371
2377
|
parameters,
|
|
2372
|
-
returnType: suffix
|
|
2378
|
+
returnType: suffix,
|
|
2373
2379
|
ts: false,
|
|
2374
2380
|
block: expOrBlock,
|
|
2375
2381
|
children: $0
|
|
@@ -3157,7 +3163,7 @@ ${input.slice(result.pos)}
|
|
|
3157
3163
|
return result;
|
|
3158
3164
|
}
|
|
3159
3165
|
}
|
|
3160
|
-
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName,
|
|
3166
|
+
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, $E(_), Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3161
3167
|
var id = $2;
|
|
3162
3168
|
var exp = $6;
|
|
3163
3169
|
switch (exp.type) {
|
|
@@ -3302,7 +3308,8 @@ ${input.slice(result.pos)}
|
|
|
3302
3308
|
children: [$1, ...$2, ...rest.flat()]
|
|
3303
3309
|
});
|
|
3304
3310
|
});
|
|
3305
|
-
var CallExpression$2 =
|
|
3311
|
+
var CallExpression$2 = ReturnValue;
|
|
3312
|
+
var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3306
3313
|
var member = $1;
|
|
3307
3314
|
var trailing = $2;
|
|
3308
3315
|
var rest = $3;
|
|
@@ -3326,17 +3333,69 @@ ${input.slice(result.pos)}
|
|
|
3326
3333
|
}
|
|
3327
3334
|
}
|
|
3328
3335
|
if (state.tokenize) {
|
|
3329
|
-
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
3336
|
+
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state));
|
|
3330
3337
|
if (state.events)
|
|
3331
3338
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3332
3339
|
return result;
|
|
3333
3340
|
} else {
|
|
3334
|
-
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
|
|
3341
|
+
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state) || CallExpression$3(state);
|
|
3335
3342
|
if (state.events)
|
|
3336
3343
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
3337
3344
|
return result;
|
|
3338
3345
|
}
|
|
3339
3346
|
}
|
|
3347
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L14, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
3348
|
+
return { type: "ReturnValue", children: [$1[0]] };
|
|
3349
|
+
});
|
|
3350
|
+
function ReturnValue(state) {
|
|
3351
|
+
let eventData;
|
|
3352
|
+
if (state.events) {
|
|
3353
|
+
const result = state.events.enter?.("ReturnValue", state);
|
|
3354
|
+
if (result) {
|
|
3355
|
+
if (result.cache)
|
|
3356
|
+
return result.cache;
|
|
3357
|
+
eventData = result.data;
|
|
3358
|
+
}
|
|
3359
|
+
}
|
|
3360
|
+
if (state.tokenize) {
|
|
3361
|
+
const result = $TOKEN("ReturnValue", state, ReturnValue$0(state));
|
|
3362
|
+
if (state.events)
|
|
3363
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3364
|
+
return result;
|
|
3365
|
+
} else {
|
|
3366
|
+
const result = ReturnValue$0(state);
|
|
3367
|
+
if (state.events)
|
|
3368
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
3369
|
+
return result;
|
|
3370
|
+
}
|
|
3371
|
+
}
|
|
3372
|
+
var AfterReturnShorthand$0 = WAssignmentOp;
|
|
3373
|
+
var AfterReturnShorthand$1 = UpdateExpressionSymbol;
|
|
3374
|
+
var AfterReturnShorthand$2 = TypeSuffix;
|
|
3375
|
+
var AfterReturnShorthand$3 = $S(__, LetAssignment);
|
|
3376
|
+
var AfterReturnShorthand$4 = $S(__, ConstAssignment);
|
|
3377
|
+
function AfterReturnShorthand(state) {
|
|
3378
|
+
let eventData;
|
|
3379
|
+
if (state.events) {
|
|
3380
|
+
const result = state.events.enter?.("AfterReturnShorthand", state);
|
|
3381
|
+
if (result) {
|
|
3382
|
+
if (result.cache)
|
|
3383
|
+
return result.cache;
|
|
3384
|
+
eventData = result.data;
|
|
3385
|
+
}
|
|
3386
|
+
}
|
|
3387
|
+
if (state.tokenize) {
|
|
3388
|
+
const result = $TOKEN("AfterReturnShorthand", state, AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state));
|
|
3389
|
+
if (state.events)
|
|
3390
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3391
|
+
return result;
|
|
3392
|
+
} else {
|
|
3393
|
+
const result = AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state);
|
|
3394
|
+
if (state.events)
|
|
3395
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
3396
|
+
return result;
|
|
3397
|
+
}
|
|
3398
|
+
}
|
|
3340
3399
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
3341
3400
|
var CallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
|
|
3342
3401
|
if ($1.type === "StringLiteral") {
|
|
@@ -3423,7 +3482,7 @@ ${input.slice(result.pos)}
|
|
|
3423
3482
|
return result;
|
|
3424
3483
|
}
|
|
3425
3484
|
}
|
|
3426
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
3485
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L15, fail, 'NonNullAssertion "!"'), $N($EXPECT($L16, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3427
3486
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3428
3487
|
});
|
|
3429
3488
|
function NonNullAssertion(state) {
|
|
@@ -3561,7 +3620,7 @@ ${input.slice(result.pos)}
|
|
|
3561
3620
|
]
|
|
3562
3621
|
};
|
|
3563
3622
|
});
|
|
3564
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3623
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L17, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3565
3624
|
var dot = $1;
|
|
3566
3625
|
var neg = $2;
|
|
3567
3626
|
var num = $3;
|
|
@@ -3758,7 +3817,7 @@ ${input.slice(result.pos)}
|
|
|
3758
3817
|
}
|
|
3759
3818
|
}
|
|
3760
3819
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3761
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3820
|
+
var MetaProperty$1 = $TS($S($EXPECT($L18, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3762
3821
|
return { $loc, token: $1 };
|
|
3763
3822
|
});
|
|
3764
3823
|
function MetaProperty(state) {
|
|
@@ -3784,7 +3843,7 @@ ${input.slice(result.pos)}
|
|
|
3784
3843
|
}
|
|
3785
3844
|
}
|
|
3786
3845
|
var Parameters$0 = NonEmptyParameters;
|
|
3787
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3846
|
+
var Parameters$1 = $TV($EXPECT($L19, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3788
3847
|
return {
|
|
3789
3848
|
type: "Parameters",
|
|
3790
3849
|
children: [{ $loc, token: "()" }],
|
|
@@ -4007,6 +4066,9 @@ ${input.slice(result.pos)}
|
|
|
4007
4066
|
};
|
|
4008
4067
|
});
|
|
4009
4068
|
var NWBindingIdentifier$1 = Identifier;
|
|
4069
|
+
var NWBindingIdentifier$2 = $TS($S(ReturnValue), function($skip, $loc, $0, $1) {
|
|
4070
|
+
return { children: [$1], names: [] };
|
|
4071
|
+
});
|
|
4010
4072
|
function NWBindingIdentifier(state) {
|
|
4011
4073
|
let eventData;
|
|
4012
4074
|
if (state.events) {
|
|
@@ -4018,12 +4080,12 @@ ${input.slice(result.pos)}
|
|
|
4018
4080
|
}
|
|
4019
4081
|
}
|
|
4020
4082
|
if (state.tokenize) {
|
|
4021
|
-
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state));
|
|
4083
|
+
const result = $TOKEN("NWBindingIdentifier", state, NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state));
|
|
4022
4084
|
if (state.events)
|
|
4023
4085
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4024
4086
|
return result;
|
|
4025
4087
|
} else {
|
|
4026
|
-
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state);
|
|
4088
|
+
const result = NWBindingIdentifier$0(state) || NWBindingIdentifier$1(state) || NWBindingIdentifier$2(state);
|
|
4027
4089
|
if (state.events)
|
|
4028
4090
|
state.events.exit?.("NWBindingIdentifier", state, result, eventData);
|
|
4029
4091
|
return result;
|
|
@@ -4404,7 +4466,7 @@ ${input.slice(result.pos)}
|
|
|
4404
4466
|
}
|
|
4405
4467
|
}
|
|
4406
4468
|
var BindingProperty$0 = BindingRestProperty;
|
|
4407
|
-
var BindingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4469
|
+
var BindingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4408
4470
|
var name = $2;
|
|
4409
4471
|
var b = $5;
|
|
4410
4472
|
var init = $6;
|
|
@@ -4565,7 +4627,7 @@ ${input.slice(result.pos)}
|
|
|
4565
4627
|
children: $0
|
|
4566
4628
|
};
|
|
4567
4629
|
});
|
|
4568
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4630
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4569
4631
|
return {
|
|
4570
4632
|
children: [{
|
|
4571
4633
|
type: "ElisionElement",
|
|
@@ -4638,7 +4700,7 @@ ${input.slice(result.pos)}
|
|
|
4638
4700
|
return result;
|
|
4639
4701
|
}
|
|
4640
4702
|
}
|
|
4641
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4703
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L19, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4642
4704
|
const ref = {
|
|
4643
4705
|
type: "Ref",
|
|
4644
4706
|
base: "ref",
|
|
@@ -4856,7 +4918,7 @@ ${input.slice(result.pos)}
|
|
|
4856
4918
|
}
|
|
4857
4919
|
}
|
|
4858
4920
|
var MatchingProperty$0 = MatchingRestProperty;
|
|
4859
|
-
var MatchingProperty$1 = $TS($S($E(_), PropertyName,
|
|
4921
|
+
var MatchingProperty$1 = $TS($S($E(_), PropertyName, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4860
4922
|
var name = $2;
|
|
4861
4923
|
var match = $6;
|
|
4862
4924
|
return {
|
|
@@ -5082,7 +5144,7 @@ ${input.slice(result.pos)}
|
|
|
5082
5144
|
}
|
|
5083
5145
|
}
|
|
5084
5146
|
var MatchingElement$0 = MatchingRestElement;
|
|
5085
|
-
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier,
|
|
5147
|
+
var MatchingElement$1 = $TS($S($E(_), BindingIdentifier, $E(_), Colon, $E(_), $C(BindingIdentifier, MatchingPattern)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5086
5148
|
var ws = $1;
|
|
5087
5149
|
var name = $2;
|
|
5088
5150
|
var match = $6;
|
|
@@ -5114,7 +5176,7 @@ ${input.slice(result.pos)}
|
|
|
5114
5176
|
children: [ws, binding]
|
|
5115
5177
|
};
|
|
5116
5178
|
});
|
|
5117
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5179
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5118
5180
|
return {
|
|
5119
5181
|
children: [{
|
|
5120
5182
|
type: "ElisionElement",
|
|
@@ -5207,7 +5269,7 @@ ${input.slice(result.pos)}
|
|
|
5207
5269
|
type: "FunctionSignature",
|
|
5208
5270
|
id: wid?.[1],
|
|
5209
5271
|
parameters,
|
|
5210
|
-
returnType: suffix
|
|
5272
|
+
returnType: suffix,
|
|
5211
5273
|
ts: false,
|
|
5212
5274
|
block: null,
|
|
5213
5275
|
children: !parameters.implicit ? $0 : [async, func, star, wid, parameters, w, suffix]
|
|
@@ -5366,7 +5428,7 @@ ${input.slice(result.pos)}
|
|
|
5366
5428
|
type: "FunctionSignature",
|
|
5367
5429
|
id,
|
|
5368
5430
|
parameters,
|
|
5369
|
-
returnType: suffix
|
|
5431
|
+
returnType: suffix,
|
|
5370
5432
|
ts: false,
|
|
5371
5433
|
block: null,
|
|
5372
5434
|
children: [func, w1, id, w2, parameters, suffix]
|
|
@@ -5475,7 +5537,7 @@ ${input.slice(result.pos)}
|
|
|
5475
5537
|
type: "FunctionExpression",
|
|
5476
5538
|
id: void 0,
|
|
5477
5539
|
parameters,
|
|
5478
|
-
returnType: suffix
|
|
5540
|
+
returnType: suffix,
|
|
5479
5541
|
ts: false,
|
|
5480
5542
|
block,
|
|
5481
5543
|
children: [
|
|
@@ -5508,7 +5570,7 @@ ${input.slice(result.pos)}
|
|
|
5508
5570
|
return result;
|
|
5509
5571
|
}
|
|
5510
5572
|
}
|
|
5511
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5573
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5512
5574
|
return { $loc, token: $1 };
|
|
5513
5575
|
});
|
|
5514
5576
|
function Arrow(state) {
|
|
@@ -5572,12 +5634,16 @@ ${input.slice(result.pos)}
|
|
|
5572
5634
|
return result;
|
|
5573
5635
|
}
|
|
5574
5636
|
}
|
|
5575
|
-
var ImplicitNestedBlock$0 = $TS($S(InsertOpenBrace, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5576
|
-
var
|
|
5577
|
-
|
|
5578
|
-
|
|
5637
|
+
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) {
|
|
5638
|
+
var open = $2;
|
|
5639
|
+
if (!$4)
|
|
5640
|
+
return $skip;
|
|
5641
|
+
const [block, ...tail] = $4;
|
|
5642
|
+
return {
|
|
5643
|
+
...block,
|
|
5644
|
+
children: [open, ...block.children, ...tail],
|
|
5579
5645
|
bare: false
|
|
5580
|
-
}
|
|
5646
|
+
};
|
|
5581
5647
|
});
|
|
5582
5648
|
function ImplicitNestedBlock(state) {
|
|
5583
5649
|
let eventData;
|
|
@@ -5742,7 +5808,7 @@ ${input.slice(result.pos)}
|
|
|
5742
5808
|
return result;
|
|
5743
5809
|
}
|
|
5744
5810
|
}
|
|
5745
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5811
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L19, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5746
5812
|
const expressions = [];
|
|
5747
5813
|
return {
|
|
5748
5814
|
type: "BlockStatement",
|
|
@@ -5845,12 +5911,16 @@ ${input.slice(result.pos)}
|
|
|
5845
5911
|
return result;
|
|
5846
5912
|
}
|
|
5847
5913
|
}
|
|
5848
|
-
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5849
|
-
var
|
|
5914
|
+
var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5915
|
+
var ws1 = $1;
|
|
5916
|
+
var open = $2;
|
|
5917
|
+
if (!$4)
|
|
5918
|
+
return $skip;
|
|
5919
|
+
const [block, ws2, close] = $4;
|
|
5850
5920
|
return {
|
|
5851
5921
|
type: "BlockStatement",
|
|
5852
5922
|
expressions: block.expressions,
|
|
5853
|
-
children: [
|
|
5923
|
+
children: [ws1, open, ...block.children, ws2, close],
|
|
5854
5924
|
bare: false
|
|
5855
5925
|
};
|
|
5856
5926
|
return block;
|
|
@@ -5965,7 +6035,7 @@ ${input.slice(result.pos)}
|
|
|
5965
6035
|
children: [$1, expressions]
|
|
5966
6036
|
};
|
|
5967
6037
|
});
|
|
5968
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6038
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5969
6039
|
const expressions = [];
|
|
5970
6040
|
return {
|
|
5971
6041
|
type: "BlockStatement",
|
|
@@ -6110,7 +6180,7 @@ ${input.slice(result.pos)}
|
|
|
6110
6180
|
return result;
|
|
6111
6181
|
}
|
|
6112
6182
|
}
|
|
6113
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6183
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6114
6184
|
return { $loc, token: $1 };
|
|
6115
6185
|
});
|
|
6116
6186
|
function NullLiteral(state) {
|
|
@@ -6138,7 +6208,7 @@ ${input.slice(result.pos)}
|
|
|
6138
6208
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6139
6209
|
return value[1];
|
|
6140
6210
|
});
|
|
6141
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6211
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6142
6212
|
return { $loc, token: $1 };
|
|
6143
6213
|
});
|
|
6144
6214
|
function BooleanLiteral(state) {
|
|
@@ -6163,10 +6233,10 @@ ${input.slice(result.pos)}
|
|
|
6163
6233
|
return result;
|
|
6164
6234
|
}
|
|
6165
6235
|
}
|
|
6166
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6236
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6167
6237
|
return { $loc, token: "true" };
|
|
6168
6238
|
});
|
|
6169
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6239
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6170
6240
|
return { $loc, token: "false" };
|
|
6171
6241
|
});
|
|
6172
6242
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6272,7 +6342,7 @@ ${input.slice(result.pos)}
|
|
|
6272
6342
|
return result;
|
|
6273
6343
|
}
|
|
6274
6344
|
}
|
|
6275
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6345
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6276
6346
|
function UpcomingAssignment(state) {
|
|
6277
6347
|
let eventData;
|
|
6278
6348
|
if (state.events) {
|
|
@@ -6538,7 +6608,7 @@ ${input.slice(result.pos)}
|
|
|
6538
6608
|
}
|
|
6539
6609
|
}
|
|
6540
6610
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6541
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6611
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6542
6612
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6543
6613
|
return value[1];
|
|
6544
6614
|
});
|
|
@@ -6965,7 +7035,7 @@ ${input.slice(result.pos)}
|
|
|
6965
7035
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6966
7036
|
return value[1];
|
|
6967
7037
|
});
|
|
6968
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
7038
|
+
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) {
|
|
6969
7039
|
return "";
|
|
6970
7040
|
});
|
|
6971
7041
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6994,7 +7064,7 @@ ${input.slice(result.pos)}
|
|
|
6994
7064
|
}
|
|
6995
7065
|
}
|
|
6996
7066
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
6997
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7067
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
6998
7068
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6999
7069
|
return value[1];
|
|
7000
7070
|
});
|
|
@@ -7164,7 +7234,7 @@ ${input.slice(result.pos)}
|
|
|
7164
7234
|
return result;
|
|
7165
7235
|
}
|
|
7166
7236
|
}
|
|
7167
|
-
var NamedProperty$0 = $TS($S(PropertyName,
|
|
7237
|
+
var NamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7168
7238
|
var name = $1;
|
|
7169
7239
|
var exp = $4;
|
|
7170
7240
|
return {
|
|
@@ -7197,7 +7267,7 @@ ${input.slice(result.pos)}
|
|
|
7197
7267
|
return result;
|
|
7198
7268
|
}
|
|
7199
7269
|
}
|
|
7200
|
-
var ImplicitNamedProperty$0 = $TS($S(PropertyName,
|
|
7270
|
+
var ImplicitNamedProperty$0 = $TS($S(PropertyName, $E(_), Colon, $C(MultiLineImplicitObjectLiteralAllowed, $N(EOS)), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7201
7271
|
var name = $1;
|
|
7202
7272
|
var exp = $5;
|
|
7203
7273
|
return {
|
|
@@ -7304,7 +7374,7 @@ ${input.slice(result.pos)}
|
|
|
7304
7374
|
expression
|
|
7305
7375
|
};
|
|
7306
7376
|
});
|
|
7307
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7377
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L17, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7308
7378
|
return {
|
|
7309
7379
|
type: "ComputedPropertyName",
|
|
7310
7380
|
children: $0
|
|
@@ -7472,7 +7542,7 @@ ${input.slice(result.pos)}
|
|
|
7472
7542
|
children: $0,
|
|
7473
7543
|
name,
|
|
7474
7544
|
modifier: $1?.[0]?.token,
|
|
7475
|
-
returnType:
|
|
7545
|
+
returnType: suffix,
|
|
7476
7546
|
parameters
|
|
7477
7547
|
};
|
|
7478
7548
|
});
|
|
@@ -7653,22 +7723,22 @@ ${input.slice(result.pos)}
|
|
|
7653
7723
|
return result;
|
|
7654
7724
|
}
|
|
7655
7725
|
}
|
|
7656
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7657
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7658
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7659
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7660
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7661
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7662
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7663
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7664
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7665
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7666
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7667
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7668
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7669
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7670
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7671
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7726
|
+
var AssignmentOpSymbol$0 = $EXPECT($L34, fail, 'AssignmentOpSymbol "**="');
|
|
7727
|
+
var AssignmentOpSymbol$1 = $EXPECT($L35, fail, 'AssignmentOpSymbol "*="');
|
|
7728
|
+
var AssignmentOpSymbol$2 = $EXPECT($L36, fail, 'AssignmentOpSymbol "/="');
|
|
7729
|
+
var AssignmentOpSymbol$3 = $EXPECT($L37, fail, 'AssignmentOpSymbol "%="');
|
|
7730
|
+
var AssignmentOpSymbol$4 = $EXPECT($L38, fail, 'AssignmentOpSymbol "+="');
|
|
7731
|
+
var AssignmentOpSymbol$5 = $EXPECT($L39, fail, 'AssignmentOpSymbol "-="');
|
|
7732
|
+
var AssignmentOpSymbol$6 = $EXPECT($L40, fail, 'AssignmentOpSymbol "<<="');
|
|
7733
|
+
var AssignmentOpSymbol$7 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>>="');
|
|
7734
|
+
var AssignmentOpSymbol$8 = $EXPECT($L42, fail, 'AssignmentOpSymbol ">>="');
|
|
7735
|
+
var AssignmentOpSymbol$9 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&&="');
|
|
7736
|
+
var AssignmentOpSymbol$10 = $EXPECT($L44, fail, 'AssignmentOpSymbol "&="');
|
|
7737
|
+
var AssignmentOpSymbol$11 = $EXPECT($L45, fail, 'AssignmentOpSymbol "^="');
|
|
7738
|
+
var AssignmentOpSymbol$12 = $EXPECT($L46, fail, 'AssignmentOpSymbol "||="');
|
|
7739
|
+
var AssignmentOpSymbol$13 = $EXPECT($L47, fail, 'AssignmentOpSymbol "|="');
|
|
7740
|
+
var AssignmentOpSymbol$14 = $EXPECT($L48, fail, 'AssignmentOpSymbol "??="');
|
|
7741
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L49, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7672
7742
|
return "??=";
|
|
7673
7743
|
});
|
|
7674
7744
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7699,10 +7769,10 @@ ${input.slice(result.pos)}
|
|
|
7699
7769
|
return result;
|
|
7700
7770
|
}
|
|
7701
7771
|
}
|
|
7702
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7772
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7703
7773
|
return "&&=";
|
|
7704
7774
|
});
|
|
7705
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7775
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L51, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7706
7776
|
return "||=";
|
|
7707
7777
|
});
|
|
7708
7778
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7741,7 +7811,7 @@ ${input.slice(result.pos)}
|
|
|
7741
7811
|
special: true
|
|
7742
7812
|
};
|
|
7743
7813
|
});
|
|
7744
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7814
|
+
var BinaryOp$2 = $TS($S($EXPECT($L52, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7745
7815
|
var id = $4;
|
|
7746
7816
|
if (!module.operators.has(id.name))
|
|
7747
7817
|
return $skip;
|
|
@@ -7773,21 +7843,21 @@ ${input.slice(result.pos)}
|
|
|
7773
7843
|
return result;
|
|
7774
7844
|
}
|
|
7775
7845
|
}
|
|
7776
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7777
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7778
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7779
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7846
|
+
var BinaryOpSymbol$0 = $EXPECT($L53, fail, 'BinaryOpSymbol "**"');
|
|
7847
|
+
var BinaryOpSymbol$1 = $EXPECT($L54, fail, 'BinaryOpSymbol "*"');
|
|
7848
|
+
var BinaryOpSymbol$2 = $EXPECT($L55, fail, 'BinaryOpSymbol "/"');
|
|
7849
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7780
7850
|
return {
|
|
7781
7851
|
call: module.getRef("modulo"),
|
|
7782
7852
|
special: true
|
|
7783
7853
|
};
|
|
7784
7854
|
});
|
|
7785
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7786
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7787
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7788
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7789
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7790
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7855
|
+
var BinaryOpSymbol$4 = $EXPECT($L57, fail, 'BinaryOpSymbol "%"');
|
|
7856
|
+
var BinaryOpSymbol$5 = $EXPECT($L58, fail, 'BinaryOpSymbol "+"');
|
|
7857
|
+
var BinaryOpSymbol$6 = $EXPECT($L17, fail, 'BinaryOpSymbol "-"');
|
|
7858
|
+
var BinaryOpSymbol$7 = $EXPECT($L59, fail, 'BinaryOpSymbol "<="');
|
|
7859
|
+
var BinaryOpSymbol$8 = $EXPECT($L60, fail, 'BinaryOpSymbol ">="');
|
|
7860
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7791
7861
|
return {
|
|
7792
7862
|
$loc,
|
|
7793
7863
|
token: "instanceof",
|
|
@@ -7795,7 +7865,7 @@ ${input.slice(result.pos)}
|
|
|
7795
7865
|
special: true
|
|
7796
7866
|
};
|
|
7797
7867
|
});
|
|
7798
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7868
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L62, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7799
7869
|
return {
|
|
7800
7870
|
$loc,
|
|
7801
7871
|
token: "instanceof",
|
|
@@ -7804,58 +7874,58 @@ ${input.slice(result.pos)}
|
|
|
7804
7874
|
negated: true
|
|
7805
7875
|
};
|
|
7806
7876
|
});
|
|
7807
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7877
|
+
var BinaryOpSymbol$11 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
7808
7878
|
var BinaryOpSymbol$12 = $TR($EXPECT($R7, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7809
7879
|
return "<";
|
|
7810
7880
|
});
|
|
7811
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7812
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7813
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7814
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7815
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7881
|
+
var BinaryOpSymbol$13 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
7882
|
+
var BinaryOpSymbol$14 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
7883
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7884
|
+
var BinaryOpSymbol$16 = $EXPECT($L66, fail, 'BinaryOpSymbol "!=="');
|
|
7885
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L67, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7816
7886
|
if (module.config.coffeeEq)
|
|
7817
7887
|
return "!==";
|
|
7818
7888
|
return $1;
|
|
7819
7889
|
});
|
|
7820
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7890
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7821
7891
|
if (module.config.coffeeIsnt)
|
|
7822
7892
|
return "!==";
|
|
7823
7893
|
return $skip;
|
|
7824
7894
|
});
|
|
7825
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7826
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7895
|
+
var BinaryOpSymbol$19 = $EXPECT($L69, fail, 'BinaryOpSymbol "==="');
|
|
7896
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7827
7897
|
if (module.config.coffeeEq)
|
|
7828
7898
|
return "===";
|
|
7829
7899
|
return $1;
|
|
7830
7900
|
});
|
|
7831
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7901
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7832
7902
|
return "&&";
|
|
7833
7903
|
});
|
|
7834
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7835
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7904
|
+
var BinaryOpSymbol$22 = $EXPECT($L72, fail, 'BinaryOpSymbol "&&"');
|
|
7905
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7836
7906
|
return "in";
|
|
7837
7907
|
});
|
|
7838
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7908
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7839
7909
|
return "||";
|
|
7840
7910
|
});
|
|
7841
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7842
|
-
var BinaryOpSymbol$26 = $TV($C($EXPECT($
|
|
7911
|
+
var BinaryOpSymbol$25 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
7912
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L76, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7843
7913
|
return {
|
|
7844
7914
|
call: module.getRef("xor"),
|
|
7845
7915
|
special: true
|
|
7846
7916
|
};
|
|
7847
7917
|
});
|
|
7848
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
7918
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L78, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7849
7919
|
return {
|
|
7850
7920
|
call: module.getRef("xnor"),
|
|
7851
7921
|
special: true
|
|
7852
7922
|
};
|
|
7853
7923
|
});
|
|
7854
|
-
var BinaryOpSymbol$28 = $EXPECT($
|
|
7924
|
+
var BinaryOpSymbol$28 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
|
|
7855
7925
|
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7856
7926
|
return "??";
|
|
7857
7927
|
});
|
|
7858
|
-
var BinaryOpSymbol$30 = $TS($S($EXPECT($
|
|
7928
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7859
7929
|
return {
|
|
7860
7930
|
$loc,
|
|
7861
7931
|
token: $1,
|
|
@@ -7863,7 +7933,7 @@ ${input.slice(result.pos)}
|
|
|
7863
7933
|
special: true
|
|
7864
7934
|
};
|
|
7865
7935
|
});
|
|
7866
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
7936
|
+
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) {
|
|
7867
7937
|
return {
|
|
7868
7938
|
$loc,
|
|
7869
7939
|
token: "instanceof",
|
|
@@ -7872,7 +7942,7 @@ ${input.slice(result.pos)}
|
|
|
7872
7942
|
negated: true
|
|
7873
7943
|
};
|
|
7874
7944
|
});
|
|
7875
|
-
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($
|
|
7945
|
+
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) {
|
|
7876
7946
|
return {
|
|
7877
7947
|
$loc,
|
|
7878
7948
|
token: "in",
|
|
@@ -7880,7 +7950,7 @@ ${input.slice(result.pos)}
|
|
|
7880
7950
|
negated: true
|
|
7881
7951
|
};
|
|
7882
7952
|
});
|
|
7883
|
-
var BinaryOpSymbol$33 = $TS($S($EXPECT($
|
|
7953
|
+
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) {
|
|
7884
7954
|
return {
|
|
7885
7955
|
method: "includes",
|
|
7886
7956
|
relational: true,
|
|
@@ -7888,7 +7958,7 @@ ${input.slice(result.pos)}
|
|
|
7888
7958
|
special: true
|
|
7889
7959
|
};
|
|
7890
7960
|
});
|
|
7891
|
-
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7961
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7892
7962
|
return {
|
|
7893
7963
|
call: [module.getRef("indexOf"), ".call"],
|
|
7894
7964
|
relational: true,
|
|
@@ -7897,7 +7967,7 @@ ${input.slice(result.pos)}
|
|
|
7897
7967
|
special: true
|
|
7898
7968
|
};
|
|
7899
7969
|
});
|
|
7900
|
-
var BinaryOpSymbol$35 = $TS($S($EXPECT($
|
|
7970
|
+
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) {
|
|
7901
7971
|
return {
|
|
7902
7972
|
method: "includes",
|
|
7903
7973
|
relational: true,
|
|
@@ -7906,7 +7976,7 @@ ${input.slice(result.pos)}
|
|
|
7906
7976
|
negated: true
|
|
7907
7977
|
};
|
|
7908
7978
|
});
|
|
7909
|
-
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
7979
|
+
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) {
|
|
7910
7980
|
return {
|
|
7911
7981
|
call: [module.getRef("indexOf"), ".call"],
|
|
7912
7982
|
relational: true,
|
|
@@ -7915,7 +7985,7 @@ ${input.slice(result.pos)}
|
|
|
7915
7985
|
special: true
|
|
7916
7986
|
};
|
|
7917
7987
|
});
|
|
7918
|
-
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($
|
|
7988
|
+
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) {
|
|
7919
7989
|
if (module.config.objectIs) {
|
|
7920
7990
|
return {
|
|
7921
7991
|
call: module.getRef("is"),
|
|
@@ -7927,7 +7997,7 @@ ${input.slice(result.pos)}
|
|
|
7927
7997
|
}
|
|
7928
7998
|
return "!==";
|
|
7929
7999
|
});
|
|
7930
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8000
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L82, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7931
8001
|
if (module.config.objectIs) {
|
|
7932
8002
|
return {
|
|
7933
8003
|
call: module.getRef("is"),
|
|
@@ -7938,12 +8008,12 @@ ${input.slice(result.pos)}
|
|
|
7938
8008
|
}
|
|
7939
8009
|
return "===";
|
|
7940
8010
|
});
|
|
7941
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
8011
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7942
8012
|
return $1;
|
|
7943
8013
|
});
|
|
7944
|
-
var BinaryOpSymbol$40 = $EXPECT($
|
|
7945
|
-
var BinaryOpSymbol$41 = $EXPECT($
|
|
7946
|
-
var BinaryOpSymbol$42 = $EXPECT($
|
|
8014
|
+
var BinaryOpSymbol$40 = $EXPECT($L83, fail, 'BinaryOpSymbol "&"');
|
|
8015
|
+
var BinaryOpSymbol$41 = $EXPECT($L16, fail, 'BinaryOpSymbol "^"');
|
|
8016
|
+
var BinaryOpSymbol$42 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
|
|
7947
8017
|
function BinaryOpSymbol(state) {
|
|
7948
8018
|
let eventData;
|
|
7949
8019
|
if (state.events) {
|
|
@@ -7966,8 +8036,8 @@ ${input.slice(result.pos)}
|
|
|
7966
8036
|
return result;
|
|
7967
8037
|
}
|
|
7968
8038
|
}
|
|
7969
|
-
var Xor$0 = $EXPECT($
|
|
7970
|
-
var Xor$1 = $S($EXPECT($
|
|
8039
|
+
var Xor$0 = $EXPECT($L76, fail, 'Xor "^^"');
|
|
8040
|
+
var Xor$1 = $S($EXPECT($L77, fail, 'Xor "xor"'), NonIdContinue);
|
|
7971
8041
|
function Xor(state) {
|
|
7972
8042
|
let eventData;
|
|
7973
8043
|
if (state.events) {
|
|
@@ -7991,7 +8061,7 @@ ${input.slice(result.pos)}
|
|
|
7991
8061
|
}
|
|
7992
8062
|
}
|
|
7993
8063
|
var Xnor$0 = $R$0($EXPECT($R8, fail, "Xnor /!\\^\\^?/"));
|
|
7994
|
-
var Xnor$1 = $EXPECT($
|
|
8064
|
+
var Xnor$1 = $EXPECT($L78, fail, 'Xnor "xnor"');
|
|
7995
8065
|
function Xnor(state) {
|
|
7996
8066
|
let eventData;
|
|
7997
8067
|
if (state.events) {
|
|
@@ -8212,7 +8282,7 @@ ${input.slice(result.pos)}
|
|
|
8212
8282
|
return result;
|
|
8213
8283
|
}
|
|
8214
8284
|
}
|
|
8215
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8285
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8216
8286
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8217
8287
|
});
|
|
8218
8288
|
function EmptyStatement(state) {
|
|
@@ -8291,7 +8361,7 @@ ${input.slice(result.pos)}
|
|
|
8291
8361
|
var w = $3;
|
|
8292
8362
|
return [id, colon, w];
|
|
8293
8363
|
});
|
|
8294
|
-
var Label$1 = $S($EXPECT($
|
|
8364
|
+
var Label$1 = $S($EXPECT($L86, fail, 'Label "$:"'), Whitespace);
|
|
8295
8365
|
function Label(state) {
|
|
8296
8366
|
let eventData;
|
|
8297
8367
|
if (state.events) {
|
|
@@ -9243,7 +9313,7 @@ ${input.slice(result.pos)}
|
|
|
9243
9313
|
return result;
|
|
9244
9314
|
}
|
|
9245
9315
|
}
|
|
9246
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9316
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L87, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9247
9317
|
var own = $1;
|
|
9248
9318
|
var binding = $2;
|
|
9249
9319
|
return {
|
|
@@ -9727,8 +9797,8 @@ ${input.slice(result.pos)}
|
|
|
9727
9797
|
return result;
|
|
9728
9798
|
}
|
|
9729
9799
|
}
|
|
9730
|
-
var ImpliedColon$0 = $S(
|
|
9731
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9800
|
+
var ImpliedColon$0 = $S($E(_), Colon);
|
|
9801
|
+
var ImpliedColon$1 = $TV($EXPECT($L19, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9732
9802
|
return { $loc, token: ":" };
|
|
9733
9803
|
});
|
|
9734
9804
|
function ImpliedColon(state) {
|
|
@@ -9981,7 +10051,7 @@ ${input.slice(result.pos)}
|
|
|
9981
10051
|
return result;
|
|
9982
10052
|
}
|
|
9983
10053
|
}
|
|
9984
|
-
var ForbidIndentedApplication$0 = $TV($EXPECT($
|
|
10054
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L19, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9985
10055
|
module.forbidIndentedApplication.push(true);
|
|
9986
10056
|
});
|
|
9987
10057
|
function ForbidIndentedApplication(state) {
|
|
@@ -10006,7 +10076,7 @@ ${input.slice(result.pos)}
|
|
|
10006
10076
|
return result;
|
|
10007
10077
|
}
|
|
10008
10078
|
}
|
|
10009
|
-
var AllowIndentedApplication$0 = $TV($EXPECT($
|
|
10079
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L19, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10010
10080
|
module.forbidIndentedApplication.push(false);
|
|
10011
10081
|
});
|
|
10012
10082
|
function AllowIndentedApplication(state) {
|
|
@@ -10031,7 +10101,7 @@ ${input.slice(result.pos)}
|
|
|
10031
10101
|
return result;
|
|
10032
10102
|
}
|
|
10033
10103
|
}
|
|
10034
|
-
var RestoreIndentedApplication$0 = $TV($EXPECT($
|
|
10104
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L19, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10035
10105
|
module.forbidIndentedApplication.pop();
|
|
10036
10106
|
});
|
|
10037
10107
|
function RestoreIndentedApplication(state) {
|
|
@@ -10056,7 +10126,7 @@ ${input.slice(result.pos)}
|
|
|
10056
10126
|
return result;
|
|
10057
10127
|
}
|
|
10058
10128
|
}
|
|
10059
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
10129
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L19, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10060
10130
|
if (module.config.verbose) {
|
|
10061
10131
|
console.log("forbidIndentedApplication:", module.forbidIndentedApplication);
|
|
10062
10132
|
}
|
|
@@ -10086,7 +10156,7 @@ ${input.slice(result.pos)}
|
|
|
10086
10156
|
return result;
|
|
10087
10157
|
}
|
|
10088
10158
|
}
|
|
10089
|
-
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10159
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10090
10160
|
module.forbidTrailingMemberProperty.push(true);
|
|
10091
10161
|
});
|
|
10092
10162
|
function ForbidTrailingMemberProperty(state) {
|
|
@@ -10111,7 +10181,7 @@ ${input.slice(result.pos)}
|
|
|
10111
10181
|
return result;
|
|
10112
10182
|
}
|
|
10113
10183
|
}
|
|
10114
|
-
var AllowTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10184
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10115
10185
|
module.forbidTrailingMemberProperty.push(false);
|
|
10116
10186
|
});
|
|
10117
10187
|
function AllowTrailingMemberProperty(state) {
|
|
@@ -10136,7 +10206,7 @@ ${input.slice(result.pos)}
|
|
|
10136
10206
|
return result;
|
|
10137
10207
|
}
|
|
10138
10208
|
}
|
|
10139
|
-
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10209
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L19, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10140
10210
|
module.forbidTrailingMemberProperty.pop();
|
|
10141
10211
|
});
|
|
10142
10212
|
function RestoreTrailingMemberProperty(state) {
|
|
@@ -10161,7 +10231,7 @@ ${input.slice(result.pos)}
|
|
|
10161
10231
|
return result;
|
|
10162
10232
|
}
|
|
10163
10233
|
}
|
|
10164
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
10234
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L19, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10165
10235
|
if (module.config.verbose) {
|
|
10166
10236
|
console.log("forbidTrailingMemberProperty:", module.forbidTrailingMemberProperty);
|
|
10167
10237
|
}
|
|
@@ -10190,7 +10260,7 @@ ${input.slice(result.pos)}
|
|
|
10190
10260
|
return result;
|
|
10191
10261
|
}
|
|
10192
10262
|
}
|
|
10193
|
-
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10263
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10194
10264
|
module.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10195
10265
|
});
|
|
10196
10266
|
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10215,7 +10285,7 @@ ${input.slice(result.pos)}
|
|
|
10215
10285
|
return result;
|
|
10216
10286
|
}
|
|
10217
10287
|
}
|
|
10218
|
-
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10288
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10219
10289
|
module.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10220
10290
|
});
|
|
10221
10291
|
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10240,7 +10310,7 @@ ${input.slice(result.pos)}
|
|
|
10240
10310
|
return result;
|
|
10241
10311
|
}
|
|
10242
10312
|
}
|
|
10243
|
-
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10313
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L19, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10244
10314
|
module.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10245
10315
|
});
|
|
10246
10316
|
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10265,7 +10335,7 @@ ${input.slice(result.pos)}
|
|
|
10265
10335
|
return result;
|
|
10266
10336
|
}
|
|
10267
10337
|
}
|
|
10268
|
-
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($
|
|
10338
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L19, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10269
10339
|
if (module.config.verbose) {
|
|
10270
10340
|
console.log("forbidMultiLineImplicitObjectLiteral:", module.forbidMultiLineImplicitObjectLiteral);
|
|
10271
10341
|
}
|
|
@@ -10363,17 +10433,24 @@ ${input.slice(result.pos)}
|
|
|
10363
10433
|
return result;
|
|
10364
10434
|
}
|
|
10365
10435
|
}
|
|
10366
|
-
var KeywordStatement$0 = $
|
|
10367
|
-
return {
|
|
10436
|
+
var KeywordStatement$0 = $TS($S(Break, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10437
|
+
return {
|
|
10438
|
+
type: "BreakStatement",
|
|
10439
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10440
|
+
};
|
|
10368
10441
|
});
|
|
10369
|
-
var KeywordStatement$1 = $
|
|
10370
|
-
return {
|
|
10442
|
+
var KeywordStatement$1 = $TS($S(Continue, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
|
|
10443
|
+
return {
|
|
10444
|
+
type: "ContinueStatement",
|
|
10445
|
+
children: $2 ? [$1, $2[0], $2[2]] : [$1]
|
|
10446
|
+
};
|
|
10371
10447
|
});
|
|
10372
|
-
var KeywordStatement$2 = $T($S(
|
|
10448
|
+
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
10373
10449
|
return { "type": "DebuggerStatement", "children": value };
|
|
10374
10450
|
});
|
|
10375
|
-
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
10376
|
-
|
|
10451
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L4, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10452
|
+
var expression = value[2];
|
|
10453
|
+
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10377
10454
|
});
|
|
10378
10455
|
var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
|
|
10379
10456
|
return { "type": "ThrowStatement", "children": value };
|
|
@@ -10400,7 +10477,82 @@ ${input.slice(result.pos)}
|
|
|
10400
10477
|
return result;
|
|
10401
10478
|
}
|
|
10402
10479
|
}
|
|
10403
|
-
var
|
|
10480
|
+
var Break$0 = $TS($S($EXPECT($L88, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10481
|
+
return { $loc, token: $1 };
|
|
10482
|
+
});
|
|
10483
|
+
function Break(state) {
|
|
10484
|
+
let eventData;
|
|
10485
|
+
if (state.events) {
|
|
10486
|
+
const result = state.events.enter?.("Break", state);
|
|
10487
|
+
if (result) {
|
|
10488
|
+
if (result.cache)
|
|
10489
|
+
return result.cache;
|
|
10490
|
+
eventData = result.data;
|
|
10491
|
+
}
|
|
10492
|
+
}
|
|
10493
|
+
if (state.tokenize) {
|
|
10494
|
+
const result = $TOKEN("Break", state, Break$0(state));
|
|
10495
|
+
if (state.events)
|
|
10496
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10497
|
+
return result;
|
|
10498
|
+
} else {
|
|
10499
|
+
const result = Break$0(state);
|
|
10500
|
+
if (state.events)
|
|
10501
|
+
state.events.exit?.("Break", state, result, eventData);
|
|
10502
|
+
return result;
|
|
10503
|
+
}
|
|
10504
|
+
}
|
|
10505
|
+
var Continue$0 = $TS($S($EXPECT($L89, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10506
|
+
return { $loc, token: $1 };
|
|
10507
|
+
});
|
|
10508
|
+
function Continue(state) {
|
|
10509
|
+
let eventData;
|
|
10510
|
+
if (state.events) {
|
|
10511
|
+
const result = state.events.enter?.("Continue", state);
|
|
10512
|
+
if (result) {
|
|
10513
|
+
if (result.cache)
|
|
10514
|
+
return result.cache;
|
|
10515
|
+
eventData = result.data;
|
|
10516
|
+
}
|
|
10517
|
+
}
|
|
10518
|
+
if (state.tokenize) {
|
|
10519
|
+
const result = $TOKEN("Continue", state, Continue$0(state));
|
|
10520
|
+
if (state.events)
|
|
10521
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10522
|
+
return result;
|
|
10523
|
+
} else {
|
|
10524
|
+
const result = Continue$0(state);
|
|
10525
|
+
if (state.events)
|
|
10526
|
+
state.events.exit?.("Continue", state, result, eventData);
|
|
10527
|
+
return result;
|
|
10528
|
+
}
|
|
10529
|
+
}
|
|
10530
|
+
var Debugger$0 = $TS($S($EXPECT($L90, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10531
|
+
return { $loc, token: $1 };
|
|
10532
|
+
});
|
|
10533
|
+
function Debugger(state) {
|
|
10534
|
+
let eventData;
|
|
10535
|
+
if (state.events) {
|
|
10536
|
+
const result = state.events.enter?.("Debugger", state);
|
|
10537
|
+
if (result) {
|
|
10538
|
+
if (result.cache)
|
|
10539
|
+
return result.cache;
|
|
10540
|
+
eventData = result.data;
|
|
10541
|
+
}
|
|
10542
|
+
}
|
|
10543
|
+
if (state.tokenize) {
|
|
10544
|
+
const result = $TOKEN("Debugger", state, Debugger$0(state));
|
|
10545
|
+
if (state.events)
|
|
10546
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10547
|
+
return result;
|
|
10548
|
+
} else {
|
|
10549
|
+
const result = Debugger$0(state);
|
|
10550
|
+
if (state.events)
|
|
10551
|
+
state.events.exit?.("Debugger", state, result, eventData);
|
|
10552
|
+
return result;
|
|
10553
|
+
}
|
|
10554
|
+
}
|
|
10555
|
+
var DebuggerExpression$0 = $TS($S(Debugger), function($skip, $loc, $0, $1) {
|
|
10404
10556
|
return {
|
|
10405
10557
|
type: "DebuggerExpression",
|
|
10406
10558
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10528,7 +10680,7 @@ ${input.slice(result.pos)}
|
|
|
10528
10680
|
return result;
|
|
10529
10681
|
}
|
|
10530
10682
|
}
|
|
10531
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10683
|
+
var ImpliedImport$0 = $TV($EXPECT($L19, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10532
10684
|
return { $loc, token: "import " };
|
|
10533
10685
|
});
|
|
10534
10686
|
function ImpliedImport(state) {
|
|
@@ -10677,7 +10829,7 @@ ${input.slice(result.pos)}
|
|
|
10677
10829
|
return result;
|
|
10678
10830
|
}
|
|
10679
10831
|
}
|
|
10680
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10832
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L91, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10681
10833
|
function ImportAssertion(state) {
|
|
10682
10834
|
let eventData;
|
|
10683
10835
|
if (state.events) {
|
|
@@ -11281,7 +11433,7 @@ ${input.slice(result.pos)}
|
|
|
11281
11433
|
return result;
|
|
11282
11434
|
}
|
|
11283
11435
|
}
|
|
11284
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
11436
|
+
var ConstAssignment$0 = $TV($EXPECT($L92, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
11285
11437
|
return { $loc, token: "=" };
|
|
11286
11438
|
});
|
|
11287
11439
|
function ConstAssignment(state) {
|
|
@@ -11306,7 +11458,7 @@ ${input.slice(result.pos)}
|
|
|
11306
11458
|
return result;
|
|
11307
11459
|
}
|
|
11308
11460
|
}
|
|
11309
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
11461
|
+
var LetAssignment$0 = $TV($EXPECT($L93, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
11310
11462
|
return { $loc, token: "=" };
|
|
11311
11463
|
});
|
|
11312
11464
|
function LetAssignment(state) {
|
|
@@ -12004,7 +12156,7 @@ ${input.slice(result.pos)}
|
|
|
12004
12156
|
}
|
|
12005
12157
|
}
|
|
12006
12158
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
12007
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
12159
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L55, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
12008
12160
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
12009
12161
|
});
|
|
12010
12162
|
function RegularExpressionLiteral(state) {
|
|
@@ -12571,7 +12723,7 @@ ${input.slice(result.pos)}
|
|
|
12571
12723
|
return result;
|
|
12572
12724
|
}
|
|
12573
12725
|
}
|
|
12574
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12726
|
+
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) {
|
|
12575
12727
|
return { $loc, token: $1 };
|
|
12576
12728
|
});
|
|
12577
12729
|
function JSMultiLineComment(state) {
|
|
@@ -12670,7 +12822,7 @@ ${input.slice(result.pos)}
|
|
|
12670
12822
|
return result;
|
|
12671
12823
|
}
|
|
12672
12824
|
}
|
|
12673
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12825
|
+
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) {
|
|
12674
12826
|
return { $loc, token: $1 };
|
|
12675
12827
|
});
|
|
12676
12828
|
function InlineComment(state) {
|
|
@@ -12769,7 +12921,7 @@ ${input.slice(result.pos)}
|
|
|
12769
12921
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12770
12922
|
return { $loc, token: $0 };
|
|
12771
12923
|
});
|
|
12772
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12924
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L96, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12773
12925
|
return "";
|
|
12774
12926
|
});
|
|
12775
12927
|
function NonNewlineWhitespace(state) {
|
|
@@ -12921,7 +13073,7 @@ ${input.slice(result.pos)}
|
|
|
12921
13073
|
}
|
|
12922
13074
|
}
|
|
12923
13075
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12924
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
13076
|
+
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);
|
|
12925
13077
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12926
13078
|
function StatementDelimiter(state) {
|
|
12927
13079
|
let eventData;
|
|
@@ -12996,7 +13148,7 @@ ${input.slice(result.pos)}
|
|
|
12996
13148
|
return result;
|
|
12997
13149
|
}
|
|
12998
13150
|
}
|
|
12999
|
-
var Loc$0 = $TV($EXPECT($
|
|
13151
|
+
var Loc$0 = $TV($EXPECT($L19, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
13000
13152
|
return { $loc, token: "" };
|
|
13001
13153
|
});
|
|
13002
13154
|
function Loc(state) {
|
|
@@ -13021,7 +13173,7 @@ ${input.slice(result.pos)}
|
|
|
13021
13173
|
return result;
|
|
13022
13174
|
}
|
|
13023
13175
|
}
|
|
13024
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
13176
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
13025
13177
|
return { $loc, token: $1, ts: true };
|
|
13026
13178
|
});
|
|
13027
13179
|
function Abstract(state) {
|
|
@@ -13046,7 +13198,7 @@ ${input.slice(result.pos)}
|
|
|
13046
13198
|
return result;
|
|
13047
13199
|
}
|
|
13048
13200
|
}
|
|
13049
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
13201
|
+
var Ampersand$0 = $TV($EXPECT($L83, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
13050
13202
|
return { $loc, token: $1 };
|
|
13051
13203
|
});
|
|
13052
13204
|
function Ampersand(state) {
|
|
@@ -13071,7 +13223,7 @@ ${input.slice(result.pos)}
|
|
|
13071
13223
|
return result;
|
|
13072
13224
|
}
|
|
13073
13225
|
}
|
|
13074
|
-
var As$0 = $TS($S($EXPECT($
|
|
13226
|
+
var As$0 = $TS($S($EXPECT($L100, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13075
13227
|
return { $loc, token: $1 };
|
|
13076
13228
|
});
|
|
13077
13229
|
function As(state) {
|
|
@@ -13096,7 +13248,7 @@ ${input.slice(result.pos)}
|
|
|
13096
13248
|
return result;
|
|
13097
13249
|
}
|
|
13098
13250
|
}
|
|
13099
|
-
var At$0 = $TV($EXPECT($
|
|
13251
|
+
var At$0 = $TV($EXPECT($L101, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
13100
13252
|
return { $loc, token: $1 };
|
|
13101
13253
|
});
|
|
13102
13254
|
function At(state) {
|
|
@@ -13121,7 +13273,7 @@ ${input.slice(result.pos)}
|
|
|
13121
13273
|
return result;
|
|
13122
13274
|
}
|
|
13123
13275
|
}
|
|
13124
|
-
var AtAt$0 = $TV($EXPECT($
|
|
13276
|
+
var AtAt$0 = $TV($EXPECT($L102, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
13125
13277
|
return { $loc, token: "@" };
|
|
13126
13278
|
});
|
|
13127
13279
|
function AtAt(state) {
|
|
@@ -13146,7 +13298,7 @@ ${input.slice(result.pos)}
|
|
|
13146
13298
|
return result;
|
|
13147
13299
|
}
|
|
13148
13300
|
}
|
|
13149
|
-
var Async$0 = $TS($S($EXPECT($
|
|
13301
|
+
var Async$0 = $TS($S($EXPECT($L103, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13150
13302
|
return { $loc, token: $1, type: "Async" };
|
|
13151
13303
|
});
|
|
13152
13304
|
function Async(state) {
|
|
@@ -13171,7 +13323,7 @@ ${input.slice(result.pos)}
|
|
|
13171
13323
|
return result;
|
|
13172
13324
|
}
|
|
13173
13325
|
}
|
|
13174
|
-
var Await$0 = $TS($S($EXPECT($
|
|
13326
|
+
var Await$0 = $TS($S($EXPECT($L104, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13175
13327
|
return { $loc, token: $1 };
|
|
13176
13328
|
});
|
|
13177
13329
|
function Await(state) {
|
|
@@ -13196,7 +13348,7 @@ ${input.slice(result.pos)}
|
|
|
13196
13348
|
return result;
|
|
13197
13349
|
}
|
|
13198
13350
|
}
|
|
13199
|
-
var Backtick$0 = $TV($EXPECT($
|
|
13351
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
13200
13352
|
return { $loc, token: $1 };
|
|
13201
13353
|
});
|
|
13202
13354
|
function Backtick(state) {
|
|
@@ -13221,7 +13373,7 @@ ${input.slice(result.pos)}
|
|
|
13221
13373
|
return result;
|
|
13222
13374
|
}
|
|
13223
13375
|
}
|
|
13224
|
-
var By$0 = $TS($S($EXPECT($
|
|
13376
|
+
var By$0 = $TS($S($EXPECT($L105, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13225
13377
|
return { $loc, token: $1 };
|
|
13226
13378
|
});
|
|
13227
13379
|
function By(state) {
|
|
@@ -13246,7 +13398,7 @@ ${input.slice(result.pos)}
|
|
|
13246
13398
|
return result;
|
|
13247
13399
|
}
|
|
13248
13400
|
}
|
|
13249
|
-
var Case$0 = $TS($S($EXPECT($
|
|
13401
|
+
var Case$0 = $TS($S($EXPECT($L106, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13250
13402
|
return { $loc, token: $1 };
|
|
13251
13403
|
});
|
|
13252
13404
|
function Case(state) {
|
|
@@ -13271,7 +13423,7 @@ ${input.slice(result.pos)}
|
|
|
13271
13423
|
return result;
|
|
13272
13424
|
}
|
|
13273
13425
|
}
|
|
13274
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
13426
|
+
var Catch$0 = $TS($S($EXPECT($L107, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13275
13427
|
return { $loc, token: $1 };
|
|
13276
13428
|
});
|
|
13277
13429
|
function Catch(state) {
|
|
@@ -13296,7 +13448,7 @@ ${input.slice(result.pos)}
|
|
|
13296
13448
|
return result;
|
|
13297
13449
|
}
|
|
13298
13450
|
}
|
|
13299
|
-
var Class$0 = $TS($S($EXPECT($
|
|
13451
|
+
var Class$0 = $TS($S($EXPECT($L108, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13300
13452
|
return { $loc, token: $1 };
|
|
13301
13453
|
});
|
|
13302
13454
|
function Class(state) {
|
|
@@ -13321,7 +13473,7 @@ ${input.slice(result.pos)}
|
|
|
13321
13473
|
return result;
|
|
13322
13474
|
}
|
|
13323
13475
|
}
|
|
13324
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
13476
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
13325
13477
|
return { $loc, token: $1 };
|
|
13326
13478
|
});
|
|
13327
13479
|
function CloseBrace(state) {
|
|
@@ -13346,7 +13498,7 @@ ${input.slice(result.pos)}
|
|
|
13346
13498
|
return result;
|
|
13347
13499
|
}
|
|
13348
13500
|
}
|
|
13349
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
13501
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
13350
13502
|
return { $loc, token: $1 };
|
|
13351
13503
|
});
|
|
13352
13504
|
function CloseBracket(state) {
|
|
@@ -13371,7 +13523,7 @@ ${input.slice(result.pos)}
|
|
|
13371
13523
|
return result;
|
|
13372
13524
|
}
|
|
13373
13525
|
}
|
|
13374
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
13526
|
+
var CloseParen$0 = $TV($EXPECT($L33, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
13375
13527
|
return { $loc, token: $1 };
|
|
13376
13528
|
});
|
|
13377
13529
|
function CloseParen(state) {
|
|
@@ -13396,7 +13548,7 @@ ${input.slice(result.pos)}
|
|
|
13396
13548
|
return result;
|
|
13397
13549
|
}
|
|
13398
13550
|
}
|
|
13399
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
13551
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L109, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
13400
13552
|
return { $loc, token: "${" };
|
|
13401
13553
|
});
|
|
13402
13554
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -13421,7 +13573,7 @@ ${input.slice(result.pos)}
|
|
|
13421
13573
|
return result;
|
|
13422
13574
|
}
|
|
13423
13575
|
}
|
|
13424
|
-
var Colon$0 = $TV($EXPECT($
|
|
13576
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
13425
13577
|
return { $loc, token: $1 };
|
|
13426
13578
|
});
|
|
13427
13579
|
function Colon(state) {
|
|
@@ -13446,7 +13598,7 @@ ${input.slice(result.pos)}
|
|
|
13446
13598
|
return result;
|
|
13447
13599
|
}
|
|
13448
13600
|
}
|
|
13449
|
-
var Comma$0 = $TV($EXPECT($
|
|
13601
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
13450
13602
|
return { $loc, token: $1 };
|
|
13451
13603
|
});
|
|
13452
13604
|
function Comma(state) {
|
|
@@ -13471,7 +13623,7 @@ ${input.slice(result.pos)}
|
|
|
13471
13623
|
return result;
|
|
13472
13624
|
}
|
|
13473
13625
|
}
|
|
13474
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13626
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L101, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
13475
13627
|
return { $loc, token: "constructor" };
|
|
13476
13628
|
});
|
|
13477
13629
|
function ConstructorShorthand(state) {
|
|
@@ -13496,7 +13648,7 @@ ${input.slice(result.pos)}
|
|
|
13496
13648
|
return result;
|
|
13497
13649
|
}
|
|
13498
13650
|
}
|
|
13499
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13651
|
+
var Declare$0 = $TS($S($EXPECT($L110, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13500
13652
|
return { $loc, token: $1 };
|
|
13501
13653
|
});
|
|
13502
13654
|
function Declare(state) {
|
|
@@ -13521,7 +13673,7 @@ ${input.slice(result.pos)}
|
|
|
13521
13673
|
return result;
|
|
13522
13674
|
}
|
|
13523
13675
|
}
|
|
13524
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13676
|
+
var Default$0 = $TS($S($EXPECT($L111, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13525
13677
|
return { $loc, token: $1 };
|
|
13526
13678
|
});
|
|
13527
13679
|
function Default(state) {
|
|
@@ -13546,7 +13698,7 @@ ${input.slice(result.pos)}
|
|
|
13546
13698
|
return result;
|
|
13547
13699
|
}
|
|
13548
13700
|
}
|
|
13549
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13701
|
+
var Delete$0 = $TS($S($EXPECT($L112, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13550
13702
|
return { $loc, token: $1 };
|
|
13551
13703
|
});
|
|
13552
13704
|
function Delete(state) {
|
|
@@ -13571,7 +13723,7 @@ ${input.slice(result.pos)}
|
|
|
13571
13723
|
return result;
|
|
13572
13724
|
}
|
|
13573
13725
|
}
|
|
13574
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13726
|
+
var Do$0 = $TS($S($EXPECT($L113, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13575
13727
|
return { $loc, token: $1 };
|
|
13576
13728
|
});
|
|
13577
13729
|
function Do(state) {
|
|
@@ -13621,7 +13773,7 @@ ${input.slice(result.pos)}
|
|
|
13621
13773
|
return result;
|
|
13622
13774
|
}
|
|
13623
13775
|
}
|
|
13624
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13776
|
+
var DotDot$0 = $TV($EXPECT($L114, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13625
13777
|
return { $loc, token: $1 };
|
|
13626
13778
|
});
|
|
13627
13779
|
function DotDot(state) {
|
|
@@ -13646,7 +13798,7 @@ ${input.slice(result.pos)}
|
|
|
13646
13798
|
return result;
|
|
13647
13799
|
}
|
|
13648
13800
|
}
|
|
13649
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13801
|
+
var DotDotDot$0 = $TV($EXPECT($L115, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13650
13802
|
return { $loc, token: $1 };
|
|
13651
13803
|
});
|
|
13652
13804
|
function DotDotDot(state) {
|
|
@@ -13671,7 +13823,7 @@ ${input.slice(result.pos)}
|
|
|
13671
13823
|
return result;
|
|
13672
13824
|
}
|
|
13673
13825
|
}
|
|
13674
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13826
|
+
var DoubleColon$0 = $TV($EXPECT($L116, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13675
13827
|
return { $loc, token: $1 };
|
|
13676
13828
|
});
|
|
13677
13829
|
function DoubleColon(state) {
|
|
@@ -13696,7 +13848,7 @@ ${input.slice(result.pos)}
|
|
|
13696
13848
|
return result;
|
|
13697
13849
|
}
|
|
13698
13850
|
}
|
|
13699
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13851
|
+
var DoubleQuote$0 = $TV($EXPECT($L117, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13700
13852
|
return { $loc, token: $1 };
|
|
13701
13853
|
});
|
|
13702
13854
|
function DoubleQuote(state) {
|
|
@@ -13721,7 +13873,7 @@ ${input.slice(result.pos)}
|
|
|
13721
13873
|
return result;
|
|
13722
13874
|
}
|
|
13723
13875
|
}
|
|
13724
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13876
|
+
var Else$0 = $TS($S($EXPECT($L118, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13725
13877
|
return { $loc, token: $1 };
|
|
13726
13878
|
});
|
|
13727
13879
|
function Else(state) {
|
|
@@ -13771,7 +13923,7 @@ ${input.slice(result.pos)}
|
|
|
13771
13923
|
return result;
|
|
13772
13924
|
}
|
|
13773
13925
|
}
|
|
13774
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13926
|
+
var Export$0 = $TS($S($EXPECT($L119, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13775
13927
|
return { $loc, token: $1 };
|
|
13776
13928
|
});
|
|
13777
13929
|
function Export(state) {
|
|
@@ -13796,7 +13948,7 @@ ${input.slice(result.pos)}
|
|
|
13796
13948
|
return result;
|
|
13797
13949
|
}
|
|
13798
13950
|
}
|
|
13799
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13951
|
+
var Extends$0 = $TS($S($EXPECT($L120, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13800
13952
|
return { $loc, token: $1 };
|
|
13801
13953
|
});
|
|
13802
13954
|
function Extends(state) {
|
|
@@ -13821,7 +13973,7 @@ ${input.slice(result.pos)}
|
|
|
13821
13973
|
return result;
|
|
13822
13974
|
}
|
|
13823
13975
|
}
|
|
13824
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13976
|
+
var Finally$0 = $TS($S($EXPECT($L121, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13825
13977
|
return { $loc, token: $1 };
|
|
13826
13978
|
});
|
|
13827
13979
|
function Finally(state) {
|
|
@@ -13846,7 +13998,7 @@ ${input.slice(result.pos)}
|
|
|
13846
13998
|
return result;
|
|
13847
13999
|
}
|
|
13848
14000
|
}
|
|
13849
|
-
var For$0 = $TS($S($EXPECT($
|
|
14001
|
+
var For$0 = $TS($S($EXPECT($L122, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13850
14002
|
return { $loc, token: $1 };
|
|
13851
14003
|
});
|
|
13852
14004
|
function For(state) {
|
|
@@ -13871,7 +14023,7 @@ ${input.slice(result.pos)}
|
|
|
13871
14023
|
return result;
|
|
13872
14024
|
}
|
|
13873
14025
|
}
|
|
13874
|
-
var From$0 = $TS($S($EXPECT($
|
|
14026
|
+
var From$0 = $TS($S($EXPECT($L123, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13875
14027
|
return { $loc, token: $1 };
|
|
13876
14028
|
});
|
|
13877
14029
|
function From(state) {
|
|
@@ -13896,7 +14048,7 @@ ${input.slice(result.pos)}
|
|
|
13896
14048
|
return result;
|
|
13897
14049
|
}
|
|
13898
14050
|
}
|
|
13899
|
-
var Function$0 = $TS($S($EXPECT($
|
|
14051
|
+
var Function$0 = $TS($S($EXPECT($L124, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13900
14052
|
return { $loc, token: $1 };
|
|
13901
14053
|
});
|
|
13902
14054
|
function Function(state) {
|
|
@@ -13921,7 +14073,7 @@ ${input.slice(result.pos)}
|
|
|
13921
14073
|
return result;
|
|
13922
14074
|
}
|
|
13923
14075
|
}
|
|
13924
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
14076
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L125, fail, 'GetOrSet "get"'), $EXPECT($L126, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13925
14077
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13926
14078
|
});
|
|
13927
14079
|
function GetOrSet(state) {
|
|
@@ -13946,7 +14098,7 @@ ${input.slice(result.pos)}
|
|
|
13946
14098
|
return result;
|
|
13947
14099
|
}
|
|
13948
14100
|
}
|
|
13949
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
14101
|
+
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13950
14102
|
return { $loc, token: $1 };
|
|
13951
14103
|
});
|
|
13952
14104
|
function If(state) {
|
|
@@ -13996,7 +14148,7 @@ ${input.slice(result.pos)}
|
|
|
13996
14148
|
return result;
|
|
13997
14149
|
}
|
|
13998
14150
|
}
|
|
13999
|
-
var In$0 = $TS($S($EXPECT($
|
|
14151
|
+
var In$0 = $TS($S($EXPECT($L81, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14000
14152
|
return { $loc, token: $1 };
|
|
14001
14153
|
});
|
|
14002
14154
|
function In(state) {
|
|
@@ -14021,7 +14173,7 @@ ${input.slice(result.pos)}
|
|
|
14021
14173
|
return result;
|
|
14022
14174
|
}
|
|
14023
14175
|
}
|
|
14024
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
14176
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L128, fail, 'LetOrConst "let"'), $EXPECT($L129, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14025
14177
|
return { $loc, token: $1 };
|
|
14026
14178
|
});
|
|
14027
14179
|
function LetOrConst(state) {
|
|
@@ -14046,7 +14198,7 @@ ${input.slice(result.pos)}
|
|
|
14046
14198
|
return result;
|
|
14047
14199
|
}
|
|
14048
14200
|
}
|
|
14049
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
14201
|
+
var Loop$0 = $TS($S($EXPECT($L130, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14050
14202
|
return { $loc, token: "while(true)" };
|
|
14051
14203
|
});
|
|
14052
14204
|
function Loop(state) {
|
|
@@ -14071,7 +14223,7 @@ ${input.slice(result.pos)}
|
|
|
14071
14223
|
return result;
|
|
14072
14224
|
}
|
|
14073
14225
|
}
|
|
14074
|
-
var New$0 = $TS($S($EXPECT($
|
|
14226
|
+
var New$0 = $TS($S($EXPECT($L131, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14075
14227
|
return { $loc, token: $1 };
|
|
14076
14228
|
});
|
|
14077
14229
|
function New(state) {
|
|
@@ -14096,7 +14248,7 @@ ${input.slice(result.pos)}
|
|
|
14096
14248
|
return result;
|
|
14097
14249
|
}
|
|
14098
14250
|
}
|
|
14099
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
14251
|
+
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) {
|
|
14100
14252
|
return { $loc, token: "!" };
|
|
14101
14253
|
});
|
|
14102
14254
|
function Not(state) {
|
|
@@ -14121,7 +14273,7 @@ ${input.slice(result.pos)}
|
|
|
14121
14273
|
return result;
|
|
14122
14274
|
}
|
|
14123
14275
|
}
|
|
14124
|
-
var Of$0 = $TS($S($EXPECT($
|
|
14276
|
+
var Of$0 = $TS($S($EXPECT($L73, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14125
14277
|
return { $loc, token: $1 };
|
|
14126
14278
|
});
|
|
14127
14279
|
function Of(state) {
|
|
@@ -14146,7 +14298,7 @@ ${input.slice(result.pos)}
|
|
|
14146
14298
|
return result;
|
|
14147
14299
|
}
|
|
14148
14300
|
}
|
|
14149
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
14301
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L132, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
14150
14302
|
return { $loc, token: $1 };
|
|
14151
14303
|
});
|
|
14152
14304
|
function OpenAngleBracket(state) {
|
|
@@ -14171,7 +14323,7 @@ ${input.slice(result.pos)}
|
|
|
14171
14323
|
return result;
|
|
14172
14324
|
}
|
|
14173
14325
|
}
|
|
14174
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
14326
|
+
var OpenBrace$0 = $TV($EXPECT($L133, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
14175
14327
|
return { $loc, token: $1 };
|
|
14176
14328
|
});
|
|
14177
14329
|
function OpenBrace(state) {
|
|
@@ -14196,7 +14348,7 @@ ${input.slice(result.pos)}
|
|
|
14196
14348
|
return result;
|
|
14197
14349
|
}
|
|
14198
14350
|
}
|
|
14199
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
14351
|
+
var OpenBracket$0 = $TV($EXPECT($L97, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
14200
14352
|
return { $loc, token: $1 };
|
|
14201
14353
|
});
|
|
14202
14354
|
function OpenBracket(state) {
|
|
@@ -14246,7 +14398,7 @@ ${input.slice(result.pos)}
|
|
|
14246
14398
|
return result;
|
|
14247
14399
|
}
|
|
14248
14400
|
}
|
|
14249
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
14401
|
+
var Operator$0 = $TS($S($EXPECT($L134, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14250
14402
|
return { $loc, token: $1 };
|
|
14251
14403
|
});
|
|
14252
14404
|
function Operator(state) {
|
|
@@ -14271,7 +14423,7 @@ ${input.slice(result.pos)}
|
|
|
14271
14423
|
return result;
|
|
14272
14424
|
}
|
|
14273
14425
|
}
|
|
14274
|
-
var Public$0 = $TS($S($EXPECT($
|
|
14426
|
+
var Public$0 = $TS($S($EXPECT($L135, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14275
14427
|
return { $loc, token: $1 };
|
|
14276
14428
|
});
|
|
14277
14429
|
function Public(state) {
|
|
@@ -14296,7 +14448,7 @@ ${input.slice(result.pos)}
|
|
|
14296
14448
|
return result;
|
|
14297
14449
|
}
|
|
14298
14450
|
}
|
|
14299
|
-
var Private$0 = $TS($S($EXPECT($
|
|
14451
|
+
var Private$0 = $TS($S($EXPECT($L136, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14300
14452
|
return { $loc, token: $1 };
|
|
14301
14453
|
});
|
|
14302
14454
|
function Private(state) {
|
|
@@ -14321,7 +14473,7 @@ ${input.slice(result.pos)}
|
|
|
14321
14473
|
return result;
|
|
14322
14474
|
}
|
|
14323
14475
|
}
|
|
14324
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
14476
|
+
var Protected$0 = $TS($S($EXPECT($L137, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14325
14477
|
return { $loc, token: $1 };
|
|
14326
14478
|
});
|
|
14327
14479
|
function Protected(state) {
|
|
@@ -14346,13 +14498,13 @@ ${input.slice(result.pos)}
|
|
|
14346
14498
|
return result;
|
|
14347
14499
|
}
|
|
14348
14500
|
}
|
|
14349
|
-
var Pipe$0 = $TV($EXPECT($
|
|
14501
|
+
var Pipe$0 = $TV($EXPECT($L138, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
14350
14502
|
return { $loc, token: $1 };
|
|
14351
14503
|
});
|
|
14352
|
-
var Pipe$1 = $TV($EXPECT($
|
|
14504
|
+
var Pipe$1 = $TV($EXPECT($L139, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
14353
14505
|
return { $loc, token: $1 };
|
|
14354
14506
|
});
|
|
14355
|
-
var Pipe$2 = $TV($EXPECT($
|
|
14507
|
+
var Pipe$2 = $TV($EXPECT($L140, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
14356
14508
|
return { $loc, token: $1 };
|
|
14357
14509
|
});
|
|
14358
14510
|
function Pipe(state) {
|
|
@@ -14402,7 +14554,7 @@ ${input.slice(result.pos)}
|
|
|
14402
14554
|
return result;
|
|
14403
14555
|
}
|
|
14404
14556
|
}
|
|
14405
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14557
|
+
var Readonly$0 = $TS($S($EXPECT($L141, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14406
14558
|
return { $loc, token: $1, ts: true };
|
|
14407
14559
|
});
|
|
14408
14560
|
function Readonly(state) {
|
|
@@ -14427,7 +14579,7 @@ ${input.slice(result.pos)}
|
|
|
14427
14579
|
return result;
|
|
14428
14580
|
}
|
|
14429
14581
|
}
|
|
14430
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14582
|
+
var Return$0 = $TS($S($EXPECT($L142, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14431
14583
|
return { $loc, token: $1 };
|
|
14432
14584
|
});
|
|
14433
14585
|
function Return(state) {
|
|
@@ -14452,7 +14604,7 @@ ${input.slice(result.pos)}
|
|
|
14452
14604
|
return result;
|
|
14453
14605
|
}
|
|
14454
14606
|
}
|
|
14455
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14607
|
+
var Satisfies$0 = $TS($S($EXPECT($L143, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14456
14608
|
return { $loc, token: $1 };
|
|
14457
14609
|
});
|
|
14458
14610
|
function Satisfies(state) {
|
|
@@ -14477,7 +14629,7 @@ ${input.slice(result.pos)}
|
|
|
14477
14629
|
return result;
|
|
14478
14630
|
}
|
|
14479
14631
|
}
|
|
14480
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14632
|
+
var Semicolon$0 = $TV($EXPECT($L85, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
14481
14633
|
return { $loc, token: $1 };
|
|
14482
14634
|
});
|
|
14483
14635
|
function Semicolon(state) {
|
|
@@ -14502,7 +14654,7 @@ ${input.slice(result.pos)}
|
|
|
14502
14654
|
return result;
|
|
14503
14655
|
}
|
|
14504
14656
|
}
|
|
14505
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14657
|
+
var SingleQuote$0 = $TV($EXPECT($L144, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14506
14658
|
return { $loc, token: $1 };
|
|
14507
14659
|
});
|
|
14508
14660
|
function SingleQuote(state) {
|
|
@@ -14527,7 +14679,7 @@ ${input.slice(result.pos)}
|
|
|
14527
14679
|
return result;
|
|
14528
14680
|
}
|
|
14529
14681
|
}
|
|
14530
|
-
var Star$0 = $TV($EXPECT($
|
|
14682
|
+
var Star$0 = $TV($EXPECT($L54, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14531
14683
|
return { $loc, token: $1 };
|
|
14532
14684
|
});
|
|
14533
14685
|
function Star(state) {
|
|
@@ -14552,10 +14704,10 @@ ${input.slice(result.pos)}
|
|
|
14552
14704
|
return result;
|
|
14553
14705
|
}
|
|
14554
14706
|
}
|
|
14555
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14707
|
+
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14556
14708
|
return { $loc, token: $1 };
|
|
14557
14709
|
});
|
|
14558
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14710
|
+
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) {
|
|
14559
14711
|
return { $loc, token: "static " };
|
|
14560
14712
|
});
|
|
14561
14713
|
function Static(state) {
|
|
@@ -14580,7 +14732,7 @@ ${input.slice(result.pos)}
|
|
|
14580
14732
|
return result;
|
|
14581
14733
|
}
|
|
14582
14734
|
}
|
|
14583
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14735
|
+
var SubstitutionStart$0 = $TV($EXPECT($L146, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14584
14736
|
return { $loc, token: $1 };
|
|
14585
14737
|
});
|
|
14586
14738
|
function SubstitutionStart(state) {
|
|
@@ -14605,7 +14757,7 @@ ${input.slice(result.pos)}
|
|
|
14605
14757
|
return result;
|
|
14606
14758
|
}
|
|
14607
14759
|
}
|
|
14608
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14760
|
+
var Switch$0 = $TS($S($EXPECT($L147, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14609
14761
|
return { $loc, token: $1 };
|
|
14610
14762
|
});
|
|
14611
14763
|
function Switch(state) {
|
|
@@ -14630,7 +14782,7 @@ ${input.slice(result.pos)}
|
|
|
14630
14782
|
return result;
|
|
14631
14783
|
}
|
|
14632
14784
|
}
|
|
14633
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14785
|
+
var Target$0 = $TS($S($EXPECT($L148, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14634
14786
|
return { $loc, token: $1 };
|
|
14635
14787
|
});
|
|
14636
14788
|
function Target(state) {
|
|
@@ -14655,7 +14807,7 @@ ${input.slice(result.pos)}
|
|
|
14655
14807
|
return result;
|
|
14656
14808
|
}
|
|
14657
14809
|
}
|
|
14658
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14810
|
+
var Then$0 = $TS($S(__, $EXPECT($L149, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14659
14811
|
return { $loc, token: "" };
|
|
14660
14812
|
});
|
|
14661
14813
|
function Then(state) {
|
|
@@ -14680,7 +14832,7 @@ ${input.slice(result.pos)}
|
|
|
14680
14832
|
return result;
|
|
14681
14833
|
}
|
|
14682
14834
|
}
|
|
14683
|
-
var This$0 = $TS($S($EXPECT($
|
|
14835
|
+
var This$0 = $TS($S($EXPECT($L150, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14684
14836
|
return { $loc, token: $1 };
|
|
14685
14837
|
});
|
|
14686
14838
|
function This(state) {
|
|
@@ -14705,7 +14857,7 @@ ${input.slice(result.pos)}
|
|
|
14705
14857
|
return result;
|
|
14706
14858
|
}
|
|
14707
14859
|
}
|
|
14708
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14860
|
+
var Throw$0 = $TS($S($EXPECT($L151, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14709
14861
|
return { $loc, token: $1 };
|
|
14710
14862
|
});
|
|
14711
14863
|
function Throw(state) {
|
|
@@ -14730,7 +14882,7 @@ ${input.slice(result.pos)}
|
|
|
14730
14882
|
return result;
|
|
14731
14883
|
}
|
|
14732
14884
|
}
|
|
14733
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14885
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L152, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14734
14886
|
return { $loc, token: "`" };
|
|
14735
14887
|
});
|
|
14736
14888
|
function TripleDoubleQuote(state) {
|
|
@@ -14755,7 +14907,7 @@ ${input.slice(result.pos)}
|
|
|
14755
14907
|
return result;
|
|
14756
14908
|
}
|
|
14757
14909
|
}
|
|
14758
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14910
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L153, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14759
14911
|
return { $loc, token: "`" };
|
|
14760
14912
|
});
|
|
14761
14913
|
function TripleSingleQuote(state) {
|
|
@@ -14780,7 +14932,7 @@ ${input.slice(result.pos)}
|
|
|
14780
14932
|
return result;
|
|
14781
14933
|
}
|
|
14782
14934
|
}
|
|
14783
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14935
|
+
var TripleSlash$0 = $TV($EXPECT($L154, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14784
14936
|
return { $loc, token: "/" };
|
|
14785
14937
|
});
|
|
14786
14938
|
function TripleSlash(state) {
|
|
@@ -14805,7 +14957,7 @@ ${input.slice(result.pos)}
|
|
|
14805
14957
|
return result;
|
|
14806
14958
|
}
|
|
14807
14959
|
}
|
|
14808
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14960
|
+
var TripleTick$0 = $TV($EXPECT($L155, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14809
14961
|
return { $loc, token: "`" };
|
|
14810
14962
|
});
|
|
14811
14963
|
function TripleTick(state) {
|
|
@@ -14830,7 +14982,7 @@ ${input.slice(result.pos)}
|
|
|
14830
14982
|
return result;
|
|
14831
14983
|
}
|
|
14832
14984
|
}
|
|
14833
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14985
|
+
var Try$0 = $TS($S($EXPECT($L156, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14834
14986
|
return { $loc, token: $1 };
|
|
14835
14987
|
});
|
|
14836
14988
|
function Try(state) {
|
|
@@ -14855,7 +15007,7 @@ ${input.slice(result.pos)}
|
|
|
14855
15007
|
return result;
|
|
14856
15008
|
}
|
|
14857
15009
|
}
|
|
14858
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
15010
|
+
var Typeof$0 = $TS($S($EXPECT($L157, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14859
15011
|
return { $loc, token: $1 };
|
|
14860
15012
|
});
|
|
14861
15013
|
function Typeof(state) {
|
|
@@ -14880,7 +15032,7 @@ ${input.slice(result.pos)}
|
|
|
14880
15032
|
return result;
|
|
14881
15033
|
}
|
|
14882
15034
|
}
|
|
14883
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
15035
|
+
var Unless$0 = $TS($S($EXPECT($L158, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14884
15036
|
return { $loc, token: $1 };
|
|
14885
15037
|
});
|
|
14886
15038
|
function Unless(state) {
|
|
@@ -14905,7 +15057,7 @@ ${input.slice(result.pos)}
|
|
|
14905
15057
|
return result;
|
|
14906
15058
|
}
|
|
14907
15059
|
}
|
|
14908
|
-
var Until$0 = $TS($S($EXPECT($
|
|
15060
|
+
var Until$0 = $TS($S($EXPECT($L159, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14909
15061
|
return { $loc, token: $1 };
|
|
14910
15062
|
});
|
|
14911
15063
|
function Until(state) {
|
|
@@ -14930,7 +15082,7 @@ ${input.slice(result.pos)}
|
|
|
14930
15082
|
return result;
|
|
14931
15083
|
}
|
|
14932
15084
|
}
|
|
14933
|
-
var Var$0 = $TS($S($EXPECT($
|
|
15085
|
+
var Var$0 = $TS($S($EXPECT($L160, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14934
15086
|
return { $loc, token: $1 };
|
|
14935
15087
|
});
|
|
14936
15088
|
function Var(state) {
|
|
@@ -14955,7 +15107,7 @@ ${input.slice(result.pos)}
|
|
|
14955
15107
|
return result;
|
|
14956
15108
|
}
|
|
14957
15109
|
}
|
|
14958
|
-
var Void$0 = $TS($S($EXPECT($
|
|
15110
|
+
var Void$0 = $TS($S($EXPECT($L161, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14959
15111
|
return { $loc, token: $1 };
|
|
14960
15112
|
});
|
|
14961
15113
|
function Void(state) {
|
|
@@ -14980,7 +15132,7 @@ ${input.slice(result.pos)}
|
|
|
14980
15132
|
return result;
|
|
14981
15133
|
}
|
|
14982
15134
|
}
|
|
14983
|
-
var When$0 = $TS($S($EXPECT($
|
|
15135
|
+
var When$0 = $TS($S($EXPECT($L162, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14984
15136
|
return { $loc, token: "case" };
|
|
14985
15137
|
});
|
|
14986
15138
|
function When(state) {
|
|
@@ -15005,7 +15157,7 @@ ${input.slice(result.pos)}
|
|
|
15005
15157
|
return result;
|
|
15006
15158
|
}
|
|
15007
15159
|
}
|
|
15008
|
-
var While$0 = $TS($S($EXPECT($
|
|
15160
|
+
var While$0 = $TS($S($EXPECT($L163, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15009
15161
|
return { $loc, token: $1 };
|
|
15010
15162
|
});
|
|
15011
15163
|
function While(state) {
|
|
@@ -15030,7 +15182,7 @@ ${input.slice(result.pos)}
|
|
|
15030
15182
|
return result;
|
|
15031
15183
|
}
|
|
15032
15184
|
}
|
|
15033
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
15185
|
+
var Yield$0 = $TS($S($EXPECT($L164, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15034
15186
|
return { $loc, token: $1 };
|
|
15035
15187
|
});
|
|
15036
15188
|
function Yield(state) {
|
|
@@ -15175,7 +15327,7 @@ ${input.slice(result.pos)}
|
|
|
15175
15327
|
return result;
|
|
15176
15328
|
}
|
|
15177
15329
|
}
|
|
15178
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
15330
|
+
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) {
|
|
15179
15331
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
15180
15332
|
});
|
|
15181
15333
|
function JSXSelfClosingElement(state) {
|
|
@@ -15226,7 +15378,7 @@ ${input.slice(result.pos)}
|
|
|
15226
15378
|
return result;
|
|
15227
15379
|
}
|
|
15228
15380
|
}
|
|
15229
|
-
var PopJSXStack$0 = $TV($EXPECT($
|
|
15381
|
+
var PopJSXStack$0 = $TV($EXPECT($L19, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15230
15382
|
module.JSXTagStack.pop();
|
|
15231
15383
|
});
|
|
15232
15384
|
function PopJSXStack(state) {
|
|
@@ -15251,7 +15403,7 @@ ${input.slice(result.pos)}
|
|
|
15251
15403
|
return result;
|
|
15252
15404
|
}
|
|
15253
15405
|
}
|
|
15254
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
15406
|
+
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
15255
15407
|
function JSXOpeningElement(state) {
|
|
15256
15408
|
let eventData;
|
|
15257
15409
|
if (state.events) {
|
|
@@ -15280,7 +15432,7 @@ ${input.slice(result.pos)}
|
|
|
15280
15432
|
return $skip;
|
|
15281
15433
|
return $0;
|
|
15282
15434
|
});
|
|
15283
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
15435
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L19, fail, 'JSXOptionalClosingElement ""');
|
|
15284
15436
|
function JSXOptionalClosingElement(state) {
|
|
15285
15437
|
let eventData;
|
|
15286
15438
|
if (state.events) {
|
|
@@ -15303,7 +15455,7 @@ ${input.slice(result.pos)}
|
|
|
15303
15455
|
return result;
|
|
15304
15456
|
}
|
|
15305
15457
|
}
|
|
15306
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
15458
|
+
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
15307
15459
|
function JSXClosingElement(state) {
|
|
15308
15460
|
let eventData;
|
|
15309
15461
|
if (state.events) {
|
|
@@ -15341,7 +15493,7 @@ ${input.slice(result.pos)}
|
|
|
15341
15493
|
];
|
|
15342
15494
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
15343
15495
|
});
|
|
15344
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
15496
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L167, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
15345
15497
|
var children = $3;
|
|
15346
15498
|
$0 = $0.slice(1);
|
|
15347
15499
|
return {
|
|
@@ -15372,7 +15524,7 @@ ${input.slice(result.pos)}
|
|
|
15372
15524
|
return result;
|
|
15373
15525
|
}
|
|
15374
15526
|
}
|
|
15375
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
15527
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L167, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
15376
15528
|
module.JSXTagStack.push("");
|
|
15377
15529
|
return $1;
|
|
15378
15530
|
});
|
|
@@ -15403,7 +15555,7 @@ ${input.slice(result.pos)}
|
|
|
15403
15555
|
return $skip;
|
|
15404
15556
|
return $0;
|
|
15405
15557
|
});
|
|
15406
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
15558
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L19, fail, 'JSXOptionalClosingFragment ""');
|
|
15407
15559
|
function JSXOptionalClosingFragment(state) {
|
|
15408
15560
|
let eventData;
|
|
15409
15561
|
if (state.events) {
|
|
@@ -15426,7 +15578,7 @@ ${input.slice(result.pos)}
|
|
|
15426
15578
|
return result;
|
|
15427
15579
|
}
|
|
15428
15580
|
}
|
|
15429
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15581
|
+
var JSXClosingFragment$0 = $EXPECT($L168, fail, 'JSXClosingFragment "</>"');
|
|
15430
15582
|
function JSXClosingFragment(state) {
|
|
15431
15583
|
let eventData;
|
|
15432
15584
|
if (state.events) {
|
|
@@ -16193,7 +16345,7 @@ ${input.slice(result.pos)}
|
|
|
16193
16345
|
}
|
|
16194
16346
|
return $skip;
|
|
16195
16347
|
});
|
|
16196
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
16348
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
16197
16349
|
return { children: [], jsxChildren: [] };
|
|
16198
16350
|
});
|
|
16199
16351
|
function JSXNestedChildren(state) {
|
|
@@ -16322,7 +16474,7 @@ ${input.slice(result.pos)}
|
|
|
16322
16474
|
return result;
|
|
16323
16475
|
}
|
|
16324
16476
|
}
|
|
16325
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
16477
|
+
var JSXComment$0 = $TS($S($EXPECT($L169, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L170, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16326
16478
|
return ["{/*", $2, "*/}"];
|
|
16327
16479
|
});
|
|
16328
16480
|
function JSXComment(state) {
|
|
@@ -16620,7 +16772,7 @@ ${input.slice(result.pos)}
|
|
|
16620
16772
|
return result;
|
|
16621
16773
|
}
|
|
16622
16774
|
}
|
|
16623
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16775
|
+
var TypeKeyword$0 = $S($EXPECT($L171, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16624
16776
|
function TypeKeyword(state) {
|
|
16625
16777
|
let eventData;
|
|
16626
16778
|
if (state.events) {
|
|
@@ -16643,7 +16795,7 @@ ${input.slice(result.pos)}
|
|
|
16643
16795
|
return result;
|
|
16644
16796
|
}
|
|
16645
16797
|
}
|
|
16646
|
-
var Interface$0 = $S($EXPECT($
|
|
16798
|
+
var Interface$0 = $S($EXPECT($L172, fail, 'Interface "interface"'), NonIdContinue);
|
|
16647
16799
|
function Interface(state) {
|
|
16648
16800
|
let eventData;
|
|
16649
16801
|
if (state.events) {
|
|
@@ -16666,7 +16818,7 @@ ${input.slice(result.pos)}
|
|
|
16666
16818
|
return result;
|
|
16667
16819
|
}
|
|
16668
16820
|
}
|
|
16669
|
-
var Namespace$0 = $S($EXPECT($
|
|
16821
|
+
var Namespace$0 = $S($EXPECT($L173, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16670
16822
|
function Namespace(state) {
|
|
16671
16823
|
let eventData;
|
|
16672
16824
|
if (state.events) {
|
|
@@ -16914,7 +17066,7 @@ ${input.slice(result.pos)}
|
|
|
16914
17066
|
return result;
|
|
16915
17067
|
}
|
|
16916
17068
|
}
|
|
16917
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R57, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
17069
|
+
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)));
|
|
16918
17070
|
function TypeIndexSignature(state) {
|
|
16919
17071
|
let eventData;
|
|
16920
17072
|
if (state.events) {
|
|
@@ -16961,7 +17113,7 @@ ${input.slice(result.pos)}
|
|
|
16961
17113
|
return result;
|
|
16962
17114
|
}
|
|
16963
17115
|
}
|
|
16964
|
-
var TypeSuffix$0 = $T($S($E(QuestionMark),
|
|
17116
|
+
var TypeSuffix$0 = $T($S($E(QuestionMark), $E(_), Colon, Type), function(value) {
|
|
16965
17117
|
return { "type": "TypeSuffix", "ts": true, "children": value };
|
|
16966
17118
|
});
|
|
16967
17119
|
function TypeSuffix(state) {
|
|
@@ -16986,14 +17138,20 @@ ${input.slice(result.pos)}
|
|
|
16986
17138
|
return result;
|
|
16987
17139
|
}
|
|
16988
17140
|
}
|
|
16989
|
-
var ReturnTypeSuffix$0 = $TS($S(
|
|
16990
|
-
|
|
16991
|
-
|
|
16992
|
-
|
|
16993
|
-
|
|
17141
|
+
var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L174, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17142
|
+
var asserts = $3;
|
|
17143
|
+
var t = $4;
|
|
17144
|
+
if (asserts) {
|
|
17145
|
+
t = {
|
|
17146
|
+
type: "AssertsType",
|
|
17147
|
+
t,
|
|
17148
|
+
children: [asserts[0], asserts[1], t]
|
|
17149
|
+
};
|
|
17150
|
+
}
|
|
16994
17151
|
return {
|
|
16995
17152
|
type: "ReturnTypeAnnotation",
|
|
16996
|
-
children,
|
|
17153
|
+
children: [$1, $2, t],
|
|
17154
|
+
t,
|
|
16997
17155
|
ts: true
|
|
16998
17156
|
};
|
|
16999
17157
|
});
|
|
@@ -17019,10 +17177,17 @@ ${input.slice(result.pos)}
|
|
|
17019
17177
|
return result;
|
|
17020
17178
|
}
|
|
17021
17179
|
}
|
|
17022
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
17023
|
-
|
|
17024
|
-
|
|
17025
|
-
|
|
17180
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L82, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
17181
|
+
var lhs = $1;
|
|
17182
|
+
var rhs = $2;
|
|
17183
|
+
if (!rhs)
|
|
17184
|
+
return lhs;
|
|
17185
|
+
return {
|
|
17186
|
+
type: "TypePredicate",
|
|
17187
|
+
lhs,
|
|
17188
|
+
rhs: rhs[3],
|
|
17189
|
+
children: [lhs, ...rhs]
|
|
17190
|
+
};
|
|
17026
17191
|
});
|
|
17027
17192
|
function TypePredicate(state) {
|
|
17028
17193
|
let eventData;
|
|
@@ -17097,6 +17262,8 @@ ${input.slice(result.pos)}
|
|
|
17097
17262
|
}
|
|
17098
17263
|
}
|
|
17099
17264
|
var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
17265
|
+
if (!$1.length && !$3.length)
|
|
17266
|
+
return $2;
|
|
17100
17267
|
return [...$1, $2, ...$3];
|
|
17101
17268
|
});
|
|
17102
17269
|
function TypeUnary(state) {
|
|
@@ -17145,10 +17312,10 @@ ${input.slice(result.pos)}
|
|
|
17145
17312
|
return result;
|
|
17146
17313
|
}
|
|
17147
17314
|
}
|
|
17148
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
17149
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
17150
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
17151
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
17315
|
+
var TypeUnaryOp$0 = $S($EXPECT($L175, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
17316
|
+
var TypeUnaryOp$1 = $S($EXPECT($L157, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
17317
|
+
var TypeUnaryOp$2 = $S($EXPECT($L176, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
17318
|
+
var TypeUnaryOp$3 = $S($EXPECT($L141, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
17152
17319
|
function TypeUnaryOp(state) {
|
|
17153
17320
|
let eventData;
|
|
17154
17321
|
if (state.events) {
|
|
@@ -17199,8 +17366,23 @@ ${input.slice(result.pos)}
|
|
|
17199
17366
|
var TypePrimary$2 = $S($E(_), InlineInterfaceLiteral);
|
|
17200
17367
|
var TypePrimary$3 = $S($E(_), TypeTuple);
|
|
17201
17368
|
var TypePrimary$4 = $S($E(_), ImportType);
|
|
17202
|
-
var TypePrimary$5 = $S($E(_), TypeLiteral)
|
|
17203
|
-
|
|
17369
|
+
var TypePrimary$5 = $TS($S($E(_), TypeLiteral), function($skip, $loc, $0, $1, $2) {
|
|
17370
|
+
var t = $2;
|
|
17371
|
+
return {
|
|
17372
|
+
type: "LiteralType",
|
|
17373
|
+
t,
|
|
17374
|
+
children: $0
|
|
17375
|
+
};
|
|
17376
|
+
});
|
|
17377
|
+
var TypePrimary$6 = $TS($S($E(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17378
|
+
var args = $4;
|
|
17379
|
+
return {
|
|
17380
|
+
type: "IdentifierType",
|
|
17381
|
+
children: $0,
|
|
17382
|
+
raw: [$2.name, ...$3.map(([dot, id]) => dot.token + id.name)].join(""),
|
|
17383
|
+
args
|
|
17384
|
+
};
|
|
17385
|
+
});
|
|
17204
17386
|
var TypePrimary$7 = $S(__, OpenParen, $C(Type, $S(EOS, Type)), __, CloseParen);
|
|
17205
17387
|
function TypePrimary(state) {
|
|
17206
17388
|
let eventData;
|
|
@@ -17346,7 +17528,7 @@ ${input.slice(result.pos)}
|
|
|
17346
17528
|
return result;
|
|
17347
17529
|
}
|
|
17348
17530
|
}
|
|
17349
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
17531
|
+
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) {
|
|
17350
17532
|
if ($2)
|
|
17351
17533
|
return $0;
|
|
17352
17534
|
return $1;
|
|
@@ -17375,10 +17557,10 @@ ${input.slice(result.pos)}
|
|
|
17375
17557
|
}
|
|
17376
17558
|
var TypeLiteral$0 = TemplateLiteral;
|
|
17377
17559
|
var TypeLiteral$1 = Literal;
|
|
17378
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
17379
|
-
return { $loc, token:
|
|
17560
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L161, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
17561
|
+
return { type: "VoidType", $loc, token: $1 };
|
|
17380
17562
|
});
|
|
17381
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
17563
|
+
var TypeLiteral$3 = $TV($EXPECT($L177, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
17382
17564
|
return { $loc, token: "[]" };
|
|
17383
17565
|
});
|
|
17384
17566
|
function TypeLiteral(state) {
|
|
@@ -17453,7 +17635,7 @@ ${input.slice(result.pos)}
|
|
|
17453
17635
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
17454
17636
|
return value[1];
|
|
17455
17637
|
});
|
|
17456
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17638
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L33, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
17457
17639
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
17458
17640
|
function InlineInterfacePropertyDelimiter(state) {
|
|
17459
17641
|
let eventData;
|
|
@@ -17477,10 +17659,10 @@ ${input.slice(result.pos)}
|
|
|
17477
17659
|
return result;
|
|
17478
17660
|
}
|
|
17479
17661
|
}
|
|
17480
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17662
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L84, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
17481
17663
|
return { $loc, token: "|" };
|
|
17482
17664
|
});
|
|
17483
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17665
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
17484
17666
|
return { $loc, token: "&" };
|
|
17485
17667
|
});
|
|
17486
17668
|
function TypeBinaryOp(state) {
|
|
@@ -17537,7 +17719,7 @@ ${input.slice(result.pos)}
|
|
|
17537
17719
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17538
17720
|
return { $loc, token: "=>" };
|
|
17539
17721
|
});
|
|
17540
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17722
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17541
17723
|
return { $loc, token: "=>" };
|
|
17542
17724
|
});
|
|
17543
17725
|
function TypeArrowFunction(state) {
|
|
@@ -17562,7 +17744,7 @@ ${input.slice(result.pos)}
|
|
|
17562
17744
|
return result;
|
|
17563
17745
|
}
|
|
17564
17746
|
}
|
|
17565
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17747
|
+
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17566
17748
|
return { ts: true, children: $0 };
|
|
17567
17749
|
});
|
|
17568
17750
|
function TypeArguments(state) {
|
|
@@ -17633,7 +17815,7 @@ ${input.slice(result.pos)}
|
|
|
17633
17815
|
return result;
|
|
17634
17816
|
}
|
|
17635
17817
|
}
|
|
17636
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17818
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L132, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17637
17819
|
var parameters = $3;
|
|
17638
17820
|
return {
|
|
17639
17821
|
type: "TypeParameters",
|
|
@@ -17687,7 +17869,7 @@ ${input.slice(result.pos)}
|
|
|
17687
17869
|
return result;
|
|
17688
17870
|
}
|
|
17689
17871
|
}
|
|
17690
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17872
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L120, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17691
17873
|
function TypeConstraint(state) {
|
|
17692
17874
|
let eventData;
|
|
17693
17875
|
if (state.events) {
|
|
@@ -17734,7 +17916,7 @@ ${input.slice(result.pos)}
|
|
|
17734
17916
|
}
|
|
17735
17917
|
}
|
|
17736
17918
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17737
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17919
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17738
17920
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17739
17921
|
return value[1];
|
|
17740
17922
|
});
|
|
@@ -17838,7 +18020,7 @@ ${input.slice(result.pos)}
|
|
|
17838
18020
|
return result;
|
|
17839
18021
|
}
|
|
17840
18022
|
}
|
|
17841
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
18023
|
+
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) {
|
|
17842
18024
|
var options = $3;
|
|
17843
18025
|
return {
|
|
17844
18026
|
type: "CivetPrologue",
|
|
@@ -17999,13 +18181,13 @@ ${input.slice(result.pos)}
|
|
|
17999
18181
|
return result;
|
|
18000
18182
|
}
|
|
18001
18183
|
}
|
|
18002
|
-
var
|
|
18184
|
+
var DebugHere$0 = $TV($EXPECT($L19, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
18003
18185
|
debugger;
|
|
18004
18186
|
});
|
|
18005
|
-
function
|
|
18187
|
+
function DebugHere(state) {
|
|
18006
18188
|
let eventData;
|
|
18007
18189
|
if (state.events) {
|
|
18008
|
-
const result = state.events.enter?.("
|
|
18190
|
+
const result = state.events.enter?.("DebugHere", state);
|
|
18009
18191
|
if (result) {
|
|
18010
18192
|
if (result.cache)
|
|
18011
18193
|
return result.cache;
|
|
@@ -18013,18 +18195,18 @@ ${input.slice(result.pos)}
|
|
|
18013
18195
|
}
|
|
18014
18196
|
}
|
|
18015
18197
|
if (state.tokenize) {
|
|
18016
|
-
const result = $TOKEN("
|
|
18198
|
+
const result = $TOKEN("DebugHere", state, DebugHere$0(state));
|
|
18017
18199
|
if (state.events)
|
|
18018
|
-
state.events.exit?.("
|
|
18200
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
18019
18201
|
return result;
|
|
18020
18202
|
} else {
|
|
18021
|
-
const result =
|
|
18203
|
+
const result = DebugHere$0(state);
|
|
18022
18204
|
if (state.events)
|
|
18023
|
-
state.events.exit?.("
|
|
18205
|
+
state.events.exit?.("DebugHere", state, result, eventData);
|
|
18024
18206
|
return result;
|
|
18025
18207
|
}
|
|
18026
18208
|
}
|
|
18027
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
18209
|
+
var InsertSemicolon$0 = $TV($EXPECT($L19, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
18028
18210
|
return { $loc, token: ";" };
|
|
18029
18211
|
});
|
|
18030
18212
|
function InsertSemicolon(state) {
|
|
@@ -18049,7 +18231,7 @@ ${input.slice(result.pos)}
|
|
|
18049
18231
|
return result;
|
|
18050
18232
|
}
|
|
18051
18233
|
}
|
|
18052
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
18234
|
+
var InsertOpenParen$0 = $TV($EXPECT($L19, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
18053
18235
|
return { $loc, token: "(" };
|
|
18054
18236
|
});
|
|
18055
18237
|
function InsertOpenParen(state) {
|
|
@@ -18074,7 +18256,7 @@ ${input.slice(result.pos)}
|
|
|
18074
18256
|
return result;
|
|
18075
18257
|
}
|
|
18076
18258
|
}
|
|
18077
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
18259
|
+
var InsertCloseParen$0 = $TV($EXPECT($L19, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
18078
18260
|
return { $loc, token: ")" };
|
|
18079
18261
|
});
|
|
18080
18262
|
function InsertCloseParen(state) {
|
|
@@ -18099,7 +18281,7 @@ ${input.slice(result.pos)}
|
|
|
18099
18281
|
return result;
|
|
18100
18282
|
}
|
|
18101
18283
|
}
|
|
18102
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
18284
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18103
18285
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
18104
18286
|
});
|
|
18105
18287
|
function InsertOpenBrace(state) {
|
|
@@ -18124,7 +18306,7 @@ ${input.slice(result.pos)}
|
|
|
18124
18306
|
return result;
|
|
18125
18307
|
}
|
|
18126
18308
|
}
|
|
18127
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
18309
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L19, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
18128
18310
|
return { $loc, token: "{" };
|
|
18129
18311
|
});
|
|
18130
18312
|
function InsertInlineOpenBrace(state) {
|
|
@@ -18149,7 +18331,7 @@ ${input.slice(result.pos)}
|
|
|
18149
18331
|
return result;
|
|
18150
18332
|
}
|
|
18151
18333
|
}
|
|
18152
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
18334
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L19, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
18153
18335
|
return { $loc, token: "}" };
|
|
18154
18336
|
});
|
|
18155
18337
|
function InsertCloseBrace(state) {
|
|
@@ -18174,7 +18356,7 @@ ${input.slice(result.pos)}
|
|
|
18174
18356
|
return result;
|
|
18175
18357
|
}
|
|
18176
18358
|
}
|
|
18177
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
18359
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L19, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
18178
18360
|
return { $loc, token: "[" };
|
|
18179
18361
|
});
|
|
18180
18362
|
function InsertOpenBracket(state) {
|
|
@@ -18199,7 +18381,7 @@ ${input.slice(result.pos)}
|
|
|
18199
18381
|
return result;
|
|
18200
18382
|
}
|
|
18201
18383
|
}
|
|
18202
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
18384
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L19, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
18203
18385
|
return { $loc, token: "]" };
|
|
18204
18386
|
});
|
|
18205
18387
|
function InsertCloseBracket(state) {
|
|
@@ -18224,7 +18406,7 @@ ${input.slice(result.pos)}
|
|
|
18224
18406
|
return result;
|
|
18225
18407
|
}
|
|
18226
18408
|
}
|
|
18227
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
18409
|
+
var InsertComma$0 = $TV($EXPECT($L19, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
18228
18410
|
return { $loc, token: "," };
|
|
18229
18411
|
});
|
|
18230
18412
|
function InsertComma(state) {
|
|
@@ -18249,7 +18431,7 @@ ${input.slice(result.pos)}
|
|
|
18249
18431
|
return result;
|
|
18250
18432
|
}
|
|
18251
18433
|
}
|
|
18252
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
18434
|
+
var InsertConst$0 = $TV($EXPECT($L19, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
18253
18435
|
return { $loc, token: "const " };
|
|
18254
18436
|
});
|
|
18255
18437
|
function InsertConst(state) {
|
|
@@ -18274,7 +18456,7 @@ ${input.slice(result.pos)}
|
|
|
18274
18456
|
return result;
|
|
18275
18457
|
}
|
|
18276
18458
|
}
|
|
18277
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
18459
|
+
var InsertLet$0 = $TV($EXPECT($L19, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
18278
18460
|
return { $loc, token: "let " };
|
|
18279
18461
|
});
|
|
18280
18462
|
function InsertLet(state) {
|
|
@@ -18299,7 +18481,7 @@ ${input.slice(result.pos)}
|
|
|
18299
18481
|
return result;
|
|
18300
18482
|
}
|
|
18301
18483
|
}
|
|
18302
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
18484
|
+
var InsertReadonly$0 = $TV($EXPECT($L19, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
18303
18485
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
18304
18486
|
});
|
|
18305
18487
|
function InsertReadonly(state) {
|
|
@@ -18324,7 +18506,7 @@ ${input.slice(result.pos)}
|
|
|
18324
18506
|
return result;
|
|
18325
18507
|
}
|
|
18326
18508
|
}
|
|
18327
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
18509
|
+
var InsertNewline$0 = $TV($EXPECT($L19, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
18328
18510
|
return "\n";
|
|
18329
18511
|
});
|
|
18330
18512
|
function InsertNewline(state) {
|
|
@@ -18349,7 +18531,7 @@ ${input.slice(result.pos)}
|
|
|
18349
18531
|
return result;
|
|
18350
18532
|
}
|
|
18351
18533
|
}
|
|
18352
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
18534
|
+
var InsertIndent$0 = $TV($EXPECT($L19, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
18353
18535
|
return module.currentIndent.token;
|
|
18354
18536
|
});
|
|
18355
18537
|
function InsertIndent(state) {
|
|
@@ -18374,7 +18556,7 @@ ${input.slice(result.pos)}
|
|
|
18374
18556
|
return result;
|
|
18375
18557
|
}
|
|
18376
18558
|
}
|
|
18377
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
18559
|
+
var InsertSpace$0 = $TV($EXPECT($L19, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
18378
18560
|
return { $loc, token: " " };
|
|
18379
18561
|
});
|
|
18380
18562
|
function InsertSpace(state) {
|
|
@@ -18399,7 +18581,7 @@ ${input.slice(result.pos)}
|
|
|
18399
18581
|
return result;
|
|
18400
18582
|
}
|
|
18401
18583
|
}
|
|
18402
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
18584
|
+
var InsertDot$0 = $TV($EXPECT($L19, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
18403
18585
|
return { $loc, token: "." };
|
|
18404
18586
|
});
|
|
18405
18587
|
function InsertDot(state) {
|
|
@@ -18424,7 +18606,7 @@ ${input.slice(result.pos)}
|
|
|
18424
18606
|
return result;
|
|
18425
18607
|
}
|
|
18426
18608
|
}
|
|
18427
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18609
|
+
var InsertBreak$0 = $TV($EXPECT($L19, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
18428
18610
|
return { $loc, token: ";break;" };
|
|
18429
18611
|
});
|
|
18430
18612
|
function InsertBreak(state) {
|
|
@@ -18449,7 +18631,7 @@ ${input.slice(result.pos)}
|
|
|
18449
18631
|
return result;
|
|
18450
18632
|
}
|
|
18451
18633
|
}
|
|
18452
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18634
|
+
var InsertVar$0 = $TV($EXPECT($L19, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
18453
18635
|
return { $loc, token: "var " };
|
|
18454
18636
|
});
|
|
18455
18637
|
function InsertVar(state) {
|
|
@@ -18474,7 +18656,7 @@ ${input.slice(result.pos)}
|
|
|
18474
18656
|
return result;
|
|
18475
18657
|
}
|
|
18476
18658
|
}
|
|
18477
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18659
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18478
18660
|
if (module.config.coffeeBinaryExistential)
|
|
18479
18661
|
return;
|
|
18480
18662
|
return $skip;
|
|
@@ -18501,7 +18683,7 @@ ${input.slice(result.pos)}
|
|
|
18501
18683
|
return result;
|
|
18502
18684
|
}
|
|
18503
18685
|
}
|
|
18504
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18686
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18505
18687
|
if (module.config.coffeeBooleans)
|
|
18506
18688
|
return;
|
|
18507
18689
|
return $skip;
|
|
@@ -18528,7 +18710,7 @@ ${input.slice(result.pos)}
|
|
|
18528
18710
|
return result;
|
|
18529
18711
|
}
|
|
18530
18712
|
}
|
|
18531
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18713
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18532
18714
|
if (module.config.coffeeClasses)
|
|
18533
18715
|
return;
|
|
18534
18716
|
return $skip;
|
|
@@ -18555,7 +18737,7 @@ ${input.slice(result.pos)}
|
|
|
18555
18737
|
return result;
|
|
18556
18738
|
}
|
|
18557
18739
|
}
|
|
18558
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18740
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18559
18741
|
if (module.config.coffeeComment)
|
|
18560
18742
|
return;
|
|
18561
18743
|
return $skip;
|
|
@@ -18582,7 +18764,7 @@ ${input.slice(result.pos)}
|
|
|
18582
18764
|
return result;
|
|
18583
18765
|
}
|
|
18584
18766
|
}
|
|
18585
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18767
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18586
18768
|
if (module.config.coffeeDo)
|
|
18587
18769
|
return;
|
|
18588
18770
|
return $skip;
|
|
@@ -18609,7 +18791,7 @@ ${input.slice(result.pos)}
|
|
|
18609
18791
|
return result;
|
|
18610
18792
|
}
|
|
18611
18793
|
}
|
|
18612
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18794
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18613
18795
|
if (module.config.coffeeForLoops)
|
|
18614
18796
|
return;
|
|
18615
18797
|
return $skip;
|
|
@@ -18636,7 +18818,7 @@ ${input.slice(result.pos)}
|
|
|
18636
18818
|
return result;
|
|
18637
18819
|
}
|
|
18638
18820
|
}
|
|
18639
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18821
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18640
18822
|
if (module.config.coffeeInterpolation)
|
|
18641
18823
|
return;
|
|
18642
18824
|
return $skip;
|
|
@@ -18663,7 +18845,7 @@ ${input.slice(result.pos)}
|
|
|
18663
18845
|
return result;
|
|
18664
18846
|
}
|
|
18665
18847
|
}
|
|
18666
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18848
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18667
18849
|
if (module.config.coffeeIsnt)
|
|
18668
18850
|
return;
|
|
18669
18851
|
return $skip;
|
|
@@ -18690,7 +18872,7 @@ ${input.slice(result.pos)}
|
|
|
18690
18872
|
return result;
|
|
18691
18873
|
}
|
|
18692
18874
|
}
|
|
18693
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18875
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18694
18876
|
if (module.config.coffeeJSX)
|
|
18695
18877
|
return;
|
|
18696
18878
|
return $skip;
|
|
@@ -18717,7 +18899,7 @@ ${input.slice(result.pos)}
|
|
|
18717
18899
|
return result;
|
|
18718
18900
|
}
|
|
18719
18901
|
}
|
|
18720
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18902
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18721
18903
|
if (module.config.coffeeLineContinuation)
|
|
18722
18904
|
return;
|
|
18723
18905
|
return $skip;
|
|
@@ -18744,7 +18926,7 @@ ${input.slice(result.pos)}
|
|
|
18744
18926
|
return result;
|
|
18745
18927
|
}
|
|
18746
18928
|
}
|
|
18747
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18929
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18748
18930
|
if (module.config.coffeeNot)
|
|
18749
18931
|
return;
|
|
18750
18932
|
return $skip;
|
|
@@ -18771,7 +18953,7 @@ ${input.slice(result.pos)}
|
|
|
18771
18953
|
return result;
|
|
18772
18954
|
}
|
|
18773
18955
|
}
|
|
18774
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18956
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18775
18957
|
if (module.config.coffeeOf)
|
|
18776
18958
|
return;
|
|
18777
18959
|
return $skip;
|
|
@@ -18798,7 +18980,7 @@ ${input.slice(result.pos)}
|
|
|
18798
18980
|
return result;
|
|
18799
18981
|
}
|
|
18800
18982
|
}
|
|
18801
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18983
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L19, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18802
18984
|
if (module.config.coffeePrototype)
|
|
18803
18985
|
return;
|
|
18804
18986
|
return $skip;
|
|
@@ -18825,7 +19007,7 @@ ${input.slice(result.pos)}
|
|
|
18825
19007
|
return result;
|
|
18826
19008
|
}
|
|
18827
19009
|
}
|
|
18828
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
19010
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L19, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18829
19011
|
if (module.config.objectIs)
|
|
18830
19012
|
return;
|
|
18831
19013
|
return $skip;
|
|
@@ -18852,7 +19034,7 @@ ${input.slice(result.pos)}
|
|
|
18852
19034
|
return result;
|
|
18853
19035
|
}
|
|
18854
19036
|
}
|
|
18855
|
-
var Reset$0 = $TV($EXPECT($
|
|
19037
|
+
var Reset$0 = $TV($EXPECT($L19, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18856
19038
|
module.indentLevels = [{
|
|
18857
19039
|
level: 0,
|
|
18858
19040
|
token: ""
|
|
@@ -19159,7 +19341,7 @@ ${input.slice(result.pos)}
|
|
|
19159
19341
|
return result;
|
|
19160
19342
|
}
|
|
19161
19343
|
}
|
|
19162
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
19344
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L19, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
19163
19345
|
var directives = $2;
|
|
19164
19346
|
directives.forEach((directive) => {
|
|
19165
19347
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19462,6 +19644,12 @@ ${input.slice(result.pos)}
|
|
|
19462
19644
|
return;
|
|
19463
19645
|
}
|
|
19464
19646
|
}
|
|
19647
|
+
function getIndent(statement) {
|
|
19648
|
+
let indent = statement?.[0];
|
|
19649
|
+
if (Array.isArray(indent))
|
|
19650
|
+
indent = indent[indent.length - 1];
|
|
19651
|
+
return indent;
|
|
19652
|
+
}
|
|
19465
19653
|
function insertReturn(node) {
|
|
19466
19654
|
if (!node)
|
|
19467
19655
|
return;
|
|
@@ -19486,9 +19674,7 @@ ${input.slice(result.pos)}
|
|
|
19486
19674
|
const [, exp, semi] = node;
|
|
19487
19675
|
if (semi?.type === "SemicolonDelimiter")
|
|
19488
19676
|
return;
|
|
19489
|
-
let indent = node
|
|
19490
|
-
if (Array.isArray(indent))
|
|
19491
|
-
indent = indent[indent.length - 1];
|
|
19677
|
+
let indent = getIndent(node);
|
|
19492
19678
|
if (!exp)
|
|
19493
19679
|
return;
|
|
19494
19680
|
switch (exp.type) {
|
|
@@ -19877,7 +20063,12 @@ ${input.slice(result.pos)}
|
|
|
19877
20063
|
names
|
|
19878
20064
|
};
|
|
19879
20065
|
}
|
|
19880
|
-
|
|
20066
|
+
return {
|
|
20067
|
+
children: [{
|
|
20068
|
+
type: "Error",
|
|
20069
|
+
message: "Multiple rest properties in object pattern"
|
|
20070
|
+
}, props2]
|
|
20071
|
+
};
|
|
19881
20072
|
};
|
|
19882
20073
|
function gatherNodes(node, predicate) {
|
|
19883
20074
|
if (node == null)
|
|
@@ -19903,12 +20094,14 @@ ${input.slice(result.pos)}
|
|
|
19903
20094
|
}
|
|
19904
20095
|
return [];
|
|
19905
20096
|
}
|
|
19906
|
-
function gatherRecursive(node, predicate) {
|
|
20097
|
+
function gatherRecursive(node, predicate, skipPredicate) {
|
|
19907
20098
|
if (node == null)
|
|
19908
20099
|
return [];
|
|
19909
20100
|
if (Array.isArray(node)) {
|
|
19910
20101
|
return node.flatMap((n) => gatherRecursive(n, predicate));
|
|
19911
20102
|
}
|
|
20103
|
+
if (skipPredicate?.(node))
|
|
20104
|
+
return [];
|
|
19912
20105
|
if (predicate(node)) {
|
|
19913
20106
|
return [node];
|
|
19914
20107
|
}
|
|
@@ -19926,6 +20119,36 @@ ${input.slice(result.pos)}
|
|
|
19926
20119
|
}
|
|
19927
20120
|
return nodes;
|
|
19928
20121
|
}
|
|
20122
|
+
function isFunction({ type }) {
|
|
20123
|
+
return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition";
|
|
20124
|
+
}
|
|
20125
|
+
function gatherRecursiveWithinFunction(node, predicate) {
|
|
20126
|
+
return gatherRecursive(node, predicate, isFunction);
|
|
20127
|
+
}
|
|
20128
|
+
function addParentPointers(node, parent) {
|
|
20129
|
+
if (node == null)
|
|
20130
|
+
return;
|
|
20131
|
+
if (typeof node !== "object")
|
|
20132
|
+
return;
|
|
20133
|
+
node.parent = parent;
|
|
20134
|
+
if (Array.isArray(node)) {
|
|
20135
|
+
for (const child of node) {
|
|
20136
|
+
addParentPointers(child, node);
|
|
20137
|
+
}
|
|
20138
|
+
} else if (node.children) {
|
|
20139
|
+
for (const child of node.children) {
|
|
20140
|
+
addParentPointers(child, node);
|
|
20141
|
+
}
|
|
20142
|
+
}
|
|
20143
|
+
}
|
|
20144
|
+
function findAncestor(node, predicate, stopPredicate) {
|
|
20145
|
+
node = node.parent;
|
|
20146
|
+
while (node && !stopPredicate?.(node)) {
|
|
20147
|
+
if (predicate(node))
|
|
20148
|
+
return node;
|
|
20149
|
+
node = node.parent;
|
|
20150
|
+
}
|
|
20151
|
+
}
|
|
19929
20152
|
function processParams(f) {
|
|
19930
20153
|
const { type, parameters, block } = f;
|
|
19931
20154
|
if (type === "ArrowFunction" && parameters && parameters.tp && parameters.tp.parameters.length === 1) {
|
|
@@ -19971,26 +20194,89 @@ ${input.slice(result.pos)}
|
|
|
19971
20194
|
}
|
|
19972
20195
|
});
|
|
19973
20196
|
}
|
|
20197
|
+
function processReturnValue(func) {
|
|
20198
|
+
const { block } = func;
|
|
20199
|
+
const values = gatherRecursiveWithinFunction(
|
|
20200
|
+
block,
|
|
20201
|
+
({ type }) => type === "ReturnValue"
|
|
20202
|
+
);
|
|
20203
|
+
if (!values.length)
|
|
20204
|
+
return false;
|
|
20205
|
+
const ref = {
|
|
20206
|
+
type: "Ref",
|
|
20207
|
+
base: "ret",
|
|
20208
|
+
id: "ret"
|
|
20209
|
+
};
|
|
20210
|
+
let declared;
|
|
20211
|
+
values.forEach((value) => {
|
|
20212
|
+
value.children = [ref];
|
|
20213
|
+
const ancestor = findAncestor(
|
|
20214
|
+
value,
|
|
20215
|
+
({ type }) => type === "Declaration",
|
|
20216
|
+
isFunction
|
|
20217
|
+
);
|
|
20218
|
+
if (ancestor)
|
|
20219
|
+
declared = true;
|
|
20220
|
+
});
|
|
20221
|
+
if (!declared) {
|
|
20222
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
20223
|
+
if (returnType) {
|
|
20224
|
+
const { t } = returnType;
|
|
20225
|
+
if (t.type === "TypePredicate") {
|
|
20226
|
+
returnType = ": boolean";
|
|
20227
|
+
} else if (t.type === "AssertsType") {
|
|
20228
|
+
returnType = void 0;
|
|
20229
|
+
}
|
|
20230
|
+
}
|
|
20231
|
+
block.expressions.unshift([
|
|
20232
|
+
getIndent(block.expressions[0]),
|
|
20233
|
+
{
|
|
20234
|
+
type: "Declaration",
|
|
20235
|
+
children: ["let ", ref, returnType, ";\n"],
|
|
20236
|
+
names: []
|
|
20237
|
+
}
|
|
20238
|
+
]);
|
|
20239
|
+
}
|
|
20240
|
+
gatherRecursiveWithinFunction(
|
|
20241
|
+
block,
|
|
20242
|
+
(r) => r.type === "ReturnStatement" && !r.expression
|
|
20243
|
+
).forEach((r) => {
|
|
20244
|
+
r.expression = ref;
|
|
20245
|
+
r.children.splice(-1, 1, " ", ref);
|
|
20246
|
+
});
|
|
20247
|
+
if (block.children.at(-2)?.type !== "ReturnStatement") {
|
|
20248
|
+
block.expressions.push([
|
|
20249
|
+
["\n", getIndent(block.expressions.at(-1))],
|
|
20250
|
+
{
|
|
20251
|
+
type: "ReturnStatement",
|
|
20252
|
+
expression: ref,
|
|
20253
|
+
children: ["return ", ref]
|
|
20254
|
+
}
|
|
20255
|
+
]);
|
|
20256
|
+
}
|
|
20257
|
+
return true;
|
|
20258
|
+
}
|
|
20259
|
+
function isVoidType(t) {
|
|
20260
|
+
return t?.type === "LiteralType" && t.t.type === "VoidType";
|
|
20261
|
+
}
|
|
19974
20262
|
function processFunctions(statements) {
|
|
19975
|
-
gatherRecursiveAll(statements, (
|
|
19976
|
-
return n.type === "FunctionExpression" || n.type === "ArrowFunction";
|
|
19977
|
-
}).forEach((f) => {
|
|
20263
|
+
gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
|
|
19978
20264
|
processParams(f);
|
|
19979
|
-
|
|
19980
|
-
|
|
19981
|
-
const isVoid = returnType
|
|
20265
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20266
|
+
const { block, returnType } = f;
|
|
20267
|
+
const isVoid = isVoidType(returnType?.t);
|
|
19982
20268
|
const isBlock = block?.type === "BlockStatement";
|
|
19983
20269
|
if (!isVoid && isBlock) {
|
|
19984
20270
|
insertReturn(block);
|
|
19985
20271
|
}
|
|
19986
20272
|
}
|
|
19987
20273
|
});
|
|
19988
|
-
gatherRecursiveAll(statements, (
|
|
20274
|
+
gatherRecursiveAll(statements, ({ type }) => type === "MethodDefinition").forEach((f) => {
|
|
19989
20275
|
processParams(f);
|
|
19990
|
-
|
|
19991
|
-
|
|
20276
|
+
if (!processReturnValue(f) && module.config.implicitReturns) {
|
|
20277
|
+
const { signature, block } = f;
|
|
19992
20278
|
const isConstructor = signature.name === "constructor";
|
|
19993
|
-
const isVoid = signature.returnType
|
|
20279
|
+
const isVoid = isVoidType(signature.returnType?.t);
|
|
19994
20280
|
const isSet = signature.modifier === "set";
|
|
19995
20281
|
if (!isConstructor && !isSet && !isVoid) {
|
|
19996
20282
|
insertReturn(block);
|
|
@@ -20478,6 +20764,7 @@ ${input.slice(result.pos)}
|
|
|
20478
20764
|
});
|
|
20479
20765
|
}
|
|
20480
20766
|
module.processProgram = function(statements) {
|
|
20767
|
+
addParentPointers(statements);
|
|
20481
20768
|
processPipelineExpressions(statements);
|
|
20482
20769
|
processAssignments(statements);
|
|
20483
20770
|
processFunctions(statements);
|
|
@@ -20504,18 +20791,7 @@ ${input.slice(result.pos)}
|
|
|
20504
20791
|
return new Set(declarationNames);
|
|
20505
20792
|
}
|
|
20506
20793
|
function populateRefs(statements) {
|
|
20507
|
-
const refNodes =
|
|
20508
|
-
const blockNodes = new Set(gatherNodes(statements, ({ type }) => type === "BlockStatement"));
|
|
20509
|
-
const forNodes = gatherNodes(statements, ({ type }) => type === "ForStatement");
|
|
20510
|
-
forNodes.forEach(({ declaration, block }) => {
|
|
20511
|
-
if (block.type === "BlockStatement") {
|
|
20512
|
-
populateRefs([declaration, ...block.children]);
|
|
20513
|
-
} else {
|
|
20514
|
-
populateRefs([declaration, ...block]);
|
|
20515
|
-
}
|
|
20516
|
-
blockNodes.delete(block);
|
|
20517
|
-
});
|
|
20518
|
-
blockNodes.forEach(({ expressions }) => populateRefs(expressions));
|
|
20794
|
+
const refNodes = gatherRecursive(statements, ({ type }) => type === "Ref");
|
|
20519
20795
|
if (refNodes.length) {
|
|
20520
20796
|
const ids = gatherRecursive(statements, (s) => s.type === "Identifier");
|
|
20521
20797
|
const names = new Set(ids.flatMap(({ names: names2 }) => names2 || []));
|
|
@@ -20921,7 +21197,7 @@ ${input.slice(result.pos)}
|
|
|
20921
21197
|
return result;
|
|
20922
21198
|
}
|
|
20923
21199
|
}
|
|
20924
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
21200
|
+
var PopIndent$0 = $TV($EXPECT($L19, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
20925
21201
|
if (module.config.verbose) {
|
|
20926
21202
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
20927
21203
|
}
|
|
@@ -21060,6 +21336,9 @@ var prune = function(node) {
|
|
|
21060
21336
|
if (node.length === 0) {
|
|
21061
21337
|
return;
|
|
21062
21338
|
}
|
|
21339
|
+
if (node.parent != null) {
|
|
21340
|
+
delete node.parent;
|
|
21341
|
+
}
|
|
21063
21342
|
if (Array.isArray(node)) {
|
|
21064
21343
|
a = node.map(function(n) {
|
|
21065
21344
|
return prune(n);
|
|
@@ -21450,7 +21729,9 @@ ${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode2(JSON.stri
|
|
|
21450
21729
|
}
|
|
21451
21730
|
result = generate_default(ast, options);
|
|
21452
21731
|
if ((ref = options.errors) != null ? ref.length : void 0) {
|
|
21453
|
-
throw new Error(`Parse errors: ${options.errors.
|
|
21732
|
+
throw new Error(`Parse errors: ${options.errors.map(function(e) {
|
|
21733
|
+
return e.message;
|
|
21734
|
+
}).join("\n")} `);
|
|
21454
21735
|
}
|
|
21455
21736
|
return result;
|
|
21456
21737
|
};
|