@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.js
CHANGED
|
@@ -625,6 +625,8 @@ ${input.slice(result.pos)}
|
|
|
625
625
|
CoffeeWordAssignmentOp,
|
|
626
626
|
BinaryOp,
|
|
627
627
|
BinaryOpSymbol,
|
|
628
|
+
Xor,
|
|
629
|
+
Xnor,
|
|
628
630
|
UnaryOp,
|
|
629
631
|
ModuleItem,
|
|
630
632
|
StatementListItem,
|
|
@@ -1021,225 +1023,231 @@ ${input.slice(result.pos)}
|
|
|
1021
1023
|
var $L12 = $L("super");
|
|
1022
1024
|
var $L13 = $L("import");
|
|
1023
1025
|
var $L14 = $L("!");
|
|
1024
|
-
var $L15 = $L("
|
|
1025
|
-
var $L16 = $L("
|
|
1026
|
-
var $L17 = $L("");
|
|
1027
|
-
var $L18 = $L("
|
|
1028
|
-
var $L19 = $L("
|
|
1029
|
-
var $L20 = $L("
|
|
1030
|
-
var $L21 = $L("
|
|
1031
|
-
var $L22 = $L("
|
|
1032
|
-
var $L23 = $L("
|
|
1033
|
-
var $L24 = $L("
|
|
1034
|
-
var $L25 = $L("
|
|
1035
|
-
var $L26 = $L("
|
|
1036
|
-
var $L27 = $L("
|
|
1037
|
-
var $L28 = $L("
|
|
1038
|
-
var $L29 = $L("
|
|
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("
|
|
1059
|
-
var $L50 = $L("
|
|
1060
|
-
var $L51 = $L("
|
|
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("
|
|
1077
|
-
var $L68 = $L("
|
|
1078
|
-
var $L69 = $L("
|
|
1079
|
-
var $L70 = $L("
|
|
1080
|
-
var $L71 = $L("
|
|
1081
|
-
var $L72 = $L("
|
|
1082
|
-
var $L73 = $L("
|
|
1083
|
-
var $L74 = $L("
|
|
1084
|
-
var $L75 = $L("
|
|
1085
|
-
var $L76 = $L("
|
|
1086
|
-
var $L77 = $L("
|
|
1087
|
-
var $L78 = $L("
|
|
1088
|
-
var $L79 = $L("
|
|
1089
|
-
var $L80 = $L("
|
|
1090
|
-
var $L81 = $L("
|
|
1091
|
-
var $L82 = $L("
|
|
1092
|
-
var $L83 = $L("
|
|
1093
|
-
var $L84 = $L("
|
|
1094
|
-
var $L85 = $L("
|
|
1095
|
-
var $L86 = $L("
|
|
1096
|
-
var $L87 = $L("
|
|
1097
|
-
var $L88 = $L("
|
|
1098
|
-
var $L89 = $L("
|
|
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("
|
|
1107
|
-
var $L98 = $L("
|
|
1108
|
-
var $L99 = $L("
|
|
1109
|
-
var $L100 = $L("
|
|
1110
|
-
var $L101 = $L("
|
|
1111
|
-
var $L102 = $L("
|
|
1112
|
-
var $L103 = $L("
|
|
1113
|
-
var $L104 = $L("
|
|
1114
|
-
var $L105 = $L("
|
|
1115
|
-
var $L106 = $L("
|
|
1116
|
-
var $L107 = $L("
|
|
1117
|
-
var $L108 = $L("
|
|
1118
|
-
var $L109 = $L("
|
|
1119
|
-
var $L110 = $L("
|
|
1120
|
-
var $L111 = $L("
|
|
1121
|
-
var $L112 = $L(
|
|
1122
|
-
var $L113 = $L("
|
|
1123
|
-
var $L114 = $L("
|
|
1124
|
-
var $L115 = $L("
|
|
1125
|
-
var $L116 = $L("
|
|
1126
|
-
var $L117 = $L("
|
|
1127
|
-
var $L118 = $L("
|
|
1128
|
-
var $L119 = $L("
|
|
1129
|
-
var $L120 = $L("
|
|
1130
|
-
var $L121 = $L("
|
|
1131
|
-
var $L122 = $L("
|
|
1132
|
-
var $L123 = $L("
|
|
1133
|
-
var $L124 = $L("
|
|
1134
|
-
var $L125 = $L("
|
|
1135
|
-
var $L126 = $L("
|
|
1136
|
-
var $L127 = $L("
|
|
1137
|
-
var $L128 = $L("
|
|
1138
|
-
var $L129 = $L("
|
|
1139
|
-
var $L130 = $L("
|
|
1140
|
-
var $L131 = $L("
|
|
1141
|
-
var $L132 = $L("
|
|
1142
|
-
var $L133 = $L("
|
|
1143
|
-
var $L134 = $L("
|
|
1144
|
-
var $L135 = $L("
|
|
1145
|
-
var $L136 = $L("
|
|
1146
|
-
var $L137 = $L("
|
|
1147
|
-
var $L138 = $L("
|
|
1148
|
-
var $L139 = $L("
|
|
1149
|
-
var $L140 = $L("
|
|
1150
|
-
var $L141 = $L("
|
|
1151
|
-
var $L142 = $L("
|
|
1152
|
-
var $L143 = $L("
|
|
1153
|
-
var $L144 = $L("
|
|
1154
|
-
var $L145 = $L(
|
|
1155
|
-
var $L146 = $L("
|
|
1156
|
-
var $L147 = $L("
|
|
1157
|
-
var $L148 = $L("
|
|
1158
|
-
var $L149 = $L("
|
|
1159
|
-
var $L150 = $L("
|
|
1160
|
-
var $L151 = $L("
|
|
1161
|
-
var $L152 = $L("
|
|
1162
|
-
var $L153 = $L("
|
|
1163
|
-
var $L154 = $L("
|
|
1164
|
-
var $L155 = $L("
|
|
1165
|
-
var $L156 = $L("
|
|
1166
|
-
var $L157 = $L("
|
|
1167
|
-
var $L158 = $L("
|
|
1168
|
-
var $L159 = $L("
|
|
1169
|
-
var $L160 = $L("
|
|
1170
|
-
var $L161 = $L("
|
|
1171
|
-
var $L162 = $L("
|
|
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("
|
|
1179
|
-
var $L170 = $L("
|
|
1180
|
-
var $L171 = $L("
|
|
1181
|
-
var $
|
|
1026
|
+
var $L15 = $L("^");
|
|
1027
|
+
var $L16 = $L("-");
|
|
1028
|
+
var $L17 = $L("import.meta");
|
|
1029
|
+
var $L18 = $L("");
|
|
1030
|
+
var $L19 = $L(")");
|
|
1031
|
+
var $L20 = $L(",");
|
|
1032
|
+
var $L21 = $L("->");
|
|
1033
|
+
var $L22 = $L("}");
|
|
1034
|
+
var $L23 = $L("null");
|
|
1035
|
+
var $L24 = $L("true");
|
|
1036
|
+
var $L25 = $L("false");
|
|
1037
|
+
var $L26 = $L("yes");
|
|
1038
|
+
var $L27 = $L("on");
|
|
1039
|
+
var $L28 = $L("no");
|
|
1040
|
+
var $L29 = $L("off");
|
|
1041
|
+
var $L30 = $L(">");
|
|
1042
|
+
var $L31 = $L("]");
|
|
1043
|
+
var $L32 = $L(":");
|
|
1044
|
+
var $L33 = $L("**=");
|
|
1045
|
+
var $L34 = $L("*=");
|
|
1046
|
+
var $L35 = $L("/=");
|
|
1047
|
+
var $L36 = $L("%=");
|
|
1048
|
+
var $L37 = $L("+=");
|
|
1049
|
+
var $L38 = $L("-=");
|
|
1050
|
+
var $L39 = $L("<<=");
|
|
1051
|
+
var $L40 = $L(">>>=");
|
|
1052
|
+
var $L41 = $L(">>=");
|
|
1053
|
+
var $L42 = $L("&&=");
|
|
1054
|
+
var $L43 = $L("&=");
|
|
1055
|
+
var $L44 = $L("^=");
|
|
1056
|
+
var $L45 = $L("||=");
|
|
1057
|
+
var $L46 = $L("|=");
|
|
1058
|
+
var $L47 = $L("??=");
|
|
1059
|
+
var $L48 = $L("?=");
|
|
1060
|
+
var $L49 = $L("and=");
|
|
1061
|
+
var $L50 = $L("or=");
|
|
1062
|
+
var $L51 = $L("not");
|
|
1063
|
+
var $L52 = $L("**");
|
|
1064
|
+
var $L53 = $L("*");
|
|
1065
|
+
var $L54 = $L("/");
|
|
1066
|
+
var $L55 = $L("%%");
|
|
1067
|
+
var $L56 = $L("%");
|
|
1068
|
+
var $L57 = $L("+");
|
|
1069
|
+
var $L58 = $L("<=");
|
|
1070
|
+
var $L59 = $L(">=");
|
|
1071
|
+
var $L60 = $L("<?");
|
|
1072
|
+
var $L61 = $L("!<?");
|
|
1073
|
+
var $L62 = $L("<<");
|
|
1074
|
+
var $L63 = $L(">>>");
|
|
1075
|
+
var $L64 = $L(">>");
|
|
1076
|
+
var $L65 = $L("!==");
|
|
1077
|
+
var $L66 = $L("!=");
|
|
1078
|
+
var $L67 = $L("isnt");
|
|
1079
|
+
var $L68 = $L("===");
|
|
1080
|
+
var $L69 = $L("==");
|
|
1081
|
+
var $L70 = $L("and");
|
|
1082
|
+
var $L71 = $L("&&");
|
|
1083
|
+
var $L72 = $L("of");
|
|
1084
|
+
var $L73 = $L("or");
|
|
1085
|
+
var $L74 = $L("||");
|
|
1086
|
+
var $L75 = $L("^^");
|
|
1087
|
+
var $L76 = $L("xor");
|
|
1088
|
+
var $L77 = $L("xnor");
|
|
1089
|
+
var $L78 = $L("??");
|
|
1090
|
+
var $L79 = $L("instanceof");
|
|
1091
|
+
var $L80 = $L("in");
|
|
1092
|
+
var $L81 = $L("is");
|
|
1093
|
+
var $L82 = $L("&");
|
|
1094
|
+
var $L83 = $L("|");
|
|
1095
|
+
var $L84 = $L(";");
|
|
1096
|
+
var $L85 = $L("own");
|
|
1097
|
+
var $L86 = $L("break");
|
|
1098
|
+
var $L87 = $L("continue");
|
|
1099
|
+
var $L88 = $L("debugger");
|
|
1100
|
+
var $L89 = $L("assert");
|
|
1101
|
+
var $L90 = $L(":=");
|
|
1102
|
+
var $L91 = $L(".=");
|
|
1103
|
+
var $L92 = $L("/*");
|
|
1104
|
+
var $L93 = $L("*/");
|
|
1105
|
+
var $L94 = $L("\\");
|
|
1106
|
+
var $L95 = $L("[");
|
|
1107
|
+
var $L96 = $L("`");
|
|
1108
|
+
var $L97 = $L("abstract");
|
|
1109
|
+
var $L98 = $L("as");
|
|
1110
|
+
var $L99 = $L("@");
|
|
1111
|
+
var $L100 = $L("@@");
|
|
1112
|
+
var $L101 = $L("async");
|
|
1113
|
+
var $L102 = $L("await");
|
|
1114
|
+
var $L103 = $L("by");
|
|
1115
|
+
var $L104 = $L("case");
|
|
1116
|
+
var $L105 = $L("catch");
|
|
1117
|
+
var $L106 = $L("class");
|
|
1118
|
+
var $L107 = $L("#{");
|
|
1119
|
+
var $L108 = $L("declare");
|
|
1120
|
+
var $L109 = $L("default");
|
|
1121
|
+
var $L110 = $L("delete");
|
|
1122
|
+
var $L111 = $L("do");
|
|
1123
|
+
var $L112 = $L("..");
|
|
1124
|
+
var $L113 = $L("...");
|
|
1125
|
+
var $L114 = $L("::");
|
|
1126
|
+
var $L115 = $L('"');
|
|
1127
|
+
var $L116 = $L("else");
|
|
1128
|
+
var $L117 = $L("export");
|
|
1129
|
+
var $L118 = $L("extends");
|
|
1130
|
+
var $L119 = $L("finally");
|
|
1131
|
+
var $L120 = $L("for");
|
|
1132
|
+
var $L121 = $L("from");
|
|
1133
|
+
var $L122 = $L("function");
|
|
1134
|
+
var $L123 = $L("get");
|
|
1135
|
+
var $L124 = $L("set");
|
|
1136
|
+
var $L125 = $L("if");
|
|
1137
|
+
var $L126 = $L("let");
|
|
1138
|
+
var $L127 = $L("const");
|
|
1139
|
+
var $L128 = $L("loop");
|
|
1140
|
+
var $L129 = $L("new");
|
|
1141
|
+
var $L130 = $L("<");
|
|
1142
|
+
var $L131 = $L("{");
|
|
1143
|
+
var $L132 = $L("operator");
|
|
1144
|
+
var $L133 = $L("public");
|
|
1145
|
+
var $L134 = $L("private");
|
|
1146
|
+
var $L135 = $L("protected");
|
|
1147
|
+
var $L136 = $L("||>");
|
|
1148
|
+
var $L137 = $L("|>=");
|
|
1149
|
+
var $L138 = $L("|>");
|
|
1150
|
+
var $L139 = $L("readonly");
|
|
1151
|
+
var $L140 = $L("return");
|
|
1152
|
+
var $L141 = $L("satisfies");
|
|
1153
|
+
var $L142 = $L("'");
|
|
1154
|
+
var $L143 = $L("static");
|
|
1155
|
+
var $L144 = $L("${");
|
|
1156
|
+
var $L145 = $L("switch");
|
|
1157
|
+
var $L146 = $L("target");
|
|
1158
|
+
var $L147 = $L("then");
|
|
1159
|
+
var $L148 = $L("this");
|
|
1160
|
+
var $L149 = $L("throw");
|
|
1161
|
+
var $L150 = $L('"""');
|
|
1162
|
+
var $L151 = $L("'''");
|
|
1163
|
+
var $L152 = $L("///");
|
|
1164
|
+
var $L153 = $L("```");
|
|
1165
|
+
var $L154 = $L("try");
|
|
1166
|
+
var $L155 = $L("typeof");
|
|
1167
|
+
var $L156 = $L("unless");
|
|
1168
|
+
var $L157 = $L("until");
|
|
1169
|
+
var $L158 = $L("var");
|
|
1170
|
+
var $L159 = $L("void");
|
|
1171
|
+
var $L160 = $L("when");
|
|
1172
|
+
var $L161 = $L("while");
|
|
1173
|
+
var $L162 = $L("yield");
|
|
1174
|
+
var $L163 = $L("/>");
|
|
1175
|
+
var $L164 = $L("</");
|
|
1176
|
+
var $L165 = $L("<>");
|
|
1177
|
+
var $L166 = $L("</>");
|
|
1178
|
+
var $L167 = $L("<!--");
|
|
1179
|
+
var $L168 = $L("-->");
|
|
1180
|
+
var $L169 = $L("type");
|
|
1181
|
+
var $L170 = $L("interface");
|
|
1182
|
+
var $L171 = $L("namespace");
|
|
1183
|
+
var $L172 = $L("asserts");
|
|
1184
|
+
var $L173 = $L("keyof");
|
|
1185
|
+
var $L174 = $L("infer");
|
|
1186
|
+
var $L175 = $L("[]");
|
|
1187
|
+
var $L176 = $L("civet");
|
|
1188
|
+
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1182
1189
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1183
1190
|
var $R2 = $R(new RegExp("[&]", "suy"));
|
|
1184
1191
|
var $R3 = $R(new RegExp("[!~+-]+", "suy"));
|
|
1185
1192
|
var $R4 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1186
1193
|
var $R5 = $R(new RegExp("[!+-]", "suy"));
|
|
1187
1194
|
var $R6 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
1188
|
-
var $R7 = $R(new RegExp("
|
|
1189
|
-
var $R8 = $R(new RegExp("(
|
|
1190
|
-
var $R9 = $R(new RegExp(
|
|
1191
|
-
var $R10 = $R(new RegExp("
|
|
1192
|
-
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
1193
|
-
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
1194
|
-
var $R13 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1195
|
-
var $R14 = $R(new RegExp("(
|
|
1196
|
-
var $R15 = $R(new RegExp("
|
|
1197
|
-
var $R16 = $R(new RegExp("0[
|
|
1198
|
-
var $R17 = $R(new RegExp("0[
|
|
1199
|
-
var $R18 = $R(new RegExp("
|
|
1200
|
-
var $R19 = $R(new RegExp(
|
|
1201
|
-
var $R20 = $R(new RegExp(
|
|
1202
|
-
var $R21 = $R(new RegExp(
|
|
1203
|
-
var $R22 = $R(new RegExp(
|
|
1204
|
-
var $R23 = $R(new RegExp('(
|
|
1205
|
-
var $R24 = $R(new RegExp(
|
|
1206
|
-
var $R25 = $R(new RegExp("(
|
|
1207
|
-
var $R26 = $R(new RegExp("
|
|
1208
|
-
var $R27 = $R(new RegExp("
|
|
1209
|
-
var $R28 = $R(new RegExp("
|
|
1210
|
-
var $R29 = $R(new RegExp("[
|
|
1211
|
-
var $R30 = $R(new RegExp("
|
|
1212
|
-
var $R31 = $R(new RegExp("(
|
|
1213
|
-
var $R32 = $R(new RegExp("(
|
|
1214
|
-
var $R33 = $R(new RegExp("(?:\\$(?!\\{)
|
|
1215
|
-
var $R34 = $R(new RegExp("(
|
|
1216
|
-
var $R35 = $R(new RegExp("(?:
|
|
1217
|
-
var $R36 = $R(new RegExp("(?:
|
|
1218
|
-
var $R37 = $R(new RegExp("(?:
|
|
1219
|
-
var $R38 = $R(new RegExp("(?:
|
|
1220
|
-
var $R39 = $R(new RegExp("
|
|
1221
|
-
var $R40 = $R(new RegExp("
|
|
1222
|
-
var $R41 = $R(new RegExp("
|
|
1223
|
-
var $R42 = $R(new RegExp("[
|
|
1224
|
-
var $R43 = $R(new RegExp("
|
|
1225
|
-
var $R44 = $R(new RegExp("
|
|
1226
|
-
var $R45 = $R(new RegExp("[
|
|
1227
|
-
var $R46 = $R(new RegExp("
|
|
1228
|
-
var $R47 = $R(new RegExp("
|
|
1229
|
-
var $R48 = $R(new RegExp("
|
|
1230
|
-
var $R49 = $R(new RegExp("[\\
|
|
1231
|
-
var $R50 = $R(new RegExp("
|
|
1232
|
-
var $R51 = $R(new RegExp("[
|
|
1233
|
-
var $R52 = $R(new RegExp("
|
|
1234
|
-
var $R53 = $R(new RegExp("[
|
|
1235
|
-
var $R54 = $R(new RegExp("[
|
|
1236
|
-
var $R55 = $R(new RegExp("[+-]", "suy"));
|
|
1237
|
-
var $R56 = $R(new RegExp("
|
|
1238
|
-
var $R57 = $R(new RegExp("[\\
|
|
1239
|
-
var $R58 = $R(new RegExp("[\\
|
|
1240
|
-
var $R59 = $R(new RegExp("
|
|
1241
|
-
var $R60 = $R(new RegExp("\\
|
|
1242
|
-
var $R61 = $R(new RegExp("
|
|
1195
|
+
var $R7 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
1196
|
+
var $R8 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1197
|
+
var $R9 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
1198
|
+
var $R10 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
1199
|
+
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
1200
|
+
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
1201
|
+
var $R13 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
1202
|
+
var $R14 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1203
|
+
var $R15 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
1204
|
+
var $R16 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
1205
|
+
var $R17 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
1206
|
+
var $R18 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
1207
|
+
var $R19 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1208
|
+
var $R20 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
1209
|
+
var $R21 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
1210
|
+
var $R22 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
1211
|
+
var $R23 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
1212
|
+
var $R24 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
1213
|
+
var $R25 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
1214
|
+
var $R26 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
1215
|
+
var $R27 = $R(new RegExp("[\\s]+", "suy"));
|
|
1216
|
+
var $R28 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
1217
|
+
var $R29 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
1218
|
+
var $R30 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
1219
|
+
var $R31 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
1220
|
+
var $R32 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1221
|
+
var $R33 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
1222
|
+
var $R34 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
1223
|
+
var $R35 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1224
|
+
var $R36 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1225
|
+
var $R37 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1226
|
+
var $R38 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1227
|
+
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"));
|
|
1228
|
+
var $R40 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1229
|
+
var $R41 = $R(new RegExp(".", "suy"));
|
|
1230
|
+
var $R42 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
1231
|
+
var $R43 = $R(new RegExp("[^]*?###", "suy"));
|
|
1232
|
+
var $R44 = $R(new RegExp("###(?!#)", "suy"));
|
|
1233
|
+
var $R45 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
1234
|
+
var $R46 = $R(new RegExp("[ \\t]+", "suy"));
|
|
1235
|
+
var $R47 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
1236
|
+
var $R48 = $R(new RegExp("\\s", "suy"));
|
|
1237
|
+
var $R49 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1238
|
+
var $R50 = $R(new RegExp("[\\s>]", "suy"));
|
|
1239
|
+
var $R51 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
1240
|
+
var $R52 = $R(new RegExp("[<>]", "suy"));
|
|
1241
|
+
var $R53 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
1242
|
+
var $R54 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
1243
|
+
var $R55 = $R(new RegExp("[+-]?", "suy"));
|
|
1244
|
+
var $R56 = $R(new RegExp("[+-]", "suy"));
|
|
1245
|
+
var $R57 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1246
|
+
var $R58 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1247
|
+
var $R59 = $R(new RegExp("[\\s]*", "suy"));
|
|
1248
|
+
var $R60 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1249
|
+
var $R61 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1250
|
+
var $R62 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1243
1251
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1244
1252
|
var statements = $4;
|
|
1245
1253
|
module2.processProgram(statements);
|
|
@@ -1559,7 +1567,7 @@ ${input.slice(result.pos)}
|
|
|
1559
1567
|
return result;
|
|
1560
1568
|
}
|
|
1561
1569
|
}
|
|
1562
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1570
|
+
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$])/"));
|
|
1563
1571
|
var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1564
1572
|
var ForbiddenImplicitCalls$2 = AtAt;
|
|
1565
1573
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L1, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -2096,7 +2104,6 @@ ${input.slice(result.pos)}
|
|
|
2096
2104
|
}
|
|
2097
2105
|
}
|
|
2098
2106
|
var NonPipelineAssignmentExpression$0 = SingleLineAssignmentExpression;
|
|
2099
|
-
var NonPipelineAssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
2100
2107
|
function NonPipelineAssignmentExpression(state) {
|
|
2101
2108
|
let eventData;
|
|
2102
2109
|
if (state.events) {
|
|
@@ -2108,12 +2115,12 @@ ${input.slice(result.pos)}
|
|
|
2108
2115
|
}
|
|
2109
2116
|
}
|
|
2110
2117
|
if (state.tokenize) {
|
|
2111
|
-
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state)
|
|
2118
|
+
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state));
|
|
2112
2119
|
if (state.events)
|
|
2113
2120
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2114
2121
|
return result;
|
|
2115
2122
|
} else {
|
|
2116
|
-
const result = NonPipelineAssignmentExpression$0(state)
|
|
2123
|
+
const result = NonPipelineAssignmentExpression$0(state);
|
|
2117
2124
|
if (state.events)
|
|
2118
2125
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2119
2126
|
return result;
|
|
@@ -2485,30 +2492,12 @@ ${input.slice(result.pos)}
|
|
|
2485
2492
|
return result;
|
|
2486
2493
|
}
|
|
2487
2494
|
}
|
|
2488
|
-
var PipelineExpression$0 = $TS($S(
|
|
2495
|
+
var PipelineExpression$0 = $TS($S(PipelineHeadItem, $P($S(__, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2) {
|
|
2489
2496
|
var head = $1;
|
|
2490
2497
|
var body = $2;
|
|
2491
|
-
var preTailWS = $3;
|
|
2492
|
-
var tail = $4;
|
|
2493
|
-
let children = head.slice(0, -1).map(module2.skipIfOnlyWS);
|
|
2494
|
-
for (const [leadingComment, expr, trailingComment] of body) {
|
|
2495
|
-
children = module2.constructPipeStep(
|
|
2496
|
-
{
|
|
2497
|
-
leadingComment: module2.skipIfOnlyWS(leadingComment),
|
|
2498
|
-
trailingComment: module2.skipIfOnlyWS(trailingComment),
|
|
2499
|
-
expr
|
|
2500
|
-
},
|
|
2501
|
-
{ expr: children }
|
|
2502
|
-
);
|
|
2503
|
-
}
|
|
2504
2498
|
return {
|
|
2505
|
-
|
|
2506
|
-
|
|
2507
|
-
leadingComment: module2.skipIfOnlyWS(preTailWS),
|
|
2508
|
-
expr: tail
|
|
2509
|
-
},
|
|
2510
|
-
{ expr: children }
|
|
2511
|
-
)
|
|
2499
|
+
type: "PipelineExpression",
|
|
2500
|
+
children: [head, body]
|
|
2512
2501
|
};
|
|
2513
2502
|
});
|
|
2514
2503
|
function PipelineExpression(state) {
|
|
@@ -3367,8 +3356,8 @@ ${input.slice(result.pos)}
|
|
|
3367
3356
|
return result;
|
|
3368
3357
|
}
|
|
3369
3358
|
}
|
|
3370
|
-
var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
|
|
3371
|
-
return { "type": "NonNullAssertion", "ts": true, "children": value };
|
|
3359
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L14, fail, 'NonNullAssertion "!"'), $N($EXPECT($L15, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3360
|
+
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3372
3361
|
});
|
|
3373
3362
|
function NonNullAssertion(state) {
|
|
3374
3363
|
let eventData;
|
|
@@ -3505,7 +3494,7 @@ ${input.slice(result.pos)}
|
|
|
3505
3494
|
]
|
|
3506
3495
|
};
|
|
3507
3496
|
});
|
|
3508
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3497
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L16, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3509
3498
|
var dot = $1;
|
|
3510
3499
|
var neg = $2;
|
|
3511
3500
|
var num = $3;
|
|
@@ -3702,7 +3691,7 @@ ${input.slice(result.pos)}
|
|
|
3702
3691
|
}
|
|
3703
3692
|
}
|
|
3704
3693
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3705
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3694
|
+
var MetaProperty$1 = $TS($S($EXPECT($L17, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3706
3695
|
return { $loc, token: $1 };
|
|
3707
3696
|
});
|
|
3708
3697
|
function MetaProperty(state) {
|
|
@@ -3728,7 +3717,7 @@ ${input.slice(result.pos)}
|
|
|
3728
3717
|
}
|
|
3729
3718
|
}
|
|
3730
3719
|
var Parameters$0 = NonEmptyParameters;
|
|
3731
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3720
|
+
var Parameters$1 = $TV($EXPECT($L18, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3732
3721
|
return {
|
|
3733
3722
|
type: "Parameters",
|
|
3734
3723
|
children: [{ $loc, token: "()" }],
|
|
@@ -3889,7 +3878,7 @@ ${input.slice(result.pos)}
|
|
|
3889
3878
|
}
|
|
3890
3879
|
}
|
|
3891
3880
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3892
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3881
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L19, fail, 'ParameterElementDelimiter ")"')));
|
|
3893
3882
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3894
3883
|
return value[1];
|
|
3895
3884
|
});
|
|
@@ -4509,7 +4498,7 @@ ${input.slice(result.pos)}
|
|
|
4509
4498
|
children: $0
|
|
4510
4499
|
};
|
|
4511
4500
|
});
|
|
4512
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4501
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4513
4502
|
return {
|
|
4514
4503
|
children: [{
|
|
4515
4504
|
type: "ElisionElement",
|
|
@@ -4582,7 +4571,7 @@ ${input.slice(result.pos)}
|
|
|
4582
4571
|
return result;
|
|
4583
4572
|
}
|
|
4584
4573
|
}
|
|
4585
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4574
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L18, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4586
4575
|
const ref = {
|
|
4587
4576
|
type: "Ref",
|
|
4588
4577
|
base: "ref",
|
|
@@ -5058,7 +5047,7 @@ ${input.slice(result.pos)}
|
|
|
5058
5047
|
children: [ws, binding]
|
|
5059
5048
|
};
|
|
5060
5049
|
});
|
|
5061
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5050
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5062
5051
|
return {
|
|
5063
5052
|
children: [{
|
|
5064
5053
|
type: "ElisionElement",
|
|
@@ -5452,7 +5441,7 @@ ${input.slice(result.pos)}
|
|
|
5452
5441
|
return result;
|
|
5453
5442
|
}
|
|
5454
5443
|
}
|
|
5455
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5444
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5456
5445
|
return { $loc, token: $1 };
|
|
5457
5446
|
});
|
|
5458
5447
|
function Arrow(state) {
|
|
@@ -5686,7 +5675,7 @@ ${input.slice(result.pos)}
|
|
|
5686
5675
|
return result;
|
|
5687
5676
|
}
|
|
5688
5677
|
}
|
|
5689
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5678
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L18, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5690
5679
|
const expressions = [];
|
|
5691
5680
|
return {
|
|
5692
5681
|
type: "BlockStatement",
|
|
@@ -5909,7 +5898,7 @@ ${input.slice(result.pos)}
|
|
|
5909
5898
|
children: [$1, expressions]
|
|
5910
5899
|
};
|
|
5911
5900
|
});
|
|
5912
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
5901
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5913
5902
|
const expressions = [];
|
|
5914
5903
|
return {
|
|
5915
5904
|
type: "BlockStatement",
|
|
@@ -6054,7 +6043,7 @@ ${input.slice(result.pos)}
|
|
|
6054
6043
|
return result;
|
|
6055
6044
|
}
|
|
6056
6045
|
}
|
|
6057
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6046
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6058
6047
|
return { $loc, token: $1 };
|
|
6059
6048
|
});
|
|
6060
6049
|
function NullLiteral(state) {
|
|
@@ -6082,7 +6071,7 @@ ${input.slice(result.pos)}
|
|
|
6082
6071
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6083
6072
|
return value[1];
|
|
6084
6073
|
});
|
|
6085
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6074
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6086
6075
|
return { $loc, token: $1 };
|
|
6087
6076
|
});
|
|
6088
6077
|
function BooleanLiteral(state) {
|
|
@@ -6107,10 +6096,10 @@ ${input.slice(result.pos)}
|
|
|
6107
6096
|
return result;
|
|
6108
6097
|
}
|
|
6109
6098
|
}
|
|
6110
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6099
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6111
6100
|
return { $loc, token: "true" };
|
|
6112
6101
|
});
|
|
6113
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6102
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6114
6103
|
return { $loc, token: "false" };
|
|
6115
6104
|
});
|
|
6116
6105
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6216,7 +6205,7 @@ ${input.slice(result.pos)}
|
|
|
6216
6205
|
return result;
|
|
6217
6206
|
}
|
|
6218
6207
|
}
|
|
6219
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6208
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6220
6209
|
function UpcomingAssignment(state) {
|
|
6221
6210
|
let eventData;
|
|
6222
6211
|
if (state.events) {
|
|
@@ -6489,7 +6478,7 @@ ${input.slice(result.pos)}
|
|
|
6489
6478
|
}
|
|
6490
6479
|
}
|
|
6491
6480
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6492
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6481
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6493
6482
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6494
6483
|
return value[1];
|
|
6495
6484
|
});
|
|
@@ -6915,7 +6904,7 @@ ${input.slice(result.pos)}
|
|
|
6915
6904
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6916
6905
|
return value[1];
|
|
6917
6906
|
});
|
|
6918
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
6907
|
+
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) {
|
|
6919
6908
|
return "";
|
|
6920
6909
|
});
|
|
6921
6910
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6944,7 +6933,7 @@ ${input.slice(result.pos)}
|
|
|
6944
6933
|
}
|
|
6945
6934
|
}
|
|
6946
6935
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
6947
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6936
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
6948
6937
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6949
6938
|
return value[1];
|
|
6950
6939
|
});
|
|
@@ -7219,7 +7208,7 @@ ${input.slice(result.pos)}
|
|
|
7219
7208
|
expression
|
|
7220
7209
|
};
|
|
7221
7210
|
});
|
|
7222
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7211
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L16, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7223
7212
|
return {
|
|
7224
7213
|
type: "ComputedPropertyName",
|
|
7225
7214
|
children: $0
|
|
@@ -7525,7 +7514,21 @@ ${input.slice(result.pos)}
|
|
|
7525
7514
|
return result;
|
|
7526
7515
|
}
|
|
7527
7516
|
}
|
|
7528
|
-
var OperatorAssignmentOp$0 = $TS($S(
|
|
7517
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7518
|
+
return {
|
|
7519
|
+
special: true,
|
|
7520
|
+
call: module2.getRef("xor"),
|
|
7521
|
+
children: [$2, ...$4]
|
|
7522
|
+
};
|
|
7523
|
+
});
|
|
7524
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7525
|
+
return {
|
|
7526
|
+
special: true,
|
|
7527
|
+
call: module2.getRef("xnor"),
|
|
7528
|
+
children: [$2, ...$4]
|
|
7529
|
+
};
|
|
7530
|
+
});
|
|
7531
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7529
7532
|
return {
|
|
7530
7533
|
special: true,
|
|
7531
7534
|
call: $1,
|
|
@@ -7543,33 +7546,33 @@ ${input.slice(result.pos)}
|
|
|
7543
7546
|
}
|
|
7544
7547
|
}
|
|
7545
7548
|
if (state.tokenize) {
|
|
7546
|
-
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state));
|
|
7549
|
+
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state));
|
|
7547
7550
|
if (state.events)
|
|
7548
7551
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7549
7552
|
return result;
|
|
7550
7553
|
} else {
|
|
7551
|
-
const result = OperatorAssignmentOp$0(state);
|
|
7554
|
+
const result = OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state);
|
|
7552
7555
|
if (state.events)
|
|
7553
7556
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7554
7557
|
return result;
|
|
7555
7558
|
}
|
|
7556
7559
|
}
|
|
7557
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7558
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7559
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7560
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7561
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7562
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7563
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7564
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7565
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7566
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7567
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7568
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7569
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7570
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7571
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7572
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7560
|
+
var AssignmentOpSymbol$0 = $EXPECT($L33, fail, 'AssignmentOpSymbol "**="');
|
|
7561
|
+
var AssignmentOpSymbol$1 = $EXPECT($L34, fail, 'AssignmentOpSymbol "*="');
|
|
7562
|
+
var AssignmentOpSymbol$2 = $EXPECT($L35, fail, 'AssignmentOpSymbol "/="');
|
|
7563
|
+
var AssignmentOpSymbol$3 = $EXPECT($L36, fail, 'AssignmentOpSymbol "%="');
|
|
7564
|
+
var AssignmentOpSymbol$4 = $EXPECT($L37, fail, 'AssignmentOpSymbol "+="');
|
|
7565
|
+
var AssignmentOpSymbol$5 = $EXPECT($L38, fail, 'AssignmentOpSymbol "-="');
|
|
7566
|
+
var AssignmentOpSymbol$6 = $EXPECT($L39, fail, 'AssignmentOpSymbol "<<="');
|
|
7567
|
+
var AssignmentOpSymbol$7 = $EXPECT($L40, fail, 'AssignmentOpSymbol ">>>="');
|
|
7568
|
+
var AssignmentOpSymbol$8 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>="');
|
|
7569
|
+
var AssignmentOpSymbol$9 = $EXPECT($L42, fail, 'AssignmentOpSymbol "&&="');
|
|
7570
|
+
var AssignmentOpSymbol$10 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&="');
|
|
7571
|
+
var AssignmentOpSymbol$11 = $EXPECT($L44, fail, 'AssignmentOpSymbol "^="');
|
|
7572
|
+
var AssignmentOpSymbol$12 = $EXPECT($L45, fail, 'AssignmentOpSymbol "||="');
|
|
7573
|
+
var AssignmentOpSymbol$13 = $EXPECT($L46, fail, 'AssignmentOpSymbol "|="');
|
|
7574
|
+
var AssignmentOpSymbol$14 = $EXPECT($L47, fail, 'AssignmentOpSymbol "??="');
|
|
7575
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L48, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7573
7576
|
return "??=";
|
|
7574
7577
|
});
|
|
7575
7578
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7600,10 +7603,10 @@ ${input.slice(result.pos)}
|
|
|
7600
7603
|
return result;
|
|
7601
7604
|
}
|
|
7602
7605
|
}
|
|
7603
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7606
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L49, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7604
7607
|
return "&&=";
|
|
7605
7608
|
});
|
|
7606
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7609
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7607
7610
|
return "||=";
|
|
7608
7611
|
});
|
|
7609
7612
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7642,7 +7645,7 @@ ${input.slice(result.pos)}
|
|
|
7642
7645
|
special: true
|
|
7643
7646
|
};
|
|
7644
7647
|
});
|
|
7645
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7648
|
+
var BinaryOp$2 = $TS($S($EXPECT($L51, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7646
7649
|
var id = $4;
|
|
7647
7650
|
if (!module2.operators.has(id.name))
|
|
7648
7651
|
return $skip;
|
|
@@ -7674,21 +7677,21 @@ ${input.slice(result.pos)}
|
|
|
7674
7677
|
return result;
|
|
7675
7678
|
}
|
|
7676
7679
|
}
|
|
7677
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7678
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7679
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7680
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7680
|
+
var BinaryOpSymbol$0 = $EXPECT($L52, fail, 'BinaryOpSymbol "**"');
|
|
7681
|
+
var BinaryOpSymbol$1 = $EXPECT($L53, fail, 'BinaryOpSymbol "*"');
|
|
7682
|
+
var BinaryOpSymbol$2 = $EXPECT($L54, fail, 'BinaryOpSymbol "/"');
|
|
7683
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7681
7684
|
return {
|
|
7682
7685
|
call: module2.getRef("modulo"),
|
|
7683
7686
|
special: true
|
|
7684
7687
|
};
|
|
7685
7688
|
});
|
|
7686
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7687
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7688
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7689
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7690
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7691
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7689
|
+
var BinaryOpSymbol$4 = $EXPECT($L56, fail, 'BinaryOpSymbol "%"');
|
|
7690
|
+
var BinaryOpSymbol$5 = $EXPECT($L57, fail, 'BinaryOpSymbol "+"');
|
|
7691
|
+
var BinaryOpSymbol$6 = $EXPECT($L16, fail, 'BinaryOpSymbol "-"');
|
|
7692
|
+
var BinaryOpSymbol$7 = $EXPECT($L58, fail, 'BinaryOpSymbol "<="');
|
|
7693
|
+
var BinaryOpSymbol$8 = $EXPECT($L59, fail, 'BinaryOpSymbol ">="');
|
|
7694
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7692
7695
|
return {
|
|
7693
7696
|
$loc,
|
|
7694
7697
|
token: "instanceof",
|
|
@@ -7696,7 +7699,7 @@ ${input.slice(result.pos)}
|
|
|
7696
7699
|
special: true
|
|
7697
7700
|
};
|
|
7698
7701
|
});
|
|
7699
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7702
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7700
7703
|
return {
|
|
7701
7704
|
$loc,
|
|
7702
7705
|
token: "instanceof",
|
|
@@ -7705,46 +7708,58 @@ ${input.slice(result.pos)}
|
|
|
7705
7708
|
negated: true
|
|
7706
7709
|
};
|
|
7707
7710
|
});
|
|
7708
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7711
|
+
var BinaryOpSymbol$11 = $EXPECT($L62, fail, 'BinaryOpSymbol "<<"');
|
|
7709
7712
|
var BinaryOpSymbol$12 = $TR($EXPECT($R6, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7710
7713
|
return "<";
|
|
7711
7714
|
});
|
|
7712
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7713
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7714
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7715
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7716
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7715
|
+
var BinaryOpSymbol$13 = $EXPECT($L63, fail, 'BinaryOpSymbol ">>>"');
|
|
7716
|
+
var BinaryOpSymbol$14 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>"');
|
|
7717
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7718
|
+
var BinaryOpSymbol$16 = $EXPECT($L65, fail, 'BinaryOpSymbol "!=="');
|
|
7719
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L66, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7717
7720
|
if (module2.config.coffeeEq)
|
|
7718
7721
|
return "!==";
|
|
7719
7722
|
return $1;
|
|
7720
7723
|
});
|
|
7721
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7724
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7722
7725
|
if (module2.config.coffeeIsnt)
|
|
7723
7726
|
return "!==";
|
|
7724
7727
|
return $skip;
|
|
7725
7728
|
});
|
|
7726
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7727
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7729
|
+
var BinaryOpSymbol$19 = $EXPECT($L68, fail, 'BinaryOpSymbol "==="');
|
|
7730
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7728
7731
|
if (module2.config.coffeeEq)
|
|
7729
7732
|
return "===";
|
|
7730
7733
|
return $1;
|
|
7731
7734
|
});
|
|
7732
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7735
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7733
7736
|
return "&&";
|
|
7734
7737
|
});
|
|
7735
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7736
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7738
|
+
var BinaryOpSymbol$22 = $EXPECT($L71, fail, 'BinaryOpSymbol "&&"');
|
|
7739
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7737
7740
|
return "in";
|
|
7738
7741
|
});
|
|
7739
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7742
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7740
7743
|
return "||";
|
|
7741
7744
|
});
|
|
7742
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7743
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
7744
|
-
|
|
7745
|
+
var BinaryOpSymbol$25 = $EXPECT($L74, fail, 'BinaryOpSymbol "||"');
|
|
7746
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L75, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L76, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7747
|
+
return {
|
|
7748
|
+
call: module2.getRef("xor"),
|
|
7749
|
+
special: true
|
|
7750
|
+
};
|
|
7751
|
+
});
|
|
7752
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R7, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7753
|
+
return {
|
|
7754
|
+
call: module2.getRef("xnor"),
|
|
7755
|
+
special: true
|
|
7756
|
+
};
|
|
7757
|
+
});
|
|
7758
|
+
var BinaryOpSymbol$28 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
|
|
7759
|
+
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7745
7760
|
return "??";
|
|
7746
7761
|
});
|
|
7747
|
-
var BinaryOpSymbol$
|
|
7762
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7748
7763
|
return {
|
|
7749
7764
|
$loc,
|
|
7750
7765
|
token: $1,
|
|
@@ -7752,7 +7767,7 @@ ${input.slice(result.pos)}
|
|
|
7752
7767
|
special: true
|
|
7753
7768
|
};
|
|
7754
7769
|
});
|
|
7755
|
-
var BinaryOpSymbol$
|
|
7770
|
+
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) {
|
|
7756
7771
|
return {
|
|
7757
7772
|
$loc,
|
|
7758
7773
|
token: "instanceof",
|
|
@@ -7761,7 +7776,7 @@ ${input.slice(result.pos)}
|
|
|
7761
7776
|
negated: true
|
|
7762
7777
|
};
|
|
7763
7778
|
});
|
|
7764
|
-
var BinaryOpSymbol$
|
|
7779
|
+
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) {
|
|
7765
7780
|
return {
|
|
7766
7781
|
$loc,
|
|
7767
7782
|
token: "in",
|
|
@@ -7769,7 +7784,7 @@ ${input.slice(result.pos)}
|
|
|
7769
7784
|
negated: true
|
|
7770
7785
|
};
|
|
7771
7786
|
});
|
|
7772
|
-
var BinaryOpSymbol$
|
|
7787
|
+
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) {
|
|
7773
7788
|
return {
|
|
7774
7789
|
method: "includes",
|
|
7775
7790
|
relational: true,
|
|
@@ -7777,7 +7792,7 @@ ${input.slice(result.pos)}
|
|
|
7777
7792
|
special: true
|
|
7778
7793
|
};
|
|
7779
7794
|
});
|
|
7780
|
-
var BinaryOpSymbol$
|
|
7795
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7781
7796
|
return {
|
|
7782
7797
|
call: [module2.getRef("indexOf"), ".call"],
|
|
7783
7798
|
relational: true,
|
|
@@ -7786,7 +7801,7 @@ ${input.slice(result.pos)}
|
|
|
7786
7801
|
special: true
|
|
7787
7802
|
};
|
|
7788
7803
|
});
|
|
7789
|
-
var BinaryOpSymbol$
|
|
7804
|
+
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) {
|
|
7790
7805
|
return {
|
|
7791
7806
|
method: "includes",
|
|
7792
7807
|
relational: true,
|
|
@@ -7795,7 +7810,7 @@ ${input.slice(result.pos)}
|
|
|
7795
7810
|
negated: true
|
|
7796
7811
|
};
|
|
7797
7812
|
});
|
|
7798
|
-
var BinaryOpSymbol$
|
|
7813
|
+
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) {
|
|
7799
7814
|
return {
|
|
7800
7815
|
call: [module2.getRef("indexOf"), ".call"],
|
|
7801
7816
|
relational: true,
|
|
@@ -7804,7 +7819,7 @@ ${input.slice(result.pos)}
|
|
|
7804
7819
|
special: true
|
|
7805
7820
|
};
|
|
7806
7821
|
});
|
|
7807
|
-
var BinaryOpSymbol$
|
|
7822
|
+
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) {
|
|
7808
7823
|
if (module2.config.objectIs) {
|
|
7809
7824
|
return {
|
|
7810
7825
|
call: module2.getRef("is"),
|
|
@@ -7816,7 +7831,7 @@ ${input.slice(result.pos)}
|
|
|
7816
7831
|
}
|
|
7817
7832
|
return "!==";
|
|
7818
7833
|
});
|
|
7819
|
-
var BinaryOpSymbol$
|
|
7834
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7820
7835
|
if (module2.config.objectIs) {
|
|
7821
7836
|
return {
|
|
7822
7837
|
call: module2.getRef("is"),
|
|
@@ -7827,12 +7842,12 @@ ${input.slice(result.pos)}
|
|
|
7827
7842
|
}
|
|
7828
7843
|
return "===";
|
|
7829
7844
|
});
|
|
7830
|
-
var BinaryOpSymbol$
|
|
7845
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7831
7846
|
return $1;
|
|
7832
7847
|
});
|
|
7833
|
-
var BinaryOpSymbol$
|
|
7834
|
-
var BinaryOpSymbol$
|
|
7835
|
-
var BinaryOpSymbol$
|
|
7848
|
+
var BinaryOpSymbol$40 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
|
|
7849
|
+
var BinaryOpSymbol$41 = $EXPECT($L15, fail, 'BinaryOpSymbol "^"');
|
|
7850
|
+
var BinaryOpSymbol$42 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
|
|
7836
7851
|
function BinaryOpSymbol(state) {
|
|
7837
7852
|
let eventData;
|
|
7838
7853
|
if (state.events) {
|
|
@@ -7844,18 +7859,66 @@ ${input.slice(result.pos)}
|
|
|
7844
7859
|
}
|
|
7845
7860
|
}
|
|
7846
7861
|
if (state.tokenize) {
|
|
7847
|
-
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));
|
|
7862
|
+
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));
|
|
7848
7863
|
if (state.events)
|
|
7849
7864
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7850
7865
|
return result;
|
|
7851
7866
|
} else {
|
|
7852
|
-
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);
|
|
7867
|
+
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);
|
|
7853
7868
|
if (state.events)
|
|
7854
7869
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7855
7870
|
return result;
|
|
7856
7871
|
}
|
|
7857
7872
|
}
|
|
7858
|
-
var
|
|
7873
|
+
var Xor$0 = $EXPECT($L75, fail, 'Xor "^^"');
|
|
7874
|
+
var Xor$1 = $S($EXPECT($L76, fail, 'Xor "xor"'), NonIdContinue);
|
|
7875
|
+
function Xor(state) {
|
|
7876
|
+
let eventData;
|
|
7877
|
+
if (state.events) {
|
|
7878
|
+
const result = state.events.enter?.("Xor", state);
|
|
7879
|
+
if (result) {
|
|
7880
|
+
if (result.cache)
|
|
7881
|
+
return result.cache;
|
|
7882
|
+
eventData = result.data;
|
|
7883
|
+
}
|
|
7884
|
+
}
|
|
7885
|
+
if (state.tokenize) {
|
|
7886
|
+
const result = $TOKEN("Xor", state, Xor$0(state) || Xor$1(state));
|
|
7887
|
+
if (state.events)
|
|
7888
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7889
|
+
return result;
|
|
7890
|
+
} else {
|
|
7891
|
+
const result = Xor$0(state) || Xor$1(state);
|
|
7892
|
+
if (state.events)
|
|
7893
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7894
|
+
return result;
|
|
7895
|
+
}
|
|
7896
|
+
}
|
|
7897
|
+
var Xnor$0 = $R$0($EXPECT($R7, fail, "Xnor /!\\^\\^?/"));
|
|
7898
|
+
var Xnor$1 = $EXPECT($L77, fail, 'Xnor "xnor"');
|
|
7899
|
+
function Xnor(state) {
|
|
7900
|
+
let eventData;
|
|
7901
|
+
if (state.events) {
|
|
7902
|
+
const result = state.events.enter?.("Xnor", state);
|
|
7903
|
+
if (result) {
|
|
7904
|
+
if (result.cache)
|
|
7905
|
+
return result.cache;
|
|
7906
|
+
eventData = result.data;
|
|
7907
|
+
}
|
|
7908
|
+
}
|
|
7909
|
+
if (state.tokenize) {
|
|
7910
|
+
const result = $TOKEN("Xnor", state, Xnor$0(state) || Xnor$1(state));
|
|
7911
|
+
if (state.events)
|
|
7912
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7913
|
+
return result;
|
|
7914
|
+
} else {
|
|
7915
|
+
const result = Xnor$0(state) || Xnor$1(state);
|
|
7916
|
+
if (state.events)
|
|
7917
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7918
|
+
return result;
|
|
7919
|
+
}
|
|
7920
|
+
}
|
|
7921
|
+
var UnaryOp$0 = $TR($EXPECT($R8, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7859
7922
|
return { $loc, token: $0 };
|
|
7860
7923
|
});
|
|
7861
7924
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -8052,7 +8115,7 @@ ${input.slice(result.pos)}
|
|
|
8052
8115
|
return result;
|
|
8053
8116
|
}
|
|
8054
8117
|
}
|
|
8055
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8118
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L84, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8056
8119
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8057
8120
|
});
|
|
8058
8121
|
function EmptyStatement(state) {
|
|
@@ -9007,7 +9070,7 @@ ${input.slice(result.pos)}
|
|
|
9007
9070
|
return result;
|
|
9008
9071
|
}
|
|
9009
9072
|
}
|
|
9010
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9073
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L85, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9011
9074
|
var own = $1;
|
|
9012
9075
|
var binding = $2;
|
|
9013
9076
|
return {
|
|
@@ -9130,7 +9193,7 @@ ${input.slice(result.pos)}
|
|
|
9130
9193
|
names: binding.names
|
|
9131
9194
|
};
|
|
9132
9195
|
});
|
|
9133
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9196
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R9, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9134
9197
|
var c = $1;
|
|
9135
9198
|
var binding = $2;
|
|
9136
9199
|
return {
|
|
@@ -9488,7 +9551,7 @@ ${input.slice(result.pos)}
|
|
|
9488
9551
|
}
|
|
9489
9552
|
}
|
|
9490
9553
|
var ImpliedColon$0 = $S(__, Colon);
|
|
9491
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9554
|
+
var ImpliedColon$1 = $TV($EXPECT($L18, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9492
9555
|
return { $loc, token: ":" };
|
|
9493
9556
|
});
|
|
9494
9557
|
function ImpliedColon(state) {
|
|
@@ -9742,7 +9805,7 @@ ${input.slice(result.pos)}
|
|
|
9742
9805
|
return result;
|
|
9743
9806
|
}
|
|
9744
9807
|
}
|
|
9745
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
9808
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L18, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9746
9809
|
module2.suppressIndentedApplication = true;
|
|
9747
9810
|
});
|
|
9748
9811
|
function SuppressIndentedApplication(state) {
|
|
@@ -9767,7 +9830,7 @@ ${input.slice(result.pos)}
|
|
|
9767
9830
|
return result;
|
|
9768
9831
|
}
|
|
9769
9832
|
}
|
|
9770
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
9833
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L18, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9771
9834
|
if (module2.suppressIndentedApplication)
|
|
9772
9835
|
return $skip;
|
|
9773
9836
|
return;
|
|
@@ -9794,7 +9857,7 @@ ${input.slice(result.pos)}
|
|
|
9794
9857
|
return result;
|
|
9795
9858
|
}
|
|
9796
9859
|
}
|
|
9797
|
-
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($
|
|
9860
|
+
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'SuppressTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
9798
9861
|
module2.suppressTrailingMemberProperty.push(true);
|
|
9799
9862
|
});
|
|
9800
9863
|
function SuppressTrailingMemberProperty(state) {
|
|
@@ -9819,7 +9882,7 @@ ${input.slice(result.pos)}
|
|
|
9819
9882
|
return result;
|
|
9820
9883
|
}
|
|
9821
9884
|
}
|
|
9822
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
9885
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L18, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9823
9886
|
if (module2.trailingMemberPropertySuppressed)
|
|
9824
9887
|
return $skip;
|
|
9825
9888
|
});
|
|
@@ -9868,13 +9931,13 @@ ${input.slice(result.pos)}
|
|
|
9868
9931
|
return result;
|
|
9869
9932
|
}
|
|
9870
9933
|
}
|
|
9871
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
9934
|
+
var KeywordStatement$0 = $T($S($EXPECT($L86, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
9872
9935
|
return { "type": "BreakStatement", "children": value };
|
|
9873
9936
|
});
|
|
9874
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
9937
|
+
var KeywordStatement$1 = $T($S($EXPECT($L87, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
9875
9938
|
return { "type": "ContinueStatement", "children": value };
|
|
9876
9939
|
});
|
|
9877
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
9940
|
+
var KeywordStatement$2 = $T($S($EXPECT($L88, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
9878
9941
|
return { "type": "DebuggerStatement", "children": value };
|
|
9879
9942
|
});
|
|
9880
9943
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -9905,7 +9968,7 @@ ${input.slice(result.pos)}
|
|
|
9905
9968
|
return result;
|
|
9906
9969
|
}
|
|
9907
9970
|
}
|
|
9908
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
9971
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L88, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9909
9972
|
return {
|
|
9910
9973
|
type: "DebuggerExpression",
|
|
9911
9974
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10033,7 +10096,7 @@ ${input.slice(result.pos)}
|
|
|
10033
10096
|
return result;
|
|
10034
10097
|
}
|
|
10035
10098
|
}
|
|
10036
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10099
|
+
var ImpliedImport$0 = $TV($EXPECT($L18, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10037
10100
|
return { $loc, token: "import " };
|
|
10038
10101
|
});
|
|
10039
10102
|
function ImpliedImport(state) {
|
|
@@ -10182,7 +10245,7 @@ ${input.slice(result.pos)}
|
|
|
10182
10245
|
return result;
|
|
10183
10246
|
}
|
|
10184
10247
|
}
|
|
10185
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10248
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L89, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10186
10249
|
function ImportAssertion(state) {
|
|
10187
10250
|
let eventData;
|
|
10188
10251
|
if (state.events) {
|
|
@@ -10398,7 +10461,7 @@ ${input.slice(result.pos)}
|
|
|
10398
10461
|
return result;
|
|
10399
10462
|
}
|
|
10400
10463
|
}
|
|
10401
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10464
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R10, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10402
10465
|
var spec = $0;
|
|
10403
10466
|
return { $loc, token: `"${spec}"` };
|
|
10404
10467
|
});
|
|
@@ -10786,7 +10849,7 @@ ${input.slice(result.pos)}
|
|
|
10786
10849
|
return result;
|
|
10787
10850
|
}
|
|
10788
10851
|
}
|
|
10789
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
10852
|
+
var ConstAssignment$0 = $TV($EXPECT($L90, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
10790
10853
|
return { $loc, token: "=" };
|
|
10791
10854
|
});
|
|
10792
10855
|
function ConstAssignment(state) {
|
|
@@ -10811,7 +10874,7 @@ ${input.slice(result.pos)}
|
|
|
10811
10874
|
return result;
|
|
10812
10875
|
}
|
|
10813
10876
|
}
|
|
10814
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10877
|
+
var LetAssignment$0 = $TV($EXPECT($L91, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10815
10878
|
return { $loc, token: "=" };
|
|
10816
10879
|
});
|
|
10817
10880
|
function LetAssignment(state) {
|
|
@@ -11060,7 +11123,7 @@ ${input.slice(result.pos)}
|
|
|
11060
11123
|
return result;
|
|
11061
11124
|
}
|
|
11062
11125
|
}
|
|
11063
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
11126
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
11064
11127
|
function DecimalBigIntegerLiteral(state) {
|
|
11065
11128
|
let eventData;
|
|
11066
11129
|
if (state.events) {
|
|
@@ -11083,11 +11146,11 @@ ${input.slice(result.pos)}
|
|
|
11083
11146
|
return result;
|
|
11084
11147
|
}
|
|
11085
11148
|
}
|
|
11086
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
11149
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R12, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
11087
11150
|
return $1 + ".";
|
|
11088
11151
|
});
|
|
11089
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
11090
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
11152
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R13, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
11153
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R14, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
11091
11154
|
function DecimalLiteral(state) {
|
|
11092
11155
|
let eventData;
|
|
11093
11156
|
if (state.events) {
|
|
@@ -11110,7 +11173,7 @@ ${input.slice(result.pos)}
|
|
|
11110
11173
|
return result;
|
|
11111
11174
|
}
|
|
11112
11175
|
}
|
|
11113
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
11176
|
+
var ExponentPart$0 = $R$0($EXPECT($R15, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
11114
11177
|
function ExponentPart(state) {
|
|
11115
11178
|
let eventData;
|
|
11116
11179
|
if (state.events) {
|
|
@@ -11133,7 +11196,7 @@ ${input.slice(result.pos)}
|
|
|
11133
11196
|
return result;
|
|
11134
11197
|
}
|
|
11135
11198
|
}
|
|
11136
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
11199
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R16, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
11137
11200
|
function BinaryIntegerLiteral(state) {
|
|
11138
11201
|
let eventData;
|
|
11139
11202
|
if (state.events) {
|
|
@@ -11156,7 +11219,7 @@ ${input.slice(result.pos)}
|
|
|
11156
11219
|
return result;
|
|
11157
11220
|
}
|
|
11158
11221
|
}
|
|
11159
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11222
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R17, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
11160
11223
|
function OctalIntegerLiteral(state) {
|
|
11161
11224
|
let eventData;
|
|
11162
11225
|
if (state.events) {
|
|
@@ -11179,7 +11242,7 @@ ${input.slice(result.pos)}
|
|
|
11179
11242
|
return result;
|
|
11180
11243
|
}
|
|
11181
11244
|
}
|
|
11182
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
11245
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R18, fail, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
11183
11246
|
function HexIntegerLiteral(state) {
|
|
11184
11247
|
let eventData;
|
|
11185
11248
|
if (state.events) {
|
|
@@ -11254,7 +11317,7 @@ ${input.slice(result.pos)}
|
|
|
11254
11317
|
return result;
|
|
11255
11318
|
}
|
|
11256
11319
|
}
|
|
11257
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11320
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R19, fail, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
11258
11321
|
function DecimalIntegerLiteral(state) {
|
|
11259
11322
|
let eventData;
|
|
11260
11323
|
if (state.events) {
|
|
@@ -11315,7 +11378,7 @@ ${input.slice(result.pos)}
|
|
|
11315
11378
|
return result;
|
|
11316
11379
|
}
|
|
11317
11380
|
}
|
|
11318
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11381
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R20, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11319
11382
|
return { $loc, token: $0 };
|
|
11320
11383
|
});
|
|
11321
11384
|
function DoubleStringCharacters(state) {
|
|
@@ -11340,7 +11403,7 @@ ${input.slice(result.pos)}
|
|
|
11340
11403
|
return result;
|
|
11341
11404
|
}
|
|
11342
11405
|
}
|
|
11343
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11406
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R21, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11344
11407
|
return { $loc, token: $0 };
|
|
11345
11408
|
});
|
|
11346
11409
|
function SingleStringCharacters(state) {
|
|
@@ -11365,7 +11428,7 @@ ${input.slice(result.pos)}
|
|
|
11365
11428
|
return result;
|
|
11366
11429
|
}
|
|
11367
11430
|
}
|
|
11368
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11431
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R22, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11369
11432
|
return { $loc, token: $0 };
|
|
11370
11433
|
});
|
|
11371
11434
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -11390,7 +11453,7 @@ ${input.slice(result.pos)}
|
|
|
11390
11453
|
return result;
|
|
11391
11454
|
}
|
|
11392
11455
|
}
|
|
11393
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11456
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R23, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11394
11457
|
return { $loc, token: $0 };
|
|
11395
11458
|
});
|
|
11396
11459
|
function TripleSingleStringCharacters(state) {
|
|
@@ -11483,7 +11546,7 @@ ${input.slice(result.pos)}
|
|
|
11483
11546
|
return result;
|
|
11484
11547
|
}
|
|
11485
11548
|
}
|
|
11486
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11549
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R24, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11487
11550
|
return { $loc, token: $0 };
|
|
11488
11551
|
});
|
|
11489
11552
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -11509,7 +11572,7 @@ ${input.slice(result.pos)}
|
|
|
11509
11572
|
}
|
|
11510
11573
|
}
|
|
11511
11574
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
11512
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
11575
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
11513
11576
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
11514
11577
|
});
|
|
11515
11578
|
function RegularExpressionLiteral(state) {
|
|
@@ -11559,7 +11622,7 @@ ${input.slice(result.pos)}
|
|
|
11559
11622
|
return result;
|
|
11560
11623
|
}
|
|
11561
11624
|
}
|
|
11562
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11625
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R25, fail, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11563
11626
|
return { $loc, token: $0 };
|
|
11564
11627
|
});
|
|
11565
11628
|
function RegularExpressionClassCharacters(state) {
|
|
@@ -11669,7 +11732,7 @@ ${input.slice(result.pos)}
|
|
|
11669
11732
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
11670
11733
|
return { "type": "Substitution", "children": value[0] };
|
|
11671
11734
|
});
|
|
11672
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11735
|
+
var HeregexPart$3 = $TR($EXPECT($R26, fail, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11673
11736
|
let token = $0;
|
|
11674
11737
|
switch ($0[1]) {
|
|
11675
11738
|
case "\n":
|
|
@@ -11687,13 +11750,13 @@ ${input.slice(result.pos)}
|
|
|
11687
11750
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
11688
11751
|
return { $loc, token: "" };
|
|
11689
11752
|
});
|
|
11690
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11753
|
+
var HeregexPart$5 = $TR($EXPECT($R27, fail, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11691
11754
|
return { $loc, token: "" };
|
|
11692
11755
|
});
|
|
11693
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11756
|
+
var HeregexPart$6 = $TR($EXPECT($R28, fail, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11694
11757
|
return { $loc, token: "\\/" };
|
|
11695
11758
|
});
|
|
11696
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11759
|
+
var HeregexPart$7 = $TR($EXPECT($R29, fail, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11697
11760
|
return { $loc, token: $0 };
|
|
11698
11761
|
});
|
|
11699
11762
|
function HeregexPart(state) {
|
|
@@ -11742,7 +11805,7 @@ ${input.slice(result.pos)}
|
|
|
11742
11805
|
return result;
|
|
11743
11806
|
}
|
|
11744
11807
|
}
|
|
11745
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11808
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R30, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11746
11809
|
function RegularExpressionBody(state) {
|
|
11747
11810
|
let eventData;
|
|
11748
11811
|
if (state.events) {
|
|
@@ -11789,7 +11852,7 @@ ${input.slice(result.pos)}
|
|
|
11789
11852
|
return result;
|
|
11790
11853
|
}
|
|
11791
11854
|
}
|
|
11792
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
11855
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R31, fail, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11793
11856
|
function RegExpCharacter(state) {
|
|
11794
11857
|
let eventData;
|
|
11795
11858
|
if (state.events) {
|
|
@@ -11812,7 +11875,7 @@ ${input.slice(result.pos)}
|
|
|
11812
11875
|
return result;
|
|
11813
11876
|
}
|
|
11814
11877
|
}
|
|
11815
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11878
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R32, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11816
11879
|
function RegularExpressionFlags(state) {
|
|
11817
11880
|
let eventData;
|
|
11818
11881
|
if (state.events) {
|
|
@@ -11902,7 +11965,7 @@ ${input.slice(result.pos)}
|
|
|
11902
11965
|
return result;
|
|
11903
11966
|
}
|
|
11904
11967
|
}
|
|
11905
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11968
|
+
var TemplateCharacters$0 = $TR($EXPECT($R33, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11906
11969
|
return { $loc, token: $0 };
|
|
11907
11970
|
});
|
|
11908
11971
|
function TemplateCharacters(state) {
|
|
@@ -11927,7 +11990,7 @@ ${input.slice(result.pos)}
|
|
|
11927
11990
|
return result;
|
|
11928
11991
|
}
|
|
11929
11992
|
}
|
|
11930
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
11993
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R34, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11931
11994
|
return { $loc, token: $0 };
|
|
11932
11995
|
});
|
|
11933
11996
|
function TemplateBlockCharacters(state) {
|
|
@@ -11952,11 +12015,11 @@ ${input.slice(result.pos)}
|
|
|
11952
12015
|
return result;
|
|
11953
12016
|
}
|
|
11954
12017
|
}
|
|
11955
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
11956
|
-
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($
|
|
11957
|
-
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($
|
|
11958
|
-
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($
|
|
11959
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
12018
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R35, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
12019
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R36, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
12020
|
+
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R37, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
12021
|
+
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R38, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
12022
|
+
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})/"));
|
|
11960
12023
|
function ReservedWord(state) {
|
|
11961
12024
|
let eventData;
|
|
11962
12025
|
if (state.events) {
|
|
@@ -12027,7 +12090,7 @@ ${input.slice(result.pos)}
|
|
|
12027
12090
|
return result;
|
|
12028
12091
|
}
|
|
12029
12092
|
}
|
|
12030
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
12093
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R40, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12031
12094
|
return { $loc, token: $0 };
|
|
12032
12095
|
});
|
|
12033
12096
|
function JSSingleLineComment(state) {
|
|
@@ -12076,7 +12139,7 @@ ${input.slice(result.pos)}
|
|
|
12076
12139
|
return result;
|
|
12077
12140
|
}
|
|
12078
12141
|
}
|
|
12079
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12142
|
+
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) {
|
|
12080
12143
|
return { $loc, token: $1 };
|
|
12081
12144
|
});
|
|
12082
12145
|
function JSMultiLineComment(state) {
|
|
@@ -12101,7 +12164,7 @@ ${input.slice(result.pos)}
|
|
|
12101
12164
|
return result;
|
|
12102
12165
|
}
|
|
12103
12166
|
}
|
|
12104
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
12167
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R42, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12105
12168
|
return { $loc, token: `//${$1}` };
|
|
12106
12169
|
});
|
|
12107
12170
|
function CoffeeSingleLineComment(state) {
|
|
@@ -12126,7 +12189,7 @@ ${input.slice(result.pos)}
|
|
|
12126
12189
|
return result;
|
|
12127
12190
|
}
|
|
12128
12191
|
}
|
|
12129
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
12192
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R43, fail, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
12130
12193
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
12131
12194
|
return { $loc, token: `/*${$2}*/` };
|
|
12132
12195
|
});
|
|
@@ -12152,7 +12215,7 @@ ${input.slice(result.pos)}
|
|
|
12152
12215
|
return result;
|
|
12153
12216
|
}
|
|
12154
12217
|
}
|
|
12155
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
12218
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R44, fail, "CoffeeHereCommentStart /###(?!#)/"));
|
|
12156
12219
|
function CoffeeHereCommentStart(state) {
|
|
12157
12220
|
let eventData;
|
|
12158
12221
|
if (state.events) {
|
|
@@ -12175,7 +12238,7 @@ ${input.slice(result.pos)}
|
|
|
12175
12238
|
return result;
|
|
12176
12239
|
}
|
|
12177
12240
|
}
|
|
12178
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12241
|
+
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) {
|
|
12179
12242
|
return { $loc, token: $1 };
|
|
12180
12243
|
});
|
|
12181
12244
|
function InlineComment(state) {
|
|
@@ -12271,10 +12334,10 @@ ${input.slice(result.pos)}
|
|
|
12271
12334
|
return result;
|
|
12272
12335
|
}
|
|
12273
12336
|
}
|
|
12274
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
12337
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R46, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12275
12338
|
return { $loc, token: $0 };
|
|
12276
12339
|
});
|
|
12277
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12340
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L94, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12278
12341
|
return "";
|
|
12279
12342
|
});
|
|
12280
12343
|
function NonNewlineWhitespace(state) {
|
|
@@ -12348,7 +12411,7 @@ ${input.slice(result.pos)}
|
|
|
12348
12411
|
return result;
|
|
12349
12412
|
}
|
|
12350
12413
|
}
|
|
12351
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
12414
|
+
var Whitespace$0 = $TR($EXPECT($R27, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12352
12415
|
return { $loc, token: $0 };
|
|
12353
12416
|
});
|
|
12354
12417
|
function Whitespace(state) {
|
|
@@ -12426,7 +12489,7 @@ ${input.slice(result.pos)}
|
|
|
12426
12489
|
}
|
|
12427
12490
|
}
|
|
12428
12491
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12429
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
12492
|
+
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);
|
|
12430
12493
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12431
12494
|
function StatementDelimiter(state) {
|
|
12432
12495
|
let eventData;
|
|
@@ -12478,7 +12541,7 @@ ${input.slice(result.pos)}
|
|
|
12478
12541
|
return result;
|
|
12479
12542
|
}
|
|
12480
12543
|
}
|
|
12481
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
12544
|
+
var NonIdContinue$0 = $R$0($EXPECT($R47, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
12482
12545
|
function NonIdContinue(state) {
|
|
12483
12546
|
let eventData;
|
|
12484
12547
|
if (state.events) {
|
|
@@ -12501,7 +12564,7 @@ ${input.slice(result.pos)}
|
|
|
12501
12564
|
return result;
|
|
12502
12565
|
}
|
|
12503
12566
|
}
|
|
12504
|
-
var Loc$0 = $TV($EXPECT($
|
|
12567
|
+
var Loc$0 = $TV($EXPECT($L18, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
12505
12568
|
return { $loc, token: "" };
|
|
12506
12569
|
});
|
|
12507
12570
|
function Loc(state) {
|
|
@@ -12526,7 +12589,7 @@ ${input.slice(result.pos)}
|
|
|
12526
12589
|
return result;
|
|
12527
12590
|
}
|
|
12528
12591
|
}
|
|
12529
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
12592
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L97, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
12530
12593
|
return { $loc, token: $1, ts: true };
|
|
12531
12594
|
});
|
|
12532
12595
|
function Abstract(state) {
|
|
@@ -12551,7 +12614,7 @@ ${input.slice(result.pos)}
|
|
|
12551
12614
|
return result;
|
|
12552
12615
|
}
|
|
12553
12616
|
}
|
|
12554
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
12617
|
+
var Ampersand$0 = $TV($EXPECT($L82, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
12555
12618
|
return { $loc, token: $1 };
|
|
12556
12619
|
});
|
|
12557
12620
|
function Ampersand(state) {
|
|
@@ -12576,7 +12639,7 @@ ${input.slice(result.pos)}
|
|
|
12576
12639
|
return result;
|
|
12577
12640
|
}
|
|
12578
12641
|
}
|
|
12579
|
-
var As$0 = $TS($S($EXPECT($
|
|
12642
|
+
var As$0 = $TS($S($EXPECT($L98, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12580
12643
|
return { $loc, token: $1 };
|
|
12581
12644
|
});
|
|
12582
12645
|
function As(state) {
|
|
@@ -12601,7 +12664,7 @@ ${input.slice(result.pos)}
|
|
|
12601
12664
|
return result;
|
|
12602
12665
|
}
|
|
12603
12666
|
}
|
|
12604
|
-
var At$0 = $TV($EXPECT($
|
|
12667
|
+
var At$0 = $TV($EXPECT($L99, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
12605
12668
|
return { $loc, token: $1 };
|
|
12606
12669
|
});
|
|
12607
12670
|
function At(state) {
|
|
@@ -12626,7 +12689,7 @@ ${input.slice(result.pos)}
|
|
|
12626
12689
|
return result;
|
|
12627
12690
|
}
|
|
12628
12691
|
}
|
|
12629
|
-
var AtAt$0 = $TV($EXPECT($
|
|
12692
|
+
var AtAt$0 = $TV($EXPECT($L100, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
12630
12693
|
return { $loc, token: "@" };
|
|
12631
12694
|
});
|
|
12632
12695
|
function AtAt(state) {
|
|
@@ -12651,7 +12714,7 @@ ${input.slice(result.pos)}
|
|
|
12651
12714
|
return result;
|
|
12652
12715
|
}
|
|
12653
12716
|
}
|
|
12654
|
-
var Async$0 = $TS($S($EXPECT($
|
|
12717
|
+
var Async$0 = $TS($S($EXPECT($L101, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12655
12718
|
return { $loc, token: $1, type: "Async" };
|
|
12656
12719
|
});
|
|
12657
12720
|
function Async(state) {
|
|
@@ -12676,7 +12739,7 @@ ${input.slice(result.pos)}
|
|
|
12676
12739
|
return result;
|
|
12677
12740
|
}
|
|
12678
12741
|
}
|
|
12679
|
-
var Await$0 = $TS($S($EXPECT($
|
|
12742
|
+
var Await$0 = $TS($S($EXPECT($L102, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12680
12743
|
return { $loc, token: $1 };
|
|
12681
12744
|
});
|
|
12682
12745
|
function Await(state) {
|
|
@@ -12701,7 +12764,7 @@ ${input.slice(result.pos)}
|
|
|
12701
12764
|
return result;
|
|
12702
12765
|
}
|
|
12703
12766
|
}
|
|
12704
|
-
var Backtick$0 = $TV($EXPECT($
|
|
12767
|
+
var Backtick$0 = $TV($EXPECT($L96, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
12705
12768
|
return { $loc, token: $1 };
|
|
12706
12769
|
});
|
|
12707
12770
|
function Backtick(state) {
|
|
@@ -12726,7 +12789,7 @@ ${input.slice(result.pos)}
|
|
|
12726
12789
|
return result;
|
|
12727
12790
|
}
|
|
12728
12791
|
}
|
|
12729
|
-
var By$0 = $TS($S($EXPECT($
|
|
12792
|
+
var By$0 = $TS($S($EXPECT($L103, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12730
12793
|
return { $loc, token: $1 };
|
|
12731
12794
|
});
|
|
12732
12795
|
function By(state) {
|
|
@@ -12751,7 +12814,7 @@ ${input.slice(result.pos)}
|
|
|
12751
12814
|
return result;
|
|
12752
12815
|
}
|
|
12753
12816
|
}
|
|
12754
|
-
var Case$0 = $TS($S($EXPECT($
|
|
12817
|
+
var Case$0 = $TS($S($EXPECT($L104, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12755
12818
|
return { $loc, token: $1 };
|
|
12756
12819
|
});
|
|
12757
12820
|
function Case(state) {
|
|
@@ -12776,7 +12839,7 @@ ${input.slice(result.pos)}
|
|
|
12776
12839
|
return result;
|
|
12777
12840
|
}
|
|
12778
12841
|
}
|
|
12779
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
12842
|
+
var Catch$0 = $TS($S($EXPECT($L105, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12780
12843
|
return { $loc, token: $1 };
|
|
12781
12844
|
});
|
|
12782
12845
|
function Catch(state) {
|
|
@@ -12801,7 +12864,7 @@ ${input.slice(result.pos)}
|
|
|
12801
12864
|
return result;
|
|
12802
12865
|
}
|
|
12803
12866
|
}
|
|
12804
|
-
var Class$0 = $TS($S($EXPECT($
|
|
12867
|
+
var Class$0 = $TS($S($EXPECT($L106, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12805
12868
|
return { $loc, token: $1 };
|
|
12806
12869
|
});
|
|
12807
12870
|
function Class(state) {
|
|
@@ -12826,7 +12889,7 @@ ${input.slice(result.pos)}
|
|
|
12826
12889
|
return result;
|
|
12827
12890
|
}
|
|
12828
12891
|
}
|
|
12829
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
12892
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
12830
12893
|
return { $loc, token: $1 };
|
|
12831
12894
|
});
|
|
12832
12895
|
function CloseBrace(state) {
|
|
@@ -12851,7 +12914,7 @@ ${input.slice(result.pos)}
|
|
|
12851
12914
|
return result;
|
|
12852
12915
|
}
|
|
12853
12916
|
}
|
|
12854
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
12917
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
12855
12918
|
return { $loc, token: $1 };
|
|
12856
12919
|
});
|
|
12857
12920
|
function CloseBracket(state) {
|
|
@@ -12876,7 +12939,7 @@ ${input.slice(result.pos)}
|
|
|
12876
12939
|
return result;
|
|
12877
12940
|
}
|
|
12878
12941
|
}
|
|
12879
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
12942
|
+
var CloseParen$0 = $TV($EXPECT($L19, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
12880
12943
|
return { $loc, token: $1 };
|
|
12881
12944
|
});
|
|
12882
12945
|
function CloseParen(state) {
|
|
@@ -12901,7 +12964,7 @@ ${input.slice(result.pos)}
|
|
|
12901
12964
|
return result;
|
|
12902
12965
|
}
|
|
12903
12966
|
}
|
|
12904
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
12967
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L107, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
12905
12968
|
return { $loc, token: "${" };
|
|
12906
12969
|
});
|
|
12907
12970
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -12926,7 +12989,7 @@ ${input.slice(result.pos)}
|
|
|
12926
12989
|
return result;
|
|
12927
12990
|
}
|
|
12928
12991
|
}
|
|
12929
|
-
var Colon$0 = $TV($EXPECT($
|
|
12992
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
12930
12993
|
return { $loc, token: $1 };
|
|
12931
12994
|
});
|
|
12932
12995
|
function Colon(state) {
|
|
@@ -12951,7 +13014,7 @@ ${input.slice(result.pos)}
|
|
|
12951
13014
|
return result;
|
|
12952
13015
|
}
|
|
12953
13016
|
}
|
|
12954
|
-
var Comma$0 = $TV($EXPECT($
|
|
13017
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
12955
13018
|
return { $loc, token: $1 };
|
|
12956
13019
|
});
|
|
12957
13020
|
function Comma(state) {
|
|
@@ -12976,7 +13039,7 @@ ${input.slice(result.pos)}
|
|
|
12976
13039
|
return result;
|
|
12977
13040
|
}
|
|
12978
13041
|
}
|
|
12979
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13042
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L99, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
12980
13043
|
return { $loc, token: "constructor" };
|
|
12981
13044
|
});
|
|
12982
13045
|
function ConstructorShorthand(state) {
|
|
@@ -13001,7 +13064,7 @@ ${input.slice(result.pos)}
|
|
|
13001
13064
|
return result;
|
|
13002
13065
|
}
|
|
13003
13066
|
}
|
|
13004
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13067
|
+
var Declare$0 = $TS($S($EXPECT($L108, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13005
13068
|
return { $loc, token: $1 };
|
|
13006
13069
|
});
|
|
13007
13070
|
function Declare(state) {
|
|
@@ -13026,7 +13089,7 @@ ${input.slice(result.pos)}
|
|
|
13026
13089
|
return result;
|
|
13027
13090
|
}
|
|
13028
13091
|
}
|
|
13029
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13092
|
+
var Default$0 = $TS($S($EXPECT($L109, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13030
13093
|
return { $loc, token: $1 };
|
|
13031
13094
|
});
|
|
13032
13095
|
function Default(state) {
|
|
@@ -13051,7 +13114,7 @@ ${input.slice(result.pos)}
|
|
|
13051
13114
|
return result;
|
|
13052
13115
|
}
|
|
13053
13116
|
}
|
|
13054
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13117
|
+
var Delete$0 = $TS($S($EXPECT($L110, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13055
13118
|
return { $loc, token: $1 };
|
|
13056
13119
|
});
|
|
13057
13120
|
function Delete(state) {
|
|
@@ -13076,7 +13139,7 @@ ${input.slice(result.pos)}
|
|
|
13076
13139
|
return result;
|
|
13077
13140
|
}
|
|
13078
13141
|
}
|
|
13079
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13142
|
+
var Do$0 = $TS($S($EXPECT($L111, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13080
13143
|
return { $loc, token: $1 };
|
|
13081
13144
|
});
|
|
13082
13145
|
function Do(state) {
|
|
@@ -13126,7 +13189,7 @@ ${input.slice(result.pos)}
|
|
|
13126
13189
|
return result;
|
|
13127
13190
|
}
|
|
13128
13191
|
}
|
|
13129
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13192
|
+
var DotDot$0 = $TV($EXPECT($L112, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13130
13193
|
return { $loc, token: $1 };
|
|
13131
13194
|
});
|
|
13132
13195
|
function DotDot(state) {
|
|
@@ -13151,7 +13214,7 @@ ${input.slice(result.pos)}
|
|
|
13151
13214
|
return result;
|
|
13152
13215
|
}
|
|
13153
13216
|
}
|
|
13154
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13217
|
+
var DotDotDot$0 = $TV($EXPECT($L113, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13155
13218
|
return { $loc, token: $1 };
|
|
13156
13219
|
});
|
|
13157
13220
|
function DotDotDot(state) {
|
|
@@ -13176,7 +13239,7 @@ ${input.slice(result.pos)}
|
|
|
13176
13239
|
return result;
|
|
13177
13240
|
}
|
|
13178
13241
|
}
|
|
13179
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13242
|
+
var DoubleColon$0 = $TV($EXPECT($L114, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13180
13243
|
return { $loc, token: $1 };
|
|
13181
13244
|
});
|
|
13182
13245
|
function DoubleColon(state) {
|
|
@@ -13201,7 +13264,7 @@ ${input.slice(result.pos)}
|
|
|
13201
13264
|
return result;
|
|
13202
13265
|
}
|
|
13203
13266
|
}
|
|
13204
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13267
|
+
var DoubleQuote$0 = $TV($EXPECT($L115, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13205
13268
|
return { $loc, token: $1 };
|
|
13206
13269
|
});
|
|
13207
13270
|
function DoubleQuote(state) {
|
|
@@ -13226,7 +13289,7 @@ ${input.slice(result.pos)}
|
|
|
13226
13289
|
return result;
|
|
13227
13290
|
}
|
|
13228
13291
|
}
|
|
13229
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13292
|
+
var Else$0 = $TS($S($EXPECT($L116, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13230
13293
|
return { $loc, token: $1 };
|
|
13231
13294
|
});
|
|
13232
13295
|
function Else(state) {
|
|
@@ -13276,7 +13339,7 @@ ${input.slice(result.pos)}
|
|
|
13276
13339
|
return result;
|
|
13277
13340
|
}
|
|
13278
13341
|
}
|
|
13279
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13342
|
+
var Export$0 = $TS($S($EXPECT($L117, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13280
13343
|
return { $loc, token: $1 };
|
|
13281
13344
|
});
|
|
13282
13345
|
function Export(state) {
|
|
@@ -13301,7 +13364,7 @@ ${input.slice(result.pos)}
|
|
|
13301
13364
|
return result;
|
|
13302
13365
|
}
|
|
13303
13366
|
}
|
|
13304
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13367
|
+
var Extends$0 = $TS($S($EXPECT($L118, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13305
13368
|
return { $loc, token: $1 };
|
|
13306
13369
|
});
|
|
13307
13370
|
function Extends(state) {
|
|
@@ -13326,7 +13389,7 @@ ${input.slice(result.pos)}
|
|
|
13326
13389
|
return result;
|
|
13327
13390
|
}
|
|
13328
13391
|
}
|
|
13329
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13392
|
+
var Finally$0 = $TS($S($EXPECT($L119, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13330
13393
|
return { $loc, token: $1 };
|
|
13331
13394
|
});
|
|
13332
13395
|
function Finally(state) {
|
|
@@ -13351,7 +13414,7 @@ ${input.slice(result.pos)}
|
|
|
13351
13414
|
return result;
|
|
13352
13415
|
}
|
|
13353
13416
|
}
|
|
13354
|
-
var For$0 = $TS($S($EXPECT($
|
|
13417
|
+
var For$0 = $TS($S($EXPECT($L120, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13355
13418
|
return { $loc, token: $1 };
|
|
13356
13419
|
});
|
|
13357
13420
|
function For(state) {
|
|
@@ -13376,7 +13439,7 @@ ${input.slice(result.pos)}
|
|
|
13376
13439
|
return result;
|
|
13377
13440
|
}
|
|
13378
13441
|
}
|
|
13379
|
-
var From$0 = $TS($S($EXPECT($
|
|
13442
|
+
var From$0 = $TS($S($EXPECT($L121, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13380
13443
|
return { $loc, token: $1 };
|
|
13381
13444
|
});
|
|
13382
13445
|
function From(state) {
|
|
@@ -13401,7 +13464,7 @@ ${input.slice(result.pos)}
|
|
|
13401
13464
|
return result;
|
|
13402
13465
|
}
|
|
13403
13466
|
}
|
|
13404
|
-
var Function$0 = $TS($S($EXPECT($
|
|
13467
|
+
var Function$0 = $TS($S($EXPECT($L122, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13405
13468
|
return { $loc, token: $1 };
|
|
13406
13469
|
});
|
|
13407
13470
|
function Function(state) {
|
|
@@ -13426,7 +13489,7 @@ ${input.slice(result.pos)}
|
|
|
13426
13489
|
return result;
|
|
13427
13490
|
}
|
|
13428
13491
|
}
|
|
13429
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
13492
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L123, fail, 'GetOrSet "get"'), $EXPECT($L124, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13430
13493
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13431
13494
|
});
|
|
13432
13495
|
function GetOrSet(state) {
|
|
@@ -13451,7 +13514,7 @@ ${input.slice(result.pos)}
|
|
|
13451
13514
|
return result;
|
|
13452
13515
|
}
|
|
13453
13516
|
}
|
|
13454
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
13517
|
+
var If$0 = $TV($TEXT($S($EXPECT($L125, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13455
13518
|
return { $loc, token: $1 };
|
|
13456
13519
|
});
|
|
13457
13520
|
function If(state) {
|
|
@@ -13476,7 +13539,7 @@ ${input.slice(result.pos)}
|
|
|
13476
13539
|
return result;
|
|
13477
13540
|
}
|
|
13478
13541
|
}
|
|
13479
|
-
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($
|
|
13542
|
+
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R48, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
13480
13543
|
return { $loc, token: $1 };
|
|
13481
13544
|
});
|
|
13482
13545
|
function Import(state) {
|
|
@@ -13501,7 +13564,7 @@ ${input.slice(result.pos)}
|
|
|
13501
13564
|
return result;
|
|
13502
13565
|
}
|
|
13503
13566
|
}
|
|
13504
|
-
var In$0 = $TS($S($EXPECT($
|
|
13567
|
+
var In$0 = $TS($S($EXPECT($L80, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13505
13568
|
return { $loc, token: $1 };
|
|
13506
13569
|
});
|
|
13507
13570
|
function In(state) {
|
|
@@ -13526,7 +13589,7 @@ ${input.slice(result.pos)}
|
|
|
13526
13589
|
return result;
|
|
13527
13590
|
}
|
|
13528
13591
|
}
|
|
13529
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
13592
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L126, fail, 'LetOrConst "let"'), $EXPECT($L127, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13530
13593
|
return { $loc, token: $1 };
|
|
13531
13594
|
});
|
|
13532
13595
|
function LetOrConst(state) {
|
|
@@ -13551,7 +13614,7 @@ ${input.slice(result.pos)}
|
|
|
13551
13614
|
return result;
|
|
13552
13615
|
}
|
|
13553
13616
|
}
|
|
13554
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
13617
|
+
var Loop$0 = $TS($S($EXPECT($L128, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13555
13618
|
return { $loc, token: "while(true)" };
|
|
13556
13619
|
});
|
|
13557
13620
|
function Loop(state) {
|
|
@@ -13576,7 +13639,7 @@ ${input.slice(result.pos)}
|
|
|
13576
13639
|
return result;
|
|
13577
13640
|
}
|
|
13578
13641
|
}
|
|
13579
|
-
var New$0 = $TS($S($EXPECT($
|
|
13642
|
+
var New$0 = $TS($S($EXPECT($L129, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13580
13643
|
return { $loc, token: $1 };
|
|
13581
13644
|
});
|
|
13582
13645
|
function New(state) {
|
|
@@ -13601,7 +13664,7 @@ ${input.slice(result.pos)}
|
|
|
13601
13664
|
return result;
|
|
13602
13665
|
}
|
|
13603
13666
|
}
|
|
13604
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
13667
|
+
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) {
|
|
13605
13668
|
return { $loc, token: "!" };
|
|
13606
13669
|
});
|
|
13607
13670
|
function Not(state) {
|
|
@@ -13626,7 +13689,7 @@ ${input.slice(result.pos)}
|
|
|
13626
13689
|
return result;
|
|
13627
13690
|
}
|
|
13628
13691
|
}
|
|
13629
|
-
var Of$0 = $TS($S($EXPECT($
|
|
13692
|
+
var Of$0 = $TS($S($EXPECT($L72, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13630
13693
|
return { $loc, token: $1 };
|
|
13631
13694
|
});
|
|
13632
13695
|
function Of(state) {
|
|
@@ -13651,7 +13714,7 @@ ${input.slice(result.pos)}
|
|
|
13651
13714
|
return result;
|
|
13652
13715
|
}
|
|
13653
13716
|
}
|
|
13654
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
13717
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L130, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
13655
13718
|
return { $loc, token: $1 };
|
|
13656
13719
|
});
|
|
13657
13720
|
function OpenAngleBracket(state) {
|
|
@@ -13676,7 +13739,7 @@ ${input.slice(result.pos)}
|
|
|
13676
13739
|
return result;
|
|
13677
13740
|
}
|
|
13678
13741
|
}
|
|
13679
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
13742
|
+
var OpenBrace$0 = $TV($EXPECT($L131, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
13680
13743
|
return { $loc, token: $1 };
|
|
13681
13744
|
});
|
|
13682
13745
|
function OpenBrace(state) {
|
|
@@ -13701,7 +13764,7 @@ ${input.slice(result.pos)}
|
|
|
13701
13764
|
return result;
|
|
13702
13765
|
}
|
|
13703
13766
|
}
|
|
13704
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
13767
|
+
var OpenBracket$0 = $TV($EXPECT($L95, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
13705
13768
|
return { $loc, token: $1 };
|
|
13706
13769
|
});
|
|
13707
13770
|
function OpenBracket(state) {
|
|
@@ -13751,7 +13814,7 @@ ${input.slice(result.pos)}
|
|
|
13751
13814
|
return result;
|
|
13752
13815
|
}
|
|
13753
13816
|
}
|
|
13754
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
13817
|
+
var Operator$0 = $TS($S($EXPECT($L132, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13755
13818
|
return { $loc, token: $1 };
|
|
13756
13819
|
});
|
|
13757
13820
|
function Operator(state) {
|
|
@@ -13776,7 +13839,7 @@ ${input.slice(result.pos)}
|
|
|
13776
13839
|
return result;
|
|
13777
13840
|
}
|
|
13778
13841
|
}
|
|
13779
|
-
var Public$0 = $TS($S($EXPECT($
|
|
13842
|
+
var Public$0 = $TS($S($EXPECT($L133, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13780
13843
|
return { $loc, token: $1 };
|
|
13781
13844
|
});
|
|
13782
13845
|
function Public(state) {
|
|
@@ -13801,7 +13864,7 @@ ${input.slice(result.pos)}
|
|
|
13801
13864
|
return result;
|
|
13802
13865
|
}
|
|
13803
13866
|
}
|
|
13804
|
-
var Private$0 = $TS($S($EXPECT($
|
|
13867
|
+
var Private$0 = $TS($S($EXPECT($L134, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13805
13868
|
return { $loc, token: $1 };
|
|
13806
13869
|
});
|
|
13807
13870
|
function Private(state) {
|
|
@@ -13826,7 +13889,7 @@ ${input.slice(result.pos)}
|
|
|
13826
13889
|
return result;
|
|
13827
13890
|
}
|
|
13828
13891
|
}
|
|
13829
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
13892
|
+
var Protected$0 = $TS($S($EXPECT($L135, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13830
13893
|
return { $loc, token: $1 };
|
|
13831
13894
|
});
|
|
13832
13895
|
function Protected(state) {
|
|
@@ -13851,7 +13914,13 @@ ${input.slice(result.pos)}
|
|
|
13851
13914
|
return result;
|
|
13852
13915
|
}
|
|
13853
13916
|
}
|
|
13854
|
-
var Pipe$0 = $TV($EXPECT($
|
|
13917
|
+
var Pipe$0 = $TV($EXPECT($L136, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
13918
|
+
return { $loc, token: $1 };
|
|
13919
|
+
});
|
|
13920
|
+
var Pipe$1 = $TV($EXPECT($L137, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
13921
|
+
return { $loc, token: $1 };
|
|
13922
|
+
});
|
|
13923
|
+
var Pipe$2 = $TV($EXPECT($L138, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
13855
13924
|
return { $loc, token: $1 };
|
|
13856
13925
|
});
|
|
13857
13926
|
function Pipe(state) {
|
|
@@ -13865,12 +13934,12 @@ ${input.slice(result.pos)}
|
|
|
13865
13934
|
}
|
|
13866
13935
|
}
|
|
13867
13936
|
if (state.tokenize) {
|
|
13868
|
-
const result = $TOKEN("Pipe", state, Pipe$0(state));
|
|
13937
|
+
const result = $TOKEN("Pipe", state, Pipe$0(state) || Pipe$1(state) || Pipe$2(state));
|
|
13869
13938
|
if (state.events)
|
|
13870
13939
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13871
13940
|
return result;
|
|
13872
13941
|
} else {
|
|
13873
|
-
const result = Pipe$0(state);
|
|
13942
|
+
const result = Pipe$0(state) || Pipe$1(state) || Pipe$2(state);
|
|
13874
13943
|
if (state.events)
|
|
13875
13944
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13876
13945
|
return result;
|
|
@@ -13901,7 +13970,7 @@ ${input.slice(result.pos)}
|
|
|
13901
13970
|
return result;
|
|
13902
13971
|
}
|
|
13903
13972
|
}
|
|
13904
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
13973
|
+
var Readonly$0 = $TS($S($EXPECT($L139, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13905
13974
|
return { $loc, token: $1, ts: true };
|
|
13906
13975
|
});
|
|
13907
13976
|
function Readonly(state) {
|
|
@@ -13926,7 +13995,7 @@ ${input.slice(result.pos)}
|
|
|
13926
13995
|
return result;
|
|
13927
13996
|
}
|
|
13928
13997
|
}
|
|
13929
|
-
var Return$0 = $TS($S($EXPECT($
|
|
13998
|
+
var Return$0 = $TS($S($EXPECT($L140, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13930
13999
|
return { $loc, token: $1 };
|
|
13931
14000
|
});
|
|
13932
14001
|
function Return(state) {
|
|
@@ -13951,7 +14020,7 @@ ${input.slice(result.pos)}
|
|
|
13951
14020
|
return result;
|
|
13952
14021
|
}
|
|
13953
14022
|
}
|
|
13954
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14023
|
+
var Satisfies$0 = $TS($S($EXPECT($L141, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13955
14024
|
return { $loc, token: $1 };
|
|
13956
14025
|
});
|
|
13957
14026
|
function Satisfies(state) {
|
|
@@ -13976,7 +14045,7 @@ ${input.slice(result.pos)}
|
|
|
13976
14045
|
return result;
|
|
13977
14046
|
}
|
|
13978
14047
|
}
|
|
13979
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14048
|
+
var Semicolon$0 = $TV($EXPECT($L84, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
13980
14049
|
return { $loc, token: $1 };
|
|
13981
14050
|
});
|
|
13982
14051
|
function Semicolon(state) {
|
|
@@ -14001,7 +14070,7 @@ ${input.slice(result.pos)}
|
|
|
14001
14070
|
return result;
|
|
14002
14071
|
}
|
|
14003
14072
|
}
|
|
14004
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14073
|
+
var SingleQuote$0 = $TV($EXPECT($L142, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14005
14074
|
return { $loc, token: $1 };
|
|
14006
14075
|
});
|
|
14007
14076
|
function SingleQuote(state) {
|
|
@@ -14026,7 +14095,7 @@ ${input.slice(result.pos)}
|
|
|
14026
14095
|
return result;
|
|
14027
14096
|
}
|
|
14028
14097
|
}
|
|
14029
|
-
var Star$0 = $TV($EXPECT($
|
|
14098
|
+
var Star$0 = $TV($EXPECT($L53, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14030
14099
|
return { $loc, token: $1 };
|
|
14031
14100
|
});
|
|
14032
14101
|
function Star(state) {
|
|
@@ -14051,10 +14120,10 @@ ${input.slice(result.pos)}
|
|
|
14051
14120
|
return result;
|
|
14052
14121
|
}
|
|
14053
14122
|
}
|
|
14054
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14123
|
+
var Static$0 = $TS($S($EXPECT($L143, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14055
14124
|
return { $loc, token: $1 };
|
|
14056
14125
|
});
|
|
14057
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14126
|
+
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) {
|
|
14058
14127
|
return { $loc, token: "static " };
|
|
14059
14128
|
});
|
|
14060
14129
|
function Static(state) {
|
|
@@ -14079,7 +14148,7 @@ ${input.slice(result.pos)}
|
|
|
14079
14148
|
return result;
|
|
14080
14149
|
}
|
|
14081
14150
|
}
|
|
14082
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14151
|
+
var SubstitutionStart$0 = $TV($EXPECT($L144, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14083
14152
|
return { $loc, token: $1 };
|
|
14084
14153
|
});
|
|
14085
14154
|
function SubstitutionStart(state) {
|
|
@@ -14104,7 +14173,7 @@ ${input.slice(result.pos)}
|
|
|
14104
14173
|
return result;
|
|
14105
14174
|
}
|
|
14106
14175
|
}
|
|
14107
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14176
|
+
var Switch$0 = $TS($S($EXPECT($L145, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14108
14177
|
return { $loc, token: $1 };
|
|
14109
14178
|
});
|
|
14110
14179
|
function Switch(state) {
|
|
@@ -14129,7 +14198,7 @@ ${input.slice(result.pos)}
|
|
|
14129
14198
|
return result;
|
|
14130
14199
|
}
|
|
14131
14200
|
}
|
|
14132
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14201
|
+
var Target$0 = $TS($S($EXPECT($L146, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14133
14202
|
return { $loc, token: $1 };
|
|
14134
14203
|
});
|
|
14135
14204
|
function Target(state) {
|
|
@@ -14154,7 +14223,7 @@ ${input.slice(result.pos)}
|
|
|
14154
14223
|
return result;
|
|
14155
14224
|
}
|
|
14156
14225
|
}
|
|
14157
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14226
|
+
var Then$0 = $TS($S(__, $EXPECT($L147, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14158
14227
|
return { $loc, token: "" };
|
|
14159
14228
|
});
|
|
14160
14229
|
function Then(state) {
|
|
@@ -14179,7 +14248,7 @@ ${input.slice(result.pos)}
|
|
|
14179
14248
|
return result;
|
|
14180
14249
|
}
|
|
14181
14250
|
}
|
|
14182
|
-
var This$0 = $TS($S($EXPECT($
|
|
14251
|
+
var This$0 = $TS($S($EXPECT($L148, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14183
14252
|
return { $loc, token: $1 };
|
|
14184
14253
|
});
|
|
14185
14254
|
function This(state) {
|
|
@@ -14204,7 +14273,7 @@ ${input.slice(result.pos)}
|
|
|
14204
14273
|
return result;
|
|
14205
14274
|
}
|
|
14206
14275
|
}
|
|
14207
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14276
|
+
var Throw$0 = $TS($S($EXPECT($L149, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14208
14277
|
return { $loc, token: $1 };
|
|
14209
14278
|
});
|
|
14210
14279
|
function Throw(state) {
|
|
@@ -14229,7 +14298,7 @@ ${input.slice(result.pos)}
|
|
|
14229
14298
|
return result;
|
|
14230
14299
|
}
|
|
14231
14300
|
}
|
|
14232
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14301
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L150, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14233
14302
|
return { $loc, token: "`" };
|
|
14234
14303
|
});
|
|
14235
14304
|
function TripleDoubleQuote(state) {
|
|
@@ -14254,7 +14323,7 @@ ${input.slice(result.pos)}
|
|
|
14254
14323
|
return result;
|
|
14255
14324
|
}
|
|
14256
14325
|
}
|
|
14257
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14326
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L151, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14258
14327
|
return { $loc, token: "`" };
|
|
14259
14328
|
});
|
|
14260
14329
|
function TripleSingleQuote(state) {
|
|
@@ -14279,7 +14348,7 @@ ${input.slice(result.pos)}
|
|
|
14279
14348
|
return result;
|
|
14280
14349
|
}
|
|
14281
14350
|
}
|
|
14282
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14351
|
+
var TripleSlash$0 = $TV($EXPECT($L152, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14283
14352
|
return { $loc, token: "/" };
|
|
14284
14353
|
});
|
|
14285
14354
|
function TripleSlash(state) {
|
|
@@ -14304,7 +14373,7 @@ ${input.slice(result.pos)}
|
|
|
14304
14373
|
return result;
|
|
14305
14374
|
}
|
|
14306
14375
|
}
|
|
14307
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14376
|
+
var TripleTick$0 = $TV($EXPECT($L153, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14308
14377
|
return { $loc, token: "`" };
|
|
14309
14378
|
});
|
|
14310
14379
|
function TripleTick(state) {
|
|
@@ -14329,7 +14398,7 @@ ${input.slice(result.pos)}
|
|
|
14329
14398
|
return result;
|
|
14330
14399
|
}
|
|
14331
14400
|
}
|
|
14332
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14401
|
+
var Try$0 = $TS($S($EXPECT($L154, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14333
14402
|
return { $loc, token: $1 };
|
|
14334
14403
|
});
|
|
14335
14404
|
function Try(state) {
|
|
@@ -14354,7 +14423,7 @@ ${input.slice(result.pos)}
|
|
|
14354
14423
|
return result;
|
|
14355
14424
|
}
|
|
14356
14425
|
}
|
|
14357
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
14426
|
+
var Typeof$0 = $TS($S($EXPECT($L155, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14358
14427
|
return { $loc, token: $1 };
|
|
14359
14428
|
});
|
|
14360
14429
|
function Typeof(state) {
|
|
@@ -14379,7 +14448,7 @@ ${input.slice(result.pos)}
|
|
|
14379
14448
|
return result;
|
|
14380
14449
|
}
|
|
14381
14450
|
}
|
|
14382
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
14451
|
+
var Unless$0 = $TS($S($EXPECT($L156, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14383
14452
|
return { $loc, token: $1 };
|
|
14384
14453
|
});
|
|
14385
14454
|
function Unless(state) {
|
|
@@ -14404,7 +14473,7 @@ ${input.slice(result.pos)}
|
|
|
14404
14473
|
return result;
|
|
14405
14474
|
}
|
|
14406
14475
|
}
|
|
14407
|
-
var Until$0 = $TS($S($EXPECT($
|
|
14476
|
+
var Until$0 = $TS($S($EXPECT($L157, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14408
14477
|
return { $loc, token: $1 };
|
|
14409
14478
|
});
|
|
14410
14479
|
function Until(state) {
|
|
@@ -14429,7 +14498,7 @@ ${input.slice(result.pos)}
|
|
|
14429
14498
|
return result;
|
|
14430
14499
|
}
|
|
14431
14500
|
}
|
|
14432
|
-
var Var$0 = $TS($S($EXPECT($
|
|
14501
|
+
var Var$0 = $TS($S($EXPECT($L158, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14433
14502
|
return { $loc, token: $1 };
|
|
14434
14503
|
});
|
|
14435
14504
|
function Var(state) {
|
|
@@ -14454,7 +14523,7 @@ ${input.slice(result.pos)}
|
|
|
14454
14523
|
return result;
|
|
14455
14524
|
}
|
|
14456
14525
|
}
|
|
14457
|
-
var Void$0 = $TS($S($EXPECT($
|
|
14526
|
+
var Void$0 = $TS($S($EXPECT($L159, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14458
14527
|
return { $loc, token: $1 };
|
|
14459
14528
|
});
|
|
14460
14529
|
function Void(state) {
|
|
@@ -14479,7 +14548,7 @@ ${input.slice(result.pos)}
|
|
|
14479
14548
|
return result;
|
|
14480
14549
|
}
|
|
14481
14550
|
}
|
|
14482
|
-
var When$0 = $TS($S($EXPECT($
|
|
14551
|
+
var When$0 = $TS($S($EXPECT($L160, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14483
14552
|
return { $loc, token: "case" };
|
|
14484
14553
|
});
|
|
14485
14554
|
function When(state) {
|
|
@@ -14504,7 +14573,7 @@ ${input.slice(result.pos)}
|
|
|
14504
14573
|
return result;
|
|
14505
14574
|
}
|
|
14506
14575
|
}
|
|
14507
|
-
var While$0 = $TS($S($EXPECT($
|
|
14576
|
+
var While$0 = $TS($S($EXPECT($L161, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14508
14577
|
return { $loc, token: $1 };
|
|
14509
14578
|
});
|
|
14510
14579
|
function While(state) {
|
|
@@ -14529,7 +14598,7 @@ ${input.slice(result.pos)}
|
|
|
14529
14598
|
return result;
|
|
14530
14599
|
}
|
|
14531
14600
|
}
|
|
14532
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
14601
|
+
var Yield$0 = $TS($S($EXPECT($L162, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14533
14602
|
return { $loc, token: $1 };
|
|
14534
14603
|
});
|
|
14535
14604
|
function Yield(state) {
|
|
@@ -14675,7 +14744,7 @@ ${input.slice(result.pos)}
|
|
|
14675
14744
|
return result;
|
|
14676
14745
|
}
|
|
14677
14746
|
}
|
|
14678
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
14747
|
+
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) {
|
|
14679
14748
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
14680
14749
|
});
|
|
14681
14750
|
function JSXSelfClosingElement(state) {
|
|
@@ -14726,7 +14795,7 @@ ${input.slice(result.pos)}
|
|
|
14726
14795
|
return result;
|
|
14727
14796
|
}
|
|
14728
14797
|
}
|
|
14729
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
14798
|
+
var JSXOpeningElement$0 = $S($EXPECT($L130, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
14730
14799
|
function JSXOpeningElement(state) {
|
|
14731
14800
|
let eventData;
|
|
14732
14801
|
if (state.events) {
|
|
@@ -14755,7 +14824,7 @@ ${input.slice(result.pos)}
|
|
|
14755
14824
|
return $skip;
|
|
14756
14825
|
return $0;
|
|
14757
14826
|
});
|
|
14758
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
14827
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L18, fail, 'JSXOptionalClosingElement ""');
|
|
14759
14828
|
function JSXOptionalClosingElement(state) {
|
|
14760
14829
|
let eventData;
|
|
14761
14830
|
if (state.events) {
|
|
@@ -14778,7 +14847,7 @@ ${input.slice(result.pos)}
|
|
|
14778
14847
|
return result;
|
|
14779
14848
|
}
|
|
14780
14849
|
}
|
|
14781
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
14850
|
+
var JSXClosingElement$0 = $S($EXPECT($L164, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
14782
14851
|
function JSXClosingElement(state) {
|
|
14783
14852
|
let eventData;
|
|
14784
14853
|
if (state.events) {
|
|
@@ -14817,7 +14886,7 @@ ${input.slice(result.pos)}
|
|
|
14817
14886
|
];
|
|
14818
14887
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
14819
14888
|
});
|
|
14820
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
14889
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L165, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14821
14890
|
var children = $3;
|
|
14822
14891
|
$0 = $0.slice(1);
|
|
14823
14892
|
return {
|
|
@@ -14848,7 +14917,7 @@ ${input.slice(result.pos)}
|
|
|
14848
14917
|
return result;
|
|
14849
14918
|
}
|
|
14850
14919
|
}
|
|
14851
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
14920
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L165, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
14852
14921
|
module2.JSXTagStack.push("");
|
|
14853
14922
|
return $1;
|
|
14854
14923
|
});
|
|
@@ -14879,7 +14948,7 @@ ${input.slice(result.pos)}
|
|
|
14879
14948
|
return $skip;
|
|
14880
14949
|
return $0;
|
|
14881
14950
|
});
|
|
14882
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
14951
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L18, fail, 'JSXOptionalClosingFragment ""');
|
|
14883
14952
|
function JSXOptionalClosingFragment(state) {
|
|
14884
14953
|
let eventData;
|
|
14885
14954
|
if (state.events) {
|
|
@@ -14902,7 +14971,7 @@ ${input.slice(result.pos)}
|
|
|
14902
14971
|
return result;
|
|
14903
14972
|
}
|
|
14904
14973
|
}
|
|
14905
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
14974
|
+
var JSXClosingFragment$0 = $EXPECT($L166, fail, 'JSXClosingFragment "</>"');
|
|
14906
14975
|
function JSXClosingFragment(state) {
|
|
14907
14976
|
let eventData;
|
|
14908
14977
|
if (state.events) {
|
|
@@ -14948,7 +15017,7 @@ ${input.slice(result.pos)}
|
|
|
14948
15017
|
return result;
|
|
14949
15018
|
}
|
|
14950
15019
|
}
|
|
14951
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
15020
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R49, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
14952
15021
|
function JSXIdentifierName(state) {
|
|
14953
15022
|
let eventData;
|
|
14954
15023
|
if (state.events) {
|
|
@@ -15164,7 +15233,7 @@ ${input.slice(result.pos)}
|
|
|
15164
15233
|
return result;
|
|
15165
15234
|
}
|
|
15166
15235
|
}
|
|
15167
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
15236
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R50, fail, "JSXAttributeSpace /[\\s>]/"));
|
|
15168
15237
|
function JSXAttributeSpace(state) {
|
|
15169
15238
|
let eventData;
|
|
15170
15239
|
if (state.events) {
|
|
@@ -15187,7 +15256,7 @@ ${input.slice(result.pos)}
|
|
|
15187
15256
|
return result;
|
|
15188
15257
|
}
|
|
15189
15258
|
}
|
|
15190
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
15259
|
+
var JSXShorthandString$0 = $TR($EXPECT($R51, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15191
15260
|
return module2.quoteString($0);
|
|
15192
15261
|
});
|
|
15193
15262
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -15323,7 +15392,7 @@ ${input.slice(result.pos)}
|
|
|
15323
15392
|
return result;
|
|
15324
15393
|
}
|
|
15325
15394
|
}
|
|
15326
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
15395
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R52, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
15327
15396
|
var op = $2;
|
|
15328
15397
|
var rhs = $3;
|
|
15329
15398
|
return [[], op, [], rhs];
|
|
@@ -15378,7 +15447,7 @@ ${input.slice(result.pos)}
|
|
|
15378
15447
|
return result;
|
|
15379
15448
|
}
|
|
15380
15449
|
}
|
|
15381
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
15450
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R8, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15382
15451
|
return { $loc, token: $0 };
|
|
15383
15452
|
});
|
|
15384
15453
|
function InlineJSXUnaryOp(state) {
|
|
@@ -15669,7 +15738,7 @@ ${input.slice(result.pos)}
|
|
|
15669
15738
|
}
|
|
15670
15739
|
return $skip;
|
|
15671
15740
|
});
|
|
15672
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
15741
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
15673
15742
|
return { children: [], jsxChildren: [] };
|
|
15674
15743
|
});
|
|
15675
15744
|
function JSXNestedChildren(state) {
|
|
@@ -15798,7 +15867,7 @@ ${input.slice(result.pos)}
|
|
|
15798
15867
|
return result;
|
|
15799
15868
|
}
|
|
15800
15869
|
}
|
|
15801
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
15870
|
+
var JSXComment$0 = $TS($S($EXPECT($L167, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L168, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
15802
15871
|
return ["{/*", $2, "*/}"];
|
|
15803
15872
|
});
|
|
15804
15873
|
function JSXComment(state) {
|
|
@@ -15823,7 +15892,7 @@ ${input.slice(result.pos)}
|
|
|
15823
15892
|
return result;
|
|
15824
15893
|
}
|
|
15825
15894
|
}
|
|
15826
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
15895
|
+
var JSXCommentContent$0 = $TR($EXPECT($R53, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15827
15896
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
15828
15897
|
});
|
|
15829
15898
|
function JSXCommentContent(state) {
|
|
@@ -15848,7 +15917,7 @@ ${input.slice(result.pos)}
|
|
|
15848
15917
|
return result;
|
|
15849
15918
|
}
|
|
15850
15919
|
}
|
|
15851
|
-
var JSXText$0 = $TR($EXPECT($
|
|
15920
|
+
var JSXText$0 = $TR($EXPECT($R54, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15852
15921
|
return {
|
|
15853
15922
|
type: "JSXText",
|
|
15854
15923
|
token: $0,
|
|
@@ -16096,7 +16165,7 @@ ${input.slice(result.pos)}
|
|
|
16096
16165
|
return result;
|
|
16097
16166
|
}
|
|
16098
16167
|
}
|
|
16099
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16168
|
+
var TypeKeyword$0 = $S($EXPECT($L169, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16100
16169
|
function TypeKeyword(state) {
|
|
16101
16170
|
let eventData;
|
|
16102
16171
|
if (state.events) {
|
|
@@ -16119,7 +16188,7 @@ ${input.slice(result.pos)}
|
|
|
16119
16188
|
return result;
|
|
16120
16189
|
}
|
|
16121
16190
|
}
|
|
16122
|
-
var Interface$0 = $S($EXPECT($
|
|
16191
|
+
var Interface$0 = $S($EXPECT($L170, fail, 'Interface "interface"'), NonIdContinue);
|
|
16123
16192
|
function Interface(state) {
|
|
16124
16193
|
let eventData;
|
|
16125
16194
|
if (state.events) {
|
|
@@ -16142,7 +16211,7 @@ ${input.slice(result.pos)}
|
|
|
16142
16211
|
return result;
|
|
16143
16212
|
}
|
|
16144
16213
|
}
|
|
16145
|
-
var Namespace$0 = $S($EXPECT($
|
|
16214
|
+
var Namespace$0 = $S($EXPECT($L171, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16146
16215
|
function Namespace(state) {
|
|
16147
16216
|
let eventData;
|
|
16148
16217
|
if (state.events) {
|
|
@@ -16390,7 +16459,7 @@ ${input.slice(result.pos)}
|
|
|
16390
16459
|
return result;
|
|
16391
16460
|
}
|
|
16392
16461
|
}
|
|
16393
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
16462
|
+
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)));
|
|
16394
16463
|
function TypeIndexSignature(state) {
|
|
16395
16464
|
let eventData;
|
|
16396
16465
|
if (state.events) {
|
|
@@ -16462,7 +16531,7 @@ ${input.slice(result.pos)}
|
|
|
16462
16531
|
return result;
|
|
16463
16532
|
}
|
|
16464
16533
|
}
|
|
16465
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
16534
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L172, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
16466
16535
|
const children = [...$1, $2];
|
|
16467
16536
|
if ($3)
|
|
16468
16537
|
children.push($3);
|
|
@@ -16495,7 +16564,7 @@ ${input.slice(result.pos)}
|
|
|
16495
16564
|
return result;
|
|
16496
16565
|
}
|
|
16497
16566
|
}
|
|
16498
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
16567
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L81, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
16499
16568
|
if (!$2)
|
|
16500
16569
|
return $1;
|
|
16501
16570
|
return $0;
|
|
@@ -16621,10 +16690,10 @@ ${input.slice(result.pos)}
|
|
|
16621
16690
|
return result;
|
|
16622
16691
|
}
|
|
16623
16692
|
}
|
|
16624
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
16625
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
16626
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
16627
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
16693
|
+
var TypeUnaryOp$0 = $S($EXPECT($L173, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
16694
|
+
var TypeUnaryOp$1 = $S($EXPECT($L155, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
16695
|
+
var TypeUnaryOp$2 = $S($EXPECT($L174, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
16696
|
+
var TypeUnaryOp$3 = $S($EXPECT($L139, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
16628
16697
|
function TypeUnaryOp(state) {
|
|
16629
16698
|
let eventData;
|
|
16630
16699
|
if (state.events) {
|
|
@@ -16822,7 +16891,7 @@ ${input.slice(result.pos)}
|
|
|
16822
16891
|
return result;
|
|
16823
16892
|
}
|
|
16824
16893
|
}
|
|
16825
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
16894
|
+
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) {
|
|
16826
16895
|
if ($2)
|
|
16827
16896
|
return $0;
|
|
16828
16897
|
return $1;
|
|
@@ -16851,10 +16920,10 @@ ${input.slice(result.pos)}
|
|
|
16851
16920
|
}
|
|
16852
16921
|
var TypeLiteral$0 = TemplateLiteral;
|
|
16853
16922
|
var TypeLiteral$1 = Literal;
|
|
16854
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
16923
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L159, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16855
16924
|
return { $loc, token: "void" };
|
|
16856
16925
|
});
|
|
16857
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
16926
|
+
var TypeLiteral$3 = $TV($EXPECT($L175, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
16858
16927
|
return { $loc, token: "[]" };
|
|
16859
16928
|
});
|
|
16860
16929
|
function TypeLiteral(state) {
|
|
@@ -16929,7 +16998,7 @@ ${input.slice(result.pos)}
|
|
|
16929
16998
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
16930
16999
|
return value[1];
|
|
16931
17000
|
});
|
|
16932
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17001
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L19, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
16933
17002
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
16934
17003
|
function InlineInterfacePropertyDelimiter(state) {
|
|
16935
17004
|
let eventData;
|
|
@@ -16953,10 +17022,10 @@ ${input.slice(result.pos)}
|
|
|
16953
17022
|
return result;
|
|
16954
17023
|
}
|
|
16955
17024
|
}
|
|
16956
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17025
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
16957
17026
|
return { $loc, token: "|" };
|
|
16958
17027
|
});
|
|
16959
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17028
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L82, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
16960
17029
|
return { $loc, token: "&" };
|
|
16961
17030
|
});
|
|
16962
17031
|
function TypeBinaryOp(state) {
|
|
@@ -17013,7 +17082,7 @@ ${input.slice(result.pos)}
|
|
|
17013
17082
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17014
17083
|
return { $loc, token: "=>" };
|
|
17015
17084
|
});
|
|
17016
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17085
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17017
17086
|
return { $loc, token: "=>" };
|
|
17018
17087
|
});
|
|
17019
17088
|
function TypeArrowFunction(state) {
|
|
@@ -17038,7 +17107,7 @@ ${input.slice(result.pos)}
|
|
|
17038
17107
|
return result;
|
|
17039
17108
|
}
|
|
17040
17109
|
}
|
|
17041
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17110
|
+
var TypeArguments$0 = $TS($S($EXPECT($L130, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17042
17111
|
return { ts: true, children: $0 };
|
|
17043
17112
|
});
|
|
17044
17113
|
function TypeArguments(state) {
|
|
@@ -17109,7 +17178,7 @@ ${input.slice(result.pos)}
|
|
|
17109
17178
|
return result;
|
|
17110
17179
|
}
|
|
17111
17180
|
}
|
|
17112
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17181
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L130, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17113
17182
|
var parameters = $3;
|
|
17114
17183
|
return {
|
|
17115
17184
|
type: "TypeParameters",
|
|
@@ -17163,7 +17232,7 @@ ${input.slice(result.pos)}
|
|
|
17163
17232
|
return result;
|
|
17164
17233
|
}
|
|
17165
17234
|
}
|
|
17166
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17235
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L118, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17167
17236
|
function TypeConstraint(state) {
|
|
17168
17237
|
let eventData;
|
|
17169
17238
|
if (state.events) {
|
|
@@ -17210,7 +17279,7 @@ ${input.slice(result.pos)}
|
|
|
17210
17279
|
}
|
|
17211
17280
|
}
|
|
17212
17281
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17213
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17282
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17214
17283
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17215
17284
|
return value[1];
|
|
17216
17285
|
});
|
|
@@ -17261,7 +17330,7 @@ ${input.slice(result.pos)}
|
|
|
17261
17330
|
return result;
|
|
17262
17331
|
}
|
|
17263
17332
|
}
|
|
17264
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
17333
|
+
var Shebang$0 = $S($R$0($EXPECT($R57, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
17265
17334
|
function Shebang(state) {
|
|
17266
17335
|
let eventData;
|
|
17267
17336
|
if (state.events) {
|
|
@@ -17284,11 +17353,11 @@ ${input.slice(result.pos)}
|
|
|
17284
17353
|
return result;
|
|
17285
17354
|
}
|
|
17286
17355
|
}
|
|
17287
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
17356
|
+
var CivetPrologue$0 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17288
17357
|
var content = value[2];
|
|
17289
17358
|
return content;
|
|
17290
17359
|
});
|
|
17291
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
17360
|
+
var CivetPrologue$1 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17292
17361
|
var content = value[2];
|
|
17293
17362
|
return content;
|
|
17294
17363
|
});
|
|
@@ -17314,7 +17383,7 @@ ${input.slice(result.pos)}
|
|
|
17314
17383
|
return result;
|
|
17315
17384
|
}
|
|
17316
17385
|
}
|
|
17317
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
17386
|
+
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) {
|
|
17318
17387
|
var options = $3;
|
|
17319
17388
|
return {
|
|
17320
17389
|
type: "CivetPrologue",
|
|
@@ -17344,7 +17413,7 @@ ${input.slice(result.pos)}
|
|
|
17344
17413
|
return result;
|
|
17345
17414
|
}
|
|
17346
17415
|
}
|
|
17347
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
17416
|
+
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) {
|
|
17348
17417
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
17349
17418
|
if (l)
|
|
17350
17419
|
return l.toUpperCase();
|
|
@@ -17380,7 +17449,7 @@ ${input.slice(result.pos)}
|
|
|
17380
17449
|
return result;
|
|
17381
17450
|
}
|
|
17382
17451
|
}
|
|
17383
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
17452
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R58, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
17384
17453
|
function UnknownPrologue(state) {
|
|
17385
17454
|
let eventData;
|
|
17386
17455
|
if (state.events) {
|
|
@@ -17450,7 +17519,7 @@ ${input.slice(result.pos)}
|
|
|
17450
17519
|
return result;
|
|
17451
17520
|
}
|
|
17452
17521
|
}
|
|
17453
|
-
var EOL$0 = $TR($EXPECT($
|
|
17522
|
+
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) {
|
|
17454
17523
|
return { $loc, token: $0 };
|
|
17455
17524
|
});
|
|
17456
17525
|
function EOL(state) {
|
|
@@ -17475,7 +17544,7 @@ ${input.slice(result.pos)}
|
|
|
17475
17544
|
return result;
|
|
17476
17545
|
}
|
|
17477
17546
|
}
|
|
17478
|
-
var Debugger$0 = $TV($EXPECT($
|
|
17547
|
+
var Debugger$0 = $TV($EXPECT($L18, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
17479
17548
|
debugger;
|
|
17480
17549
|
});
|
|
17481
17550
|
function Debugger(state) {
|
|
@@ -17500,7 +17569,7 @@ ${input.slice(result.pos)}
|
|
|
17500
17569
|
return result;
|
|
17501
17570
|
}
|
|
17502
17571
|
}
|
|
17503
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
17572
|
+
var InsertSemicolon$0 = $TV($EXPECT($L18, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
17504
17573
|
return { $loc, token: ";" };
|
|
17505
17574
|
});
|
|
17506
17575
|
function InsertSemicolon(state) {
|
|
@@ -17525,7 +17594,7 @@ ${input.slice(result.pos)}
|
|
|
17525
17594
|
return result;
|
|
17526
17595
|
}
|
|
17527
17596
|
}
|
|
17528
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
17597
|
+
var InsertOpenParen$0 = $TV($EXPECT($L18, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
17529
17598
|
return { $loc, token: "(" };
|
|
17530
17599
|
});
|
|
17531
17600
|
function InsertOpenParen(state) {
|
|
@@ -17550,7 +17619,7 @@ ${input.slice(result.pos)}
|
|
|
17550
17619
|
return result;
|
|
17551
17620
|
}
|
|
17552
17621
|
}
|
|
17553
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
17622
|
+
var InsertCloseParen$0 = $TV($EXPECT($L18, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
17554
17623
|
return { $loc, token: ")" };
|
|
17555
17624
|
});
|
|
17556
17625
|
function InsertCloseParen(state) {
|
|
@@ -17575,7 +17644,7 @@ ${input.slice(result.pos)}
|
|
|
17575
17644
|
return result;
|
|
17576
17645
|
}
|
|
17577
17646
|
}
|
|
17578
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
17647
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17579
17648
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
17580
17649
|
});
|
|
17581
17650
|
function InsertOpenBrace(state) {
|
|
@@ -17600,7 +17669,7 @@ ${input.slice(result.pos)}
|
|
|
17600
17669
|
return result;
|
|
17601
17670
|
}
|
|
17602
17671
|
}
|
|
17603
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
17672
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17604
17673
|
return { $loc, token: "{" };
|
|
17605
17674
|
});
|
|
17606
17675
|
function InsertInlineOpenBrace(state) {
|
|
@@ -17625,7 +17694,7 @@ ${input.slice(result.pos)}
|
|
|
17625
17694
|
return result;
|
|
17626
17695
|
}
|
|
17627
17696
|
}
|
|
17628
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
17697
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L18, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
17629
17698
|
return { $loc, token: "}" };
|
|
17630
17699
|
});
|
|
17631
17700
|
function InsertCloseBrace(state) {
|
|
@@ -17650,7 +17719,7 @@ ${input.slice(result.pos)}
|
|
|
17650
17719
|
return result;
|
|
17651
17720
|
}
|
|
17652
17721
|
}
|
|
17653
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
17722
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L18, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
17654
17723
|
return { $loc, token: "[" };
|
|
17655
17724
|
});
|
|
17656
17725
|
function InsertOpenBracket(state) {
|
|
@@ -17675,7 +17744,7 @@ ${input.slice(result.pos)}
|
|
|
17675
17744
|
return result;
|
|
17676
17745
|
}
|
|
17677
17746
|
}
|
|
17678
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
17747
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L18, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
17679
17748
|
return { $loc, token: "]" };
|
|
17680
17749
|
});
|
|
17681
17750
|
function InsertCloseBracket(state) {
|
|
@@ -17700,7 +17769,7 @@ ${input.slice(result.pos)}
|
|
|
17700
17769
|
return result;
|
|
17701
17770
|
}
|
|
17702
17771
|
}
|
|
17703
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
17772
|
+
var InsertComma$0 = $TV($EXPECT($L18, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
17704
17773
|
return { $loc, token: "," };
|
|
17705
17774
|
});
|
|
17706
17775
|
function InsertComma(state) {
|
|
@@ -17725,7 +17794,7 @@ ${input.slice(result.pos)}
|
|
|
17725
17794
|
return result;
|
|
17726
17795
|
}
|
|
17727
17796
|
}
|
|
17728
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
17797
|
+
var InsertConst$0 = $TV($EXPECT($L18, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
17729
17798
|
return { $loc, token: "const " };
|
|
17730
17799
|
});
|
|
17731
17800
|
function InsertConst(state) {
|
|
@@ -17750,7 +17819,7 @@ ${input.slice(result.pos)}
|
|
|
17750
17819
|
return result;
|
|
17751
17820
|
}
|
|
17752
17821
|
}
|
|
17753
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
17822
|
+
var InsertLet$0 = $TV($EXPECT($L18, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
17754
17823
|
return { $loc, token: "let " };
|
|
17755
17824
|
});
|
|
17756
17825
|
function InsertLet(state) {
|
|
@@ -17775,7 +17844,7 @@ ${input.slice(result.pos)}
|
|
|
17775
17844
|
return result;
|
|
17776
17845
|
}
|
|
17777
17846
|
}
|
|
17778
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
17847
|
+
var InsertReadonly$0 = $TV($EXPECT($L18, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
17779
17848
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
17780
17849
|
});
|
|
17781
17850
|
function InsertReadonly(state) {
|
|
@@ -17800,7 +17869,7 @@ ${input.slice(result.pos)}
|
|
|
17800
17869
|
return result;
|
|
17801
17870
|
}
|
|
17802
17871
|
}
|
|
17803
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
17872
|
+
var InsertNewline$0 = $TV($EXPECT($L18, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
17804
17873
|
return "\n";
|
|
17805
17874
|
});
|
|
17806
17875
|
function InsertNewline(state) {
|
|
@@ -17825,7 +17894,7 @@ ${input.slice(result.pos)}
|
|
|
17825
17894
|
return result;
|
|
17826
17895
|
}
|
|
17827
17896
|
}
|
|
17828
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
17897
|
+
var InsertIndent$0 = $TV($EXPECT($L18, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
17829
17898
|
return module2.currentIndent.token;
|
|
17830
17899
|
});
|
|
17831
17900
|
function InsertIndent(state) {
|
|
@@ -17850,7 +17919,7 @@ ${input.slice(result.pos)}
|
|
|
17850
17919
|
return result;
|
|
17851
17920
|
}
|
|
17852
17921
|
}
|
|
17853
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
17922
|
+
var InsertSpace$0 = $TV($EXPECT($L18, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
17854
17923
|
return { $loc, token: " " };
|
|
17855
17924
|
});
|
|
17856
17925
|
function InsertSpace(state) {
|
|
@@ -17875,7 +17944,7 @@ ${input.slice(result.pos)}
|
|
|
17875
17944
|
return result;
|
|
17876
17945
|
}
|
|
17877
17946
|
}
|
|
17878
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
17947
|
+
var InsertDot$0 = $TV($EXPECT($L18, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
17879
17948
|
return { $loc, token: "." };
|
|
17880
17949
|
});
|
|
17881
17950
|
function InsertDot(state) {
|
|
@@ -17900,7 +17969,7 @@ ${input.slice(result.pos)}
|
|
|
17900
17969
|
return result;
|
|
17901
17970
|
}
|
|
17902
17971
|
}
|
|
17903
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
17972
|
+
var InsertBreak$0 = $TV($EXPECT($L18, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
17904
17973
|
return { $loc, token: ";break;" };
|
|
17905
17974
|
});
|
|
17906
17975
|
function InsertBreak(state) {
|
|
@@ -17925,7 +17994,7 @@ ${input.slice(result.pos)}
|
|
|
17925
17994
|
return result;
|
|
17926
17995
|
}
|
|
17927
17996
|
}
|
|
17928
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
17997
|
+
var InsertVar$0 = $TV($EXPECT($L18, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
17929
17998
|
return { $loc, token: "var " };
|
|
17930
17999
|
});
|
|
17931
18000
|
function InsertVar(state) {
|
|
@@ -17950,7 +18019,7 @@ ${input.slice(result.pos)}
|
|
|
17950
18019
|
return result;
|
|
17951
18020
|
}
|
|
17952
18021
|
}
|
|
17953
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18022
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17954
18023
|
if (module2.config.coffeeBinaryExistential)
|
|
17955
18024
|
return;
|
|
17956
18025
|
return $skip;
|
|
@@ -17977,7 +18046,7 @@ ${input.slice(result.pos)}
|
|
|
17977
18046
|
return result;
|
|
17978
18047
|
}
|
|
17979
18048
|
}
|
|
17980
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18049
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17981
18050
|
if (module2.config.coffeeBooleans)
|
|
17982
18051
|
return;
|
|
17983
18052
|
return $skip;
|
|
@@ -18004,7 +18073,7 @@ ${input.slice(result.pos)}
|
|
|
18004
18073
|
return result;
|
|
18005
18074
|
}
|
|
18006
18075
|
}
|
|
18007
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18076
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18008
18077
|
if (module2.config.coffeeClasses)
|
|
18009
18078
|
return;
|
|
18010
18079
|
return $skip;
|
|
@@ -18031,7 +18100,7 @@ ${input.slice(result.pos)}
|
|
|
18031
18100
|
return result;
|
|
18032
18101
|
}
|
|
18033
18102
|
}
|
|
18034
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18103
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18035
18104
|
if (module2.config.coffeeComment)
|
|
18036
18105
|
return;
|
|
18037
18106
|
return $skip;
|
|
@@ -18058,7 +18127,7 @@ ${input.slice(result.pos)}
|
|
|
18058
18127
|
return result;
|
|
18059
18128
|
}
|
|
18060
18129
|
}
|
|
18061
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18130
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18062
18131
|
if (module2.config.coffeeDo)
|
|
18063
18132
|
return;
|
|
18064
18133
|
return $skip;
|
|
@@ -18085,7 +18154,7 @@ ${input.slice(result.pos)}
|
|
|
18085
18154
|
return result;
|
|
18086
18155
|
}
|
|
18087
18156
|
}
|
|
18088
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18157
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18089
18158
|
if (module2.config.coffeeForLoops)
|
|
18090
18159
|
return;
|
|
18091
18160
|
return $skip;
|
|
@@ -18112,7 +18181,7 @@ ${input.slice(result.pos)}
|
|
|
18112
18181
|
return result;
|
|
18113
18182
|
}
|
|
18114
18183
|
}
|
|
18115
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18184
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18116
18185
|
if (module2.config.coffeeInterpolation)
|
|
18117
18186
|
return;
|
|
18118
18187
|
return $skip;
|
|
@@ -18139,7 +18208,7 @@ ${input.slice(result.pos)}
|
|
|
18139
18208
|
return result;
|
|
18140
18209
|
}
|
|
18141
18210
|
}
|
|
18142
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18211
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18143
18212
|
if (module2.config.coffeeIsnt)
|
|
18144
18213
|
return;
|
|
18145
18214
|
return $skip;
|
|
@@ -18166,7 +18235,7 @@ ${input.slice(result.pos)}
|
|
|
18166
18235
|
return result;
|
|
18167
18236
|
}
|
|
18168
18237
|
}
|
|
18169
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18238
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18170
18239
|
if (module2.config.coffeeJSX)
|
|
18171
18240
|
return;
|
|
18172
18241
|
return $skip;
|
|
@@ -18193,7 +18262,7 @@ ${input.slice(result.pos)}
|
|
|
18193
18262
|
return result;
|
|
18194
18263
|
}
|
|
18195
18264
|
}
|
|
18196
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18265
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18197
18266
|
if (module2.config.coffeeLineContinuation)
|
|
18198
18267
|
return;
|
|
18199
18268
|
return $skip;
|
|
@@ -18220,7 +18289,7 @@ ${input.slice(result.pos)}
|
|
|
18220
18289
|
return result;
|
|
18221
18290
|
}
|
|
18222
18291
|
}
|
|
18223
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18292
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18224
18293
|
if (module2.config.coffeeNot)
|
|
18225
18294
|
return;
|
|
18226
18295
|
return $skip;
|
|
@@ -18247,7 +18316,7 @@ ${input.slice(result.pos)}
|
|
|
18247
18316
|
return result;
|
|
18248
18317
|
}
|
|
18249
18318
|
}
|
|
18250
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18319
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18251
18320
|
if (module2.config.coffeeOf)
|
|
18252
18321
|
return;
|
|
18253
18322
|
return $skip;
|
|
@@ -18274,7 +18343,7 @@ ${input.slice(result.pos)}
|
|
|
18274
18343
|
return result;
|
|
18275
18344
|
}
|
|
18276
18345
|
}
|
|
18277
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18346
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18278
18347
|
if (module2.config.coffeePrototype)
|
|
18279
18348
|
return;
|
|
18280
18349
|
return $skip;
|
|
@@ -18301,7 +18370,7 @@ ${input.slice(result.pos)}
|
|
|
18301
18370
|
return result;
|
|
18302
18371
|
}
|
|
18303
18372
|
}
|
|
18304
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
18373
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L18, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18305
18374
|
if (module2.config.objectIs)
|
|
18306
18375
|
return;
|
|
18307
18376
|
return $skip;
|
|
@@ -18328,7 +18397,7 @@ ${input.slice(result.pos)}
|
|
|
18328
18397
|
return result;
|
|
18329
18398
|
}
|
|
18330
18399
|
}
|
|
18331
|
-
var Reset$0 = $TV($EXPECT($
|
|
18400
|
+
var Reset$0 = $TV($EXPECT($L18, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18332
18401
|
module2.indentLevels = [{
|
|
18333
18402
|
level: 0,
|
|
18334
18403
|
token: ""
|
|
@@ -18401,28 +18470,42 @@ ${input.slice(result.pos)}
|
|
|
18401
18470
|
ts: true,
|
|
18402
18471
|
children: [": <T>(this: T[], searchElement: T) => boolean"]
|
|
18403
18472
|
};
|
|
18404
|
-
module2.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module2.asAny, "
|
|
18473
|
+
module2.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module2.asAny, ";\n"]]);
|
|
18405
18474
|
},
|
|
18406
18475
|
hasProp(hasPropRef) {
|
|
18407
18476
|
const typeSuffix = {
|
|
18408
18477
|
ts: true,
|
|
18409
18478
|
children: [": <T>(this: T, prop: keyof T) => boolean"]
|
|
18410
18479
|
};
|
|
18411
|
-
module2.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module2.asAny, "
|
|
18480
|
+
module2.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module2.asAny, ";\n"]]);
|
|
18412
18481
|
},
|
|
18413
18482
|
is(isRef) {
|
|
18414
18483
|
const typeSuffix = {
|
|
18415
18484
|
ts: true,
|
|
18416
18485
|
children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
|
|
18417
18486
|
};
|
|
18418
|
-
module2.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module2.asAny, "
|
|
18487
|
+
module2.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module2.asAny, ";\n"]]);
|
|
18419
18488
|
},
|
|
18420
18489
|
modulo(moduloRef) {
|
|
18421
18490
|
const typeSuffix = {
|
|
18422
18491
|
ts: true,
|
|
18423
18492
|
children: [": (a: number, b: number) => number"]
|
|
18424
18493
|
};
|
|
18425
|
-
module2.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b", "\n"]]);
|
|
18494
|
+
module2.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
|
|
18495
|
+
},
|
|
18496
|
+
xor(xorRef) {
|
|
18497
|
+
const typeSuffix = {
|
|
18498
|
+
ts: true,
|
|
18499
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18500
|
+
};
|
|
18501
|
+
module2.prelude.push(["", ["const ", xorRef, typeSuffix, " = (a, b) => a && b ? false : a || b;", "\n"]]);
|
|
18502
|
+
},
|
|
18503
|
+
xnor(xnorRef) {
|
|
18504
|
+
const typeSuffix = {
|
|
18505
|
+
ts: true,
|
|
18506
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18507
|
+
};
|
|
18508
|
+
module2.prelude.push(["", ["const ", xnorRef, typeSuffix, " = (a, b) => a || b ? a && b : true;", "\n"]]);
|
|
18426
18509
|
},
|
|
18427
18510
|
returnSymbol(ref) {
|
|
18428
18511
|
module2.prelude.push({
|
|
@@ -18606,7 +18689,7 @@ ${input.slice(result.pos)}
|
|
|
18606
18689
|
return result;
|
|
18607
18690
|
}
|
|
18608
18691
|
}
|
|
18609
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
18692
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L18, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
18610
18693
|
var directives = $2;
|
|
18611
18694
|
directives.forEach((directive) => {
|
|
18612
18695
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19795,7 +19878,52 @@ ${input.slice(result.pos)}
|
|
|
19795
19878
|
s.children = [root];
|
|
19796
19879
|
});
|
|
19797
19880
|
}
|
|
19881
|
+
function processPipelineExpressions(statements) {
|
|
19882
|
+
gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
|
|
19883
|
+
const [, body] = s.children;
|
|
19884
|
+
let [arg] = s.children;
|
|
19885
|
+
let i = 0, l = body.length;
|
|
19886
|
+
const children = [];
|
|
19887
|
+
for (i = 0; i < l; i++) {
|
|
19888
|
+
const step = body[i];
|
|
19889
|
+
const [leadingComment, pipe, trailingComment, expr] = step;
|
|
19890
|
+
const returns = pipe.token === "||>";
|
|
19891
|
+
if (pipe.token === "|>=") {
|
|
19892
|
+
if (i === 0) {
|
|
19893
|
+
children.push(arg, " = ");
|
|
19894
|
+
} else {
|
|
19895
|
+
children.push({
|
|
19896
|
+
type: "Error",
|
|
19897
|
+
message: "Can't use |>= in the middle of a pipeline"
|
|
19898
|
+
});
|
|
19899
|
+
}
|
|
19900
|
+
}
|
|
19901
|
+
const [result, returning] = module2.constructPipeStep(
|
|
19902
|
+
{
|
|
19903
|
+
leadingComment: module2.skipIfOnlyWS(leadingComment),
|
|
19904
|
+
trailingComment: module2.skipIfOnlyWS(trailingComment),
|
|
19905
|
+
expr
|
|
19906
|
+
},
|
|
19907
|
+
arg,
|
|
19908
|
+
returns ? arg : null
|
|
19909
|
+
);
|
|
19910
|
+
if (result.type === "ReturnStatement") {
|
|
19911
|
+
arg = result;
|
|
19912
|
+
break;
|
|
19913
|
+
}
|
|
19914
|
+
if (returning) {
|
|
19915
|
+
arg = returning;
|
|
19916
|
+
children.push(result, ",");
|
|
19917
|
+
} else {
|
|
19918
|
+
arg = result;
|
|
19919
|
+
}
|
|
19920
|
+
}
|
|
19921
|
+
children.push(arg);
|
|
19922
|
+
s.children = children;
|
|
19923
|
+
});
|
|
19924
|
+
}
|
|
19798
19925
|
module2.processProgram = function(statements) {
|
|
19926
|
+
processPipelineExpressions(statements);
|
|
19799
19927
|
processAssignments(statements);
|
|
19800
19928
|
processFunctions(statements);
|
|
19801
19929
|
processSwitchExpressions(statements);
|
|
@@ -20008,20 +20136,56 @@ ${input.slice(result.pos)}
|
|
|
20008
20136
|
return [splices, thisAssignments];
|
|
20009
20137
|
}
|
|
20010
20138
|
module2.gatherBindingCode = gatherBindingCode;
|
|
20011
|
-
module2.constructInvocation = function(
|
|
20012
|
-
const
|
|
20013
|
-
const
|
|
20014
|
-
|
|
20015
|
-
|
|
20016
|
-
|
|
20017
|
-
|
|
20139
|
+
module2.constructInvocation = function(fn, arg) {
|
|
20140
|
+
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20141
|
+
const lhs = module2.makeLeftHandSideExpression(fn.expr);
|
|
20142
|
+
let comment = module2.skipIfOnlyWS(fn.trailingComment);
|
|
20143
|
+
if (comment)
|
|
20144
|
+
lhs.children.splice(2, 0, comment);
|
|
20145
|
+
comment = module2.skipIfOnlyWS(fn.leadingComment);
|
|
20146
|
+
if (comment)
|
|
20147
|
+
lhs.children.splice(1, 0, comment);
|
|
20148
|
+
switch (arg.type) {
|
|
20149
|
+
case "CommaExpression":
|
|
20150
|
+
arg = {
|
|
20151
|
+
type: "ParenthesizedExpression",
|
|
20152
|
+
children: ["(", arg, ")"]
|
|
20153
|
+
};
|
|
20154
|
+
break;
|
|
20018
20155
|
}
|
|
20156
|
+
return {
|
|
20157
|
+
type: "CallExpression",
|
|
20158
|
+
children: [lhs, "(", arg, ")"]
|
|
20159
|
+
};
|
|
20019
20160
|
};
|
|
20020
|
-
module2.constructPipeStep = function(
|
|
20021
|
-
|
|
20022
|
-
|
|
20161
|
+
module2.constructPipeStep = function(fn, arg, returning) {
|
|
20162
|
+
const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(module2.skipIfOnlyWS), " ", arg];
|
|
20163
|
+
switch (fn.expr.token) {
|
|
20164
|
+
case "yield":
|
|
20165
|
+
case "await":
|
|
20166
|
+
if (returning) {
|
|
20167
|
+
return [
|
|
20168
|
+
children,
|
|
20169
|
+
returning
|
|
20170
|
+
];
|
|
20171
|
+
}
|
|
20172
|
+
return [
|
|
20173
|
+
children,
|
|
20174
|
+
null
|
|
20175
|
+
];
|
|
20176
|
+
case "return":
|
|
20177
|
+
return [{
|
|
20178
|
+
type: "ReturnStatement",
|
|
20179
|
+
children
|
|
20180
|
+
}, null];
|
|
20181
|
+
}
|
|
20182
|
+
if (returning) {
|
|
20183
|
+
return [
|
|
20184
|
+
module2.constructInvocation(fn, arg),
|
|
20185
|
+
returning
|
|
20186
|
+
];
|
|
20023
20187
|
}
|
|
20024
|
-
return module2.constructInvocation(
|
|
20188
|
+
return [module2.constructInvocation(fn, arg), null];
|
|
20025
20189
|
};
|
|
20026
20190
|
return $0;
|
|
20027
20191
|
});
|
|
@@ -20047,7 +20211,7 @@ ${input.slice(result.pos)}
|
|
|
20047
20211
|
return result;
|
|
20048
20212
|
}
|
|
20049
20213
|
}
|
|
20050
|
-
var Indent$0 = $TR($EXPECT($
|
|
20214
|
+
var Indent$0 = $TR($EXPECT($R62, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
20051
20215
|
let level;
|
|
20052
20216
|
if (module2.config.tab) {
|
|
20053
20217
|
const tabs = $0.match(/\t/g);
|
|
@@ -20202,7 +20366,7 @@ ${input.slice(result.pos)}
|
|
|
20202
20366
|
return result;
|
|
20203
20367
|
}
|
|
20204
20368
|
}
|
|
20205
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
20369
|
+
var PopIndent$0 = $TV($EXPECT($L18, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
20206
20370
|
if (module2.config.verbose) {
|
|
20207
20371
|
console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
|
|
20208
20372
|
}
|