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