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