@danielx/civet 0.5.65 → 0.5.66
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 +724 -560
- package/dist/main.js +724 -560
- package/dist/main.mjs +724 -560
- package/package.json +1 -1
package/dist/main.mjs
CHANGED
|
@@ -623,6 +623,8 @@ ${input.slice(result.pos)}
|
|
|
623
623
|
CoffeeWordAssignmentOp,
|
|
624
624
|
BinaryOp,
|
|
625
625
|
BinaryOpSymbol,
|
|
626
|
+
Xor,
|
|
627
|
+
Xnor,
|
|
626
628
|
UnaryOp,
|
|
627
629
|
ModuleItem,
|
|
628
630
|
StatementListItem,
|
|
@@ -1019,225 +1021,231 @@ ${input.slice(result.pos)}
|
|
|
1019
1021
|
var $L12 = $L("super");
|
|
1020
1022
|
var $L13 = $L("import");
|
|
1021
1023
|
var $L14 = $L("!");
|
|
1022
|
-
var $L15 = $L("
|
|
1023
|
-
var $L16 = $L("
|
|
1024
|
-
var $L17 = $L("");
|
|
1025
|
-
var $L18 = $L("
|
|
1026
|
-
var $L19 = $L("
|
|
1027
|
-
var $L20 = $L("
|
|
1028
|
-
var $L21 = $L("
|
|
1029
|
-
var $L22 = $L("
|
|
1030
|
-
var $L23 = $L("
|
|
1031
|
-
var $L24 = $L("
|
|
1032
|
-
var $L25 = $L("
|
|
1033
|
-
var $L26 = $L("
|
|
1034
|
-
var $L27 = $L("
|
|
1035
|
-
var $L28 = $L("
|
|
1036
|
-
var $L29 = $L("
|
|
1037
|
-
var $L30 = $L("
|
|
1038
|
-
var $L31 = $L("
|
|
1039
|
-
var $L32 = $L("
|
|
1040
|
-
var $L33 = $L("
|
|
1041
|
-
var $L34 = $L("
|
|
1042
|
-
var $L35 = $L("
|
|
1043
|
-
var $L36 = $L("
|
|
1044
|
-
var $L37 = $L("
|
|
1045
|
-
var $L38 = $L("
|
|
1046
|
-
var $L39 = $L("
|
|
1047
|
-
var $L40 = $L("
|
|
1048
|
-
var $L41 = $L("
|
|
1049
|
-
var $L42 = $L("
|
|
1050
|
-
var $L43 = $L("
|
|
1051
|
-
var $L44 = $L("
|
|
1052
|
-
var $L45 = $L("
|
|
1053
|
-
var $L46 = $L("
|
|
1054
|
-
var $L47 = $L("
|
|
1055
|
-
var $L48 = $L("
|
|
1056
|
-
var $L49 = $L("
|
|
1057
|
-
var $L50 = $L("
|
|
1058
|
-
var $L51 = $L("
|
|
1059
|
-
var $L52 = $L("
|
|
1060
|
-
var $L53 = $L("
|
|
1061
|
-
var $L54 = $L("
|
|
1062
|
-
var $L55 = $L("
|
|
1063
|
-
var $L56 = $L("
|
|
1064
|
-
var $L57 = $L("
|
|
1065
|
-
var $L58 = $L("
|
|
1066
|
-
var $L59 = $L("
|
|
1067
|
-
var $L60 = $L("
|
|
1068
|
-
var $L61 = $L("
|
|
1069
|
-
var $L62 = $L("
|
|
1070
|
-
var $L63 = $L("
|
|
1071
|
-
var $L64 = $L("
|
|
1072
|
-
var $L65 = $L("
|
|
1073
|
-
var $L66 = $L("
|
|
1074
|
-
var $L67 = $L("
|
|
1075
|
-
var $L68 = $L("
|
|
1076
|
-
var $L69 = $L("
|
|
1077
|
-
var $L70 = $L("
|
|
1078
|
-
var $L71 = $L("
|
|
1079
|
-
var $L72 = $L("
|
|
1080
|
-
var $L73 = $L("
|
|
1081
|
-
var $L74 = $L("
|
|
1082
|
-
var $L75 = $L("
|
|
1083
|
-
var $L76 = $L("
|
|
1084
|
-
var $L77 = $L("
|
|
1085
|
-
var $L78 = $L("
|
|
1086
|
-
var $L79 = $L("
|
|
1087
|
-
var $L80 = $L("
|
|
1088
|
-
var $L81 = $L("
|
|
1089
|
-
var $L82 = $L("
|
|
1090
|
-
var $L83 = $L("
|
|
1091
|
-
var $L84 = $L("
|
|
1092
|
-
var $L85 = $L("
|
|
1093
|
-
var $L86 = $L("
|
|
1094
|
-
var $L87 = $L("
|
|
1095
|
-
var $L88 = $L("
|
|
1096
|
-
var $L89 = $L("
|
|
1097
|
-
var $L90 = $L("
|
|
1098
|
-
var $L91 = $L("
|
|
1099
|
-
var $L92 = $L("
|
|
1100
|
-
var $L93 = $L("
|
|
1101
|
-
var $L94 = $L("
|
|
1102
|
-
var $L95 = $L("
|
|
1103
|
-
var $L96 = $L("
|
|
1104
|
-
var $L97 = $L("
|
|
1105
|
-
var $L98 = $L("
|
|
1106
|
-
var $L99 = $L("
|
|
1107
|
-
var $L100 = $L("
|
|
1108
|
-
var $L101 = $L("
|
|
1109
|
-
var $L102 = $L("
|
|
1110
|
-
var $L103 = $L("
|
|
1111
|
-
var $L104 = $L("
|
|
1112
|
-
var $L105 = $L("
|
|
1113
|
-
var $L106 = $L("
|
|
1114
|
-
var $L107 = $L("
|
|
1115
|
-
var $L108 = $L("
|
|
1116
|
-
var $L109 = $L("
|
|
1117
|
-
var $L110 = $L("
|
|
1118
|
-
var $L111 = $L("
|
|
1119
|
-
var $L112 = $L(
|
|
1120
|
-
var $L113 = $L("
|
|
1121
|
-
var $L114 = $L("
|
|
1122
|
-
var $L115 = $L("
|
|
1123
|
-
var $L116 = $L("
|
|
1124
|
-
var $L117 = $L("
|
|
1125
|
-
var $L118 = $L("
|
|
1126
|
-
var $L119 = $L("
|
|
1127
|
-
var $L120 = $L("
|
|
1128
|
-
var $L121 = $L("
|
|
1129
|
-
var $L122 = $L("
|
|
1130
|
-
var $L123 = $L("
|
|
1131
|
-
var $L124 = $L("
|
|
1132
|
-
var $L125 = $L("
|
|
1133
|
-
var $L126 = $L("
|
|
1134
|
-
var $L127 = $L("
|
|
1135
|
-
var $L128 = $L("
|
|
1136
|
-
var $L129 = $L("
|
|
1137
|
-
var $L130 = $L("
|
|
1138
|
-
var $L131 = $L("
|
|
1139
|
-
var $L132 = $L("
|
|
1140
|
-
var $L133 = $L("
|
|
1141
|
-
var $L134 = $L("
|
|
1142
|
-
var $L135 = $L("
|
|
1143
|
-
var $L136 = $L("
|
|
1144
|
-
var $L137 = $L("
|
|
1145
|
-
var $L138 = $L("
|
|
1146
|
-
var $L139 = $L("
|
|
1147
|
-
var $L140 = $L("
|
|
1148
|
-
var $L141 = $L("
|
|
1149
|
-
var $L142 = $L("
|
|
1150
|
-
var $L143 = $L("
|
|
1151
|
-
var $L144 = $L("
|
|
1152
|
-
var $L145 = $L(
|
|
1153
|
-
var $L146 = $L("
|
|
1154
|
-
var $L147 = $L("
|
|
1155
|
-
var $L148 = $L("
|
|
1156
|
-
var $L149 = $L("
|
|
1157
|
-
var $L150 = $L("
|
|
1158
|
-
var $L151 = $L("
|
|
1159
|
-
var $L152 = $L("
|
|
1160
|
-
var $L153 = $L("
|
|
1161
|
-
var $L154 = $L("
|
|
1162
|
-
var $L155 = $L("
|
|
1163
|
-
var $L156 = $L("
|
|
1164
|
-
var $L157 = $L("
|
|
1165
|
-
var $L158 = $L("
|
|
1166
|
-
var $L159 = $L("
|
|
1167
|
-
var $L160 = $L("
|
|
1168
|
-
var $L161 = $L("
|
|
1169
|
-
var $L162 = $L("
|
|
1170
|
-
var $L163 = $L("
|
|
1171
|
-
var $L164 = $L("
|
|
1172
|
-
var $L165 = $L("
|
|
1173
|
-
var $L166 = $L("
|
|
1174
|
-
var $L167 = $L("
|
|
1175
|
-
var $L168 = $L("
|
|
1176
|
-
var $L169 = $L("
|
|
1177
|
-
var $L170 = $L("
|
|
1178
|
-
var $L171 = $L("
|
|
1179
|
-
var $
|
|
1024
|
+
var $L15 = $L("^");
|
|
1025
|
+
var $L16 = $L("-");
|
|
1026
|
+
var $L17 = $L("import.meta");
|
|
1027
|
+
var $L18 = $L("");
|
|
1028
|
+
var $L19 = $L(")");
|
|
1029
|
+
var $L20 = $L(",");
|
|
1030
|
+
var $L21 = $L("->");
|
|
1031
|
+
var $L22 = $L("}");
|
|
1032
|
+
var $L23 = $L("null");
|
|
1033
|
+
var $L24 = $L("true");
|
|
1034
|
+
var $L25 = $L("false");
|
|
1035
|
+
var $L26 = $L("yes");
|
|
1036
|
+
var $L27 = $L("on");
|
|
1037
|
+
var $L28 = $L("no");
|
|
1038
|
+
var $L29 = $L("off");
|
|
1039
|
+
var $L30 = $L(">");
|
|
1040
|
+
var $L31 = $L("]");
|
|
1041
|
+
var $L32 = $L(":");
|
|
1042
|
+
var $L33 = $L("**=");
|
|
1043
|
+
var $L34 = $L("*=");
|
|
1044
|
+
var $L35 = $L("/=");
|
|
1045
|
+
var $L36 = $L("%=");
|
|
1046
|
+
var $L37 = $L("+=");
|
|
1047
|
+
var $L38 = $L("-=");
|
|
1048
|
+
var $L39 = $L("<<=");
|
|
1049
|
+
var $L40 = $L(">>>=");
|
|
1050
|
+
var $L41 = $L(">>=");
|
|
1051
|
+
var $L42 = $L("&&=");
|
|
1052
|
+
var $L43 = $L("&=");
|
|
1053
|
+
var $L44 = $L("^=");
|
|
1054
|
+
var $L45 = $L("||=");
|
|
1055
|
+
var $L46 = $L("|=");
|
|
1056
|
+
var $L47 = $L("??=");
|
|
1057
|
+
var $L48 = $L("?=");
|
|
1058
|
+
var $L49 = $L("and=");
|
|
1059
|
+
var $L50 = $L("or=");
|
|
1060
|
+
var $L51 = $L("not");
|
|
1061
|
+
var $L52 = $L("**");
|
|
1062
|
+
var $L53 = $L("*");
|
|
1063
|
+
var $L54 = $L("/");
|
|
1064
|
+
var $L55 = $L("%%");
|
|
1065
|
+
var $L56 = $L("%");
|
|
1066
|
+
var $L57 = $L("+");
|
|
1067
|
+
var $L58 = $L("<=");
|
|
1068
|
+
var $L59 = $L(">=");
|
|
1069
|
+
var $L60 = $L("<?");
|
|
1070
|
+
var $L61 = $L("!<?");
|
|
1071
|
+
var $L62 = $L("<<");
|
|
1072
|
+
var $L63 = $L(">>>");
|
|
1073
|
+
var $L64 = $L(">>");
|
|
1074
|
+
var $L65 = $L("!==");
|
|
1075
|
+
var $L66 = $L("!=");
|
|
1076
|
+
var $L67 = $L("isnt");
|
|
1077
|
+
var $L68 = $L("===");
|
|
1078
|
+
var $L69 = $L("==");
|
|
1079
|
+
var $L70 = $L("and");
|
|
1080
|
+
var $L71 = $L("&&");
|
|
1081
|
+
var $L72 = $L("of");
|
|
1082
|
+
var $L73 = $L("or");
|
|
1083
|
+
var $L74 = $L("||");
|
|
1084
|
+
var $L75 = $L("^^");
|
|
1085
|
+
var $L76 = $L("xor");
|
|
1086
|
+
var $L77 = $L("xnor");
|
|
1087
|
+
var $L78 = $L("??");
|
|
1088
|
+
var $L79 = $L("instanceof");
|
|
1089
|
+
var $L80 = $L("in");
|
|
1090
|
+
var $L81 = $L("is");
|
|
1091
|
+
var $L82 = $L("&");
|
|
1092
|
+
var $L83 = $L("|");
|
|
1093
|
+
var $L84 = $L(";");
|
|
1094
|
+
var $L85 = $L("own");
|
|
1095
|
+
var $L86 = $L("break");
|
|
1096
|
+
var $L87 = $L("continue");
|
|
1097
|
+
var $L88 = $L("debugger");
|
|
1098
|
+
var $L89 = $L("assert");
|
|
1099
|
+
var $L90 = $L(":=");
|
|
1100
|
+
var $L91 = $L(".=");
|
|
1101
|
+
var $L92 = $L("/*");
|
|
1102
|
+
var $L93 = $L("*/");
|
|
1103
|
+
var $L94 = $L("\\");
|
|
1104
|
+
var $L95 = $L("[");
|
|
1105
|
+
var $L96 = $L("`");
|
|
1106
|
+
var $L97 = $L("abstract");
|
|
1107
|
+
var $L98 = $L("as");
|
|
1108
|
+
var $L99 = $L("@");
|
|
1109
|
+
var $L100 = $L("@@");
|
|
1110
|
+
var $L101 = $L("async");
|
|
1111
|
+
var $L102 = $L("await");
|
|
1112
|
+
var $L103 = $L("by");
|
|
1113
|
+
var $L104 = $L("case");
|
|
1114
|
+
var $L105 = $L("catch");
|
|
1115
|
+
var $L106 = $L("class");
|
|
1116
|
+
var $L107 = $L("#{");
|
|
1117
|
+
var $L108 = $L("declare");
|
|
1118
|
+
var $L109 = $L("default");
|
|
1119
|
+
var $L110 = $L("delete");
|
|
1120
|
+
var $L111 = $L("do");
|
|
1121
|
+
var $L112 = $L("..");
|
|
1122
|
+
var $L113 = $L("...");
|
|
1123
|
+
var $L114 = $L("::");
|
|
1124
|
+
var $L115 = $L('"');
|
|
1125
|
+
var $L116 = $L("else");
|
|
1126
|
+
var $L117 = $L("export");
|
|
1127
|
+
var $L118 = $L("extends");
|
|
1128
|
+
var $L119 = $L("finally");
|
|
1129
|
+
var $L120 = $L("for");
|
|
1130
|
+
var $L121 = $L("from");
|
|
1131
|
+
var $L122 = $L("function");
|
|
1132
|
+
var $L123 = $L("get");
|
|
1133
|
+
var $L124 = $L("set");
|
|
1134
|
+
var $L125 = $L("if");
|
|
1135
|
+
var $L126 = $L("let");
|
|
1136
|
+
var $L127 = $L("const");
|
|
1137
|
+
var $L128 = $L("loop");
|
|
1138
|
+
var $L129 = $L("new");
|
|
1139
|
+
var $L130 = $L("<");
|
|
1140
|
+
var $L131 = $L("{");
|
|
1141
|
+
var $L132 = $L("operator");
|
|
1142
|
+
var $L133 = $L("public");
|
|
1143
|
+
var $L134 = $L("private");
|
|
1144
|
+
var $L135 = $L("protected");
|
|
1145
|
+
var $L136 = $L("||>");
|
|
1146
|
+
var $L137 = $L("|>=");
|
|
1147
|
+
var $L138 = $L("|>");
|
|
1148
|
+
var $L139 = $L("readonly");
|
|
1149
|
+
var $L140 = $L("return");
|
|
1150
|
+
var $L141 = $L("satisfies");
|
|
1151
|
+
var $L142 = $L("'");
|
|
1152
|
+
var $L143 = $L("static");
|
|
1153
|
+
var $L144 = $L("${");
|
|
1154
|
+
var $L145 = $L("switch");
|
|
1155
|
+
var $L146 = $L("target");
|
|
1156
|
+
var $L147 = $L("then");
|
|
1157
|
+
var $L148 = $L("this");
|
|
1158
|
+
var $L149 = $L("throw");
|
|
1159
|
+
var $L150 = $L('"""');
|
|
1160
|
+
var $L151 = $L("'''");
|
|
1161
|
+
var $L152 = $L("///");
|
|
1162
|
+
var $L153 = $L("```");
|
|
1163
|
+
var $L154 = $L("try");
|
|
1164
|
+
var $L155 = $L("typeof");
|
|
1165
|
+
var $L156 = $L("unless");
|
|
1166
|
+
var $L157 = $L("until");
|
|
1167
|
+
var $L158 = $L("var");
|
|
1168
|
+
var $L159 = $L("void");
|
|
1169
|
+
var $L160 = $L("when");
|
|
1170
|
+
var $L161 = $L("while");
|
|
1171
|
+
var $L162 = $L("yield");
|
|
1172
|
+
var $L163 = $L("/>");
|
|
1173
|
+
var $L164 = $L("</");
|
|
1174
|
+
var $L165 = $L("<>");
|
|
1175
|
+
var $L166 = $L("</>");
|
|
1176
|
+
var $L167 = $L("<!--");
|
|
1177
|
+
var $L168 = $L("-->");
|
|
1178
|
+
var $L169 = $L("type");
|
|
1179
|
+
var $L170 = $L("interface");
|
|
1180
|
+
var $L171 = $L("namespace");
|
|
1181
|
+
var $L172 = $L("asserts");
|
|
1182
|
+
var $L173 = $L("keyof");
|
|
1183
|
+
var $L174 = $L("infer");
|
|
1184
|
+
var $L175 = $L("[]");
|
|
1185
|
+
var $L176 = $L("civet");
|
|
1186
|
+
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1180
1187
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1181
1188
|
var $R2 = $R(new RegExp("[&]", "suy"));
|
|
1182
1189
|
var $R3 = $R(new RegExp("[!~+-]+", "suy"));
|
|
1183
1190
|
var $R4 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1184
1191
|
var $R5 = $R(new RegExp("[!+-]", "suy"));
|
|
1185
1192
|
var $R6 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
1186
|
-
var $R7 = $R(new RegExp("
|
|
1187
|
-
var $R8 = $R(new RegExp("(
|
|
1188
|
-
var $R9 = $R(new RegExp(
|
|
1189
|
-
var $R10 = $R(new RegExp("
|
|
1190
|
-
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
1191
|
-
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
1192
|
-
var $R13 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1193
|
-
var $R14 = $R(new RegExp("(
|
|
1194
|
-
var $R15 = $R(new RegExp("
|
|
1195
|
-
var $R16 = $R(new RegExp("0[
|
|
1196
|
-
var $R17 = $R(new RegExp("0[
|
|
1197
|
-
var $R18 = $R(new RegExp("
|
|
1198
|
-
var $R19 = $R(new RegExp(
|
|
1199
|
-
var $R20 = $R(new RegExp(
|
|
1200
|
-
var $R21 = $R(new RegExp(
|
|
1201
|
-
var $R22 = $R(new RegExp(
|
|
1202
|
-
var $R23 = $R(new RegExp('(
|
|
1203
|
-
var $R24 = $R(new RegExp(
|
|
1204
|
-
var $R25 = $R(new RegExp("(
|
|
1205
|
-
var $R26 = $R(new RegExp("
|
|
1206
|
-
var $R27 = $R(new RegExp("
|
|
1207
|
-
var $R28 = $R(new RegExp("
|
|
1208
|
-
var $R29 = $R(new RegExp("[
|
|
1209
|
-
var $R30 = $R(new RegExp("
|
|
1210
|
-
var $R31 = $R(new RegExp("(
|
|
1211
|
-
var $R32 = $R(new RegExp("(
|
|
1212
|
-
var $R33 = $R(new RegExp("(?:\\$(?!\\{)
|
|
1213
|
-
var $R34 = $R(new RegExp("(
|
|
1214
|
-
var $R35 = $R(new RegExp("(?:
|
|
1215
|
-
var $R36 = $R(new RegExp("(?:
|
|
1216
|
-
var $R37 = $R(new RegExp("(?:
|
|
1217
|
-
var $R38 = $R(new RegExp("(?:
|
|
1218
|
-
var $R39 = $R(new RegExp("
|
|
1219
|
-
var $R40 = $R(new RegExp("
|
|
1220
|
-
var $R41 = $R(new RegExp("
|
|
1221
|
-
var $R42 = $R(new RegExp("[
|
|
1222
|
-
var $R43 = $R(new RegExp("
|
|
1223
|
-
var $R44 = $R(new RegExp("
|
|
1224
|
-
var $R45 = $R(new RegExp("[
|
|
1225
|
-
var $R46 = $R(new RegExp("
|
|
1226
|
-
var $R47 = $R(new RegExp("
|
|
1227
|
-
var $R48 = $R(new RegExp("
|
|
1228
|
-
var $R49 = $R(new RegExp("[\\
|
|
1229
|
-
var $R50 = $R(new RegExp("
|
|
1230
|
-
var $R51 = $R(new RegExp("[
|
|
1231
|
-
var $R52 = $R(new RegExp("
|
|
1232
|
-
var $R53 = $R(new RegExp("[
|
|
1233
|
-
var $R54 = $R(new RegExp("[
|
|
1234
|
-
var $R55 = $R(new RegExp("[+-]", "suy"));
|
|
1235
|
-
var $R56 = $R(new RegExp("
|
|
1236
|
-
var $R57 = $R(new RegExp("[\\
|
|
1237
|
-
var $R58 = $R(new RegExp("[\\
|
|
1238
|
-
var $R59 = $R(new RegExp("
|
|
1239
|
-
var $R60 = $R(new RegExp("\\
|
|
1240
|
-
var $R61 = $R(new RegExp("
|
|
1193
|
+
var $R7 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
1194
|
+
var $R8 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1195
|
+
var $R9 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
1196
|
+
var $R10 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
1197
|
+
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
1198
|
+
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
1199
|
+
var $R13 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
1200
|
+
var $R14 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1201
|
+
var $R15 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
1202
|
+
var $R16 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
1203
|
+
var $R17 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
1204
|
+
var $R18 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
1205
|
+
var $R19 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1206
|
+
var $R20 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
1207
|
+
var $R21 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
1208
|
+
var $R22 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
1209
|
+
var $R23 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
1210
|
+
var $R24 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
1211
|
+
var $R25 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
1212
|
+
var $R26 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
1213
|
+
var $R27 = $R(new RegExp("[\\s]+", "suy"));
|
|
1214
|
+
var $R28 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
1215
|
+
var $R29 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
1216
|
+
var $R30 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
1217
|
+
var $R31 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
1218
|
+
var $R32 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1219
|
+
var $R33 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
1220
|
+
var $R34 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
1221
|
+
var $R35 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1222
|
+
var $R36 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1223
|
+
var $R37 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1224
|
+
var $R38 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1225
|
+
var $R39 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
1226
|
+
var $R40 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1227
|
+
var $R41 = $R(new RegExp(".", "suy"));
|
|
1228
|
+
var $R42 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
1229
|
+
var $R43 = $R(new RegExp("[^]*?###", "suy"));
|
|
1230
|
+
var $R44 = $R(new RegExp("###(?!#)", "suy"));
|
|
1231
|
+
var $R45 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
1232
|
+
var $R46 = $R(new RegExp("[ \\t]+", "suy"));
|
|
1233
|
+
var $R47 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
1234
|
+
var $R48 = $R(new RegExp("\\s", "suy"));
|
|
1235
|
+
var $R49 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1236
|
+
var $R50 = $R(new RegExp("[\\s>]", "suy"));
|
|
1237
|
+
var $R51 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
1238
|
+
var $R52 = $R(new RegExp("[<>]", "suy"));
|
|
1239
|
+
var $R53 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
1240
|
+
var $R54 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
1241
|
+
var $R55 = $R(new RegExp("[+-]?", "suy"));
|
|
1242
|
+
var $R56 = $R(new RegExp("[+-]", "suy"));
|
|
1243
|
+
var $R57 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1244
|
+
var $R58 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1245
|
+
var $R59 = $R(new RegExp("[\\s]*", "suy"));
|
|
1246
|
+
var $R60 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1247
|
+
var $R61 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1248
|
+
var $R62 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1241
1249
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1242
1250
|
var statements = $4;
|
|
1243
1251
|
module.processProgram(statements);
|
|
@@ -1557,7 +1565,7 @@ ${input.slice(result.pos)}
|
|
|
1557
1565
|
return result;
|
|
1558
1566
|
}
|
|
1559
1567
|
}
|
|
1560
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1568
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1561
1569
|
var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1562
1570
|
var ForbiddenImplicitCalls$2 = AtAt;
|
|
1563
1571
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L1, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -2094,7 +2102,6 @@ ${input.slice(result.pos)}
|
|
|
2094
2102
|
}
|
|
2095
2103
|
}
|
|
2096
2104
|
var NonPipelineAssignmentExpression$0 = SingleLineAssignmentExpression;
|
|
2097
|
-
var NonPipelineAssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
2098
2105
|
function NonPipelineAssignmentExpression(state) {
|
|
2099
2106
|
let eventData;
|
|
2100
2107
|
if (state.events) {
|
|
@@ -2106,12 +2113,12 @@ ${input.slice(result.pos)}
|
|
|
2106
2113
|
}
|
|
2107
2114
|
}
|
|
2108
2115
|
if (state.tokenize) {
|
|
2109
|
-
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state)
|
|
2116
|
+
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state));
|
|
2110
2117
|
if (state.events)
|
|
2111
2118
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2112
2119
|
return result;
|
|
2113
2120
|
} else {
|
|
2114
|
-
const result = NonPipelineAssignmentExpression$0(state)
|
|
2121
|
+
const result = NonPipelineAssignmentExpression$0(state);
|
|
2115
2122
|
if (state.events)
|
|
2116
2123
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2117
2124
|
return result;
|
|
@@ -2483,30 +2490,12 @@ ${input.slice(result.pos)}
|
|
|
2483
2490
|
return result;
|
|
2484
2491
|
}
|
|
2485
2492
|
}
|
|
2486
|
-
var PipelineExpression$0 = $TS($S(
|
|
2493
|
+
var PipelineExpression$0 = $TS($S(PipelineHeadItem, $P($S(__, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2) {
|
|
2487
2494
|
var head = $1;
|
|
2488
2495
|
var body = $2;
|
|
2489
|
-
var preTailWS = $3;
|
|
2490
|
-
var tail = $4;
|
|
2491
|
-
let children = head.slice(0, -1).map(module.skipIfOnlyWS);
|
|
2492
|
-
for (const [leadingComment, expr, trailingComment] of body) {
|
|
2493
|
-
children = module.constructPipeStep(
|
|
2494
|
-
{
|
|
2495
|
-
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
2496
|
-
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
2497
|
-
expr
|
|
2498
|
-
},
|
|
2499
|
-
{ expr: children }
|
|
2500
|
-
);
|
|
2501
|
-
}
|
|
2502
2496
|
return {
|
|
2503
|
-
|
|
2504
|
-
|
|
2505
|
-
leadingComment: module.skipIfOnlyWS(preTailWS),
|
|
2506
|
-
expr: tail
|
|
2507
|
-
},
|
|
2508
|
-
{ expr: children }
|
|
2509
|
-
)
|
|
2497
|
+
type: "PipelineExpression",
|
|
2498
|
+
children: [head, body]
|
|
2510
2499
|
};
|
|
2511
2500
|
});
|
|
2512
2501
|
function PipelineExpression(state) {
|
|
@@ -3365,8 +3354,8 @@ ${input.slice(result.pos)}
|
|
|
3365
3354
|
return result;
|
|
3366
3355
|
}
|
|
3367
3356
|
}
|
|
3368
|
-
var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
|
|
3369
|
-
return { "type": "NonNullAssertion", "ts": true, "children": value };
|
|
3357
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L14, fail, 'NonNullAssertion "!"'), $N($EXPECT($L15, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3358
|
+
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3370
3359
|
});
|
|
3371
3360
|
function NonNullAssertion(state) {
|
|
3372
3361
|
let eventData;
|
|
@@ -3503,7 +3492,7 @@ ${input.slice(result.pos)}
|
|
|
3503
3492
|
]
|
|
3504
3493
|
};
|
|
3505
3494
|
});
|
|
3506
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3495
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L16, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3507
3496
|
var dot = $1;
|
|
3508
3497
|
var neg = $2;
|
|
3509
3498
|
var num = $3;
|
|
@@ -3700,7 +3689,7 @@ ${input.slice(result.pos)}
|
|
|
3700
3689
|
}
|
|
3701
3690
|
}
|
|
3702
3691
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3703
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3692
|
+
var MetaProperty$1 = $TS($S($EXPECT($L17, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3704
3693
|
return { $loc, token: $1 };
|
|
3705
3694
|
});
|
|
3706
3695
|
function MetaProperty(state) {
|
|
@@ -3726,7 +3715,7 @@ ${input.slice(result.pos)}
|
|
|
3726
3715
|
}
|
|
3727
3716
|
}
|
|
3728
3717
|
var Parameters$0 = NonEmptyParameters;
|
|
3729
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3718
|
+
var Parameters$1 = $TV($EXPECT($L18, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3730
3719
|
return {
|
|
3731
3720
|
type: "Parameters",
|
|
3732
3721
|
children: [{ $loc, token: "()" }],
|
|
@@ -3887,7 +3876,7 @@ ${input.slice(result.pos)}
|
|
|
3887
3876
|
}
|
|
3888
3877
|
}
|
|
3889
3878
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3890
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3879
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L19, fail, 'ParameterElementDelimiter ")"')));
|
|
3891
3880
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3892
3881
|
return value[1];
|
|
3893
3882
|
});
|
|
@@ -4507,7 +4496,7 @@ ${input.slice(result.pos)}
|
|
|
4507
4496
|
children: $0
|
|
4508
4497
|
};
|
|
4509
4498
|
});
|
|
4510
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4499
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4511
4500
|
return {
|
|
4512
4501
|
children: [{
|
|
4513
4502
|
type: "ElisionElement",
|
|
@@ -4580,7 +4569,7 @@ ${input.slice(result.pos)}
|
|
|
4580
4569
|
return result;
|
|
4581
4570
|
}
|
|
4582
4571
|
}
|
|
4583
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4572
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L18, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4584
4573
|
const ref = {
|
|
4585
4574
|
type: "Ref",
|
|
4586
4575
|
base: "ref",
|
|
@@ -5056,7 +5045,7 @@ ${input.slice(result.pos)}
|
|
|
5056
5045
|
children: [ws, binding]
|
|
5057
5046
|
};
|
|
5058
5047
|
});
|
|
5059
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5048
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5060
5049
|
return {
|
|
5061
5050
|
children: [{
|
|
5062
5051
|
type: "ElisionElement",
|
|
@@ -5450,7 +5439,7 @@ ${input.slice(result.pos)}
|
|
|
5450
5439
|
return result;
|
|
5451
5440
|
}
|
|
5452
5441
|
}
|
|
5453
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5442
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5454
5443
|
return { $loc, token: $1 };
|
|
5455
5444
|
});
|
|
5456
5445
|
function Arrow(state) {
|
|
@@ -5684,7 +5673,7 @@ ${input.slice(result.pos)}
|
|
|
5684
5673
|
return result;
|
|
5685
5674
|
}
|
|
5686
5675
|
}
|
|
5687
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5676
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L18, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5688
5677
|
const expressions = [];
|
|
5689
5678
|
return {
|
|
5690
5679
|
type: "BlockStatement",
|
|
@@ -5907,7 +5896,7 @@ ${input.slice(result.pos)}
|
|
|
5907
5896
|
children: [$1, expressions]
|
|
5908
5897
|
};
|
|
5909
5898
|
});
|
|
5910
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
5899
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5911
5900
|
const expressions = [];
|
|
5912
5901
|
return {
|
|
5913
5902
|
type: "BlockStatement",
|
|
@@ -6052,7 +6041,7 @@ ${input.slice(result.pos)}
|
|
|
6052
6041
|
return result;
|
|
6053
6042
|
}
|
|
6054
6043
|
}
|
|
6055
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6044
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6056
6045
|
return { $loc, token: $1 };
|
|
6057
6046
|
});
|
|
6058
6047
|
function NullLiteral(state) {
|
|
@@ -6080,7 +6069,7 @@ ${input.slice(result.pos)}
|
|
|
6080
6069
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6081
6070
|
return value[1];
|
|
6082
6071
|
});
|
|
6083
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6072
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6084
6073
|
return { $loc, token: $1 };
|
|
6085
6074
|
});
|
|
6086
6075
|
function BooleanLiteral(state) {
|
|
@@ -6105,10 +6094,10 @@ ${input.slice(result.pos)}
|
|
|
6105
6094
|
return result;
|
|
6106
6095
|
}
|
|
6107
6096
|
}
|
|
6108
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6097
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6109
6098
|
return { $loc, token: "true" };
|
|
6110
6099
|
});
|
|
6111
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6100
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6112
6101
|
return { $loc, token: "false" };
|
|
6113
6102
|
});
|
|
6114
6103
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6214,7 +6203,7 @@ ${input.slice(result.pos)}
|
|
|
6214
6203
|
return result;
|
|
6215
6204
|
}
|
|
6216
6205
|
}
|
|
6217
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6206
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6218
6207
|
function UpcomingAssignment(state) {
|
|
6219
6208
|
let eventData;
|
|
6220
6209
|
if (state.events) {
|
|
@@ -6487,7 +6476,7 @@ ${input.slice(result.pos)}
|
|
|
6487
6476
|
}
|
|
6488
6477
|
}
|
|
6489
6478
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6490
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6479
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6491
6480
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6492
6481
|
return value[1];
|
|
6493
6482
|
});
|
|
@@ -6913,7 +6902,7 @@ ${input.slice(result.pos)}
|
|
|
6913
6902
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6914
6903
|
return value[1];
|
|
6915
6904
|
});
|
|
6916
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
6905
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L32, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L19, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L31, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L22, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
|
|
6917
6906
|
return "";
|
|
6918
6907
|
});
|
|
6919
6908
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6942,7 +6931,7 @@ ${input.slice(result.pos)}
|
|
|
6942
6931
|
}
|
|
6943
6932
|
}
|
|
6944
6933
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
6945
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6934
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
6946
6935
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6947
6936
|
return value[1];
|
|
6948
6937
|
});
|
|
@@ -7217,7 +7206,7 @@ ${input.slice(result.pos)}
|
|
|
7217
7206
|
expression
|
|
7218
7207
|
};
|
|
7219
7208
|
});
|
|
7220
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7209
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L16, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7221
7210
|
return {
|
|
7222
7211
|
type: "ComputedPropertyName",
|
|
7223
7212
|
children: $0
|
|
@@ -7523,7 +7512,21 @@ ${input.slice(result.pos)}
|
|
|
7523
7512
|
return result;
|
|
7524
7513
|
}
|
|
7525
7514
|
}
|
|
7526
|
-
var OperatorAssignmentOp$0 = $TS($S(
|
|
7515
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7516
|
+
return {
|
|
7517
|
+
special: true,
|
|
7518
|
+
call: module.getRef("xor"),
|
|
7519
|
+
children: [$2, ...$4]
|
|
7520
|
+
};
|
|
7521
|
+
});
|
|
7522
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7523
|
+
return {
|
|
7524
|
+
special: true,
|
|
7525
|
+
call: module.getRef("xnor"),
|
|
7526
|
+
children: [$2, ...$4]
|
|
7527
|
+
};
|
|
7528
|
+
});
|
|
7529
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7527
7530
|
return {
|
|
7528
7531
|
special: true,
|
|
7529
7532
|
call: $1,
|
|
@@ -7541,33 +7544,33 @@ ${input.slice(result.pos)}
|
|
|
7541
7544
|
}
|
|
7542
7545
|
}
|
|
7543
7546
|
if (state.tokenize) {
|
|
7544
|
-
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state));
|
|
7547
|
+
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state));
|
|
7545
7548
|
if (state.events)
|
|
7546
7549
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7547
7550
|
return result;
|
|
7548
7551
|
} else {
|
|
7549
|
-
const result = OperatorAssignmentOp$0(state);
|
|
7552
|
+
const result = OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state);
|
|
7550
7553
|
if (state.events)
|
|
7551
7554
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7552
7555
|
return result;
|
|
7553
7556
|
}
|
|
7554
7557
|
}
|
|
7555
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7556
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7557
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7558
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7559
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7560
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7561
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7562
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7563
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7564
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7565
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7566
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7567
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7568
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7569
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7570
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7558
|
+
var AssignmentOpSymbol$0 = $EXPECT($L33, fail, 'AssignmentOpSymbol "**="');
|
|
7559
|
+
var AssignmentOpSymbol$1 = $EXPECT($L34, fail, 'AssignmentOpSymbol "*="');
|
|
7560
|
+
var AssignmentOpSymbol$2 = $EXPECT($L35, fail, 'AssignmentOpSymbol "/="');
|
|
7561
|
+
var AssignmentOpSymbol$3 = $EXPECT($L36, fail, 'AssignmentOpSymbol "%="');
|
|
7562
|
+
var AssignmentOpSymbol$4 = $EXPECT($L37, fail, 'AssignmentOpSymbol "+="');
|
|
7563
|
+
var AssignmentOpSymbol$5 = $EXPECT($L38, fail, 'AssignmentOpSymbol "-="');
|
|
7564
|
+
var AssignmentOpSymbol$6 = $EXPECT($L39, fail, 'AssignmentOpSymbol "<<="');
|
|
7565
|
+
var AssignmentOpSymbol$7 = $EXPECT($L40, fail, 'AssignmentOpSymbol ">>>="');
|
|
7566
|
+
var AssignmentOpSymbol$8 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>="');
|
|
7567
|
+
var AssignmentOpSymbol$9 = $EXPECT($L42, fail, 'AssignmentOpSymbol "&&="');
|
|
7568
|
+
var AssignmentOpSymbol$10 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&="');
|
|
7569
|
+
var AssignmentOpSymbol$11 = $EXPECT($L44, fail, 'AssignmentOpSymbol "^="');
|
|
7570
|
+
var AssignmentOpSymbol$12 = $EXPECT($L45, fail, 'AssignmentOpSymbol "||="');
|
|
7571
|
+
var AssignmentOpSymbol$13 = $EXPECT($L46, fail, 'AssignmentOpSymbol "|="');
|
|
7572
|
+
var AssignmentOpSymbol$14 = $EXPECT($L47, fail, 'AssignmentOpSymbol "??="');
|
|
7573
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L48, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7571
7574
|
return "??=";
|
|
7572
7575
|
});
|
|
7573
7576
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7598,10 +7601,10 @@ ${input.slice(result.pos)}
|
|
|
7598
7601
|
return result;
|
|
7599
7602
|
}
|
|
7600
7603
|
}
|
|
7601
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7604
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L49, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7602
7605
|
return "&&=";
|
|
7603
7606
|
});
|
|
7604
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7607
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7605
7608
|
return "||=";
|
|
7606
7609
|
});
|
|
7607
7610
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7640,7 +7643,7 @@ ${input.slice(result.pos)}
|
|
|
7640
7643
|
special: true
|
|
7641
7644
|
};
|
|
7642
7645
|
});
|
|
7643
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7646
|
+
var BinaryOp$2 = $TS($S($EXPECT($L51, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7644
7647
|
var id = $4;
|
|
7645
7648
|
if (!module.operators.has(id.name))
|
|
7646
7649
|
return $skip;
|
|
@@ -7672,21 +7675,21 @@ ${input.slice(result.pos)}
|
|
|
7672
7675
|
return result;
|
|
7673
7676
|
}
|
|
7674
7677
|
}
|
|
7675
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7676
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7677
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7678
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7678
|
+
var BinaryOpSymbol$0 = $EXPECT($L52, fail, 'BinaryOpSymbol "**"');
|
|
7679
|
+
var BinaryOpSymbol$1 = $EXPECT($L53, fail, 'BinaryOpSymbol "*"');
|
|
7680
|
+
var BinaryOpSymbol$2 = $EXPECT($L54, fail, 'BinaryOpSymbol "/"');
|
|
7681
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7679
7682
|
return {
|
|
7680
7683
|
call: module.getRef("modulo"),
|
|
7681
7684
|
special: true
|
|
7682
7685
|
};
|
|
7683
7686
|
});
|
|
7684
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7685
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7686
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7687
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7688
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7689
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7687
|
+
var BinaryOpSymbol$4 = $EXPECT($L56, fail, 'BinaryOpSymbol "%"');
|
|
7688
|
+
var BinaryOpSymbol$5 = $EXPECT($L57, fail, 'BinaryOpSymbol "+"');
|
|
7689
|
+
var BinaryOpSymbol$6 = $EXPECT($L16, fail, 'BinaryOpSymbol "-"');
|
|
7690
|
+
var BinaryOpSymbol$7 = $EXPECT($L58, fail, 'BinaryOpSymbol "<="');
|
|
7691
|
+
var BinaryOpSymbol$8 = $EXPECT($L59, fail, 'BinaryOpSymbol ">="');
|
|
7692
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7690
7693
|
return {
|
|
7691
7694
|
$loc,
|
|
7692
7695
|
token: "instanceof",
|
|
@@ -7694,7 +7697,7 @@ ${input.slice(result.pos)}
|
|
|
7694
7697
|
special: true
|
|
7695
7698
|
};
|
|
7696
7699
|
});
|
|
7697
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7700
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7698
7701
|
return {
|
|
7699
7702
|
$loc,
|
|
7700
7703
|
token: "instanceof",
|
|
@@ -7703,46 +7706,58 @@ ${input.slice(result.pos)}
|
|
|
7703
7706
|
negated: true
|
|
7704
7707
|
};
|
|
7705
7708
|
});
|
|
7706
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7709
|
+
var BinaryOpSymbol$11 = $EXPECT($L62, fail, 'BinaryOpSymbol "<<"');
|
|
7707
7710
|
var BinaryOpSymbol$12 = $TR($EXPECT($R6, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7708
7711
|
return "<";
|
|
7709
7712
|
});
|
|
7710
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7711
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7712
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7713
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7714
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7713
|
+
var BinaryOpSymbol$13 = $EXPECT($L63, fail, 'BinaryOpSymbol ">>>"');
|
|
7714
|
+
var BinaryOpSymbol$14 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>"');
|
|
7715
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7716
|
+
var BinaryOpSymbol$16 = $EXPECT($L65, fail, 'BinaryOpSymbol "!=="');
|
|
7717
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L66, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7715
7718
|
if (module.config.coffeeEq)
|
|
7716
7719
|
return "!==";
|
|
7717
7720
|
return $1;
|
|
7718
7721
|
});
|
|
7719
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7722
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7720
7723
|
if (module.config.coffeeIsnt)
|
|
7721
7724
|
return "!==";
|
|
7722
7725
|
return $skip;
|
|
7723
7726
|
});
|
|
7724
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7725
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7727
|
+
var BinaryOpSymbol$19 = $EXPECT($L68, fail, 'BinaryOpSymbol "==="');
|
|
7728
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7726
7729
|
if (module.config.coffeeEq)
|
|
7727
7730
|
return "===";
|
|
7728
7731
|
return $1;
|
|
7729
7732
|
});
|
|
7730
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7733
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7731
7734
|
return "&&";
|
|
7732
7735
|
});
|
|
7733
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7734
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7736
|
+
var BinaryOpSymbol$22 = $EXPECT($L71, fail, 'BinaryOpSymbol "&&"');
|
|
7737
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7735
7738
|
return "in";
|
|
7736
7739
|
});
|
|
7737
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7740
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7738
7741
|
return "||";
|
|
7739
7742
|
});
|
|
7740
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7741
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
7742
|
-
|
|
7743
|
+
var BinaryOpSymbol$25 = $EXPECT($L74, fail, 'BinaryOpSymbol "||"');
|
|
7744
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L75, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L76, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7745
|
+
return {
|
|
7746
|
+
call: module.getRef("xor"),
|
|
7747
|
+
special: true
|
|
7748
|
+
};
|
|
7749
|
+
});
|
|
7750
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R7, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7751
|
+
return {
|
|
7752
|
+
call: module.getRef("xnor"),
|
|
7753
|
+
special: true
|
|
7754
|
+
};
|
|
7755
|
+
});
|
|
7756
|
+
var BinaryOpSymbol$28 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
|
|
7757
|
+
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7743
7758
|
return "??";
|
|
7744
7759
|
});
|
|
7745
|
-
var BinaryOpSymbol$
|
|
7760
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7746
7761
|
return {
|
|
7747
7762
|
$loc,
|
|
7748
7763
|
token: $1,
|
|
@@ -7750,7 +7765,7 @@ ${input.slice(result.pos)}
|
|
|
7750
7765
|
special: true
|
|
7751
7766
|
};
|
|
7752
7767
|
});
|
|
7753
|
-
var BinaryOpSymbol$
|
|
7768
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7754
7769
|
return {
|
|
7755
7770
|
$loc,
|
|
7756
7771
|
token: "instanceof",
|
|
@@ -7759,7 +7774,7 @@ ${input.slice(result.pos)}
|
|
|
7759
7774
|
negated: true
|
|
7760
7775
|
};
|
|
7761
7776
|
});
|
|
7762
|
-
var BinaryOpSymbol$
|
|
7777
|
+
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7763
7778
|
return {
|
|
7764
7779
|
$loc,
|
|
7765
7780
|
token: "in",
|
|
@@ -7767,7 +7782,7 @@ ${input.slice(result.pos)}
|
|
|
7767
7782
|
negated: true
|
|
7768
7783
|
};
|
|
7769
7784
|
});
|
|
7770
|
-
var BinaryOpSymbol$
|
|
7785
|
+
var BinaryOpSymbol$33 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7771
7786
|
return {
|
|
7772
7787
|
method: "includes",
|
|
7773
7788
|
relational: true,
|
|
@@ -7775,7 +7790,7 @@ ${input.slice(result.pos)}
|
|
|
7775
7790
|
special: true
|
|
7776
7791
|
};
|
|
7777
7792
|
});
|
|
7778
|
-
var BinaryOpSymbol$
|
|
7793
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7779
7794
|
return {
|
|
7780
7795
|
call: [module.getRef("indexOf"), ".call"],
|
|
7781
7796
|
relational: true,
|
|
@@ -7784,7 +7799,7 @@ ${input.slice(result.pos)}
|
|
|
7784
7799
|
special: true
|
|
7785
7800
|
};
|
|
7786
7801
|
});
|
|
7787
|
-
var BinaryOpSymbol$
|
|
7802
|
+
var BinaryOpSymbol$35 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
7788
7803
|
return {
|
|
7789
7804
|
method: "includes",
|
|
7790
7805
|
relational: true,
|
|
@@ -7793,7 +7808,7 @@ ${input.slice(result.pos)}
|
|
|
7793
7808
|
negated: true
|
|
7794
7809
|
};
|
|
7795
7810
|
});
|
|
7796
|
-
var BinaryOpSymbol$
|
|
7811
|
+
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7797
7812
|
return {
|
|
7798
7813
|
call: [module.getRef("indexOf"), ".call"],
|
|
7799
7814
|
relational: true,
|
|
@@ -7802,7 +7817,7 @@ ${input.slice(result.pos)}
|
|
|
7802
7817
|
special: true
|
|
7803
7818
|
};
|
|
7804
7819
|
});
|
|
7805
|
-
var BinaryOpSymbol$
|
|
7820
|
+
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7806
7821
|
if (module.config.objectIs) {
|
|
7807
7822
|
return {
|
|
7808
7823
|
call: module.getRef("is"),
|
|
@@ -7814,7 +7829,7 @@ ${input.slice(result.pos)}
|
|
|
7814
7829
|
}
|
|
7815
7830
|
return "!==";
|
|
7816
7831
|
});
|
|
7817
|
-
var BinaryOpSymbol$
|
|
7832
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7818
7833
|
if (module.config.objectIs) {
|
|
7819
7834
|
return {
|
|
7820
7835
|
call: module.getRef("is"),
|
|
@@ -7825,12 +7840,12 @@ ${input.slice(result.pos)}
|
|
|
7825
7840
|
}
|
|
7826
7841
|
return "===";
|
|
7827
7842
|
});
|
|
7828
|
-
var BinaryOpSymbol$
|
|
7843
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7829
7844
|
return $1;
|
|
7830
7845
|
});
|
|
7831
|
-
var BinaryOpSymbol$
|
|
7832
|
-
var BinaryOpSymbol$
|
|
7833
|
-
var BinaryOpSymbol$
|
|
7846
|
+
var BinaryOpSymbol$40 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
|
|
7847
|
+
var BinaryOpSymbol$41 = $EXPECT($L15, fail, 'BinaryOpSymbol "^"');
|
|
7848
|
+
var BinaryOpSymbol$42 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
|
|
7834
7849
|
function BinaryOpSymbol(state) {
|
|
7835
7850
|
let eventData;
|
|
7836
7851
|
if (state.events) {
|
|
@@ -7842,18 +7857,66 @@ ${input.slice(result.pos)}
|
|
|
7842
7857
|
}
|
|
7843
7858
|
}
|
|
7844
7859
|
if (state.tokenize) {
|
|
7845
|
-
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state));
|
|
7860
|
+
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state) || BinaryOpSymbol$41(state) || BinaryOpSymbol$42(state));
|
|
7846
7861
|
if (state.events)
|
|
7847
7862
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7848
7863
|
return result;
|
|
7849
7864
|
} else {
|
|
7850
|
-
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state);
|
|
7865
|
+
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state) || BinaryOpSymbol$41(state) || BinaryOpSymbol$42(state);
|
|
7851
7866
|
if (state.events)
|
|
7852
7867
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7853
7868
|
return result;
|
|
7854
7869
|
}
|
|
7855
7870
|
}
|
|
7856
|
-
var
|
|
7871
|
+
var Xor$0 = $EXPECT($L75, fail, 'Xor "^^"');
|
|
7872
|
+
var Xor$1 = $S($EXPECT($L76, fail, 'Xor "xor"'), NonIdContinue);
|
|
7873
|
+
function Xor(state) {
|
|
7874
|
+
let eventData;
|
|
7875
|
+
if (state.events) {
|
|
7876
|
+
const result = state.events.enter?.("Xor", state);
|
|
7877
|
+
if (result) {
|
|
7878
|
+
if (result.cache)
|
|
7879
|
+
return result.cache;
|
|
7880
|
+
eventData = result.data;
|
|
7881
|
+
}
|
|
7882
|
+
}
|
|
7883
|
+
if (state.tokenize) {
|
|
7884
|
+
const result = $TOKEN("Xor", state, Xor$0(state) || Xor$1(state));
|
|
7885
|
+
if (state.events)
|
|
7886
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7887
|
+
return result;
|
|
7888
|
+
} else {
|
|
7889
|
+
const result = Xor$0(state) || Xor$1(state);
|
|
7890
|
+
if (state.events)
|
|
7891
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7892
|
+
return result;
|
|
7893
|
+
}
|
|
7894
|
+
}
|
|
7895
|
+
var Xnor$0 = $R$0($EXPECT($R7, fail, "Xnor /!\\^\\^?/"));
|
|
7896
|
+
var Xnor$1 = $EXPECT($L77, fail, 'Xnor "xnor"');
|
|
7897
|
+
function Xnor(state) {
|
|
7898
|
+
let eventData;
|
|
7899
|
+
if (state.events) {
|
|
7900
|
+
const result = state.events.enter?.("Xnor", state);
|
|
7901
|
+
if (result) {
|
|
7902
|
+
if (result.cache)
|
|
7903
|
+
return result.cache;
|
|
7904
|
+
eventData = result.data;
|
|
7905
|
+
}
|
|
7906
|
+
}
|
|
7907
|
+
if (state.tokenize) {
|
|
7908
|
+
const result = $TOKEN("Xnor", state, Xnor$0(state) || Xnor$1(state));
|
|
7909
|
+
if (state.events)
|
|
7910
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7911
|
+
return result;
|
|
7912
|
+
} else {
|
|
7913
|
+
const result = Xnor$0(state) || Xnor$1(state);
|
|
7914
|
+
if (state.events)
|
|
7915
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7916
|
+
return result;
|
|
7917
|
+
}
|
|
7918
|
+
}
|
|
7919
|
+
var UnaryOp$0 = $TR($EXPECT($R8, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7857
7920
|
return { $loc, token: $0 };
|
|
7858
7921
|
});
|
|
7859
7922
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -8050,7 +8113,7 @@ ${input.slice(result.pos)}
|
|
|
8050
8113
|
return result;
|
|
8051
8114
|
}
|
|
8052
8115
|
}
|
|
8053
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8116
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L84, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8054
8117
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8055
8118
|
});
|
|
8056
8119
|
function EmptyStatement(state) {
|
|
@@ -9005,7 +9068,7 @@ ${input.slice(result.pos)}
|
|
|
9005
9068
|
return result;
|
|
9006
9069
|
}
|
|
9007
9070
|
}
|
|
9008
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9071
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L85, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9009
9072
|
var own = $1;
|
|
9010
9073
|
var binding = $2;
|
|
9011
9074
|
return {
|
|
@@ -9128,7 +9191,7 @@ ${input.slice(result.pos)}
|
|
|
9128
9191
|
names: binding.names
|
|
9129
9192
|
};
|
|
9130
9193
|
});
|
|
9131
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9194
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R9, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9132
9195
|
var c = $1;
|
|
9133
9196
|
var binding = $2;
|
|
9134
9197
|
return {
|
|
@@ -9486,7 +9549,7 @@ ${input.slice(result.pos)}
|
|
|
9486
9549
|
}
|
|
9487
9550
|
}
|
|
9488
9551
|
var ImpliedColon$0 = $S(__, Colon);
|
|
9489
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9552
|
+
var ImpliedColon$1 = $TV($EXPECT($L18, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9490
9553
|
return { $loc, token: ":" };
|
|
9491
9554
|
});
|
|
9492
9555
|
function ImpliedColon(state) {
|
|
@@ -9740,7 +9803,7 @@ ${input.slice(result.pos)}
|
|
|
9740
9803
|
return result;
|
|
9741
9804
|
}
|
|
9742
9805
|
}
|
|
9743
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
9806
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L18, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9744
9807
|
module.suppressIndentedApplication = true;
|
|
9745
9808
|
});
|
|
9746
9809
|
function SuppressIndentedApplication(state) {
|
|
@@ -9765,7 +9828,7 @@ ${input.slice(result.pos)}
|
|
|
9765
9828
|
return result;
|
|
9766
9829
|
}
|
|
9767
9830
|
}
|
|
9768
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
9831
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L18, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9769
9832
|
if (module.suppressIndentedApplication)
|
|
9770
9833
|
return $skip;
|
|
9771
9834
|
return;
|
|
@@ -9792,7 +9855,7 @@ ${input.slice(result.pos)}
|
|
|
9792
9855
|
return result;
|
|
9793
9856
|
}
|
|
9794
9857
|
}
|
|
9795
|
-
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($
|
|
9858
|
+
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'SuppressTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
9796
9859
|
module.suppressTrailingMemberProperty.push(true);
|
|
9797
9860
|
});
|
|
9798
9861
|
function SuppressTrailingMemberProperty(state) {
|
|
@@ -9817,7 +9880,7 @@ ${input.slice(result.pos)}
|
|
|
9817
9880
|
return result;
|
|
9818
9881
|
}
|
|
9819
9882
|
}
|
|
9820
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
9883
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L18, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9821
9884
|
if (module.trailingMemberPropertySuppressed)
|
|
9822
9885
|
return $skip;
|
|
9823
9886
|
});
|
|
@@ -9866,13 +9929,13 @@ ${input.slice(result.pos)}
|
|
|
9866
9929
|
return result;
|
|
9867
9930
|
}
|
|
9868
9931
|
}
|
|
9869
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
9932
|
+
var KeywordStatement$0 = $T($S($EXPECT($L86, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
9870
9933
|
return { "type": "BreakStatement", "children": value };
|
|
9871
9934
|
});
|
|
9872
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
9935
|
+
var KeywordStatement$1 = $T($S($EXPECT($L87, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
9873
9936
|
return { "type": "ContinueStatement", "children": value };
|
|
9874
9937
|
});
|
|
9875
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
9938
|
+
var KeywordStatement$2 = $T($S($EXPECT($L88, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
9876
9939
|
return { "type": "DebuggerStatement", "children": value };
|
|
9877
9940
|
});
|
|
9878
9941
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -9903,7 +9966,7 @@ ${input.slice(result.pos)}
|
|
|
9903
9966
|
return result;
|
|
9904
9967
|
}
|
|
9905
9968
|
}
|
|
9906
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
9969
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L88, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9907
9970
|
return {
|
|
9908
9971
|
type: "DebuggerExpression",
|
|
9909
9972
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10031,7 +10094,7 @@ ${input.slice(result.pos)}
|
|
|
10031
10094
|
return result;
|
|
10032
10095
|
}
|
|
10033
10096
|
}
|
|
10034
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10097
|
+
var ImpliedImport$0 = $TV($EXPECT($L18, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10035
10098
|
return { $loc, token: "import " };
|
|
10036
10099
|
});
|
|
10037
10100
|
function ImpliedImport(state) {
|
|
@@ -10180,7 +10243,7 @@ ${input.slice(result.pos)}
|
|
|
10180
10243
|
return result;
|
|
10181
10244
|
}
|
|
10182
10245
|
}
|
|
10183
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10246
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L89, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10184
10247
|
function ImportAssertion(state) {
|
|
10185
10248
|
let eventData;
|
|
10186
10249
|
if (state.events) {
|
|
@@ -10396,7 +10459,7 @@ ${input.slice(result.pos)}
|
|
|
10396
10459
|
return result;
|
|
10397
10460
|
}
|
|
10398
10461
|
}
|
|
10399
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10462
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R10, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10400
10463
|
var spec = $0;
|
|
10401
10464
|
return { $loc, token: `"${spec}"` };
|
|
10402
10465
|
});
|
|
@@ -10784,7 +10847,7 @@ ${input.slice(result.pos)}
|
|
|
10784
10847
|
return result;
|
|
10785
10848
|
}
|
|
10786
10849
|
}
|
|
10787
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
10850
|
+
var ConstAssignment$0 = $TV($EXPECT($L90, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
10788
10851
|
return { $loc, token: "=" };
|
|
10789
10852
|
});
|
|
10790
10853
|
function ConstAssignment(state) {
|
|
@@ -10809,7 +10872,7 @@ ${input.slice(result.pos)}
|
|
|
10809
10872
|
return result;
|
|
10810
10873
|
}
|
|
10811
10874
|
}
|
|
10812
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10875
|
+
var LetAssignment$0 = $TV($EXPECT($L91, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10813
10876
|
return { $loc, token: "=" };
|
|
10814
10877
|
});
|
|
10815
10878
|
function LetAssignment(state) {
|
|
@@ -11058,7 +11121,7 @@ ${input.slice(result.pos)}
|
|
|
11058
11121
|
return result;
|
|
11059
11122
|
}
|
|
11060
11123
|
}
|
|
11061
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
11124
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
11062
11125
|
function DecimalBigIntegerLiteral(state) {
|
|
11063
11126
|
let eventData;
|
|
11064
11127
|
if (state.events) {
|
|
@@ -11081,11 +11144,11 @@ ${input.slice(result.pos)}
|
|
|
11081
11144
|
return result;
|
|
11082
11145
|
}
|
|
11083
11146
|
}
|
|
11084
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
11147
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R12, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
11085
11148
|
return $1 + ".";
|
|
11086
11149
|
});
|
|
11087
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
11088
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
11150
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R13, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
11151
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R14, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
11089
11152
|
function DecimalLiteral(state) {
|
|
11090
11153
|
let eventData;
|
|
11091
11154
|
if (state.events) {
|
|
@@ -11108,7 +11171,7 @@ ${input.slice(result.pos)}
|
|
|
11108
11171
|
return result;
|
|
11109
11172
|
}
|
|
11110
11173
|
}
|
|
11111
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
11174
|
+
var ExponentPart$0 = $R$0($EXPECT($R15, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
11112
11175
|
function ExponentPart(state) {
|
|
11113
11176
|
let eventData;
|
|
11114
11177
|
if (state.events) {
|
|
@@ -11131,7 +11194,7 @@ ${input.slice(result.pos)}
|
|
|
11131
11194
|
return result;
|
|
11132
11195
|
}
|
|
11133
11196
|
}
|
|
11134
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
11197
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R16, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
11135
11198
|
function BinaryIntegerLiteral(state) {
|
|
11136
11199
|
let eventData;
|
|
11137
11200
|
if (state.events) {
|
|
@@ -11154,7 +11217,7 @@ ${input.slice(result.pos)}
|
|
|
11154
11217
|
return result;
|
|
11155
11218
|
}
|
|
11156
11219
|
}
|
|
11157
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11220
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R17, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
11158
11221
|
function OctalIntegerLiteral(state) {
|
|
11159
11222
|
let eventData;
|
|
11160
11223
|
if (state.events) {
|
|
@@ -11177,7 +11240,7 @@ ${input.slice(result.pos)}
|
|
|
11177
11240
|
return result;
|
|
11178
11241
|
}
|
|
11179
11242
|
}
|
|
11180
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
11243
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R18, fail, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
11181
11244
|
function HexIntegerLiteral(state) {
|
|
11182
11245
|
let eventData;
|
|
11183
11246
|
if (state.events) {
|
|
@@ -11252,7 +11315,7 @@ ${input.slice(result.pos)}
|
|
|
11252
11315
|
return result;
|
|
11253
11316
|
}
|
|
11254
11317
|
}
|
|
11255
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11318
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R19, fail, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
11256
11319
|
function DecimalIntegerLiteral(state) {
|
|
11257
11320
|
let eventData;
|
|
11258
11321
|
if (state.events) {
|
|
@@ -11313,7 +11376,7 @@ ${input.slice(result.pos)}
|
|
|
11313
11376
|
return result;
|
|
11314
11377
|
}
|
|
11315
11378
|
}
|
|
11316
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11379
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R20, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11317
11380
|
return { $loc, token: $0 };
|
|
11318
11381
|
});
|
|
11319
11382
|
function DoubleStringCharacters(state) {
|
|
@@ -11338,7 +11401,7 @@ ${input.slice(result.pos)}
|
|
|
11338
11401
|
return result;
|
|
11339
11402
|
}
|
|
11340
11403
|
}
|
|
11341
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11404
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R21, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11342
11405
|
return { $loc, token: $0 };
|
|
11343
11406
|
});
|
|
11344
11407
|
function SingleStringCharacters(state) {
|
|
@@ -11363,7 +11426,7 @@ ${input.slice(result.pos)}
|
|
|
11363
11426
|
return result;
|
|
11364
11427
|
}
|
|
11365
11428
|
}
|
|
11366
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11429
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R22, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11367
11430
|
return { $loc, token: $0 };
|
|
11368
11431
|
});
|
|
11369
11432
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -11388,7 +11451,7 @@ ${input.slice(result.pos)}
|
|
|
11388
11451
|
return result;
|
|
11389
11452
|
}
|
|
11390
11453
|
}
|
|
11391
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11454
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R23, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11392
11455
|
return { $loc, token: $0 };
|
|
11393
11456
|
});
|
|
11394
11457
|
function TripleSingleStringCharacters(state) {
|
|
@@ -11481,7 +11544,7 @@ ${input.slice(result.pos)}
|
|
|
11481
11544
|
return result;
|
|
11482
11545
|
}
|
|
11483
11546
|
}
|
|
11484
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11547
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R24, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11485
11548
|
return { $loc, token: $0 };
|
|
11486
11549
|
});
|
|
11487
11550
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -11507,7 +11570,7 @@ ${input.slice(result.pos)}
|
|
|
11507
11570
|
}
|
|
11508
11571
|
}
|
|
11509
11572
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
11510
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
11573
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
11511
11574
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
11512
11575
|
});
|
|
11513
11576
|
function RegularExpressionLiteral(state) {
|
|
@@ -11557,7 +11620,7 @@ ${input.slice(result.pos)}
|
|
|
11557
11620
|
return result;
|
|
11558
11621
|
}
|
|
11559
11622
|
}
|
|
11560
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11623
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R25, fail, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11561
11624
|
return { $loc, token: $0 };
|
|
11562
11625
|
});
|
|
11563
11626
|
function RegularExpressionClassCharacters(state) {
|
|
@@ -11667,7 +11730,7 @@ ${input.slice(result.pos)}
|
|
|
11667
11730
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
11668
11731
|
return { "type": "Substitution", "children": value[0] };
|
|
11669
11732
|
});
|
|
11670
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11733
|
+
var HeregexPart$3 = $TR($EXPECT($R26, fail, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11671
11734
|
let token = $0;
|
|
11672
11735
|
switch ($0[1]) {
|
|
11673
11736
|
case "\n":
|
|
@@ -11685,13 +11748,13 @@ ${input.slice(result.pos)}
|
|
|
11685
11748
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
11686
11749
|
return { $loc, token: "" };
|
|
11687
11750
|
});
|
|
11688
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11751
|
+
var HeregexPart$5 = $TR($EXPECT($R27, fail, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11689
11752
|
return { $loc, token: "" };
|
|
11690
11753
|
});
|
|
11691
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11754
|
+
var HeregexPart$6 = $TR($EXPECT($R28, fail, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11692
11755
|
return { $loc, token: "\\/" };
|
|
11693
11756
|
});
|
|
11694
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11757
|
+
var HeregexPart$7 = $TR($EXPECT($R29, fail, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11695
11758
|
return { $loc, token: $0 };
|
|
11696
11759
|
});
|
|
11697
11760
|
function HeregexPart(state) {
|
|
@@ -11740,7 +11803,7 @@ ${input.slice(result.pos)}
|
|
|
11740
11803
|
return result;
|
|
11741
11804
|
}
|
|
11742
11805
|
}
|
|
11743
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11806
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R30, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11744
11807
|
function RegularExpressionBody(state) {
|
|
11745
11808
|
let eventData;
|
|
11746
11809
|
if (state.events) {
|
|
@@ -11787,7 +11850,7 @@ ${input.slice(result.pos)}
|
|
|
11787
11850
|
return result;
|
|
11788
11851
|
}
|
|
11789
11852
|
}
|
|
11790
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
11853
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R31, fail, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11791
11854
|
function RegExpCharacter(state) {
|
|
11792
11855
|
let eventData;
|
|
11793
11856
|
if (state.events) {
|
|
@@ -11810,7 +11873,7 @@ ${input.slice(result.pos)}
|
|
|
11810
11873
|
return result;
|
|
11811
11874
|
}
|
|
11812
11875
|
}
|
|
11813
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11876
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R32, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11814
11877
|
function RegularExpressionFlags(state) {
|
|
11815
11878
|
let eventData;
|
|
11816
11879
|
if (state.events) {
|
|
@@ -11900,7 +11963,7 @@ ${input.slice(result.pos)}
|
|
|
11900
11963
|
return result;
|
|
11901
11964
|
}
|
|
11902
11965
|
}
|
|
11903
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11966
|
+
var TemplateCharacters$0 = $TR($EXPECT($R33, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11904
11967
|
return { $loc, token: $0 };
|
|
11905
11968
|
});
|
|
11906
11969
|
function TemplateCharacters(state) {
|
|
@@ -11925,7 +11988,7 @@ ${input.slice(result.pos)}
|
|
|
11925
11988
|
return result;
|
|
11926
11989
|
}
|
|
11927
11990
|
}
|
|
11928
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
11991
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R34, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11929
11992
|
return { $loc, token: $0 };
|
|
11930
11993
|
});
|
|
11931
11994
|
function TemplateBlockCharacters(state) {
|
|
@@ -11950,11 +12013,11 @@ ${input.slice(result.pos)}
|
|
|
11950
12013
|
return result;
|
|
11951
12014
|
}
|
|
11952
12015
|
}
|
|
11953
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
11954
|
-
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($
|
|
11955
|
-
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($
|
|
11956
|
-
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($
|
|
11957
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
12016
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R35, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
12017
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R36, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
12018
|
+
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R37, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
12019
|
+
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R38, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
12020
|
+
var ReservedWord$4 = $R$0($EXPECT($R39, fail, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
11958
12021
|
function ReservedWord(state) {
|
|
11959
12022
|
let eventData;
|
|
11960
12023
|
if (state.events) {
|
|
@@ -12025,7 +12088,7 @@ ${input.slice(result.pos)}
|
|
|
12025
12088
|
return result;
|
|
12026
12089
|
}
|
|
12027
12090
|
}
|
|
12028
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
12091
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R40, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12029
12092
|
return { $loc, token: $0 };
|
|
12030
12093
|
});
|
|
12031
12094
|
function JSSingleLineComment(state) {
|
|
@@ -12074,7 +12137,7 @@ ${input.slice(result.pos)}
|
|
|
12074
12137
|
return result;
|
|
12075
12138
|
}
|
|
12076
12139
|
}
|
|
12077
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12140
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L93, fail, 'JSMultiLineComment "*/"')), $EXPECT($R41, fail, "JSMultiLineComment /./"))), $EXPECT($L93, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12078
12141
|
return { $loc, token: $1 };
|
|
12079
12142
|
});
|
|
12080
12143
|
function JSMultiLineComment(state) {
|
|
@@ -12099,7 +12162,7 @@ ${input.slice(result.pos)}
|
|
|
12099
12162
|
return result;
|
|
12100
12163
|
}
|
|
12101
12164
|
}
|
|
12102
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
12165
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R42, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12103
12166
|
return { $loc, token: `//${$1}` };
|
|
12104
12167
|
});
|
|
12105
12168
|
function CoffeeSingleLineComment(state) {
|
|
@@ -12124,7 +12187,7 @@ ${input.slice(result.pos)}
|
|
|
12124
12187
|
return result;
|
|
12125
12188
|
}
|
|
12126
12189
|
}
|
|
12127
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
12190
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R43, fail, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
12128
12191
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
12129
12192
|
return { $loc, token: `/*${$2}*/` };
|
|
12130
12193
|
});
|
|
@@ -12150,7 +12213,7 @@ ${input.slice(result.pos)}
|
|
|
12150
12213
|
return result;
|
|
12151
12214
|
}
|
|
12152
12215
|
}
|
|
12153
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
12216
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R44, fail, "CoffeeHereCommentStart /###(?!#)/"));
|
|
12154
12217
|
function CoffeeHereCommentStart(state) {
|
|
12155
12218
|
let eventData;
|
|
12156
12219
|
if (state.events) {
|
|
@@ -12173,7 +12236,7 @@ ${input.slice(result.pos)}
|
|
|
12173
12236
|
return result;
|
|
12174
12237
|
}
|
|
12175
12238
|
}
|
|
12176
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12239
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L93, fail, 'InlineComment "*/"')), $EXPECT($R45, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L93, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12177
12240
|
return { $loc, token: $1 };
|
|
12178
12241
|
});
|
|
12179
12242
|
function InlineComment(state) {
|
|
@@ -12269,10 +12332,10 @@ ${input.slice(result.pos)}
|
|
|
12269
12332
|
return result;
|
|
12270
12333
|
}
|
|
12271
12334
|
}
|
|
12272
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
12335
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R46, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12273
12336
|
return { $loc, token: $0 };
|
|
12274
12337
|
});
|
|
12275
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12338
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L94, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12276
12339
|
return "";
|
|
12277
12340
|
});
|
|
12278
12341
|
function NonNewlineWhitespace(state) {
|
|
@@ -12346,7 +12409,7 @@ ${input.slice(result.pos)}
|
|
|
12346
12409
|
return result;
|
|
12347
12410
|
}
|
|
12348
12411
|
}
|
|
12349
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
12412
|
+
var Whitespace$0 = $TR($EXPECT($R27, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12350
12413
|
return { $loc, token: $0 };
|
|
12351
12414
|
});
|
|
12352
12415
|
function Whitespace(state) {
|
|
@@ -12424,7 +12487,7 @@ ${input.slice(result.pos)}
|
|
|
12424
12487
|
}
|
|
12425
12488
|
}
|
|
12426
12489
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12427
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
12490
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L95, fail, 'StatementDelimiter "["'), $EXPECT($L96, fail, 'StatementDelimiter "`"'), $EXPECT($L57, fail, 'StatementDelimiter "+"'), $EXPECT($L16, fail, 'StatementDelimiter "-"'), $EXPECT($L53, fail, 'StatementDelimiter "*"'), $EXPECT($L54, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
12428
12491
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12429
12492
|
function StatementDelimiter(state) {
|
|
12430
12493
|
let eventData;
|
|
@@ -12476,7 +12539,7 @@ ${input.slice(result.pos)}
|
|
|
12476
12539
|
return result;
|
|
12477
12540
|
}
|
|
12478
12541
|
}
|
|
12479
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
12542
|
+
var NonIdContinue$0 = $R$0($EXPECT($R47, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
12480
12543
|
function NonIdContinue(state) {
|
|
12481
12544
|
let eventData;
|
|
12482
12545
|
if (state.events) {
|
|
@@ -12499,7 +12562,7 @@ ${input.slice(result.pos)}
|
|
|
12499
12562
|
return result;
|
|
12500
12563
|
}
|
|
12501
12564
|
}
|
|
12502
|
-
var Loc$0 = $TV($EXPECT($
|
|
12565
|
+
var Loc$0 = $TV($EXPECT($L18, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
12503
12566
|
return { $loc, token: "" };
|
|
12504
12567
|
});
|
|
12505
12568
|
function Loc(state) {
|
|
@@ -12524,7 +12587,7 @@ ${input.slice(result.pos)}
|
|
|
12524
12587
|
return result;
|
|
12525
12588
|
}
|
|
12526
12589
|
}
|
|
12527
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
12590
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L97, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
12528
12591
|
return { $loc, token: $1, ts: true };
|
|
12529
12592
|
});
|
|
12530
12593
|
function Abstract(state) {
|
|
@@ -12549,7 +12612,7 @@ ${input.slice(result.pos)}
|
|
|
12549
12612
|
return result;
|
|
12550
12613
|
}
|
|
12551
12614
|
}
|
|
12552
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
12615
|
+
var Ampersand$0 = $TV($EXPECT($L82, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
12553
12616
|
return { $loc, token: $1 };
|
|
12554
12617
|
});
|
|
12555
12618
|
function Ampersand(state) {
|
|
@@ -12574,7 +12637,7 @@ ${input.slice(result.pos)}
|
|
|
12574
12637
|
return result;
|
|
12575
12638
|
}
|
|
12576
12639
|
}
|
|
12577
|
-
var As$0 = $TS($S($EXPECT($
|
|
12640
|
+
var As$0 = $TS($S($EXPECT($L98, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12578
12641
|
return { $loc, token: $1 };
|
|
12579
12642
|
});
|
|
12580
12643
|
function As(state) {
|
|
@@ -12599,7 +12662,7 @@ ${input.slice(result.pos)}
|
|
|
12599
12662
|
return result;
|
|
12600
12663
|
}
|
|
12601
12664
|
}
|
|
12602
|
-
var At$0 = $TV($EXPECT($
|
|
12665
|
+
var At$0 = $TV($EXPECT($L99, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
12603
12666
|
return { $loc, token: $1 };
|
|
12604
12667
|
});
|
|
12605
12668
|
function At(state) {
|
|
@@ -12624,7 +12687,7 @@ ${input.slice(result.pos)}
|
|
|
12624
12687
|
return result;
|
|
12625
12688
|
}
|
|
12626
12689
|
}
|
|
12627
|
-
var AtAt$0 = $TV($EXPECT($
|
|
12690
|
+
var AtAt$0 = $TV($EXPECT($L100, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
12628
12691
|
return { $loc, token: "@" };
|
|
12629
12692
|
});
|
|
12630
12693
|
function AtAt(state) {
|
|
@@ -12649,7 +12712,7 @@ ${input.slice(result.pos)}
|
|
|
12649
12712
|
return result;
|
|
12650
12713
|
}
|
|
12651
12714
|
}
|
|
12652
|
-
var Async$0 = $TS($S($EXPECT($
|
|
12715
|
+
var Async$0 = $TS($S($EXPECT($L101, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12653
12716
|
return { $loc, token: $1, type: "Async" };
|
|
12654
12717
|
});
|
|
12655
12718
|
function Async(state) {
|
|
@@ -12674,7 +12737,7 @@ ${input.slice(result.pos)}
|
|
|
12674
12737
|
return result;
|
|
12675
12738
|
}
|
|
12676
12739
|
}
|
|
12677
|
-
var Await$0 = $TS($S($EXPECT($
|
|
12740
|
+
var Await$0 = $TS($S($EXPECT($L102, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12678
12741
|
return { $loc, token: $1 };
|
|
12679
12742
|
});
|
|
12680
12743
|
function Await(state) {
|
|
@@ -12699,7 +12762,7 @@ ${input.slice(result.pos)}
|
|
|
12699
12762
|
return result;
|
|
12700
12763
|
}
|
|
12701
12764
|
}
|
|
12702
|
-
var Backtick$0 = $TV($EXPECT($
|
|
12765
|
+
var Backtick$0 = $TV($EXPECT($L96, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
12703
12766
|
return { $loc, token: $1 };
|
|
12704
12767
|
});
|
|
12705
12768
|
function Backtick(state) {
|
|
@@ -12724,7 +12787,7 @@ ${input.slice(result.pos)}
|
|
|
12724
12787
|
return result;
|
|
12725
12788
|
}
|
|
12726
12789
|
}
|
|
12727
|
-
var By$0 = $TS($S($EXPECT($
|
|
12790
|
+
var By$0 = $TS($S($EXPECT($L103, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12728
12791
|
return { $loc, token: $1 };
|
|
12729
12792
|
});
|
|
12730
12793
|
function By(state) {
|
|
@@ -12749,7 +12812,7 @@ ${input.slice(result.pos)}
|
|
|
12749
12812
|
return result;
|
|
12750
12813
|
}
|
|
12751
12814
|
}
|
|
12752
|
-
var Case$0 = $TS($S($EXPECT($
|
|
12815
|
+
var Case$0 = $TS($S($EXPECT($L104, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12753
12816
|
return { $loc, token: $1 };
|
|
12754
12817
|
});
|
|
12755
12818
|
function Case(state) {
|
|
@@ -12774,7 +12837,7 @@ ${input.slice(result.pos)}
|
|
|
12774
12837
|
return result;
|
|
12775
12838
|
}
|
|
12776
12839
|
}
|
|
12777
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
12840
|
+
var Catch$0 = $TS($S($EXPECT($L105, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12778
12841
|
return { $loc, token: $1 };
|
|
12779
12842
|
});
|
|
12780
12843
|
function Catch(state) {
|
|
@@ -12799,7 +12862,7 @@ ${input.slice(result.pos)}
|
|
|
12799
12862
|
return result;
|
|
12800
12863
|
}
|
|
12801
12864
|
}
|
|
12802
|
-
var Class$0 = $TS($S($EXPECT($
|
|
12865
|
+
var Class$0 = $TS($S($EXPECT($L106, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12803
12866
|
return { $loc, token: $1 };
|
|
12804
12867
|
});
|
|
12805
12868
|
function Class(state) {
|
|
@@ -12824,7 +12887,7 @@ ${input.slice(result.pos)}
|
|
|
12824
12887
|
return result;
|
|
12825
12888
|
}
|
|
12826
12889
|
}
|
|
12827
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
12890
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
12828
12891
|
return { $loc, token: $1 };
|
|
12829
12892
|
});
|
|
12830
12893
|
function CloseBrace(state) {
|
|
@@ -12849,7 +12912,7 @@ ${input.slice(result.pos)}
|
|
|
12849
12912
|
return result;
|
|
12850
12913
|
}
|
|
12851
12914
|
}
|
|
12852
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
12915
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
12853
12916
|
return { $loc, token: $1 };
|
|
12854
12917
|
});
|
|
12855
12918
|
function CloseBracket(state) {
|
|
@@ -12874,7 +12937,7 @@ ${input.slice(result.pos)}
|
|
|
12874
12937
|
return result;
|
|
12875
12938
|
}
|
|
12876
12939
|
}
|
|
12877
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
12940
|
+
var CloseParen$0 = $TV($EXPECT($L19, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
12878
12941
|
return { $loc, token: $1 };
|
|
12879
12942
|
});
|
|
12880
12943
|
function CloseParen(state) {
|
|
@@ -12899,7 +12962,7 @@ ${input.slice(result.pos)}
|
|
|
12899
12962
|
return result;
|
|
12900
12963
|
}
|
|
12901
12964
|
}
|
|
12902
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
12965
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L107, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
12903
12966
|
return { $loc, token: "${" };
|
|
12904
12967
|
});
|
|
12905
12968
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -12924,7 +12987,7 @@ ${input.slice(result.pos)}
|
|
|
12924
12987
|
return result;
|
|
12925
12988
|
}
|
|
12926
12989
|
}
|
|
12927
|
-
var Colon$0 = $TV($EXPECT($
|
|
12990
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
12928
12991
|
return { $loc, token: $1 };
|
|
12929
12992
|
});
|
|
12930
12993
|
function Colon(state) {
|
|
@@ -12949,7 +13012,7 @@ ${input.slice(result.pos)}
|
|
|
12949
13012
|
return result;
|
|
12950
13013
|
}
|
|
12951
13014
|
}
|
|
12952
|
-
var Comma$0 = $TV($EXPECT($
|
|
13015
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
12953
13016
|
return { $loc, token: $1 };
|
|
12954
13017
|
});
|
|
12955
13018
|
function Comma(state) {
|
|
@@ -12974,7 +13037,7 @@ ${input.slice(result.pos)}
|
|
|
12974
13037
|
return result;
|
|
12975
13038
|
}
|
|
12976
13039
|
}
|
|
12977
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13040
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L99, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
12978
13041
|
return { $loc, token: "constructor" };
|
|
12979
13042
|
});
|
|
12980
13043
|
function ConstructorShorthand(state) {
|
|
@@ -12999,7 +13062,7 @@ ${input.slice(result.pos)}
|
|
|
12999
13062
|
return result;
|
|
13000
13063
|
}
|
|
13001
13064
|
}
|
|
13002
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13065
|
+
var Declare$0 = $TS($S($EXPECT($L108, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13003
13066
|
return { $loc, token: $1 };
|
|
13004
13067
|
});
|
|
13005
13068
|
function Declare(state) {
|
|
@@ -13024,7 +13087,7 @@ ${input.slice(result.pos)}
|
|
|
13024
13087
|
return result;
|
|
13025
13088
|
}
|
|
13026
13089
|
}
|
|
13027
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13090
|
+
var Default$0 = $TS($S($EXPECT($L109, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13028
13091
|
return { $loc, token: $1 };
|
|
13029
13092
|
});
|
|
13030
13093
|
function Default(state) {
|
|
@@ -13049,7 +13112,7 @@ ${input.slice(result.pos)}
|
|
|
13049
13112
|
return result;
|
|
13050
13113
|
}
|
|
13051
13114
|
}
|
|
13052
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13115
|
+
var Delete$0 = $TS($S($EXPECT($L110, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13053
13116
|
return { $loc, token: $1 };
|
|
13054
13117
|
});
|
|
13055
13118
|
function Delete(state) {
|
|
@@ -13074,7 +13137,7 @@ ${input.slice(result.pos)}
|
|
|
13074
13137
|
return result;
|
|
13075
13138
|
}
|
|
13076
13139
|
}
|
|
13077
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13140
|
+
var Do$0 = $TS($S($EXPECT($L111, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13078
13141
|
return { $loc, token: $1 };
|
|
13079
13142
|
});
|
|
13080
13143
|
function Do(state) {
|
|
@@ -13124,7 +13187,7 @@ ${input.slice(result.pos)}
|
|
|
13124
13187
|
return result;
|
|
13125
13188
|
}
|
|
13126
13189
|
}
|
|
13127
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13190
|
+
var DotDot$0 = $TV($EXPECT($L112, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13128
13191
|
return { $loc, token: $1 };
|
|
13129
13192
|
});
|
|
13130
13193
|
function DotDot(state) {
|
|
@@ -13149,7 +13212,7 @@ ${input.slice(result.pos)}
|
|
|
13149
13212
|
return result;
|
|
13150
13213
|
}
|
|
13151
13214
|
}
|
|
13152
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13215
|
+
var DotDotDot$0 = $TV($EXPECT($L113, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13153
13216
|
return { $loc, token: $1 };
|
|
13154
13217
|
});
|
|
13155
13218
|
function DotDotDot(state) {
|
|
@@ -13174,7 +13237,7 @@ ${input.slice(result.pos)}
|
|
|
13174
13237
|
return result;
|
|
13175
13238
|
}
|
|
13176
13239
|
}
|
|
13177
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13240
|
+
var DoubleColon$0 = $TV($EXPECT($L114, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13178
13241
|
return { $loc, token: $1 };
|
|
13179
13242
|
});
|
|
13180
13243
|
function DoubleColon(state) {
|
|
@@ -13199,7 +13262,7 @@ ${input.slice(result.pos)}
|
|
|
13199
13262
|
return result;
|
|
13200
13263
|
}
|
|
13201
13264
|
}
|
|
13202
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13265
|
+
var DoubleQuote$0 = $TV($EXPECT($L115, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13203
13266
|
return { $loc, token: $1 };
|
|
13204
13267
|
});
|
|
13205
13268
|
function DoubleQuote(state) {
|
|
@@ -13224,7 +13287,7 @@ ${input.slice(result.pos)}
|
|
|
13224
13287
|
return result;
|
|
13225
13288
|
}
|
|
13226
13289
|
}
|
|
13227
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13290
|
+
var Else$0 = $TS($S($EXPECT($L116, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13228
13291
|
return { $loc, token: $1 };
|
|
13229
13292
|
});
|
|
13230
13293
|
function Else(state) {
|
|
@@ -13274,7 +13337,7 @@ ${input.slice(result.pos)}
|
|
|
13274
13337
|
return result;
|
|
13275
13338
|
}
|
|
13276
13339
|
}
|
|
13277
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13340
|
+
var Export$0 = $TS($S($EXPECT($L117, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13278
13341
|
return { $loc, token: $1 };
|
|
13279
13342
|
});
|
|
13280
13343
|
function Export(state) {
|
|
@@ -13299,7 +13362,7 @@ ${input.slice(result.pos)}
|
|
|
13299
13362
|
return result;
|
|
13300
13363
|
}
|
|
13301
13364
|
}
|
|
13302
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13365
|
+
var Extends$0 = $TS($S($EXPECT($L118, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13303
13366
|
return { $loc, token: $1 };
|
|
13304
13367
|
});
|
|
13305
13368
|
function Extends(state) {
|
|
@@ -13324,7 +13387,7 @@ ${input.slice(result.pos)}
|
|
|
13324
13387
|
return result;
|
|
13325
13388
|
}
|
|
13326
13389
|
}
|
|
13327
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13390
|
+
var Finally$0 = $TS($S($EXPECT($L119, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13328
13391
|
return { $loc, token: $1 };
|
|
13329
13392
|
});
|
|
13330
13393
|
function Finally(state) {
|
|
@@ -13349,7 +13412,7 @@ ${input.slice(result.pos)}
|
|
|
13349
13412
|
return result;
|
|
13350
13413
|
}
|
|
13351
13414
|
}
|
|
13352
|
-
var For$0 = $TS($S($EXPECT($
|
|
13415
|
+
var For$0 = $TS($S($EXPECT($L120, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13353
13416
|
return { $loc, token: $1 };
|
|
13354
13417
|
});
|
|
13355
13418
|
function For(state) {
|
|
@@ -13374,7 +13437,7 @@ ${input.slice(result.pos)}
|
|
|
13374
13437
|
return result;
|
|
13375
13438
|
}
|
|
13376
13439
|
}
|
|
13377
|
-
var From$0 = $TS($S($EXPECT($
|
|
13440
|
+
var From$0 = $TS($S($EXPECT($L121, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13378
13441
|
return { $loc, token: $1 };
|
|
13379
13442
|
});
|
|
13380
13443
|
function From(state) {
|
|
@@ -13399,7 +13462,7 @@ ${input.slice(result.pos)}
|
|
|
13399
13462
|
return result;
|
|
13400
13463
|
}
|
|
13401
13464
|
}
|
|
13402
|
-
var Function$0 = $TS($S($EXPECT($
|
|
13465
|
+
var Function$0 = $TS($S($EXPECT($L122, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13403
13466
|
return { $loc, token: $1 };
|
|
13404
13467
|
});
|
|
13405
13468
|
function Function(state) {
|
|
@@ -13424,7 +13487,7 @@ ${input.slice(result.pos)}
|
|
|
13424
13487
|
return result;
|
|
13425
13488
|
}
|
|
13426
13489
|
}
|
|
13427
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
13490
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L123, fail, 'GetOrSet "get"'), $EXPECT($L124, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13428
13491
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13429
13492
|
});
|
|
13430
13493
|
function GetOrSet(state) {
|
|
@@ -13449,7 +13512,7 @@ ${input.slice(result.pos)}
|
|
|
13449
13512
|
return result;
|
|
13450
13513
|
}
|
|
13451
13514
|
}
|
|
13452
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
13515
|
+
var If$0 = $TV($TEXT($S($EXPECT($L125, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13453
13516
|
return { $loc, token: $1 };
|
|
13454
13517
|
});
|
|
13455
13518
|
function If(state) {
|
|
@@ -13474,7 +13537,7 @@ ${input.slice(result.pos)}
|
|
|
13474
13537
|
return result;
|
|
13475
13538
|
}
|
|
13476
13539
|
}
|
|
13477
|
-
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($
|
|
13540
|
+
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R48, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
13478
13541
|
return { $loc, token: $1 };
|
|
13479
13542
|
});
|
|
13480
13543
|
function Import(state) {
|
|
@@ -13499,7 +13562,7 @@ ${input.slice(result.pos)}
|
|
|
13499
13562
|
return result;
|
|
13500
13563
|
}
|
|
13501
13564
|
}
|
|
13502
|
-
var In$0 = $TS($S($EXPECT($
|
|
13565
|
+
var In$0 = $TS($S($EXPECT($L80, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13503
13566
|
return { $loc, token: $1 };
|
|
13504
13567
|
});
|
|
13505
13568
|
function In(state) {
|
|
@@ -13524,7 +13587,7 @@ ${input.slice(result.pos)}
|
|
|
13524
13587
|
return result;
|
|
13525
13588
|
}
|
|
13526
13589
|
}
|
|
13527
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
13590
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L126, fail, 'LetOrConst "let"'), $EXPECT($L127, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13528
13591
|
return { $loc, token: $1 };
|
|
13529
13592
|
});
|
|
13530
13593
|
function LetOrConst(state) {
|
|
@@ -13549,7 +13612,7 @@ ${input.slice(result.pos)}
|
|
|
13549
13612
|
return result;
|
|
13550
13613
|
}
|
|
13551
13614
|
}
|
|
13552
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
13615
|
+
var Loop$0 = $TS($S($EXPECT($L128, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13553
13616
|
return { $loc, token: "while(true)" };
|
|
13554
13617
|
});
|
|
13555
13618
|
function Loop(state) {
|
|
@@ -13574,7 +13637,7 @@ ${input.slice(result.pos)}
|
|
|
13574
13637
|
return result;
|
|
13575
13638
|
}
|
|
13576
13639
|
}
|
|
13577
|
-
var New$0 = $TS($S($EXPECT($
|
|
13640
|
+
var New$0 = $TS($S($EXPECT($L129, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13578
13641
|
return { $loc, token: $1 };
|
|
13579
13642
|
});
|
|
13580
13643
|
function New(state) {
|
|
@@ -13599,7 +13662,7 @@ ${input.slice(result.pos)}
|
|
|
13599
13662
|
return result;
|
|
13600
13663
|
}
|
|
13601
13664
|
}
|
|
13602
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
13665
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L51, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L8, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13603
13666
|
return { $loc, token: "!" };
|
|
13604
13667
|
});
|
|
13605
13668
|
function Not(state) {
|
|
@@ -13624,7 +13687,7 @@ ${input.slice(result.pos)}
|
|
|
13624
13687
|
return result;
|
|
13625
13688
|
}
|
|
13626
13689
|
}
|
|
13627
|
-
var Of$0 = $TS($S($EXPECT($
|
|
13690
|
+
var Of$0 = $TS($S($EXPECT($L72, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13628
13691
|
return { $loc, token: $1 };
|
|
13629
13692
|
});
|
|
13630
13693
|
function Of(state) {
|
|
@@ -13649,7 +13712,7 @@ ${input.slice(result.pos)}
|
|
|
13649
13712
|
return result;
|
|
13650
13713
|
}
|
|
13651
13714
|
}
|
|
13652
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
13715
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L130, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
13653
13716
|
return { $loc, token: $1 };
|
|
13654
13717
|
});
|
|
13655
13718
|
function OpenAngleBracket(state) {
|
|
@@ -13674,7 +13737,7 @@ ${input.slice(result.pos)}
|
|
|
13674
13737
|
return result;
|
|
13675
13738
|
}
|
|
13676
13739
|
}
|
|
13677
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
13740
|
+
var OpenBrace$0 = $TV($EXPECT($L131, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
13678
13741
|
return { $loc, token: $1 };
|
|
13679
13742
|
});
|
|
13680
13743
|
function OpenBrace(state) {
|
|
@@ -13699,7 +13762,7 @@ ${input.slice(result.pos)}
|
|
|
13699
13762
|
return result;
|
|
13700
13763
|
}
|
|
13701
13764
|
}
|
|
13702
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
13765
|
+
var OpenBracket$0 = $TV($EXPECT($L95, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
13703
13766
|
return { $loc, token: $1 };
|
|
13704
13767
|
});
|
|
13705
13768
|
function OpenBracket(state) {
|
|
@@ -13749,7 +13812,7 @@ ${input.slice(result.pos)}
|
|
|
13749
13812
|
return result;
|
|
13750
13813
|
}
|
|
13751
13814
|
}
|
|
13752
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
13815
|
+
var Operator$0 = $TS($S($EXPECT($L132, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13753
13816
|
return { $loc, token: $1 };
|
|
13754
13817
|
});
|
|
13755
13818
|
function Operator(state) {
|
|
@@ -13774,7 +13837,7 @@ ${input.slice(result.pos)}
|
|
|
13774
13837
|
return result;
|
|
13775
13838
|
}
|
|
13776
13839
|
}
|
|
13777
|
-
var Public$0 = $TS($S($EXPECT($
|
|
13840
|
+
var Public$0 = $TS($S($EXPECT($L133, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13778
13841
|
return { $loc, token: $1 };
|
|
13779
13842
|
});
|
|
13780
13843
|
function Public(state) {
|
|
@@ -13799,7 +13862,7 @@ ${input.slice(result.pos)}
|
|
|
13799
13862
|
return result;
|
|
13800
13863
|
}
|
|
13801
13864
|
}
|
|
13802
|
-
var Private$0 = $TS($S($EXPECT($
|
|
13865
|
+
var Private$0 = $TS($S($EXPECT($L134, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13803
13866
|
return { $loc, token: $1 };
|
|
13804
13867
|
});
|
|
13805
13868
|
function Private(state) {
|
|
@@ -13824,7 +13887,7 @@ ${input.slice(result.pos)}
|
|
|
13824
13887
|
return result;
|
|
13825
13888
|
}
|
|
13826
13889
|
}
|
|
13827
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
13890
|
+
var Protected$0 = $TS($S($EXPECT($L135, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13828
13891
|
return { $loc, token: $1 };
|
|
13829
13892
|
});
|
|
13830
13893
|
function Protected(state) {
|
|
@@ -13849,7 +13912,13 @@ ${input.slice(result.pos)}
|
|
|
13849
13912
|
return result;
|
|
13850
13913
|
}
|
|
13851
13914
|
}
|
|
13852
|
-
var Pipe$0 = $TV($EXPECT($
|
|
13915
|
+
var Pipe$0 = $TV($EXPECT($L136, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
13916
|
+
return { $loc, token: $1 };
|
|
13917
|
+
});
|
|
13918
|
+
var Pipe$1 = $TV($EXPECT($L137, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
13919
|
+
return { $loc, token: $1 };
|
|
13920
|
+
});
|
|
13921
|
+
var Pipe$2 = $TV($EXPECT($L138, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
13853
13922
|
return { $loc, token: $1 };
|
|
13854
13923
|
});
|
|
13855
13924
|
function Pipe(state) {
|
|
@@ -13863,12 +13932,12 @@ ${input.slice(result.pos)}
|
|
|
13863
13932
|
}
|
|
13864
13933
|
}
|
|
13865
13934
|
if (state.tokenize) {
|
|
13866
|
-
const result = $TOKEN("Pipe", state, Pipe$0(state));
|
|
13935
|
+
const result = $TOKEN("Pipe", state, Pipe$0(state) || Pipe$1(state) || Pipe$2(state));
|
|
13867
13936
|
if (state.events)
|
|
13868
13937
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13869
13938
|
return result;
|
|
13870
13939
|
} else {
|
|
13871
|
-
const result = Pipe$0(state);
|
|
13940
|
+
const result = Pipe$0(state) || Pipe$1(state) || Pipe$2(state);
|
|
13872
13941
|
if (state.events)
|
|
13873
13942
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13874
13943
|
return result;
|
|
@@ -13899,7 +13968,7 @@ ${input.slice(result.pos)}
|
|
|
13899
13968
|
return result;
|
|
13900
13969
|
}
|
|
13901
13970
|
}
|
|
13902
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
13971
|
+
var Readonly$0 = $TS($S($EXPECT($L139, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13903
13972
|
return { $loc, token: $1, ts: true };
|
|
13904
13973
|
});
|
|
13905
13974
|
function Readonly(state) {
|
|
@@ -13924,7 +13993,7 @@ ${input.slice(result.pos)}
|
|
|
13924
13993
|
return result;
|
|
13925
13994
|
}
|
|
13926
13995
|
}
|
|
13927
|
-
var Return$0 = $TS($S($EXPECT($
|
|
13996
|
+
var Return$0 = $TS($S($EXPECT($L140, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13928
13997
|
return { $loc, token: $1 };
|
|
13929
13998
|
});
|
|
13930
13999
|
function Return(state) {
|
|
@@ -13949,7 +14018,7 @@ ${input.slice(result.pos)}
|
|
|
13949
14018
|
return result;
|
|
13950
14019
|
}
|
|
13951
14020
|
}
|
|
13952
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14021
|
+
var Satisfies$0 = $TS($S($EXPECT($L141, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13953
14022
|
return { $loc, token: $1 };
|
|
13954
14023
|
});
|
|
13955
14024
|
function Satisfies(state) {
|
|
@@ -13974,7 +14043,7 @@ ${input.slice(result.pos)}
|
|
|
13974
14043
|
return result;
|
|
13975
14044
|
}
|
|
13976
14045
|
}
|
|
13977
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14046
|
+
var Semicolon$0 = $TV($EXPECT($L84, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
13978
14047
|
return { $loc, token: $1 };
|
|
13979
14048
|
});
|
|
13980
14049
|
function Semicolon(state) {
|
|
@@ -13999,7 +14068,7 @@ ${input.slice(result.pos)}
|
|
|
13999
14068
|
return result;
|
|
14000
14069
|
}
|
|
14001
14070
|
}
|
|
14002
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14071
|
+
var SingleQuote$0 = $TV($EXPECT($L142, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14003
14072
|
return { $loc, token: $1 };
|
|
14004
14073
|
});
|
|
14005
14074
|
function SingleQuote(state) {
|
|
@@ -14024,7 +14093,7 @@ ${input.slice(result.pos)}
|
|
|
14024
14093
|
return result;
|
|
14025
14094
|
}
|
|
14026
14095
|
}
|
|
14027
|
-
var Star$0 = $TV($EXPECT($
|
|
14096
|
+
var Star$0 = $TV($EXPECT($L53, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14028
14097
|
return { $loc, token: $1 };
|
|
14029
14098
|
});
|
|
14030
14099
|
function Star(state) {
|
|
@@ -14049,10 +14118,10 @@ ${input.slice(result.pos)}
|
|
|
14049
14118
|
return result;
|
|
14050
14119
|
}
|
|
14051
14120
|
}
|
|
14052
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14121
|
+
var Static$0 = $TS($S($EXPECT($L143, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14053
14122
|
return { $loc, token: $1 };
|
|
14054
14123
|
});
|
|
14055
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14124
|
+
var Static$1 = $TS($S($EXPECT($L99, fail, 'Static "@"'), $N($C($EXPECT($L2, fail, 'Static "("'), $EXPECT($L99, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
14056
14125
|
return { $loc, token: "static " };
|
|
14057
14126
|
});
|
|
14058
14127
|
function Static(state) {
|
|
@@ -14077,7 +14146,7 @@ ${input.slice(result.pos)}
|
|
|
14077
14146
|
return result;
|
|
14078
14147
|
}
|
|
14079
14148
|
}
|
|
14080
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14149
|
+
var SubstitutionStart$0 = $TV($EXPECT($L144, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14081
14150
|
return { $loc, token: $1 };
|
|
14082
14151
|
});
|
|
14083
14152
|
function SubstitutionStart(state) {
|
|
@@ -14102,7 +14171,7 @@ ${input.slice(result.pos)}
|
|
|
14102
14171
|
return result;
|
|
14103
14172
|
}
|
|
14104
14173
|
}
|
|
14105
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14174
|
+
var Switch$0 = $TS($S($EXPECT($L145, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14106
14175
|
return { $loc, token: $1 };
|
|
14107
14176
|
});
|
|
14108
14177
|
function Switch(state) {
|
|
@@ -14127,7 +14196,7 @@ ${input.slice(result.pos)}
|
|
|
14127
14196
|
return result;
|
|
14128
14197
|
}
|
|
14129
14198
|
}
|
|
14130
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14199
|
+
var Target$0 = $TS($S($EXPECT($L146, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14131
14200
|
return { $loc, token: $1 };
|
|
14132
14201
|
});
|
|
14133
14202
|
function Target(state) {
|
|
@@ -14152,7 +14221,7 @@ ${input.slice(result.pos)}
|
|
|
14152
14221
|
return result;
|
|
14153
14222
|
}
|
|
14154
14223
|
}
|
|
14155
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14224
|
+
var Then$0 = $TS($S(__, $EXPECT($L147, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14156
14225
|
return { $loc, token: "" };
|
|
14157
14226
|
});
|
|
14158
14227
|
function Then(state) {
|
|
@@ -14177,7 +14246,7 @@ ${input.slice(result.pos)}
|
|
|
14177
14246
|
return result;
|
|
14178
14247
|
}
|
|
14179
14248
|
}
|
|
14180
|
-
var This$0 = $TS($S($EXPECT($
|
|
14249
|
+
var This$0 = $TS($S($EXPECT($L148, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14181
14250
|
return { $loc, token: $1 };
|
|
14182
14251
|
});
|
|
14183
14252
|
function This(state) {
|
|
@@ -14202,7 +14271,7 @@ ${input.slice(result.pos)}
|
|
|
14202
14271
|
return result;
|
|
14203
14272
|
}
|
|
14204
14273
|
}
|
|
14205
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14274
|
+
var Throw$0 = $TS($S($EXPECT($L149, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14206
14275
|
return { $loc, token: $1 };
|
|
14207
14276
|
});
|
|
14208
14277
|
function Throw(state) {
|
|
@@ -14227,7 +14296,7 @@ ${input.slice(result.pos)}
|
|
|
14227
14296
|
return result;
|
|
14228
14297
|
}
|
|
14229
14298
|
}
|
|
14230
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14299
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L150, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14231
14300
|
return { $loc, token: "`" };
|
|
14232
14301
|
});
|
|
14233
14302
|
function TripleDoubleQuote(state) {
|
|
@@ -14252,7 +14321,7 @@ ${input.slice(result.pos)}
|
|
|
14252
14321
|
return result;
|
|
14253
14322
|
}
|
|
14254
14323
|
}
|
|
14255
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14324
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L151, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14256
14325
|
return { $loc, token: "`" };
|
|
14257
14326
|
});
|
|
14258
14327
|
function TripleSingleQuote(state) {
|
|
@@ -14277,7 +14346,7 @@ ${input.slice(result.pos)}
|
|
|
14277
14346
|
return result;
|
|
14278
14347
|
}
|
|
14279
14348
|
}
|
|
14280
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14349
|
+
var TripleSlash$0 = $TV($EXPECT($L152, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14281
14350
|
return { $loc, token: "/" };
|
|
14282
14351
|
});
|
|
14283
14352
|
function TripleSlash(state) {
|
|
@@ -14302,7 +14371,7 @@ ${input.slice(result.pos)}
|
|
|
14302
14371
|
return result;
|
|
14303
14372
|
}
|
|
14304
14373
|
}
|
|
14305
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14374
|
+
var TripleTick$0 = $TV($EXPECT($L153, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14306
14375
|
return { $loc, token: "`" };
|
|
14307
14376
|
});
|
|
14308
14377
|
function TripleTick(state) {
|
|
@@ -14327,7 +14396,7 @@ ${input.slice(result.pos)}
|
|
|
14327
14396
|
return result;
|
|
14328
14397
|
}
|
|
14329
14398
|
}
|
|
14330
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14399
|
+
var Try$0 = $TS($S($EXPECT($L154, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14331
14400
|
return { $loc, token: $1 };
|
|
14332
14401
|
});
|
|
14333
14402
|
function Try(state) {
|
|
@@ -14352,7 +14421,7 @@ ${input.slice(result.pos)}
|
|
|
14352
14421
|
return result;
|
|
14353
14422
|
}
|
|
14354
14423
|
}
|
|
14355
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
14424
|
+
var Typeof$0 = $TS($S($EXPECT($L155, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14356
14425
|
return { $loc, token: $1 };
|
|
14357
14426
|
});
|
|
14358
14427
|
function Typeof(state) {
|
|
@@ -14377,7 +14446,7 @@ ${input.slice(result.pos)}
|
|
|
14377
14446
|
return result;
|
|
14378
14447
|
}
|
|
14379
14448
|
}
|
|
14380
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
14449
|
+
var Unless$0 = $TS($S($EXPECT($L156, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14381
14450
|
return { $loc, token: $1 };
|
|
14382
14451
|
});
|
|
14383
14452
|
function Unless(state) {
|
|
@@ -14402,7 +14471,7 @@ ${input.slice(result.pos)}
|
|
|
14402
14471
|
return result;
|
|
14403
14472
|
}
|
|
14404
14473
|
}
|
|
14405
|
-
var Until$0 = $TS($S($EXPECT($
|
|
14474
|
+
var Until$0 = $TS($S($EXPECT($L157, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14406
14475
|
return { $loc, token: $1 };
|
|
14407
14476
|
});
|
|
14408
14477
|
function Until(state) {
|
|
@@ -14427,7 +14496,7 @@ ${input.slice(result.pos)}
|
|
|
14427
14496
|
return result;
|
|
14428
14497
|
}
|
|
14429
14498
|
}
|
|
14430
|
-
var Var$0 = $TS($S($EXPECT($
|
|
14499
|
+
var Var$0 = $TS($S($EXPECT($L158, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14431
14500
|
return { $loc, token: $1 };
|
|
14432
14501
|
});
|
|
14433
14502
|
function Var(state) {
|
|
@@ -14452,7 +14521,7 @@ ${input.slice(result.pos)}
|
|
|
14452
14521
|
return result;
|
|
14453
14522
|
}
|
|
14454
14523
|
}
|
|
14455
|
-
var Void$0 = $TS($S($EXPECT($
|
|
14524
|
+
var Void$0 = $TS($S($EXPECT($L159, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14456
14525
|
return { $loc, token: $1 };
|
|
14457
14526
|
});
|
|
14458
14527
|
function Void(state) {
|
|
@@ -14477,7 +14546,7 @@ ${input.slice(result.pos)}
|
|
|
14477
14546
|
return result;
|
|
14478
14547
|
}
|
|
14479
14548
|
}
|
|
14480
|
-
var When$0 = $TS($S($EXPECT($
|
|
14549
|
+
var When$0 = $TS($S($EXPECT($L160, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14481
14550
|
return { $loc, token: "case" };
|
|
14482
14551
|
});
|
|
14483
14552
|
function When(state) {
|
|
@@ -14502,7 +14571,7 @@ ${input.slice(result.pos)}
|
|
|
14502
14571
|
return result;
|
|
14503
14572
|
}
|
|
14504
14573
|
}
|
|
14505
|
-
var While$0 = $TS($S($EXPECT($
|
|
14574
|
+
var While$0 = $TS($S($EXPECT($L161, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14506
14575
|
return { $loc, token: $1 };
|
|
14507
14576
|
});
|
|
14508
14577
|
function While(state) {
|
|
@@ -14527,7 +14596,7 @@ ${input.slice(result.pos)}
|
|
|
14527
14596
|
return result;
|
|
14528
14597
|
}
|
|
14529
14598
|
}
|
|
14530
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
14599
|
+
var Yield$0 = $TS($S($EXPECT($L162, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14531
14600
|
return { $loc, token: $1 };
|
|
14532
14601
|
});
|
|
14533
14602
|
function Yield(state) {
|
|
@@ -14673,7 +14742,7 @@ ${input.slice(result.pos)}
|
|
|
14673
14742
|
return result;
|
|
14674
14743
|
}
|
|
14675
14744
|
}
|
|
14676
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
14745
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L130, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L163, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
14677
14746
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
14678
14747
|
});
|
|
14679
14748
|
function JSXSelfClosingElement(state) {
|
|
@@ -14724,7 +14793,7 @@ ${input.slice(result.pos)}
|
|
|
14724
14793
|
return result;
|
|
14725
14794
|
}
|
|
14726
14795
|
}
|
|
14727
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
14796
|
+
var JSXOpeningElement$0 = $S($EXPECT($L130, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
14728
14797
|
function JSXOpeningElement(state) {
|
|
14729
14798
|
let eventData;
|
|
14730
14799
|
if (state.events) {
|
|
@@ -14753,7 +14822,7 @@ ${input.slice(result.pos)}
|
|
|
14753
14822
|
return $skip;
|
|
14754
14823
|
return $0;
|
|
14755
14824
|
});
|
|
14756
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
14825
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L18, fail, 'JSXOptionalClosingElement ""');
|
|
14757
14826
|
function JSXOptionalClosingElement(state) {
|
|
14758
14827
|
let eventData;
|
|
14759
14828
|
if (state.events) {
|
|
@@ -14776,7 +14845,7 @@ ${input.slice(result.pos)}
|
|
|
14776
14845
|
return result;
|
|
14777
14846
|
}
|
|
14778
14847
|
}
|
|
14779
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
14848
|
+
var JSXClosingElement$0 = $S($EXPECT($L164, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
14780
14849
|
function JSXClosingElement(state) {
|
|
14781
14850
|
let eventData;
|
|
14782
14851
|
if (state.events) {
|
|
@@ -14815,7 +14884,7 @@ ${input.slice(result.pos)}
|
|
|
14815
14884
|
];
|
|
14816
14885
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
14817
14886
|
});
|
|
14818
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
14887
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L165, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14819
14888
|
var children = $3;
|
|
14820
14889
|
$0 = $0.slice(1);
|
|
14821
14890
|
return {
|
|
@@ -14846,7 +14915,7 @@ ${input.slice(result.pos)}
|
|
|
14846
14915
|
return result;
|
|
14847
14916
|
}
|
|
14848
14917
|
}
|
|
14849
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
14918
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L165, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
14850
14919
|
module.JSXTagStack.push("");
|
|
14851
14920
|
return $1;
|
|
14852
14921
|
});
|
|
@@ -14877,7 +14946,7 @@ ${input.slice(result.pos)}
|
|
|
14877
14946
|
return $skip;
|
|
14878
14947
|
return $0;
|
|
14879
14948
|
});
|
|
14880
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
14949
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L18, fail, 'JSXOptionalClosingFragment ""');
|
|
14881
14950
|
function JSXOptionalClosingFragment(state) {
|
|
14882
14951
|
let eventData;
|
|
14883
14952
|
if (state.events) {
|
|
@@ -14900,7 +14969,7 @@ ${input.slice(result.pos)}
|
|
|
14900
14969
|
return result;
|
|
14901
14970
|
}
|
|
14902
14971
|
}
|
|
14903
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
14972
|
+
var JSXClosingFragment$0 = $EXPECT($L166, fail, 'JSXClosingFragment "</>"');
|
|
14904
14973
|
function JSXClosingFragment(state) {
|
|
14905
14974
|
let eventData;
|
|
14906
14975
|
if (state.events) {
|
|
@@ -14946,7 +15015,7 @@ ${input.slice(result.pos)}
|
|
|
14946
15015
|
return result;
|
|
14947
15016
|
}
|
|
14948
15017
|
}
|
|
14949
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
15018
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R49, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
14950
15019
|
function JSXIdentifierName(state) {
|
|
14951
15020
|
let eventData;
|
|
14952
15021
|
if (state.events) {
|
|
@@ -15162,7 +15231,7 @@ ${input.slice(result.pos)}
|
|
|
15162
15231
|
return result;
|
|
15163
15232
|
}
|
|
15164
15233
|
}
|
|
15165
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
15234
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R50, fail, "JSXAttributeSpace /[\\s>]/"));
|
|
15166
15235
|
function JSXAttributeSpace(state) {
|
|
15167
15236
|
let eventData;
|
|
15168
15237
|
if (state.events) {
|
|
@@ -15185,7 +15254,7 @@ ${input.slice(result.pos)}
|
|
|
15185
15254
|
return result;
|
|
15186
15255
|
}
|
|
15187
15256
|
}
|
|
15188
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
15257
|
+
var JSXShorthandString$0 = $TR($EXPECT($R51, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15189
15258
|
return module.quoteString($0);
|
|
15190
15259
|
});
|
|
15191
15260
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -15321,7 +15390,7 @@ ${input.slice(result.pos)}
|
|
|
15321
15390
|
return result;
|
|
15322
15391
|
}
|
|
15323
15392
|
}
|
|
15324
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
15393
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R52, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
15325
15394
|
var op = $2;
|
|
15326
15395
|
var rhs = $3;
|
|
15327
15396
|
return [[], op, [], rhs];
|
|
@@ -15376,7 +15445,7 @@ ${input.slice(result.pos)}
|
|
|
15376
15445
|
return result;
|
|
15377
15446
|
}
|
|
15378
15447
|
}
|
|
15379
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
15448
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R8, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15380
15449
|
return { $loc, token: $0 };
|
|
15381
15450
|
});
|
|
15382
15451
|
function InlineJSXUnaryOp(state) {
|
|
@@ -15667,7 +15736,7 @@ ${input.slice(result.pos)}
|
|
|
15667
15736
|
}
|
|
15668
15737
|
return $skip;
|
|
15669
15738
|
});
|
|
15670
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
15739
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
15671
15740
|
return { children: [], jsxChildren: [] };
|
|
15672
15741
|
});
|
|
15673
15742
|
function JSXNestedChildren(state) {
|
|
@@ -15796,7 +15865,7 @@ ${input.slice(result.pos)}
|
|
|
15796
15865
|
return result;
|
|
15797
15866
|
}
|
|
15798
15867
|
}
|
|
15799
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
15868
|
+
var JSXComment$0 = $TS($S($EXPECT($L167, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L168, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
15800
15869
|
return ["{/*", $2, "*/}"];
|
|
15801
15870
|
});
|
|
15802
15871
|
function JSXComment(state) {
|
|
@@ -15821,7 +15890,7 @@ ${input.slice(result.pos)}
|
|
|
15821
15890
|
return result;
|
|
15822
15891
|
}
|
|
15823
15892
|
}
|
|
15824
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
15893
|
+
var JSXCommentContent$0 = $TR($EXPECT($R53, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15825
15894
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
15826
15895
|
});
|
|
15827
15896
|
function JSXCommentContent(state) {
|
|
@@ -15846,7 +15915,7 @@ ${input.slice(result.pos)}
|
|
|
15846
15915
|
return result;
|
|
15847
15916
|
}
|
|
15848
15917
|
}
|
|
15849
|
-
var JSXText$0 = $TR($EXPECT($
|
|
15918
|
+
var JSXText$0 = $TR($EXPECT($R54, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15850
15919
|
return {
|
|
15851
15920
|
type: "JSXText",
|
|
15852
15921
|
token: $0,
|
|
@@ -16094,7 +16163,7 @@ ${input.slice(result.pos)}
|
|
|
16094
16163
|
return result;
|
|
16095
16164
|
}
|
|
16096
16165
|
}
|
|
16097
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16166
|
+
var TypeKeyword$0 = $S($EXPECT($L169, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16098
16167
|
function TypeKeyword(state) {
|
|
16099
16168
|
let eventData;
|
|
16100
16169
|
if (state.events) {
|
|
@@ -16117,7 +16186,7 @@ ${input.slice(result.pos)}
|
|
|
16117
16186
|
return result;
|
|
16118
16187
|
}
|
|
16119
16188
|
}
|
|
16120
|
-
var Interface$0 = $S($EXPECT($
|
|
16189
|
+
var Interface$0 = $S($EXPECT($L170, fail, 'Interface "interface"'), NonIdContinue);
|
|
16121
16190
|
function Interface(state) {
|
|
16122
16191
|
let eventData;
|
|
16123
16192
|
if (state.events) {
|
|
@@ -16140,7 +16209,7 @@ ${input.slice(result.pos)}
|
|
|
16140
16209
|
return result;
|
|
16141
16210
|
}
|
|
16142
16211
|
}
|
|
16143
|
-
var Namespace$0 = $S($EXPECT($
|
|
16212
|
+
var Namespace$0 = $S($EXPECT($L171, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16144
16213
|
function Namespace(state) {
|
|
16145
16214
|
let eventData;
|
|
16146
16215
|
if (state.events) {
|
|
@@ -16388,7 +16457,7 @@ ${input.slice(result.pos)}
|
|
|
16388
16457
|
return result;
|
|
16389
16458
|
}
|
|
16390
16459
|
}
|
|
16391
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
16460
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R55, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L139, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R56, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
16392
16461
|
function TypeIndexSignature(state) {
|
|
16393
16462
|
let eventData;
|
|
16394
16463
|
if (state.events) {
|
|
@@ -16460,7 +16529,7 @@ ${input.slice(result.pos)}
|
|
|
16460
16529
|
return result;
|
|
16461
16530
|
}
|
|
16462
16531
|
}
|
|
16463
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
16532
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L172, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
16464
16533
|
const children = [...$1, $2];
|
|
16465
16534
|
if ($3)
|
|
16466
16535
|
children.push($3);
|
|
@@ -16493,7 +16562,7 @@ ${input.slice(result.pos)}
|
|
|
16493
16562
|
return result;
|
|
16494
16563
|
}
|
|
16495
16564
|
}
|
|
16496
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
16565
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L81, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
16497
16566
|
if (!$2)
|
|
16498
16567
|
return $1;
|
|
16499
16568
|
return $0;
|
|
@@ -16619,10 +16688,10 @@ ${input.slice(result.pos)}
|
|
|
16619
16688
|
return result;
|
|
16620
16689
|
}
|
|
16621
16690
|
}
|
|
16622
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
16623
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
16624
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
16625
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
16691
|
+
var TypeUnaryOp$0 = $S($EXPECT($L173, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
16692
|
+
var TypeUnaryOp$1 = $S($EXPECT($L155, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
16693
|
+
var TypeUnaryOp$2 = $S($EXPECT($L174, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
16694
|
+
var TypeUnaryOp$3 = $S($EXPECT($L139, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
16626
16695
|
function TypeUnaryOp(state) {
|
|
16627
16696
|
let eventData;
|
|
16628
16697
|
if (state.events) {
|
|
@@ -16820,7 +16889,7 @@ ${input.slice(result.pos)}
|
|
|
16820
16889
|
return result;
|
|
16821
16890
|
}
|
|
16822
16891
|
}
|
|
16823
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
16892
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L118, fail, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
16824
16893
|
if ($2)
|
|
16825
16894
|
return $0;
|
|
16826
16895
|
return $1;
|
|
@@ -16849,10 +16918,10 @@ ${input.slice(result.pos)}
|
|
|
16849
16918
|
}
|
|
16850
16919
|
var TypeLiteral$0 = TemplateLiteral;
|
|
16851
16920
|
var TypeLiteral$1 = Literal;
|
|
16852
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
16921
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L159, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16853
16922
|
return { $loc, token: "void" };
|
|
16854
16923
|
});
|
|
16855
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
16924
|
+
var TypeLiteral$3 = $TV($EXPECT($L175, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
16856
16925
|
return { $loc, token: "[]" };
|
|
16857
16926
|
});
|
|
16858
16927
|
function TypeLiteral(state) {
|
|
@@ -16927,7 +16996,7 @@ ${input.slice(result.pos)}
|
|
|
16927
16996
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
16928
16997
|
return value[1];
|
|
16929
16998
|
});
|
|
16930
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
16999
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L19, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
16931
17000
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
16932
17001
|
function InlineInterfacePropertyDelimiter(state) {
|
|
16933
17002
|
let eventData;
|
|
@@ -16951,10 +17020,10 @@ ${input.slice(result.pos)}
|
|
|
16951
17020
|
return result;
|
|
16952
17021
|
}
|
|
16953
17022
|
}
|
|
16954
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17023
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
16955
17024
|
return { $loc, token: "|" };
|
|
16956
17025
|
});
|
|
16957
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17026
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L82, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
16958
17027
|
return { $loc, token: "&" };
|
|
16959
17028
|
});
|
|
16960
17029
|
function TypeBinaryOp(state) {
|
|
@@ -17011,7 +17080,7 @@ ${input.slice(result.pos)}
|
|
|
17011
17080
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17012
17081
|
return { $loc, token: "=>" };
|
|
17013
17082
|
});
|
|
17014
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17083
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17015
17084
|
return { $loc, token: "=>" };
|
|
17016
17085
|
});
|
|
17017
17086
|
function TypeArrowFunction(state) {
|
|
@@ -17036,7 +17105,7 @@ ${input.slice(result.pos)}
|
|
|
17036
17105
|
return result;
|
|
17037
17106
|
}
|
|
17038
17107
|
}
|
|
17039
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17108
|
+
var TypeArguments$0 = $TS($S($EXPECT($L130, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17040
17109
|
return { ts: true, children: $0 };
|
|
17041
17110
|
});
|
|
17042
17111
|
function TypeArguments(state) {
|
|
@@ -17107,7 +17176,7 @@ ${input.slice(result.pos)}
|
|
|
17107
17176
|
return result;
|
|
17108
17177
|
}
|
|
17109
17178
|
}
|
|
17110
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17179
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L130, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17111
17180
|
var parameters = $3;
|
|
17112
17181
|
return {
|
|
17113
17182
|
type: "TypeParameters",
|
|
@@ -17161,7 +17230,7 @@ ${input.slice(result.pos)}
|
|
|
17161
17230
|
return result;
|
|
17162
17231
|
}
|
|
17163
17232
|
}
|
|
17164
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17233
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L118, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17165
17234
|
function TypeConstraint(state) {
|
|
17166
17235
|
let eventData;
|
|
17167
17236
|
if (state.events) {
|
|
@@ -17208,7 +17277,7 @@ ${input.slice(result.pos)}
|
|
|
17208
17277
|
}
|
|
17209
17278
|
}
|
|
17210
17279
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17211
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17280
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17212
17281
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17213
17282
|
return value[1];
|
|
17214
17283
|
});
|
|
@@ -17259,7 +17328,7 @@ ${input.slice(result.pos)}
|
|
|
17259
17328
|
return result;
|
|
17260
17329
|
}
|
|
17261
17330
|
}
|
|
17262
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
17331
|
+
var Shebang$0 = $S($R$0($EXPECT($R57, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
17263
17332
|
function Shebang(state) {
|
|
17264
17333
|
let eventData;
|
|
17265
17334
|
if (state.events) {
|
|
@@ -17282,11 +17351,11 @@ ${input.slice(result.pos)}
|
|
|
17282
17351
|
return result;
|
|
17283
17352
|
}
|
|
17284
17353
|
}
|
|
17285
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
17354
|
+
var CivetPrologue$0 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17286
17355
|
var content = value[2];
|
|
17287
17356
|
return content;
|
|
17288
17357
|
});
|
|
17289
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
17358
|
+
var CivetPrologue$1 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17290
17359
|
var content = value[2];
|
|
17291
17360
|
return content;
|
|
17292
17361
|
});
|
|
@@ -17312,7 +17381,7 @@ ${input.slice(result.pos)}
|
|
|
17312
17381
|
return result;
|
|
17313
17382
|
}
|
|
17314
17383
|
}
|
|
17315
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
17384
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L176, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R59, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17316
17385
|
var options = $3;
|
|
17317
17386
|
return {
|
|
17318
17387
|
type: "CivetPrologue",
|
|
@@ -17342,7 +17411,7 @@ ${input.slice(result.pos)}
|
|
|
17342
17411
|
return result;
|
|
17343
17412
|
}
|
|
17344
17413
|
}
|
|
17345
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
17414
|
+
var CivetOption$0 = $TR($EXPECT($R60, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17346
17415
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
17347
17416
|
if (l)
|
|
17348
17417
|
return l.toUpperCase();
|
|
@@ -17378,7 +17447,7 @@ ${input.slice(result.pos)}
|
|
|
17378
17447
|
return result;
|
|
17379
17448
|
}
|
|
17380
17449
|
}
|
|
17381
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
17450
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R58, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
17382
17451
|
function UnknownPrologue(state) {
|
|
17383
17452
|
let eventData;
|
|
17384
17453
|
if (state.events) {
|
|
@@ -17448,7 +17517,7 @@ ${input.slice(result.pos)}
|
|
|
17448
17517
|
return result;
|
|
17449
17518
|
}
|
|
17450
17519
|
}
|
|
17451
|
-
var EOL$0 = $TR($EXPECT($
|
|
17520
|
+
var EOL$0 = $TR($EXPECT($R61, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17452
17521
|
return { $loc, token: $0 };
|
|
17453
17522
|
});
|
|
17454
17523
|
function EOL(state) {
|
|
@@ -17473,7 +17542,7 @@ ${input.slice(result.pos)}
|
|
|
17473
17542
|
return result;
|
|
17474
17543
|
}
|
|
17475
17544
|
}
|
|
17476
|
-
var Debugger$0 = $TV($EXPECT($
|
|
17545
|
+
var Debugger$0 = $TV($EXPECT($L18, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
17477
17546
|
debugger;
|
|
17478
17547
|
});
|
|
17479
17548
|
function Debugger(state) {
|
|
@@ -17498,7 +17567,7 @@ ${input.slice(result.pos)}
|
|
|
17498
17567
|
return result;
|
|
17499
17568
|
}
|
|
17500
17569
|
}
|
|
17501
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
17570
|
+
var InsertSemicolon$0 = $TV($EXPECT($L18, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
17502
17571
|
return { $loc, token: ";" };
|
|
17503
17572
|
});
|
|
17504
17573
|
function InsertSemicolon(state) {
|
|
@@ -17523,7 +17592,7 @@ ${input.slice(result.pos)}
|
|
|
17523
17592
|
return result;
|
|
17524
17593
|
}
|
|
17525
17594
|
}
|
|
17526
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
17595
|
+
var InsertOpenParen$0 = $TV($EXPECT($L18, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
17527
17596
|
return { $loc, token: "(" };
|
|
17528
17597
|
});
|
|
17529
17598
|
function InsertOpenParen(state) {
|
|
@@ -17548,7 +17617,7 @@ ${input.slice(result.pos)}
|
|
|
17548
17617
|
return result;
|
|
17549
17618
|
}
|
|
17550
17619
|
}
|
|
17551
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
17620
|
+
var InsertCloseParen$0 = $TV($EXPECT($L18, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
17552
17621
|
return { $loc, token: ")" };
|
|
17553
17622
|
});
|
|
17554
17623
|
function InsertCloseParen(state) {
|
|
@@ -17573,7 +17642,7 @@ ${input.slice(result.pos)}
|
|
|
17573
17642
|
return result;
|
|
17574
17643
|
}
|
|
17575
17644
|
}
|
|
17576
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
17645
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17577
17646
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
17578
17647
|
});
|
|
17579
17648
|
function InsertOpenBrace(state) {
|
|
@@ -17598,7 +17667,7 @@ ${input.slice(result.pos)}
|
|
|
17598
17667
|
return result;
|
|
17599
17668
|
}
|
|
17600
17669
|
}
|
|
17601
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
17670
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17602
17671
|
return { $loc, token: "{" };
|
|
17603
17672
|
});
|
|
17604
17673
|
function InsertInlineOpenBrace(state) {
|
|
@@ -17623,7 +17692,7 @@ ${input.slice(result.pos)}
|
|
|
17623
17692
|
return result;
|
|
17624
17693
|
}
|
|
17625
17694
|
}
|
|
17626
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
17695
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L18, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
17627
17696
|
return { $loc, token: "}" };
|
|
17628
17697
|
});
|
|
17629
17698
|
function InsertCloseBrace(state) {
|
|
@@ -17648,7 +17717,7 @@ ${input.slice(result.pos)}
|
|
|
17648
17717
|
return result;
|
|
17649
17718
|
}
|
|
17650
17719
|
}
|
|
17651
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
17720
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L18, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
17652
17721
|
return { $loc, token: "[" };
|
|
17653
17722
|
});
|
|
17654
17723
|
function InsertOpenBracket(state) {
|
|
@@ -17673,7 +17742,7 @@ ${input.slice(result.pos)}
|
|
|
17673
17742
|
return result;
|
|
17674
17743
|
}
|
|
17675
17744
|
}
|
|
17676
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
17745
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L18, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
17677
17746
|
return { $loc, token: "]" };
|
|
17678
17747
|
});
|
|
17679
17748
|
function InsertCloseBracket(state) {
|
|
@@ -17698,7 +17767,7 @@ ${input.slice(result.pos)}
|
|
|
17698
17767
|
return result;
|
|
17699
17768
|
}
|
|
17700
17769
|
}
|
|
17701
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
17770
|
+
var InsertComma$0 = $TV($EXPECT($L18, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
17702
17771
|
return { $loc, token: "," };
|
|
17703
17772
|
});
|
|
17704
17773
|
function InsertComma(state) {
|
|
@@ -17723,7 +17792,7 @@ ${input.slice(result.pos)}
|
|
|
17723
17792
|
return result;
|
|
17724
17793
|
}
|
|
17725
17794
|
}
|
|
17726
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
17795
|
+
var InsertConst$0 = $TV($EXPECT($L18, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
17727
17796
|
return { $loc, token: "const " };
|
|
17728
17797
|
});
|
|
17729
17798
|
function InsertConst(state) {
|
|
@@ -17748,7 +17817,7 @@ ${input.slice(result.pos)}
|
|
|
17748
17817
|
return result;
|
|
17749
17818
|
}
|
|
17750
17819
|
}
|
|
17751
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
17820
|
+
var InsertLet$0 = $TV($EXPECT($L18, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
17752
17821
|
return { $loc, token: "let " };
|
|
17753
17822
|
});
|
|
17754
17823
|
function InsertLet(state) {
|
|
@@ -17773,7 +17842,7 @@ ${input.slice(result.pos)}
|
|
|
17773
17842
|
return result;
|
|
17774
17843
|
}
|
|
17775
17844
|
}
|
|
17776
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
17845
|
+
var InsertReadonly$0 = $TV($EXPECT($L18, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
17777
17846
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
17778
17847
|
});
|
|
17779
17848
|
function InsertReadonly(state) {
|
|
@@ -17798,7 +17867,7 @@ ${input.slice(result.pos)}
|
|
|
17798
17867
|
return result;
|
|
17799
17868
|
}
|
|
17800
17869
|
}
|
|
17801
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
17870
|
+
var InsertNewline$0 = $TV($EXPECT($L18, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
17802
17871
|
return "\n";
|
|
17803
17872
|
});
|
|
17804
17873
|
function InsertNewline(state) {
|
|
@@ -17823,7 +17892,7 @@ ${input.slice(result.pos)}
|
|
|
17823
17892
|
return result;
|
|
17824
17893
|
}
|
|
17825
17894
|
}
|
|
17826
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
17895
|
+
var InsertIndent$0 = $TV($EXPECT($L18, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
17827
17896
|
return module.currentIndent.token;
|
|
17828
17897
|
});
|
|
17829
17898
|
function InsertIndent(state) {
|
|
@@ -17848,7 +17917,7 @@ ${input.slice(result.pos)}
|
|
|
17848
17917
|
return result;
|
|
17849
17918
|
}
|
|
17850
17919
|
}
|
|
17851
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
17920
|
+
var InsertSpace$0 = $TV($EXPECT($L18, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
17852
17921
|
return { $loc, token: " " };
|
|
17853
17922
|
});
|
|
17854
17923
|
function InsertSpace(state) {
|
|
@@ -17873,7 +17942,7 @@ ${input.slice(result.pos)}
|
|
|
17873
17942
|
return result;
|
|
17874
17943
|
}
|
|
17875
17944
|
}
|
|
17876
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
17945
|
+
var InsertDot$0 = $TV($EXPECT($L18, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
17877
17946
|
return { $loc, token: "." };
|
|
17878
17947
|
});
|
|
17879
17948
|
function InsertDot(state) {
|
|
@@ -17898,7 +17967,7 @@ ${input.slice(result.pos)}
|
|
|
17898
17967
|
return result;
|
|
17899
17968
|
}
|
|
17900
17969
|
}
|
|
17901
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
17970
|
+
var InsertBreak$0 = $TV($EXPECT($L18, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
17902
17971
|
return { $loc, token: ";break;" };
|
|
17903
17972
|
});
|
|
17904
17973
|
function InsertBreak(state) {
|
|
@@ -17923,7 +17992,7 @@ ${input.slice(result.pos)}
|
|
|
17923
17992
|
return result;
|
|
17924
17993
|
}
|
|
17925
17994
|
}
|
|
17926
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
17995
|
+
var InsertVar$0 = $TV($EXPECT($L18, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
17927
17996
|
return { $loc, token: "var " };
|
|
17928
17997
|
});
|
|
17929
17998
|
function InsertVar(state) {
|
|
@@ -17948,7 +18017,7 @@ ${input.slice(result.pos)}
|
|
|
17948
18017
|
return result;
|
|
17949
18018
|
}
|
|
17950
18019
|
}
|
|
17951
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18020
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17952
18021
|
if (module.config.coffeeBinaryExistential)
|
|
17953
18022
|
return;
|
|
17954
18023
|
return $skip;
|
|
@@ -17975,7 +18044,7 @@ ${input.slice(result.pos)}
|
|
|
17975
18044
|
return result;
|
|
17976
18045
|
}
|
|
17977
18046
|
}
|
|
17978
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18047
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17979
18048
|
if (module.config.coffeeBooleans)
|
|
17980
18049
|
return;
|
|
17981
18050
|
return $skip;
|
|
@@ -18002,7 +18071,7 @@ ${input.slice(result.pos)}
|
|
|
18002
18071
|
return result;
|
|
18003
18072
|
}
|
|
18004
18073
|
}
|
|
18005
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18074
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18006
18075
|
if (module.config.coffeeClasses)
|
|
18007
18076
|
return;
|
|
18008
18077
|
return $skip;
|
|
@@ -18029,7 +18098,7 @@ ${input.slice(result.pos)}
|
|
|
18029
18098
|
return result;
|
|
18030
18099
|
}
|
|
18031
18100
|
}
|
|
18032
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18101
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18033
18102
|
if (module.config.coffeeComment)
|
|
18034
18103
|
return;
|
|
18035
18104
|
return $skip;
|
|
@@ -18056,7 +18125,7 @@ ${input.slice(result.pos)}
|
|
|
18056
18125
|
return result;
|
|
18057
18126
|
}
|
|
18058
18127
|
}
|
|
18059
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18128
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18060
18129
|
if (module.config.coffeeDo)
|
|
18061
18130
|
return;
|
|
18062
18131
|
return $skip;
|
|
@@ -18083,7 +18152,7 @@ ${input.slice(result.pos)}
|
|
|
18083
18152
|
return result;
|
|
18084
18153
|
}
|
|
18085
18154
|
}
|
|
18086
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18155
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18087
18156
|
if (module.config.coffeeForLoops)
|
|
18088
18157
|
return;
|
|
18089
18158
|
return $skip;
|
|
@@ -18110,7 +18179,7 @@ ${input.slice(result.pos)}
|
|
|
18110
18179
|
return result;
|
|
18111
18180
|
}
|
|
18112
18181
|
}
|
|
18113
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18182
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18114
18183
|
if (module.config.coffeeInterpolation)
|
|
18115
18184
|
return;
|
|
18116
18185
|
return $skip;
|
|
@@ -18137,7 +18206,7 @@ ${input.slice(result.pos)}
|
|
|
18137
18206
|
return result;
|
|
18138
18207
|
}
|
|
18139
18208
|
}
|
|
18140
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18209
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18141
18210
|
if (module.config.coffeeIsnt)
|
|
18142
18211
|
return;
|
|
18143
18212
|
return $skip;
|
|
@@ -18164,7 +18233,7 @@ ${input.slice(result.pos)}
|
|
|
18164
18233
|
return result;
|
|
18165
18234
|
}
|
|
18166
18235
|
}
|
|
18167
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18236
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18168
18237
|
if (module.config.coffeeJSX)
|
|
18169
18238
|
return;
|
|
18170
18239
|
return $skip;
|
|
@@ -18191,7 +18260,7 @@ ${input.slice(result.pos)}
|
|
|
18191
18260
|
return result;
|
|
18192
18261
|
}
|
|
18193
18262
|
}
|
|
18194
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18263
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18195
18264
|
if (module.config.coffeeLineContinuation)
|
|
18196
18265
|
return;
|
|
18197
18266
|
return $skip;
|
|
@@ -18218,7 +18287,7 @@ ${input.slice(result.pos)}
|
|
|
18218
18287
|
return result;
|
|
18219
18288
|
}
|
|
18220
18289
|
}
|
|
18221
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18290
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18222
18291
|
if (module.config.coffeeNot)
|
|
18223
18292
|
return;
|
|
18224
18293
|
return $skip;
|
|
@@ -18245,7 +18314,7 @@ ${input.slice(result.pos)}
|
|
|
18245
18314
|
return result;
|
|
18246
18315
|
}
|
|
18247
18316
|
}
|
|
18248
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18317
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18249
18318
|
if (module.config.coffeeOf)
|
|
18250
18319
|
return;
|
|
18251
18320
|
return $skip;
|
|
@@ -18272,7 +18341,7 @@ ${input.slice(result.pos)}
|
|
|
18272
18341
|
return result;
|
|
18273
18342
|
}
|
|
18274
18343
|
}
|
|
18275
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18344
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18276
18345
|
if (module.config.coffeePrototype)
|
|
18277
18346
|
return;
|
|
18278
18347
|
return $skip;
|
|
@@ -18299,7 +18368,7 @@ ${input.slice(result.pos)}
|
|
|
18299
18368
|
return result;
|
|
18300
18369
|
}
|
|
18301
18370
|
}
|
|
18302
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
18371
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L18, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18303
18372
|
if (module.config.objectIs)
|
|
18304
18373
|
return;
|
|
18305
18374
|
return $skip;
|
|
@@ -18326,7 +18395,7 @@ ${input.slice(result.pos)}
|
|
|
18326
18395
|
return result;
|
|
18327
18396
|
}
|
|
18328
18397
|
}
|
|
18329
|
-
var Reset$0 = $TV($EXPECT($
|
|
18398
|
+
var Reset$0 = $TV($EXPECT($L18, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18330
18399
|
module.indentLevels = [{
|
|
18331
18400
|
level: 0,
|
|
18332
18401
|
token: ""
|
|
@@ -18399,28 +18468,42 @@ ${input.slice(result.pos)}
|
|
|
18399
18468
|
ts: true,
|
|
18400
18469
|
children: [": <T>(this: T[], searchElement: T) => boolean"]
|
|
18401
18470
|
};
|
|
18402
|
-
module.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module.asAny, "
|
|
18471
|
+
module.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
|
|
18403
18472
|
},
|
|
18404
18473
|
hasProp(hasPropRef) {
|
|
18405
18474
|
const typeSuffix = {
|
|
18406
18475
|
ts: true,
|
|
18407
18476
|
children: [": <T>(this: T, prop: keyof T) => boolean"]
|
|
18408
18477
|
};
|
|
18409
|
-
module.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, "
|
|
18478
|
+
module.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
|
|
18410
18479
|
},
|
|
18411
18480
|
is(isRef) {
|
|
18412
18481
|
const typeSuffix = {
|
|
18413
18482
|
ts: true,
|
|
18414
18483
|
children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
|
|
18415
18484
|
};
|
|
18416
|
-
module.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module.asAny, "
|
|
18485
|
+
module.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
|
|
18417
18486
|
},
|
|
18418
18487
|
modulo(moduloRef) {
|
|
18419
18488
|
const typeSuffix = {
|
|
18420
18489
|
ts: true,
|
|
18421
18490
|
children: [": (a: number, b: number) => number"]
|
|
18422
18491
|
};
|
|
18423
|
-
module.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b", "\n"]]);
|
|
18492
|
+
module.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
|
|
18493
|
+
},
|
|
18494
|
+
xor(xorRef) {
|
|
18495
|
+
const typeSuffix = {
|
|
18496
|
+
ts: true,
|
|
18497
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18498
|
+
};
|
|
18499
|
+
module.prelude.push(["", ["const ", xorRef, typeSuffix, " = (a, b) => a && b ? false : a || b;", "\n"]]);
|
|
18500
|
+
},
|
|
18501
|
+
xnor(xnorRef) {
|
|
18502
|
+
const typeSuffix = {
|
|
18503
|
+
ts: true,
|
|
18504
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18505
|
+
};
|
|
18506
|
+
module.prelude.push(["", ["const ", xnorRef, typeSuffix, " = (a, b) => a || b ? a && b : true;", "\n"]]);
|
|
18424
18507
|
},
|
|
18425
18508
|
returnSymbol(ref) {
|
|
18426
18509
|
module.prelude.push({
|
|
@@ -18604,7 +18687,7 @@ ${input.slice(result.pos)}
|
|
|
18604
18687
|
return result;
|
|
18605
18688
|
}
|
|
18606
18689
|
}
|
|
18607
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
18690
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L18, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
18608
18691
|
var directives = $2;
|
|
18609
18692
|
directives.forEach((directive) => {
|
|
18610
18693
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19793,7 +19876,52 @@ ${input.slice(result.pos)}
|
|
|
19793
19876
|
s.children = [root];
|
|
19794
19877
|
});
|
|
19795
19878
|
}
|
|
19879
|
+
function processPipelineExpressions(statements) {
|
|
19880
|
+
gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
|
|
19881
|
+
const [, body] = s.children;
|
|
19882
|
+
let [arg] = s.children;
|
|
19883
|
+
let i = 0, l = body.length;
|
|
19884
|
+
const children = [];
|
|
19885
|
+
for (i = 0; i < l; i++) {
|
|
19886
|
+
const step = body[i];
|
|
19887
|
+
const [leadingComment, pipe, trailingComment, expr] = step;
|
|
19888
|
+
const returns = pipe.token === "||>";
|
|
19889
|
+
if (pipe.token === "|>=") {
|
|
19890
|
+
if (i === 0) {
|
|
19891
|
+
children.push(arg, " = ");
|
|
19892
|
+
} else {
|
|
19893
|
+
children.push({
|
|
19894
|
+
type: "Error",
|
|
19895
|
+
message: "Can't use |>= in the middle of a pipeline"
|
|
19896
|
+
});
|
|
19897
|
+
}
|
|
19898
|
+
}
|
|
19899
|
+
const [result, returning] = module.constructPipeStep(
|
|
19900
|
+
{
|
|
19901
|
+
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
19902
|
+
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
19903
|
+
expr
|
|
19904
|
+
},
|
|
19905
|
+
arg,
|
|
19906
|
+
returns ? arg : null
|
|
19907
|
+
);
|
|
19908
|
+
if (result.type === "ReturnStatement") {
|
|
19909
|
+
arg = result;
|
|
19910
|
+
break;
|
|
19911
|
+
}
|
|
19912
|
+
if (returning) {
|
|
19913
|
+
arg = returning;
|
|
19914
|
+
children.push(result, ",");
|
|
19915
|
+
} else {
|
|
19916
|
+
arg = result;
|
|
19917
|
+
}
|
|
19918
|
+
}
|
|
19919
|
+
children.push(arg);
|
|
19920
|
+
s.children = children;
|
|
19921
|
+
});
|
|
19922
|
+
}
|
|
19796
19923
|
module.processProgram = function(statements) {
|
|
19924
|
+
processPipelineExpressions(statements);
|
|
19797
19925
|
processAssignments(statements);
|
|
19798
19926
|
processFunctions(statements);
|
|
19799
19927
|
processSwitchExpressions(statements);
|
|
@@ -20006,20 +20134,56 @@ ${input.slice(result.pos)}
|
|
|
20006
20134
|
return [splices, thisAssignments];
|
|
20007
20135
|
}
|
|
20008
20136
|
module.gatherBindingCode = gatherBindingCode;
|
|
20009
|
-
module.constructInvocation = function(
|
|
20010
|
-
const
|
|
20011
|
-
const
|
|
20012
|
-
|
|
20013
|
-
|
|
20014
|
-
|
|
20015
|
-
|
|
20137
|
+
module.constructInvocation = function(fn, arg) {
|
|
20138
|
+
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20139
|
+
const lhs = module.makeLeftHandSideExpression(fn.expr);
|
|
20140
|
+
let comment = module.skipIfOnlyWS(fn.trailingComment);
|
|
20141
|
+
if (comment)
|
|
20142
|
+
lhs.children.splice(2, 0, comment);
|
|
20143
|
+
comment = module.skipIfOnlyWS(fn.leadingComment);
|
|
20144
|
+
if (comment)
|
|
20145
|
+
lhs.children.splice(1, 0, comment);
|
|
20146
|
+
switch (arg.type) {
|
|
20147
|
+
case "CommaExpression":
|
|
20148
|
+
arg = {
|
|
20149
|
+
type: "ParenthesizedExpression",
|
|
20150
|
+
children: ["(", arg, ")"]
|
|
20151
|
+
};
|
|
20152
|
+
break;
|
|
20016
20153
|
}
|
|
20154
|
+
return {
|
|
20155
|
+
type: "CallExpression",
|
|
20156
|
+
children: [lhs, "(", arg, ")"]
|
|
20157
|
+
};
|
|
20017
20158
|
};
|
|
20018
|
-
module.constructPipeStep = function(
|
|
20019
|
-
|
|
20020
|
-
|
|
20159
|
+
module.constructPipeStep = function(fn, arg, returning) {
|
|
20160
|
+
const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(module.skipIfOnlyWS), " ", arg];
|
|
20161
|
+
switch (fn.expr.token) {
|
|
20162
|
+
case "yield":
|
|
20163
|
+
case "await":
|
|
20164
|
+
if (returning) {
|
|
20165
|
+
return [
|
|
20166
|
+
children,
|
|
20167
|
+
returning
|
|
20168
|
+
];
|
|
20169
|
+
}
|
|
20170
|
+
return [
|
|
20171
|
+
children,
|
|
20172
|
+
null
|
|
20173
|
+
];
|
|
20174
|
+
case "return":
|
|
20175
|
+
return [{
|
|
20176
|
+
type: "ReturnStatement",
|
|
20177
|
+
children
|
|
20178
|
+
}, null];
|
|
20179
|
+
}
|
|
20180
|
+
if (returning) {
|
|
20181
|
+
return [
|
|
20182
|
+
module.constructInvocation(fn, arg),
|
|
20183
|
+
returning
|
|
20184
|
+
];
|
|
20021
20185
|
}
|
|
20022
|
-
return module.constructInvocation(
|
|
20186
|
+
return [module.constructInvocation(fn, arg), null];
|
|
20023
20187
|
};
|
|
20024
20188
|
return $0;
|
|
20025
20189
|
});
|
|
@@ -20045,7 +20209,7 @@ ${input.slice(result.pos)}
|
|
|
20045
20209
|
return result;
|
|
20046
20210
|
}
|
|
20047
20211
|
}
|
|
20048
|
-
var Indent$0 = $TR($EXPECT($
|
|
20212
|
+
var Indent$0 = $TR($EXPECT($R62, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
20049
20213
|
let level;
|
|
20050
20214
|
if (module.config.tab) {
|
|
20051
20215
|
const tabs = $0.match(/\t/g);
|
|
@@ -20200,7 +20364,7 @@ ${input.slice(result.pos)}
|
|
|
20200
20364
|
return result;
|
|
20201
20365
|
}
|
|
20202
20366
|
}
|
|
20203
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
20367
|
+
var PopIndent$0 = $TV($EXPECT($L18, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
20204
20368
|
if (module.config.verbose) {
|
|
20205
20369
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
20206
20370
|
}
|